fix: typing issue

This reverts commit 571ab488f8.

.github/workflows/build.yml

@@ -24,7 +24,7 @@ jobs:
           path: ./.venv
           key: venv-${{ hashFiles('poetry.lock') }}
       - name: Install the project dependencies
-        run: poetry install
+        run: poetry install --all-extras
       - name: build app
         run: poetry build
       - name: Archive production artifacts

.github/workflows/test.yml

@@ -30,7 +30,7 @@ jobs:
           path: ./.venv
           key: venv-${{ hashFiles('poetry.lock') }}
       - name: Install the project dependencies
-        run: poetry install
+        run: poetry install --all-extras
       - name: run linter, formatters and sort imports
         run: |
           poetry run black .

README.md

@@ -1,12 +1,21 @@
-# FastAnime
+# **FastAnime**
+
+![PyPI - Downloads](https://img.shields.io/pypi/dm/fastanime) ![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/Benex254/FastAnime/test.yml?label=Tests)
+![Discord](https://img.shields.io/discord/1250887070906323096?label=Discord)
+![GitHub Issues or Pull Requests](https://img.shields.io/github/issues/Benex254/FastAnime)
+![GitHub deployments](https://img.shields.io/github/deployments/Benex254/fastanime/pypi?label=PyPi%20Publish)
+![PyPI - License](https://img.shields.io/pypi/l/fastanime)
 
 Welcome to **FastAnime**, anime site experience from the terminal.
 
-**fzf mode**
+![fastanime-demo](https://github.com/user-attachments/assets/16e29f54-e9fa-48c7-b944-bfacb31ae1b5)
 
+<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>
@@ -22,7 +31,7 @@ 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).
+Heavily inspired by [animdl](https://github.com/justfoolingaround/animdl), [jerry](https://github.com/justchokingaround/jerry/tree/main),[magic-tape](https://gitlab.com/christosangel/magic-tape/-/tree/main?ref_type=heads) and [ani-cli](https://github.com/pystardust/ani-cli).
 
 <!--toc:start-->
 
@@ -41,14 +50,16 @@ Heavily inspired by [animdl](https://github.com/justfoolingaround/animdl), [magi
         - [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)
-    - [Added keybindings](#added-keybindings)
-    - [Added script messages](#added-script-messages)
+    - [MPV specific commands](#mpv-specific-commands)
+      - [Key Bindings](#key-bindings)
+      - [Script Messages](#script-messages)
+  - [styling the default interface](#styling-the-default-interface)
   - [Configuration](#configuration)
   - [Contributing](#contributing)
   - [Receiving Support](#receiving-support)
@@ -57,13 +68,19 @@ Heavily inspired by [animdl](https://github.com/justfoolingaround/animdl), [magi
 
 > [!IMPORTANT]
 >
-> This project currently scrapes allanime and animepahe and is in no way related to them nor does the project own any content servers. The site is in the public domain and can be access by any one with a browser.
+> This project currently scrapes allanime, hianime and animepahe, nyaa. The site is in the public domain and can be accessed by any one with a browser.
 
 ## Installation
 
+![Windows](https://img.shields.io/badge/-Windows_x64-blue.svg?style=for-the-badge&logo=windows)
+![Linux/BSD](https://img.shields.io/badge/-Linux/BSD-red.svg?style=for-the-badge&logo=linux)
+![Arch Linux](https://img.shields.io/badge/-Arch_Linux-black.svg?style=for-the-badge&logo=archlinux)
+![MacOS](https://img.shields.io/badge/-MacOS-lightblue.svg?style=for-the-badge&logo=apple)
+![Android](https://img.shields.io/badge/-Android-green.svg?style=for-the-badge&logo=android)
+
 The app can run wherever python can run. So all you need to have is python installed on your device.
 On android you can use [termux](https://github.com/termux/termux-app).
-If you have any difficulty consult for help on the [discord channel](https://discord.gg/HRjySFjQ)
+If you have any difficulty consult for help on the [discord channel](https://discord.gg/HBEmAwvbHV)
 
 ### Installation using your favourite package manager
 
@@ -120,7 +137,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:
 
@@ -161,30 +178,33 @@ The only required external dependency, unless you won't be streaming, is [MPV](h
 > player because we believe nothing beats **MPV** and it provides
 > everything you could ever need with a small footprint.
 > But if you have a reason feel free to encourage as to do so.
+> However, on android this is not the case so vlc is also supported
 
 **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.
+- [webtorrent-cli](https://github.com/webtorrent/webtorrent-cli) used when the provider is nyaa
+- [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) 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.
+- [feh](https://github.com/derf/feh) used in manga mode
 
 ## 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 hianime 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.
+If you are stuck anywhere just use `--help` before the command you would like to get help on
 
-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.
@@ -192,23 +212,36 @@ Overview of main commands:
 - `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 hianime
 - `--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
@@ -219,6 +252,35 @@ Available options include:
 - `--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/hianime/nyaa>` 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 hianime.
+- `--normalize-titles/--no-normalize-titles` whether to normalize provider titles
+- `--manga` toggle experimental manga mode
+
+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 -t <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
+
+# viewing manga
+fastanime --manga search -t <manga-title>
+```
 
 #### The anilist command :fire: :fire: :fire:
 
@@ -231,6 +293,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.
@@ -240,6 +303,49 @@ 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>` can be specified multiple times
+- `--media-format <MediaFormat>` or `-f <MediaFormat>`
+- `--season <MediaSeason>`
+- `--genres <genre>` or `-g <genre>` can be specified multiple times.
+- `--on-list/--not-on-list`
+
+Example:
+
+```bash
+# get anime with the tag of isekai
+fastanime anilist search -T isekai
+
+# get anime of 2024 and sort by popularity
+# that has already finished airing or is releasing
+# and is not in your anime lists
+fastanime anilist search -y 2024 -s POPULARITY_DESC --status RELEASING --status FINISHED --not-on-list
+
+# 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`
@@ -249,7 +355,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
@@ -262,7 +368,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.
 
@@ -280,12 +386,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]
 >
@@ -296,29 +405,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; hianime 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
@@ -330,9 +542,25 @@ 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 watch a specific title
+# be sure to get the completions for the best experience
+fastanime downloads --title <title>
+
 # 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
@@ -409,12 +637,12 @@ fastanime completions --bash
 fastanime completions --zsh
 ```
 
-## MPV specific commands
+### 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.
 
-### Added keybindings
+#### Key Bindings
 
 `<shift>+n` fetch the next episode
 
@@ -426,71 +654,227 @@ This is all powered with [python-mpv]() which enables writing mpv scripts with p
 
 `<shit>+r` reload episode
 
-### Added script messages
+#### 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`.
+
+> [!TIP]
+> You can now use the option `--update` to update your config file from the command-line
+> For Example:
+> `fastanime --icons --fzf --preview config --update`
+> the above will set icons to true, use_fzf to true and preview to true in your config file
+
+The default config:
 
 ```ini
+#
+#    ███████╗░█████╗░░██████╗████████╗░█████╗░███╗░░██╗██╗███╗░░░███╗███████╗  ░█████╗░░█████╗░███╗░░██╗███████╗██╗░██████╗░
+#    ██╔════╝██╔══██╗██╔════╝╚══██╔══╝██╔══██╗████╗░██║██║████╗░████║██╔════╝  ██╔══██╗██╔══██╗████╗░██║██╔════╝██║██╔════╝░
+#    █████╗░░███████║╚█████╗░░░░██║░░░███████║██╔██╗██║██║██╔████╔██║█████╗░░  ██║░░╚═╝██║░░██║██╔██╗██║█████╗░░██║██║░░██╗░
+#    ██╔══╝░░██╔══██║░╚═══██╗░░░██║░░░██╔══██║██║╚████║██║██║╚██╔╝██║██╔══╝░░  ██║░░██╗██║░░██║██║╚████║██╔══╝░░██║██║░░╚██╗
+#    ██║░░░░░██║░░██║██████╔╝░░░██║░░░██║░░██║██║░╚███║██║██║░╚═╝░██║███████╗  ╚█████╔╝╚█████╔╝██║░╚███║██║░░░░░██║╚██████╔╝
+#    ╚═╝░░░░░╚═╝░░╚═╝╚═════╝░░░░╚═╝░░░╚═╝░░╚═╝╚═╝░░╚══╝╚═╝╚═╝░░░░░╚═╝╚══════╝  ░╚════╝░░╚════╝░╚═╝░░╚══╝╚═╝░░░░░╚═╝░╚═════╝░
+#
+[general]
+# whether to show the icons in the tui [True/False]
+# more like emojis
+# by the way if you have any recommendations to which should be used where please
+# don't hesitate to share your opinion
+# cause it's a lot of work to look for the right one for each menu option
+# be sure to also give the replacement emoji
+icons = False
+
+# the quality of the stream [1080,720,480,360]
+# this option is usually only reliable when:
+# provider=animepahe
+# since it provides links that actually point to streams of different qualities
+# while the rest just point to another link that can provide the anime from the same server
+quality = 1080
+
+# whether to normalize provider titles [True/False]
+# basically takes the provider titles and finds the corresponding anilist title then changes the title to that
+# useful for uniformity especially when downloading from different providers
+# this also applies to episode titles
+normalize_titles = True
+
+# can be [allanime, animepahe, hianime]
+# allanime is the most realible
+# animepahe provides different links to streams of different quality so a quality can be selected reliably with --quality option
+# hianime which is now hianime usually provides subs in different languuages and its servers are generally faster
+provider = allanime
+
+# Display language [english, romaji]
+# this is passed to anilist directly and is used to set the language which the anime titles will be in
+# when using the anilist interface
+preferred_language = english
+
+# Download directory
+# where you will find your videos after downloading them with 'fastanime download' command
+downloads_dir = ~/Videos/FastAnime
+
+# whether to show a preview window when using fzf or rofi [True/False]
+# the preview requires you have a commandline image viewer as documented in the README
+# this is only when usinf fzf
+# if you dont care about image previews it doesnt matter
+# though its awesome
+# try it and you will see
+preview = False
+
+# the time to seek when using ffmpegthumbnailer [-1 to 100]
+# -1 means random and is the default
+# ffmpegthumbnailer is used to generate previews and you can select at what time in the video to extract an image
+# random makes things quite exciting cause you never no at what time it will extract the image from
+ffmpegthumbnailer_seek_time = -1
+
+# whether to use fzf as the interface for the anilist command and others. [True/False]
+use_fzf = False
+
+# whether to use rofi for the ui [True/False]
+# it's more useful if you want to create a desktop entry
+# which can be setup with 'fastanime config --desktop-entry'
+# though if you want it to be your sole interface even when fastanime is run directly from the terminal
+use_rofi = False
+
+# rofi themes to use
+# the values of this option is the path to the rofi config files to use
+# i choose to split it into three since it gives the best look and feel
+# you can refer to the rofi demo on github to see for your self
+# by the way i recommend getting the rofi themes from this project;
+rofi_theme =
+
+rofi_theme_input =
+
+rofi_theme_confirm =
+
+# the duration in minutes a notification will stay in the screen
+# used by notifier command
+notification_duration = 2
+
+# used when the provider gives subs of different languages
+# currently its the case for:
+# hianime
+# the values for this option are the short names for countries
+# regex is used to determine what you selected
+sub_lang = eng
+
+
 [stream]
-continue_from_history = True  # Auto continue from watch history
-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
+# Auto continue from watch history [True/False]
+# this will make fastanime to choose the episode that you last watched to completion
+# and increment it by one
+# and use that to auto select the episode you want to watch
+continue_from_history = True
+
+# which history to use [local/remote]
+# local history means it will just use the watch history stored locally in your device
+# the file that stores it is called watch_history.json and is stored next to your config file
+# remote means it ignores the last episode stored locally and instead uses the one in your anilist anime list
+# this config option is useful if you want to overwrite your local history or import history covered from another device or platform
+# since remote history will take precendence over whats available locally
+preferred_history = local
+
+# Preferred language for anime [dub/sub]
+translation_type = sub
+
+# what server to use for a particular provider
+# allanime: [dropbox, sharepoint, wetransfer, gogoanime, wixmp]
+# animepahe: [kwik]
+# hianime: [HD1, HD2, StreamSB, StreamTape]
+# 'top' can also be used as a value for this option
+# 'top' will cause fastanime to auto select the first server it sees
+# this saves on resources and is faster since not all servers are being fetched
+server = top
+
+# Auto select next episode [True/False]
+# this makes fastanime increment the current episode number
+# then after using that value to fetch the next episode instead of prompting
+# this option is useful for binging
+auto_next = False
+
+# Auto select the anime provider results with fuzzy find. [True/False]
+# Note this won't always be correct
+# this is because the providers sometime use non-standard names
+# that are there own preference rather than the official names
+# But 99% of the time will be accurate
+# if this happens just turn of auto_select in the menus or from the commandline and manually select the correct anime title
+# and then please open an issue at <> highlighting the normalized title and the title given by the provider for the anime you wished to watch
+# or even better edit this file <> and open a pull request
+auto_select = True
+
+# whether to skip the opening and ending theme songs [True/False]
+# NOTE: requires ani-skip to be in path
+# for python-mpv users am planning to create this functionality n python without the use of an external script
+# so its disabled for now
+skip = False
+
 # the maximum delta time in minutes after which the episode should be considered as completed
 # used in the continue from time stamp
-error=3
-use_mpv_mod=False
+error = 3
+
+# whether to use python-mpv [True/False]
+# to enable superior control over the player
+# adding more options to it
+# Enable this one and you will be wonder why you did not discover fastanime sooner
+# Since you basically don't have to close the player window to go to the next or previous episode, switch servers, change translation type or
+change to a given episode x
+# so try it if you haven't already
+# if you have any issues setting it up
+# don't be afraid to ask
+# especially on windows
+# honestly it can be a pain to set it up there
+# personally it took me quite sometime to figure it out
+# this is because of how windows handles shared libraries
+# so just ask when you find yourself stuck
+# or just switch to arch linux
+use_python_mpv = False
+
+# force mpv window
+# the default 'immediate' just makes mpv to open the window even if the video has not yet loaded
+# done for asthetics
+# 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=best[height<=1080]/bestvideo[height<=1080]+bestaudio/best # default
+# only works for downloaded anime if:
+# provider=allanime, server=gogoanime
+# provider=allanime, server=wixmp
+# provider=hianime
+# this is because they provider a m3u8 file that contans multiple quality streams
+format = best[height<=1080]/bestvideo[height<=1080]+bestaudio/best
 
-[general]
-# can be [allanime,animepahe]
-provider = allanime
-
-preferred_language = romaji  # Display language (options: english, romaji)
-downloads_dir = <Default-videos-dir>/FastAnime  # Download directory
-preview=false # whether to show a preview window when using fzf or rofi
-
-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>
-
-
-# whether to show the icons
-icons=false
-
-# the duration in minutes a notification will stay in the screen
-# used by notifier command
-notification_duration=2
-
-[anilist]
-# Not implemented yet
+# NOTE:
+# if you have any trouble setting up your config
+# please don't be afraid to ask in our discord
+# plus if there are any errors, improvements or suggestions please tell us in the discord
+# or help us by contributing
+# we appreciate all the help we can get
+# since we may not always have the time to immediately implement the changes
+#
+# HOPE YOU ENJOY FASTANIME AND BE SURE TO STAR THE PROJECT ON GITHUB
+#
 ```
 
 ## Contributing
@@ -499,12 +883,14 @@ We welcome your issues and feature requests. However, due to time constraints, w
 
 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.
 
+If you find an anime title that does not correspond with a provider or is just weird just [edit the data file](https://github.com/Benex254/FastAnime/blob/master/fastanime/Utility/data.py) and open a pr or if you don't want to do that open an issue.
+
 ## Receiving Support
 
-For inquiries, join our [Discord Server](https://discord.gg/4NUTj5Pt).
+For inquiries, join our [Discord Server](https://discord.gg/HBEmAwvbHV).
 
 <p align="center">
-<a href="https://discord.gg/C4rhMA4mmK">
+<a href="https://discord.gg/HBEmAwvbHV">
 <img src="https://invidget.switchblade.xyz/C4rhMA4mmK">
 </a>
 </p>

fastanime/AnimeProvider.py

@@ -1,7 +1,4 @@
-"""An abstraction over all providers offering added features with a simple and well typed api
-
-[TODO:description]
-"""
+"""An abstraction over all providers offering added features with a simple and well typed api"""
 
 import importlib
 import logging
@@ -12,7 +9,6 @@ from .libs.anime_provider import anime_sources
 if TYPE_CHECKING:
     from typing import Iterator
 
-    from .libs.anilist.types import AnilistBaseMediaDataSchema
     from .libs.anime_provider.types import Anime, SearchResults, Server
 
 logger = logging.getLogger(__name__)
@@ -37,12 +33,16 @@ 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}"
+        try:
+            self.anime_provider.session.kill_connection_to_db()
+        except Exception:
+            pass
+        _, 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()
@@ -51,7 +51,6 @@ class AnimeProvider:
         self,
         user_query,
         translation_type,
-        anilist_obj: "AnilistBaseMediaDataSchema | None" = None,
         nsfw=True,
         unknown=True,
     ) -> "SearchResults | None":
@@ -68,19 +67,15 @@ class AnimeProvider:
             [TODO:return]
         """
         anime_provider = self.anime_provider
-        try:
-            results = anime_provider.search_for_anime(
-                user_query, translation_type, nsfw, unknown
-            )
-        except Exception as e:
-            logging.error(e)
-            results = None
+        results = anime_provider.search_for_anime(
+            user_query, translation_type, nsfw, unknown
+        )
+
         return results
 
     def get_anime(
         self,
         anime_id: str,
-        anilist_obj: "AnilistBaseMediaDataSchema | None" = None,
     ) -> "Anime | None":
         """core abstraction over getting info of an anime from all providers
 
@@ -92,19 +87,15 @@ class AnimeProvider:
             [TODO:return]
         """
         anime_provider = self.anime_provider
-        try:
-            results = anime_provider.get_anime(anime_id)
-        except Exception as e:
-            logging.error(e)
-            results = None
+        results = anime_provider.get_anime(anime_id)
+
         return results
 
     def get_episode_streams(
         self,
-        anime,
+        anime_id,
         episode: str,
         translation_type: str,
-        anilist_obj: "AnilistBaseMediaDataSchema|None" = None,
     ) -> "Iterator[Server] | None":
         """core abstractions for getting juicy streams from all providers
 
@@ -118,11 +109,7 @@ class AnimeProvider:
             [TODO:return]
         """
         anime_provider = self.anime_provider
-        try:
-            results = anime_provider.get_episode_streams(
-                anime, episode, translation_type
-            )
-        except Exception as e:
-            logging.error(e)
-            results = None
-        return results  # pyright:ignore
+        results = anime_provider.get_episode_streams(
+            anime_id, episode, translation_type
+        )
+        return results

fastanime/MangaProvider.py

@@ -0,0 +1,105 @@
+"""An abstraction over all providers offering added features with a simple and well typed api
+
+[TODO:description]
+"""
+
+import importlib
+import logging
+from typing import TYPE_CHECKING
+
+from .libs.manga_provider import manga_sources
+
+if TYPE_CHECKING:
+    pass
+
+
+logger = logging.getLogger(__name__)
+
+
+class MangaProvider:
+    """Class that manages all anime sources adding some extra functionality to them.
+    Attributes:
+        PROVIDERS: [TODO:attribute]
+        provider: [TODO:attribute]
+        provider: [TODO:attribute]
+        dynamic: [TODO:attribute]
+        retries: [TODO:attribute]
+        manga_provider: [TODO:attribute]
+    """
+
+    PROVIDERS = list(manga_sources.keys())
+    provider = PROVIDERS[0]
+
+    def __init__(self, provider="mangadex", dynamic=False, retries=0) -> None:
+        self.provider = provider
+        self.dynamic = dynamic
+        self.retries = retries
+        self.lazyload_provider(self.provider)
+
+    def lazyload_provider(self, provider):
+        """updates the current provider being used"""
+        _, anime_provider_cls_name = manga_sources[provider].split(".", 1)
+        package = f"fastanime.libs.manga_provider.{provider}"
+        provider_api = importlib.import_module(".api", package)
+        manga_provider = getattr(provider_api, anime_provider_cls_name)
+        self.manga_provider = manga_provider()
+
+    def search_for_manga(
+        self,
+        user_query,
+        nsfw=True,
+        unknown=True,
+    ):
+        """core abstraction over all providers search functionality
+
+        Args:
+            user_query ([TODO:parameter]): [TODO:description]
+            translation_type ([TODO:parameter]): [TODO:description]
+            nsfw ([TODO:parameter]): [TODO:description]
+            manga_provider ([TODO:parameter]): [TODO:description]
+            anilist_obj: [TODO:description]
+
+        Returns:
+            [TODO:return]
+        """
+        manga_provider = self.manga_provider
+        try:
+            results = manga_provider.search_for_manga(user_query, nsfw, unknown)
+        except Exception as e:
+            logger.error(e)
+            results = None
+        return results
+
+    def get_manga(
+        self,
+        anime_id: str,
+    ):
+        """core abstraction over getting info of an anime from all providers
+
+        Args:
+            anime_id: [TODO:description]
+            anilist_obj: [TODO:description]
+
+        Returns:
+            [TODO:return]
+        """
+        manga_provider = self.manga_provider
+        try:
+            results = manga_provider.get_manga(anime_id)
+        except Exception as e:
+            logger.error(e)
+            results = None
+        return results
+
+    def get_chapter_thumbnails(
+        self,
+        manga_id: str,
+        chapter: str,
+    ):
+        manga_provider = self.manga_provider
+        try:
+            results = manga_provider.get_chapter_thumbnails(manga_id, chapter)
+        except Exception as e:
+            logger.error(e)
+            results = None
+        return results  # pyright:ignore

fastanime/Utility/data.py

@@ -3,12 +3,25 @@ Just contains some useful data used across the codebase
 """
 
 # useful incases where the anilist title is too different from the provider title
-anime_normalizer = {
-    "1P": "one piece",
-    "Magia Record: Mahou Shoujo Madoka☆Magica Gaiden (TV)": "Mahou Shoujo Madoka☆Magica",
-    "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",
+anime_normalizer_raw = {
+    "allanime": {
+        "1P": "one piece",
+        "Magia Record: Mahou Shoujo Madoka☆Magica Gaiden (TV)": "Mahou Shoujo Madoka☆Magica",
+        "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",
+    },
+    "hianime": {"My Star": "Oshi no Ko"},
+    "animepahe": {"Azumanga Daiou The Animation": "Azumanga Daioh"},
+    "nyaa": {},
 }
 
 
-anilist_sort_normalizer = {"search match": "SEARCH_MATCH"}
+def get_anime_normalizer():
+    """Used because there are different providers"""
+    import os
+
+    current_provider = os.environ["FASTANIME_PROVIDER"]
+    return anime_normalizer_raw[current_provider]
+
+
+anime_normalizer = get_anime_normalizer()

fastanime/Utility/downloader/_yt_dlp.py

@@ -0,0 +1,6 @@
+from yt_dlp import YoutubeDL
+
+
+# TODO: create a class that makes yt-dlp's YoutubeDL fit in more with fastanime
+class YtDlp(YoutubeDL):
+    pass

fastanime/Utility/downloader/downloader.py

@@ -1,8 +1,14 @@
 import logging
+import os
+import shutil
+import subprocess
+import tempfile
 from queue import Queue
 from threading import Thread
 
 import yt_dlp
+from rich import print
+from rich.prompt import Confirm
 from yt_dlp.utils import sanitize_filename
 
 logger = logging.getLogger(__name__)
@@ -25,8 +31,6 @@ class YtDLPDownloader:
         self._thread.daemon = True
         self._thread.start()
 
-    # Function to download the file
-    # TODO: untpack the title to its actual values episode_title and anime_title
     def _download_file(
         self,
         url: str,
@@ -35,6 +39,13 @@ class YtDLPDownloader:
         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
 
@@ -48,16 +59,120 @@ class YtDLPDownloader:
         """
         anime_title = sanitize_filename(anime_title)
         episode_title = sanitize_filename(episode_title)
+        if url.endswith(".torrent"):
+            WEBTORRENT_CLI = shutil.which("webtorrent")
+            if not WEBTORRENT_CLI:
+                import time
+
+                print(
+                    "webtorrent cli is not installed which is required for downloading and streaming from nyaa\nplease install it or use another provider"
+                )
+                time.sleep(120)
+                return
+            cmd = [
+                WEBTORRENT_CLI,
+                "download",
+                url,
+                "--out",
+                os.path.join(download_dir, anime_title, episode_title),
+            ]
+            subprocess.run(cmd)
+            return
         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: str = info["requested_downloads"][0]["filepath"]
+                if vid_path.endswith(".unknown_video"):
+                    print("Normalizing path...")
+                    _vid_path = vid_path.replace(".unknown_video", ".mp4")
+                    shutil.move(vid_path, _vid_path)
+                    vid_path = _vid_path
+                    print("successfully normalized path")
 
-        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
-            ydl.download([url])
+            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)
+
+    def merge_subtitles(self, video_path, sub_path, clean, prompt):
+        # Extract the directory and filename
+        video_dir = os.path.dirname(video_path)
+        video_name = os.path.basename(video_path)
+        video_name, _ = os.path.splitext(video_name)
+        video_name += ".mkv"
+
+        FFMPEG_EXECUTABLE = shutil.which("ffmpeg")
+        if not FFMPEG_EXECUTABLE:
+            print("[yellow bold]WARNING: [/]FFmpeg not found")
+            return
+        # Create a temporary directory
+        with tempfile.TemporaryDirectory() as temp_dir:
+            # Temporary output path in the temporary directory
+            temp_output_path = os.path.join(temp_dir, video_name)
+            # FFmpeg command to merge subtitles
+            command = [
+                FFMPEG_EXECUTABLE,
+                "-hide_banner",
+                "-i",
+                video_path,
+                "-i",
+                sub_path,
+                "-c",
+                "copy",
+                "-map",
+                "0",
+                "-map",
+                "1",
+                temp_output_path,
+            ]
+
+            # Run the command
+            try:
+                subprocess.run(command, check=True)
+
+                # Move the file back to the original directory with the original name
+                final_output_path = os.path.join(video_dir, video_name)
+
+                if os.path.exists(final_output_path):
+                    if not prompt or Confirm.ask(
+                        f"File exists({final_output_path}) would you like to overwrite it",
+                        default=True,
+                    ):
+                        # move file to dest
+                        os.remove(final_output_path)
+                        shutil.move(temp_output_path, final_output_path)
+                else:
+                    shutil.move(temp_output_path, final_output_path)
+                # clean up
+                if clean:
+                    print("[cyan]Cleaning original files...[/]")
+                    os.remove(video_path)
+                    os.remove(sub_path)
+
+                print(
+                    f"[green bold]Subtitles merged successfully.[/] Output file: {final_output_path}"
+                )
+            except subprocess.CalledProcessError as e:
+                print(f"[red bold]Error[/] during merging subtitles: {e}")
+            except Exception as e:
+                print(f"[red bold]An error[/] occurred: {e}")
 
     # WARN: May remove this legacy functionality
     def download_file(self, url: str, title, silent=True):

fastanime/Utility/utils.py

@@ -11,6 +11,13 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 
+def sort_by_episode_number(filename: str):
+    import re
+
+    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"
 ) -> float:
@@ -23,10 +30,9 @@ def anime_title_percentage_match(
     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
+    possible_user_requested_anime_title = anime_normalizer.get(
+        possible_user_requested_anime_title, possible_user_requested_anime_title
+    )
     # compares both the romaji and english names and gets highest Score
     title_a = str(anime["title"]["romaji"])
     title_b = str(anime["title"]["english"])

fastanime/__init__.py

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

fastanime/cli/__init__.py

@@ -4,7 +4,6 @@ import click
 
 from .. import __version__
 from ..libs.anime_provider import SERVERS_AVAILABLE, anime_sources
-from ..Utility.data import anilist_sort_normalizer
 from .commands import LazyGroup
 
 commands = {
@@ -16,6 +15,7 @@ commands = {
     "cache": "cache.cache",
     "completions": "completions.completions",
     "update": "update.update",
+    "grab": "grab.grab",
 }
 
 
@@ -38,8 +38,32 @@ signal.signal(signal.SIGINT, handle_exit)
     cls=LazyGroup,
     help="A command line application for streaming anime that provides a complete and featureful interface",
     short_help="Stream Anime",
+    epilog="""
+\b
+\b\bExamples:
+  # example of syncplay intergration
+  fastanime --sync-play --server sharepoint search -t <anime-title>
+\b
+  # --- or ---
+\b
+  # to watch with anilist intergration
+  fastanime --sync-play --server sharepoint anilist
+\b
+  # downloading dubbed anime
+  fastanime --dub download -t <anime>
+\b
+  # use  icons and fzf for a more elegant ui with preview
+  fastanime --icons --preview --fzf anilist
+\b
+  # use icons with default ui
+  fastanime --icons --default anilist
+\b
+  # viewing manga
+  fastanime --manga search -t <manga-title> 
+""",
 )
 @click.version_option(__version__, "--version")
+@click.option("--manga", "-m", help="Enable manga mode", is_flag=True)
 @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)
@@ -68,6 +92,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 +105,14 @@ signal.signal(signal.SIGINT, handle_exit)
 @click.option(
     "-q",
     "--quality",
-    type=click.Choice(["360", "720", "1080", "unknown"]),
+    type=click.Choice(
+        [
+            "360",
+            "480",
+            "720",
+            "1080",
+        ]
+    ),
     help="set the quality of the stream",
 )
 @click.option(
@@ -85,6 +121,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 +139,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")
@@ -127,11 +168,19 @@ signal.signal(signal.SIGINT, handle_exit)
     type=click.Path(),
 )
 @click.option(
-    "--use-mpv-mod/--use-default-player", help="Whether to use python-mpv", type=bool
+    "--use-python-mpv/--use-default-player", help="Whether to use python-mpv", type=bool
+)
+@click.option("--sync-play", "-sp", help="Use sync play", is_flag=True)
+@click.option(
+    "--player",
+    "-P",
+    help="the player to use when streaming",
+    type=click.Choice(["mpv", "vlc"]),
 )
 @click.pass_context
 def run_cli(
     ctx: click.Context,
+    manga,
     log,
     log_file,
     rich_traceback,
@@ -139,12 +188,14 @@ def run_cli(
     server,
     format,
     continue_,
+    local_history,
     skip,
     translation_type,
+    sub_lang,
     quality,
     auto_next,
     auto_select,
-    sort_by,
+    normalize_titles,
     downloads_dir,
     fzf,
     default,
@@ -157,11 +208,14 @@ def run_cli(
     rofi_theme,
     rofi_theme_confirm,
     rofi_theme_input,
-    use_mpv_mod,
+    use_python_mpv,
+    sync_play,
+    player,
 ):
     from .config import Config
 
     ctx.obj = Config()
+    ctx.obj.manga = manga
     if log:
         import logging
 
@@ -170,38 +224,53 @@ 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 sync_play:
+        ctx.obj.sync_play = sync_play
     if provider:
         ctx.obj.provider = provider
     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("player") == click.core.ParameterSource.COMMANDLINE:
+        ctx.obj.player = player
     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
@@ -209,26 +278,30 @@ 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 (
-        ctx.get_parameter_source("use_mpv_mod")
+        ctx.get_parameter_source("use_python_mpv")
         == click.core.ParameterSource.COMMANDLINE
     ):
-        ctx.obj.use_mpv_mod = use_mpv_mod
-    if sort_by:
-        ctx.obj.sort_by = sort_by
+        ctx.obj.use_python_mpv = use_python_mpv
     if downloads_dir:
         ctx.obj.downloads_dir = downloads_dir
     if translation_type:
         ctx.obj.translation_type = translation_type
-    if fzf:
-        ctx.obj.use_fzf = True
     if default:
         ctx.obj.use_fzf = False
+        ctx.obj.use_rofi = False
+    if fzf:
+        ctx.obj.use_fzf = True
     if preview:
         ctx.obj.preview = True
     if no_preview:
@@ -254,3 +327,4 @@ def run_cli(
         if rofi_theme_confirm:
             ctx.obj.rofi_theme_confirm = rofi_theme_confirm
             Rofi.rofi_theme_confirm = rofi_theme_confirm
+    ctx.obj.set_fastanime_config_environs()

fastanime/cli/app_updater.py

@@ -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, {})
@@ -95,6 +112,7 @@ def update_app():
                 "pip",
                 "install",
                 APP_NAME,
+                "-U",
                 "--user",
                 "--no-warn-script-location",
             ]

fastanime/cli/commands/anilist/__init__.py

@@ -20,6 +20,7 @@ commands = {
     "completed": "completed.completed",
     "planning": "planning.planning",
     "notifier": "notifier.notifier",
+    "stats": "stats.stats",
 }
 
 
@@ -29,6 +30,53 @@ commands = {
     invoke_without_command=True,
     help="A beautiful interface that gives you access to a commplete streaming experience",
     short_help="Access all streaming options",
+    epilog="""
+\b
+\b\bExamples:
+  # ---- search ----  
+\b
+  # get anime with the tag of isekai
+  fastanime anilist search -T isekai
+\b
+  # get anime of 2024 and sort by popularity
+  # that has already finished airing or is releasing
+  # and is not in your anime lists
+  fastanime anilist search -y 2024 -s POPULARITY_DESC --status RELEASING --status FINISHED --not-on-list
+\b
+  # get anime of 2024 season WINTER
+  fastanime anilist search -y 2024 --season WINTER
+\b
+  # get anime genre action and tag isekai,magic
+  fastanime anilist search -g Action -T Isekai -T Magic
+\b
+  # get anime of 2024 thats finished airing
+  fastanime anilist search -y 2024 -S FINISHED
+\b
+  # get the most favourite anime movies
+  fastanime anilist search -f MOVIE -s FAVOURITES_DESC
+\b
+  # ---- login ----
+\b
+  # To sign in just run 
+  fastanime anilist login
+\b
+  # To view your login status 
+  fastanime anilist login --status
+\b
+  # To erase login data
+  fastanime anilist login --erase
+\b
+  # ---- notifier ----  
+\b
+  # basic form
+  fastanime anilist notifier
+\b
+  # with logging to stdout
+  fastanime --log anilist notifier
+\b
+  # with logging to a file. stored in the same place as your config
+  fastanime --log-file anilist notifier
+""",
 )
 @click.pass_context
 def anilist(ctx: click.Context):

fastanime/cli/commands/anilist/completed.py

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

fastanime/cli/commands/anilist/dropped.py

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

fastanime/cli/commands/anilist/favourites.py

@@ -5,14 +5,30 @@ import click
     help="Fetch the top 15 most favourited anime from anilist",
     short_help="View most favourited anime",
 )
+@click.option(
+    "--dump-json",
+    "-d",
+    is_flag=True,
+    help="Only print out the results dont open anilist menu",
+)
 @click.pass_obj
-def favourites(config):
+def favourites(config, dump_json):
     from ....anilist import AniList
-    from ...interfaces.anilist_interfaces import anilist_results_menu
-    from ...utils.tools import FastAnimeRuntimeState
 
     anime_data = AniList.get_most_favourite()
     if anime_data[0]:
-        fastanime_runtime_state = FastAnimeRuntimeState()
-        fastanime_runtime_state.anilist_data = anime_data[1]
-        anilist_results_menu(config, fastanime_runtime_state)
+        if dump_json:
+            import json
+
+            print(json.dumps(anime_data[1]))
+        else:
+            from ...interfaces.anilist_interfaces import anilist_results_menu
+            from ...utils.tools import FastAnimeRuntimeState
+
+            fastanime_runtime_state = FastAnimeRuntimeState()
+            fastanime_runtime_state.anilist_results_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,9 +13,15 @@ def notifier(config: "Config"):
     import logging
     import os
     import time
+    from sys import exit
 
     import requests
-    from plyer import notification
+
+    try:
+        from plyer import notification
+    except ImportError:
+        print("Please install plyer to use this command")
+        exit(1)
 
     from ....anilist import AniList
     from ....constants import APP_CACHE_DIR, APP_DATA_DIR, APP_NAME, ICON_PATH, PLATFORM
@@ -30,7 +36,7 @@ def notifier(config: "Config"):
     if not config.user:
         print("Not Authenticated")
         print("Run the following to get started: fastanime anilist loggin")
-        return
+        exit(1)
     run = True
     # WARNING: Mess around with this value at your own risk
     timeout = 2  # time is in minutes

fastanime/cli/commands/anilist/paused.py

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

fastanime/cli/commands/anilist/planning.py

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

fastanime/cli/commands/anilist/popular.py

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

fastanime/cli/commands/anilist/random_anime.py

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

fastanime/cli/commands/anilist/recent.py

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

fastanime/cli/commands/anilist/rewatching.py

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

fastanime/cli/commands/anilist/scores.py

@@ -4,14 +4,30 @@ import click
 @click.command(
     help="Fetch the 15 most scored anime", short_help="View most scored anime"
 )
+@click.option(
+    "--dump-json",
+    "-d",
+    is_flag=True,
+    help="Only print out the results dont open anilist menu",
+)
 @click.pass_obj
-def scores(config):
+def scores(config, dump_json):
     from ....anilist import AniList
-    from ...interfaces.anilist_interfaces import anilist_results_menu
-    from ...utils.tools import FastAnimeRuntimeState
 
     anime_data = AniList.get_most_scored()
     if anime_data[0]:
-        fastanime_runtime_state = FastAnimeRuntimeState()
-        fastanime_runtime_state.data = anime_data[1]
-        anilist_results_menu(config, fastanime_runtime_state)
+        if dump_json:
+            import json
+
+            print(json.dumps(anime_data[1]))
+        else:
+            from ...interfaces.anilist_interfaces import anilist_results_menu
+            from ...utils.tools import FastAnimeRuntimeState
+
+            fastanime_runtime_state = FastAnimeRuntimeState()
+            fastanime_runtime_state.anilist_results_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,574 @@
 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",
+    multiple=True,
+    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(
+        [
+            "1900",
+            "1910",
+            "1920",
+            "1930",
+            "1940",
+            "1950",
+            "1960",
+            "1970",
+            "1980",
+            "1990",
+            "2000",
+            "2004",
+            "2005",
+            "2006",
+            "2007",
+            "2008",
+            "2009",
+            "2010",
+            "2011",
+            "2012",
+            "2013",
+            "2014",
+            "2015",
+            "2016",
+            "2017",
+            "2018",
+            "2019",
+            "2020",
+            "2021",
+            "2022",
+            "2023",
+            "2024",
+        ]
+    ),
+    help="the year the media was released",
+)
+@click.option(
+    "--on-list/--not-on-list",
+    "-L/-no-L",
+    help="Whether the anime should be in your list or not",
+    type=bool,
 )
 @click.pass_obj
-def search(config, title):
+def search(
+    config,
+    title,
+    dump_json,
+    season,
+    status,
+    sort,
+    genres,
+    tags,
+    media_format,
+    year,
+    on_list,
+):
     from ....anilist import AniList
-    from ...interfaces.anilist_interfaces import anilist_results_menu
-    from ...utils.tools import FastAnimeRuntimeState
 
-    success, search_results = AniList.search(title)
+    success, search_results = AniList.search(
+        query=title,
+        sort=sort,
+        status_in=list(status),
+        genre_in=list(genres),
+        season=season,
+        tag_in=list(tags),
+        seasonYear=year,
+        format_in=list(media_format),
+        on_list=on_list,
+    )
     if success:
-        fastanime_runtime_state = FastAnimeRuntimeState()
-        fastanime_runtime_state.anilist_data = search_results
-        anilist_results_menu(config, fastanime_runtime_state)
+        if dump_json:
+            import json
+
+            print(json.dumps(search_results))
+        else:
+            from ...interfaces.anilist_interfaces import anilist_results_menu
+            from ...utils.tools import FastAnimeRuntimeState
+
+            fastanime_runtime_state = FastAnimeRuntimeState()
+            fastanime_runtime_state.anilist_results_data = search_results
+            anilist_results_menu(config, fastanime_runtime_state)
+    else:
+        from sys import exit
+
+        exit(1)

fastanime/cli/commands/anilist/stats.py

@@ -0,0 +1,63 @@
+from typing import TYPE_CHECKING
+
+import click
+
+if TYPE_CHECKING:
+    from ...config import Config
+
+
+@click.command(help="Print out your anilist stats")
+@click.pass_obj
+def stats(
+    config: "Config",
+):
+    import shutil
+    import subprocess
+    from sys import exit
+
+    from rich.console import Console
+
+    console = Console()
+    from rich.markdown import Markdown
+    from rich.panel import Panel
+
+    from ....anilist import AniList
+
+    user_data = AniList.get_user_info()
+    if not user_data[0] or not user_data[1]:
+        print("Failed to get user info")
+        print(user_data[1])
+        exit(1)
+
+    KITTEN_EXECUTABLE = shutil.which("kitten")
+    if not KITTEN_EXECUTABLE:
+        print("Kitten not found")
+        exit(1)
+
+    image_url = user_data[1]["data"]["User"]["avatar"]["medium"]
+    user_name = user_data[1]["data"]["User"]["name"]
+    about = user_data[1]["data"]["User"]["about"] or ""
+    console.clear()
+    image_x = int(console.size.width * 0.1)
+    image_y = int(console.size.height * 0.1)
+    img_w = console.size.width // 3
+    img_h = console.size.height // 3
+    image_process = subprocess.run(
+        [
+            KITTEN_EXECUTABLE,
+            "icat",
+            "--clear",
+            "--place",
+            f"{img_w}x{img_h}@{image_x}x{image_y}",
+            image_url,
+        ],
+    )
+    if not image_process.returncode == 0:
+        print("failed to get image from icat")
+        exit(1)
+    console.print(
+        Panel(
+            Markdown(about),
+            title=user_name,
+        )
+    )

fastanime/cli/commands/anilist/trending.py

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

fastanime/cli/commands/anilist/upcoming.py

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

fastanime/cli/commands/anilist/watching.py

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

fastanime/cli/commands/cache.py

@@ -1,7 +1,24 @@
 import click
 
 
-@click.command(help="Helper command to manage cache")
+@click.command(
+    help="Helper command to manage cache",
+    epilog="""
+\b
+\b\bExamples:
+  # delete everything in the cache dir
+  fastanime cache --clean
+\b
+  # print the path to the cache dir and exit
+  fastanime cache --path
+\b
+  # print the current size of the cache dir and exit
+  fastanime cache --size
+\b
+  # open the cache dir and exit
+  fastanime cache
+""",
+)
 @click.option("--clean", help="Clean the cache dir", is_flag=True)
 @click.option("--path", help="The path to the cache dir", is_flag=True)
 @click.option("--size", help="The size of the cache dir", is_flag=True)

fastanime/cli/commands/completions.py

@@ -1,7 +1,24 @@
 import click
 
 
-@click.command(help="Helper command to get shell completions")
+@click.command(
+    help="Helper command to get shell completions",
+    epilog="""
+\b
+\b\bExamples:
+    # try to detect your shell and print completions
+    fastanime completions
+\b
+    # print fish completions
+    fastanime completions --fish
+\b
+    # print bash completions
+    fastanime completions --bash
+\b
+    # print zsh completions
+    fastanime completions --zsh
+""",
+)
 @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")

fastanime/cli/commands/config.py

@@ -7,8 +7,27 @@ if TYPE_CHECKING:
 
 
 @click.command(
-    help="Opens up your fastanime config in your preferred editor",
+    help="Manage your config with ease",
     short_help="Edit your config",
+    epilog="""
+\b
+\b\bExamples:
+  # Edit your config in your default editor 
+  # NB: If it opens vim or vi exit with `:q`
+  fastanime config
+\b
+  # get the path of the config file
+  fastanime config --path
+\b
+  # print desktop entry info
+  fastanime config --desktop-entry
+\b
+  # update your config without opening an editor
+  fastanime --icons --fzf --preview config --update
+\b 
+  # view the current contents of your config
+  fastanime config --view
+""",
 )
 @click.option("--path", "-p", help="Print the config location and exit", is_flag=True)
 @click.option(
@@ -20,37 +39,82 @@ if TYPE_CHECKING:
     help="Configure the desktop entry of fastanime",
     is_flag=True,
 )
+@click.option(
+    "--update",
+    "-u",
+    help="Persist all the config options passed to fastanime to your config file",
+    is_flag=True,
+)
 @click.pass_obj
-def config(config: "Config", path, view, desktop_entry):
-    from pyshortcuts import make_shortcut
+def config(user_config: "Config", path, view, desktop_entry, update):
+    import sys
+
     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)
+        print(user_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)
-        else:
-            print("Failed")
-    else:
-        import click
+            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:
+            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)
+    elif update:
+        with open(USER_CONFIG_PATH, "w", encoding="utf-8") as file:
+            file.write(user_config.__str__())
+        print("update successfull")
+    else:
         click.edit(filename=USER_CONFIG_PATH)

fastanime/cli/commands/download.py

@@ -1,8 +1,9 @@
-import time
 from typing import TYPE_CHECKING
 
 import click
 
+from ..completion_functions import anime_titles_shell_complete
+
 if TYPE_CHECKING:
     from ..config import Config
 
@@ -10,25 +11,125 @@ if TYPE_CHECKING:
 @click.command(
     help="Download anime using the anime provider for a specified range",
     short_help="Download anime",
+    epilog="""
+\b
+\b\bExamples:
+  # Download all available episodes
+  # 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 ':'
+\b
+  # 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'
+\b
+  # latest 5
+  fastanime download -t <anime-title> -t <anime-title> -r '-5'
+\b
+  # Download specific episode range
+  # be sure to observe the range Syntax
+  fastanime download -t <anime-title> -r '<episodes-start>:<episodes-end>:<step>'
+\b
+  fastanime download -t <anime-title> -r '<episodes-start>:<episodes-end>'
+\b
+  fastanime download -t <anime-title> -r '<episodes-start>:'
+\b
+  fastanime download -t <anime-title> -r ':<episodes-end>'
+\b
+  # download specific episode
+  # remember python indexing starts at 0
+  fastanime download -t <anime-title> -r '<episode-1>:<episode>'
+\b
+  # merge subtitles with ffmpeg to mkv format; hianime 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
+\b
+  # 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 -
+\b
+  # from file
+  fastanime download -t "EOF" -r <range> -f <file-path>
+""",
 )
-@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
@@ -36,126 +137,243 @@ def download(config: "Config", anime_title, episode_range, highest_priority):
     from ...AnimeProvider import AnimeProvider
     from ...libs.anime_provider.types import Anime
     from ...libs.fzf import fzf
+    from ...Utility.data import anime_normalizer
     from ...Utility.downloader.downloader import downloader
     from ..utils.tools import exit_app
-    from ..utils.utils import filter_by_quality, fuzzy_inquirer
+    from ..utils.utils import (
+        filter_by_quality,
+        fuzzy_inquirer,
+        move_preferred_subtitle_lang_to_top,
+    )
 
     anime_provider = AnimeProvider(config.provider)
+    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")
+        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
+            )
+        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(
+                    anime_normalizer.get(title, title), anime_title
+                ),
+            )
+            print("[cyan]Auto selecting:[/] ", selected_anime_title)
         else:
-            search_result = 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_[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
+            choices = list(search_results_.keys())
+            if config.use_fzf:
+                selected_anime_title = fzf.run(
+                    choices, "Please Select title", "FastAnime"
                 )
-                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 = next(streams)
-                stream_link = filter_by_quality(config.quality, server["links"])
-                if not stream_link:
-                    print("Quality not found")
-                    input("Enter to continue")
-                    continue
-                link = stream_link["link"]
-                episode_title = server["episode_title"]
             else:
-                with Progress() as progress:
-                    progress.add_task("Fetching servers", total=None)
-                    # prompt for server selection
-                    servers = {server["server"]: server for server in streams}
-                servers_names = list(servers.keys())
-                if config.use_fzf:
-                    server = fzf.run(servers_names, "Select an link: ")
-                else:
-                    server = fuzzy_inquirer(
-                        servers_names,
-                        "Select link",
-                    )
-                stream_link = filter_by_quality(
-                    config.quality, servers[server]["links"]
+                selected_anime_title = fuzzy_inquirer(
+                    choices,
+                    "Please Select title",
                 )
-                if not stream_link:
-                    print("Quality not found")
-                    continue
-                link = stream_link["link"]
 
-                episode_title = servers[server]["episode_title"]
-            print(f"[purple]Now Downloading:[/] {search_result} Episode {episode}")
-
-            downloader._download_file(
-                link,
-                anime["title"],
-                episode_title,
-                download_dir,
-                True,
-                config.format,
+        # ---- 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"]
             )
-        except Exception as e:
-            print(e)
-            time.sleep(1)
-            print("Continuing")
-            clear()
+        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["id"], 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,25 +1,73 @@
+import logging
 from typing import TYPE_CHECKING
 
 import click
 
+from ..completion_functions import downloaded_anime_titles
+
+logger = logging.getLogger(__name__)
 if TYPE_CHECKING:
     from ..config import Config
 
 
 @click.command(
-    help="View and watch your downloads using mpv", short_help="Watch downloads"
+    help="View and watch your downloads using mpv",
+    short_help="Watch downloads",
+    epilog="""
+\b
+\b\bExamples:
+    fastanime downloads
+\b
+    # view individual episodes
+    fastanime downloads --view-episodes
+    # --- or ---
+    fastanime downloads -v
+\b
+    # 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)>
+\b
+    # to watch a specific title
+    # be sure to get the completions for the best experience
+    fastanime downloads --title <title>
+\b
+    # to get the path to the downloads folder set
+    fastanime downloads --path
+    # useful when you want to use the value for other programs
+""",
 )
 @click.option("--path", "-p", help="print the downloads folder and exit", is_flag=True)
+@click.option(
+    "--title",
+    "-T",
+    shell_complete=downloaded_anime_titles,
+    help="watch a specific title",
+)
+@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",
+)
 @click.pass_obj
-def downloads(config: "Config", path: bool):
+def downloads(
+    config: "Config", path: bool, title, 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,24 +75,284 @@ 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")
+    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:
+            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,
+                    player=config.player,
+                )
+            stream_episode(anime_playlist_path)
+
+    def stream_anime(title=None):
+        if title:
+            from thefuzz import fuzz
+
+            playlist_name = max(anime_downloads, key=lambda t: fuzz.ratio(title, t))
+        elif 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(playlists, "Enter Playlist Name")
+            playlist_name = Rofi.run(anime_downloads, "Enter Playlist Name")
         else:
             playlist_name = fuzzy_inquirer(
-                playlists,
-                "Enter Playlist Name: ",
+                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,
+                    player=config.player,
+                )
+        stream_anime()
+
+    stream_anime(title)

fastanime/cli/commands/grab.py

@@ -0,0 +1,243 @@
+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",
+    epilog="""
+\b
+\b\bExamples:
+  # --- print anime info + episode streams ---
+\b
+  # 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 ':'
+\b
+  # print the latest episode
+  fastanime grab -t <anime-title> -r '-1'
+\b
+  # print a specific episode range
+  # be sure to observe the range Syntax
+  fastanime grab -t <anime-title> -r '<start>:<stop>'
+\b
+  fastanime grab -t <anime-title> -r '<start>:<stop>:<step>'
+\b
+  fastanime grab -t <anime-title> -r '<start>:'
+\b
+  fastanime grab -t <anime-title> -r ':<end>'
+\b
+  # --- grab options ---
+\b
+  # print search results only
+  fastanime grab -t <anime-title> -r <range> --search-results-only
+\b
+  # print anime info only
+  fastanime grab -t <anime-title> -r <range> --anime-info-only
+\b
+  # print episode streams only
+  fastanime grab -t <anime-title> -r <range> --episode-streams-only
+""",
+)
+@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
+
+    logger = getLogger(__name__)
+    if config.manga:
+        manga_title = anime_titles[0]
+        from ...MangaProvider import MangaProvider
+
+        manga_provider = MangaProvider()
+        search_data = manga_provider.search_for_manga(manga_title)
+        if not search_data:
+            exit(1)
+        if search_results_only:
+            print(json.dumps(search_data))
+            exit(0)
+        search_results = search_data["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_anime_title = max(
+            search_results_.keys(), key=lambda title: fuzz.ratio(title, anime_titles[0])
+        )
+        manga_info = manga_provider.get_manga(
+            search_results_[search_result_anime_title]["id"]
+        )
+        if not manga_info:
+            return
+        if anime_info_only:
+            print(json.dumps(manga_info))
+            exit(0)
+
+        chapter_info = manga_provider.get_chapter_thumbnails(
+            manga_info["id"], str(episode_range)
+        )
+        if not chapter_info:
+            exit(1)
+        print(json.dumps(chapter_info))
+
+    else:
+        from ...AnimeProvider import AnimeProvider
+
+        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_anime_title = max(
+                search_results_.keys(), key=lambda title: fuzz.ratio(title, anime_title)
+            )
+
+            # ---- fetch anime ----
+            anime = anime_provider.get_anime(
+                search_results_[search_result_anime_title]["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["id"], 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,175 +1,385 @@
+from typing import TYPE_CHECKING
+
 import click
 
-from ...cli.config import Config
+from ..completion_functions import anime_titles_shell_complete
+
+if TYPE_CHECKING:
+    from ...cli.config import Config
 
 
 @click.command(
     help="This subcommand directly interacts with the provider to enable basic streaming. Useful for binging anime.",
     short_help="Binge anime",
+    epilog="""
+\b
+\b\bExamples:
+  # 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>
+\b
+  # binge all episodes with this command
+  fastanime search -t <anime-title> -r ':'
+\b
+  # watch latest episode
+  fastanime search -t <anime-title> -r '-1'
+\b
+  # binge a specific episode range with this command
+  # be sure to observe the range Syntax
+  fastanime search -t <anime-title> -r '<start>:<stop>'
+\b
+  fastanime search -t <anime-title> -r '<start>:<stop>:<step>'
+\b
+  fastanime search -t <anime-title> -r '<start>:'
+\b
+  fastanime search -t <anime-title> -r ':<end>'
+""",
+)
+@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
     from thefuzz import fuzz
 
-    from ...AnimeProvider import AnimeProvider
-    from ...libs.anime_provider.types import Anime
     from ...libs.fzf import fzf
     from ...libs.rofi import Rofi
-    from ..utils.mpv import run_mpv
     from ..utils.tools import exit_app
-    from ..utils.utils import filter_by_quality, fuzzy_inquirer
+    from ..utils.utils import fuzzy_inquirer
 
-    anime_provider = AnimeProvider(config.provider)
+    if config.manga:
+        from InquirerPy.prompts.number import NumberPrompt
+        from yt_dlp.utils import sanitize_filename
 
-    # ---- 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
-    }
+        from ...MangaProvider import MangaProvider
+        from ..utils.feh import feh_manga_viewer
 
-    if config.auto_select:
-        search_result = max(
-            search_results_.keys(), key=lambda title: fuzz.ratio(title, anime_title)
-        )
-        print("[cyan]Auto Selecting:[/] ", search_result)
+        manga_title = anime_titles[0]
 
-    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",
+        manga_provider = MangaProvider()
+        search_data = manga_provider.search_for_manga(manga_title)
+        if not search_data:
+            print("No search results")
+            exit(1)
+
+        search_results = search_data["results"]
+
+        search_results_ = {
+            sanitize_filename(search_result["title"]): search_result
+            for search_result in search_results
+        }
+
+        if config.auto_select:
+            search_result_manga_title = max(
+                search_results_.keys(),
+                key=lambda title: fuzz.ratio(title, manga_title),
             )
+            print("[cyan]Auto Selecting:[/] ", search_result_manga_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
-    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))
+            choices = list(search_results_.keys())
+            preview = None
+            if config.preview:
+                from ..interfaces.utils import get_fzf_manga_preview
 
-    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:")
-                input("Enter to continue...")
-
-        if not episode or episode not in episodes:
+                preview = get_fzf_manga_preview(search_results)
             if config.use_fzf:
-                episode = fzf.run(episodes, "Select an episode: ", header=search_result)
+                search_result_manga_title = fzf.run(
+                    choices, "Please Select title", preview=preview
+                )
             elif config.use_rofi:
-                episode = Rofi.run(episodes, "Select an episode")
+                search_result_manga_title = Rofi.run(choices, "Please Select Title")
             else:
-                episode = fuzzy_inquirer(
-                    episodes,
-                    "Select episode",
+                search_result_manga_title = fuzzy_inquirer(
+                    choices,
+                    "Please Select Title",
                 )
 
-        # ---- 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
+        anilist_id = search_results_[search_result_manga_title]["id"]
+        manga_info = manga_provider.get_manga(anilist_id)
+        if not manga_info:
+            print("No manga info")
+            exit(1)
+
+        anilist_helper = None
+        if config.user:
+            from ...anilist import AniList
+
+            AniList.login_user(config.user["token"])
+            anilist_helper = AniList
+
+        def _manga_viewer():
+            chapter_number = NumberPrompt("Select a chapter number").execute()
+            chapter_info = manga_provider.get_chapter_thumbnails(
+                manga_info["id"], str(chapter_number)
             )
-            if not streams:
-                print("Failed to get streams")
+
+            if not chapter_info:
+                print("No chapter info")
+                input("Enter to retry...")
+                _manga_viewer()
                 return
-
-        try:
-            # ---- fetch servers ----
-            if config.server == "top":
-                with Progress() as progress:
-                    progress.add_task("Fetching top server...", total=None)
-                    server = next(streams)
-                stream_link = filter_by_quality(config.quality, server["links"])
-                if not stream_link:
-                    print("Quality not found")
-                    input("Enter to continue")
-                    stream_anime()
-                    return
-                link = stream_link["link"]
-                episode_title = server["episode_title"]
-            else:
-                with Progress() as progress:
-                    progress.add_task("Fetching servers", total=None)
-                    # prompt for server selection
-                    servers = {server["server"]: server for server in streams}
-                servers_names = list(servers.keys())
-                if config.use_fzf:
-                    server = fzf.run(servers_names, "Select an link: ")
-                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"]
+            print(
+                f"[purple bold]Now Reading: [/] {search_result_manga_title} [cyan bold]Chapter:[/] {chapter_info['title']}"
+            )
+            feh_manga_viewer(chapter_info["thumbnails"], str(chapter_info["title"]))
+            if anilist_helper:
+                anilist_helper.update_anime_list(
+                    {"mediaId": anilist_id, "progress": chapter_number}
                 )
-                if not stream_link:
-                    print("Quality not found")
-                    input("Enter to continue")
-                    stream_anime()
+            _manga_viewer()
+
+        _manga_viewer()
+    else:
+        from ...AnimeProvider import AnimeProvider
+        from ...libs.anime_provider.types import Anime
+        from ...Utility.data import anime_normalizer
+        from ..utils.mpv import run_mpv
+        from ..utils.utils import filter_by_quality, move_preferred_subtitle_lang_to_top
+
+        anime_provider = AnimeProvider(config.provider)
+        anilist_anime_info = None
+
+        print(f"[green bold]Streaming:[/] {anime_titles}")
+        for anime_title in anime_titles:
+            # ---- 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_manga_title = max(
+                    search_results_.keys(),
+                    key=lambda title: fuzz.ratio(
+                        anime_normalizer.get(title, title), anime_title
+                    ),
+                )
+                print("[cyan]Auto Selecting:[/] ", search_result_manga_title)
+
+            else:
+                choices = list(search_results_.keys())
+                if config.use_fzf:
+                    search_result_manga_title = fzf.run(
+                        choices, "Please Select title", "FastAnime"
+                    )
+                elif config.use_rofi:
+                    search_result_manga_title = Rofi.run(choices, "Please Select Title")
+                else:
+                    search_result_manga_title = 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_manga_title]["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(anime: "Anime"):
+                clear()
+                episode = None
+
+                if episodes_range:
+                    try:
+                        episode = next(episodes_range)  # pyright:ignore
+                        print(
+                            f"[cyan]Auto selecting:[/] {search_result_manga_title} [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_manga_title,
+                        )
+                    elif config.use_rofi:
+                        episode = Rofi.run(choices, "Select an episode")
+                    else:
+                        episode = fuzzy_inquirer(
+                            choices,
+                            "Select episode",
+                        )
+                if episode == "end":
                     return
-                link = stream_link["link"]
-                episode_title = servers[server]["episode_title"]
-            print(f"[purple]Now Playing:[/] {search_result} Episode {episode}")
 
-            run_mpv(link, episode_title)
-        except Exception as e:
-            print(e)
-            input("Enter to continue")
-        stream_anime()
+                # ---- fetch streams ----
+                with Progress() as progress:
+                    progress.add_task("Fetching Episode Streams...", total=None)
+                    streams = anime_provider.get_episode_streams(
+                        anime["id"], episode, config.translation_type
+                    )
+                    if not streams:
+                        print("Failed to get streams")
+                        return
 
-    stream_anime()
+                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(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(anime)
+                            return
+                        link = stream_link["link"]
+                        subtitles = server["subtitles"]
+                        stream_headers = server["headers"]
+                        episode_title = server["episode_title"]
+                    else:
+                        with Progress() as progress:
+                            progress.add_task("Fetching servers", total=None)
+                            # prompt for server selection
+                            servers = {server["server"]: server for server in streams}
+                        servers_names = list(servers.keys())
+                        if config.server in servers_names:
+                            server = config.server
+                        else:
+                            if config.use_fzf:
+                                server = fzf.run(servers_names, "Select an link")
+                            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(anime)
+                            return
+                        link = stream_link["link"]
+                        stream_headers = servers[server]["headers"]
+                        subtitles = servers[server]["subtitles"]
+                        episode_title = servers[server]["episode_title"]
+
+                    selected_anime_title = search_result_manga_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 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,
+                            player=config.player,
+                        )
+                except IndexError as e:
+                    print(e)
+                    input("Enter to continue")
+                stream_anime(anime)
+
+            stream_anime(anime)

fastanime/cli/commands/update.py

@@ -1,7 +1,18 @@
 import click
 
 
-@click.command(help="Helper command to update fastanime to latest")
+@click.command(
+    help="Helper command to update fastanime to latest",
+    epilog="""
+\b
+\b\bExamples:
+  # update fastanime to latest
+  fastanime update
+\b
+  # check for latest release
+  fastanime update --check
+""",
+)
 @click.option("--check", "-c", help="Check for the latest release", is_flag=True)
 def update(
     check,
@@ -9,6 +20,7 @@ def update(
     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):
@@ -23,15 +35,19 @@ def update(
         console.print(body)
 
     if check:
-        is_update, github_release_data = check_for_updates()
-        if is_update:
+        is_latest, github_release_data = check_for_updates()
+        if not is_latest:
             print(
-                "You are running an older version of fastanime please update to get the latest features"
+                f"You are running an older version ({__version__}) of fastanime please update to get the latest features"
             )
             _print_release(github_release_data)
         else:
-            print("You are running the latest version of fastanime")
+            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,95 @@
+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 downloaded_anime_titles(ctx, param, incomplete):
+    import os
+
+    from ..constants import USER_VIDEOS_DIR
+
+    try:
+        titles = [
+            title
+            for title in os.listdir(USER_VIDEOS_DIR)
+            if title.lower().startswith(incomplete.lower()) or not incomplete
+        ]
+        return titles
+    except Exception:
+        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

@@ -4,9 +4,12 @@ import os
 from configparser import ConfigParser
 from typing import TYPE_CHECKING
 
-from rich import print
-
-from ..constants import USER_CONFIG_PATH, USER_DATA_PATH, USER_VIDEOS_DIR
+from ..constants import (
+    USER_CONFIG_PATH,
+    USER_DATA_PATH,
+    USER_VIDEOS_DIR,
+    USER_WATCH_HISTORY_PATH,
+)
 from ..libs.rofi import Rofi
 
 logger = logging.getLogger(__name__)
@@ -15,97 +18,65 @@ if TYPE_CHECKING:
 
 
 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]
-    """
-
+    manga = False
+    sync_play = False
     anime_list: list
-    watch_history: dict
+    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": {}}
+    default_config = {
+        "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_python_mpv": "false",
+        "force_window": "immediate",
+        "preferred_language": "english",
+        "use_fzf": "False",
+        "preview": "False",
+        "format": "best[height<=1080]/bestvideo[height<=1080]+bestaudio/best",
+        "provider": "allanime",
+        "icons": "false",
+        "notification_duration": "2",
+        "skip": "false",
+        "use_rofi": "false",
+        "rofi_theme": "",
+        "rofi_theme_input": "",
+        "rofi_theme_confirm": "",
+        "ffmpegthumbnailer_seek_time": "-1",
+        "sub_lang": "eng",
+        "normalize_titles": "true",
+        "player": "mpv",
+        "episode_complete_at": "80",
+        "force_forward_tracking": "true",
+        "default_media_list_tracking": "None",
+        "cache_requests": "true",
+    }
 
     def __init__(self) -> None:
-        self.initialize_user_data()
+        self.initialize_user_data_and_watch_history()
         self.load_config()
 
     def load_config(self):
-        self.configparser = ConfigParser(
-            {
-                "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",
-                "use_mpv_mod": "false",
-                "force_window": "immediate",
-                "preferred_language": "english",
-                "use_fzf": "False",
-                "preview": "False",
-                "format": "best[height<=1080]/bestvideo[height<=1080]+bestaudio/best",
-                "provider": "allanime",
-                "error": "3",
-                "icons": "false",
-                "notification_duration": "2",
-                "skip": "false",
-                "use_rofi": "false",
-                "rofi_theme": "",
-                "rofi_theme_input": "",
-                "rofi_theme_confirm": "",
-            }
-        )
+        self.configparser = ConfigParser(self.default_config)
         self.configparser.add_section("stream")
         self.configparser.add_section("general")
         self.configparser.add_section("anilist")
-        if not os.path.exists(USER_CONFIG_PATH):
-            with open(USER_CONFIG_PATH, "w") as config:
-                self.configparser.write(config)
-
-        self.configparser.read(USER_CONFIG_PATH)
 
         # --- set config values from file or using defaults ---
+        if os.path.exists(USER_CONFIG_PATH):
+            self.configparser.read(USER_CONFIG_PATH, encoding="utf-8")
+
         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()
@@ -116,47 +87,69 @@ 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.use_python_mpv = self.get_use_mpv_mod()
         self.quality = self.get_quality()
         self.notification_duration = self.get_notification_duration()
-        self.error = self.get_error()
+        self.episode_complete_at = self.get_episode_complete_at()
+        self.default_media_list_tracking = self.get_default_media_list_tracking()
+        self.force_forward_tracking = self.get_force_forward_tracking()
+        self.cache_requests = self.get_cache_requests()
         self.server = self.get_server()
         self.format = self.get_format()
+        self.player = self.get_player()
         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 = self.user_data.get("watch_history", {})
         self.anime_list: list = self.user_data.get("animelist", [])
         self.user: dict = self.user_data.get("user", {})
 
+        if not os.path.exists(USER_CONFIG_PATH):
+            with open(USER_CONFIG_PATH, "w", encoding="utf-8") as config:
+                config.write(self.__repr__())
+
+    def set_fastanime_config_environs(self):
+        current_config = []
+        for key in self.default_config:
+            current_config.append((f"FASTANIME_{key.upper()}", str(getattr(self, key))))
+        os.environ.update(current_config)
+
     def update_user(self, user):
         self.user = 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"
+    def media_list_track(
+        self,
+        anime_id: int,
+        episode_no: str,
+        episode_stopped_at="0",
+        episode_total_length="0",
+        progress_tracking="prompt",
     ):
         self.watch_history.update(
             {
                 str(anime_id): {
-                    "episode": episode,
-                    "start_time": start_time,
-                    "total_time": total_time,
+                    "episode_no": episode_no,
+                    "episode_stopped_at": episode_stopped_at,
+                    "episode_total_length": episode_total_length,
+                    "progress_tracking": progress_tracking,
                 }
             }
         )
-        self.user_data["watch_history"] = self.watch_history
-        self._update_user_data()
+        with open(USER_WATCH_HISTORY_PATH, "w") as f:
+            json.dump(self.watch_history, f)
 
-    def initialize_user_data(self):
+    def initialize_user_data_and_watch_history(self):
         try:
             if os.path.isfile(USER_DATA_PATH):
                 with open(USER_DATA_PATH, "r") as f:
@@ -164,6 +157,13 @@ class Config(object):
                     self.user_data.update(user_data)
         except Exception as e:
             logger.error(e)
+        try:
+            if os.path.isfile(USER_WATCH_HISTORY_PATH):
+                with open(USER_WATCH_HISTORY_PATH, "r") as f:
+                    watch_history = json.load(f)
+                    self.watch_history.update(watch_history)
+        except Exception as e:
+            logger.error(e)
 
     def _update_user_data(self):
         """method that updates the actual user data file"""
@@ -176,9 +176,15 @@ class Config(object):
     def get_provider(self):
         return self.configparser.get("general", "provider")
 
+    def get_ffmpegthumnailer_seek_time(self):
+        return self.configparser.getint("general", "ffmpegthumbnailer_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")
 
@@ -204,6 +210,18 @@ class Config(object):
     def get_rofi_theme_confirm(self):
         return self.configparser.get("general", "rofi_theme_confirm")
 
+    def get_force_forward_tracking(self):
+        return self.configparser.getboolean("general", "force_forward_tracking")
+
+    def get_cache_requests(self):
+        return self.configparser.getboolean("general", "cache_requests")
+
+    def get_default_media_list_tracking(self):
+        return self.configparser.get("general", "default_media_list_tracking")
+
+    def get_normalize_titles(self):
+        return self.configparser.getboolean("general", "normalize_titles")
+
     # --- stream section ---
     def get_skip(self):
         return self.configparser.getboolean("stream", "skip")
@@ -218,13 +236,13 @@ class Config(object):
         return self.configparser.getboolean("stream", "continue_from_history")
 
     def get_use_mpv_mod(self):
-        return self.configparser.getboolean("stream", "use_mpv_mod")
+        return self.configparser.getboolean("stream", "use_python_mpv")
 
     def get_notification_duration(self):
         return self.configparser.getint("general", "notification_duration")
 
-    def get_error(self):
-        return self.configparser.getint("stream", "error")
+    def get_episode_complete_at(self):
+        return self.configparser.getint("stream", "episode_complete_at")
 
     def get_force_window(self):
         return self.configparser.get("stream", "force_window")
@@ -232,6 +250,9 @@ class Config(object):
     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")
 
@@ -241,6 +262,9 @@ class Config(object):
     def get_format(self):
         return self.configparser.get("stream", "format")
 
+    def get_player(self):
+        return self.configparser.get("stream", "player")
+
     def get_sort_by(self):
         return self.configparser.get("anilist", "sort_by")
 
@@ -250,93 +274,220 @@ class Config(object):
             self.configparser.write(config)
 
     def __repr__(self):
-        current_config_state = f"""
-[stream]
-# Auto continue from watch history
-continue_from_history = {self.continue_from_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}
-
-# 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}
-
+        current_config_state = f"""\
+#
+#    ███████╗░█████╗░░██████╗████████╗░█████╗░███╗░░██╗██╗███╗░░░███╗███████╗  ░█████╗░░█████╗░███╗░░██╗███████╗██╗░██████╗░
+#    ██╔════╝██╔══██╗██╔════╝╚══██╔══╝██╔══██╗████╗░██║██║████╗░████║██╔════╝  ██╔══██╗██╔══██╗████╗░██║██╔════╝██║██╔════╝░
+#    █████╗░░███████║╚█████╗░░░░██║░░░███████║██╔██╗██║██║██╔████╔██║█████╗░░  ██║░░╚═╝██║░░██║██╔██╗██║█████╗░░██║██║░░██╗░
+#    ██╔══╝░░██╔══██║░╚═══██╗░░░██║░░░██╔══██║██║╚████║██║██║╚██╔╝██║██╔══╝░░  ██║░░██╗██║░░██║██║╚████║██╔══╝░░██║██║░░╚██╗
+#    ██║░░░░░██║░░██║██████╔╝░░░██║░░░██║░░██║██║░╚███║██║██║░╚═╝░██║███████╗  ╚█████╔╝╚█████╔╝██║░╚███║██║░░░░░██║╚██████╔╝
+#    ╚═╝░░░░░╚═╝░░╚═╝╚═════╝░░░░╚═╝░░░╚═╝░░╚═╝╚═╝░░╚══╝╚═╝╚═╝░░░░░╚═╝╚══════╝  ░╚════╝░░╚════╝░╚═╝░░╚══╝╚═╝░░░░░╚═╝░╚═════╝░
+#
 [general]
+# whether to show the icons in the tui [True/False]
+# more like emojis
+# by the way if you have any recommendations to which should be used where please
+# don't hesitate to share your opinion
+# cause it's a lot of work to look for the right one for each menu option
+# be sure to also give the replacement emoji
+icons = {self.icons}
 
-# can be [allanime,animepahe]
+# the quality of the stream [1080,720,480,360]
+# this option is usually only reliable when:
+# provider=animepahe
+# since it provides links that actually point to streams of different qualities
+# while the rest just point to another link that can provide the anime from the same server
+quality = {self.quality}
+
+# whether to normalize provider titles [True/False]
+# basically takes the provider titles and finds the corresponding anilist title then changes the title to that
+# useful for uniformity especially when downloading from different providers
+# this also applies to episode titles
+normalize_titles = {self.normalize_titles}
+
+# can be [allanime, animepahe, hianime]
+# allanime is the most realible
+# animepahe provides different links to streams of different quality so a quality can be selected reliably with --quality option
+# hianime which is now hianime usually provides subs in different languuages and its servers are generally faster
 provider = {self.provider}
 
-# Display language (options: english, romaji)
+# Display language [english, romaji]
+# this is passed to anilist directly and is used to set the language which the anime titles will be in
+# when using the anilist interface
 preferred_language = {self.preferred_language}
 
 # Download directory
+# where you will find your videos after downloading them with 'fastanime download' command
 downloads_dir = {self.downloads_dir}
 
-# whether to show a preview window when using fzf or rofi
+# whether to show a preview window when using fzf or rofi [True/False]
+# the preview requires you have a commandline image viewer as documented in the README
+# this is only when usinf fzf
+# if you dont care about image previews it doesnt matter
+# though its awesome
+# try it and you will see
 preview = {self.preview} 
 
-# whether to use fzf as the interface for the anilist command and others.
+# the time to seek when using ffmpegthumbnailer [-1 to 100]
+# -1 means random and is the default
+# ffmpegthumbnailer is used to generate previews and you can select at what time in the video to extract an image
+# random makes things quite exciting cause you never no at what time it will extract the image from
+ffmpegthumbnailer_seek_time = {self.ffmpegthumbnailer_seek_time}
+
+# whether to use fzf as the interface for the anilist command and others. [True/False]
 use_fzf = {self.use_fzf} 
 
-# whether to use rofi for the ui
+# whether to use rofi for the ui [True/False]
+# it's more useful if you want to create a desktop entry 
+# which can be setup with 'fastanime config --desktop-entry'
+# though if you want it to be your sole interface even when fastanime is run directly from the terminal
 use_rofi = {self.use_rofi}
 
-# rofi theme to use
+# rofi themes to use 
+# the values of this option is the path to the rofi config files to use
+# i choose to split it into three since it gives the best look and feel
+# you can refer to the rofi demo on github to see for your self
+# by the way i recommend getting the rofi themes from this project;  
 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}
+rofi_theme_input = {self.rofi_theme_input}
+
+rofi_theme_confirm = {self.rofi_theme_confirm}
 
 # the duration in minutes a notification will stay in the screen
 # used by notifier command
 notification_duration = {self.notification_duration}
-        """
+
+# used when the provider gives subs of different languages
+# currently its the case for:
+# hianime
+# the values for this option are the short names for countries
+# regex is used to determine what you selected
+sub_lang = {self.sub_lang}
+
+# what is your default media list tracking [track/disabled/prompt]
+# only affects your anilist anime list
+# track - means your progress will always be reflected in your anilist anime list
+# disabled - means progress tracking will no longer be reflected in your anime list
+# prompt - means for every anime you will be prompted whether you want your progress to be tracked or not
+default_media_list_tracking = {self.default_media_list_tracking}
+
+# whether media list tracking should only be updated when the next episode is greater than the previous
+# this affects only your anilist anime list
+force_forward_tracking = {self.force_forward_tracking}
+
+# whether to cache requests [true/false]
+# this makes the experience better and more faster
+# as data need not always be fetched from web server
+# and instead can be gotten from a locally
+# from the cached_requests_db
+cache_requests = {self.cache_requests}
+
+
+[stream]
+# Auto continue from watch history [True/False]
+# this will make fastanime to choose the episode that you last watched to completion
+# and increment it by one
+# and use that to auto select the episode you want to watch
+continue_from_history = {self.continue_from_history}  
+
+# which history to use [local/remote]
+# local history means it will just use the watch history stored locally in your device 
+# the file that stores it is called watch_history.json and is stored next to your config file
+# remote means it ignores the last episode stored locally and instead uses the one in your anilist anime list
+# this config option is useful if you want to overwrite your local history or import history covered from another device or platform
+# since remote history will take precendence over whats available locally
+preferred_history = {self.preferred_history}
+
+# Preferred language for anime [dub/sub]
+translation_type = {self.translation_type}
+
+# what server to use for a particular provider
+# allanime: [dropbox, sharepoint, wetransfer, gogoanime, wixmp]
+# animepahe: [kwik]
+# hianime: [HD1, HD2, StreamSB, StreamTape]
+# 'top' can also be used as a value for this option
+# 'top' will cause fastanime to auto select the first server it sees
+# this saves on resources and is faster since not all servers are being fetched
+server = {self.server}
+
+# Auto select next episode [True/False]
+# this makes fastanime increment the current episode number 
+# then after using that value to fetch the next episode instead of prompting
+# this option is useful for binging
+auto_next = {self.auto_next}
+
+# Auto select the anime provider results with fuzzy find. [True/False]
+# Note this won't always be correct
+# this is because the providers sometime use non-standard names
+# that are there own preference rather than the official names
+# But 99% of the time will be accurate
+# if this happens just turn of auto_select in the menus or from the commandline and manually select the correct anime title
+# and then please open an issue at <> highlighting the normalized title and the title given by the provider for the anime you wished to watch  
+# or even better edit this file <> and open a pull request
+auto_select = {self.auto_select}
+
+# whether to skip the opening and ending theme songs [True/False]
+# NOTE: requires ani-skip to be in path
+# for python-mpv users am planning to create this functionality n python without the use of an external script
+# so its disabled for now
+skip = {self.skip}
+
+# at what percentage progress should the episode be considered as completed [0-100]
+# this value is used to determine whether to increment the current episode number and save it to your local list
+# so you can continue immediately to the next episode without select it the next time you decide to watch the anime
+# it is also used to determine whether your anilist anime list should be updated or not
+episode_complete_at = {self.episode_complete_at}
+
+# whether to use python-mpv [True/False]
+# to enable superior control over the player 
+# adding more options to it
+# Enable this one and you will be wonder why you did not discover fastanime sooner 
+# Since you basically don't have to close the player window to go to the next or previous episode, switch servers, change translation type or change to a given episode x
+# so try it if you haven't already
+# if you have any issues setting it up 
+# don't be afraid to ask
+# especially on windows
+# honestly it can be a pain to set it up there
+# personally it took me quite sometime to figure it out
+# this is because of how windows handles shared libraries
+# so just ask when you find yourself stuck
+# or just switch to arch linux
+use_python_mpv = {self.use_python_mpv}
+
+# force mpv window
+# the default 'immediate' just makes mpv to open the window even if the video has not yet loaded
+# done for asthetics
+# 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: 
+# provider=allanime, server=gogoanime
+# provider=allanime, server=wixmp
+# provider=hianime
+# this is because they provider a m3u8 file that contans multiple quality streams
+format = {self.format}
+
+# set the player to use for streaming [mpv/vlc]
+# while this option exists i will still recommend that you use mpv
+# since you will miss out on some features if you use the others
+player = {self.player}
+
+# NOTE:
+# if you have any trouble setting up your config
+# please don't be afraid to ask in our discord
+# plus if there are any errors, improvements or suggestions please tell us in the discord
+# or help us by contributing
+# we appreciate all the help we can get
+# since we may not always have the time to immediately implement the changes
+#
+# HOPE YOU ENJOY FASTANIME AND BE SURE TO STAR THE PROJECT ON GITHUB
+#
+"""
         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/anilist_interfaces.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import os
 import random
-from datetime import datetime
 from typing import TYPE_CHECKING
 
 from click import clear
@@ -20,17 +19,22 @@ from ...libs.rofi import Rofi
 from ...Utility.data import anime_normalizer
 from ...Utility.utils import anime_title_percentage_match
 from ..utils.mpv import run_mpv
-from ..utils.tools import FastAnimeRuntimeState, exit_app
-from ..utils.utils import filter_by_quality, fuzzy_inquirer
+from ..utils.tools import exit_app
+from ..utils.utils import (
+    filter_by_quality,
+    fuzzy_inquirer,
+    move_preferred_subtitle_lang_to_top,
+)
 from .utils import aniskip
 
 if TYPE_CHECKING:
     from ...libs.anilist.types import AnilistBaseMediaDataSchema
     from ...libs.anime_provider.types import Anime, SearchResult, Server
     from ..config import Config
+    from ..utils.tools import FastAnimeRuntimeState
 
 
-def calculate_time_delta(start_time, end_time):
+def calculate_percentage_completion(start_time, end_time):
     """helper function used to calculate the difference between two timestamps in seconds
 
     Args:
@@ -40,16 +44,12 @@ def calculate_time_delta(start_time, end_time):
     Returns:
         [TODO:return]
     """
-    time_format = "%H:%M:%S"
 
-    # Convert string times to datetime objects
-    start = datetime.strptime(start_time, time_format)
-    end = datetime.strptime(end_time, time_format)
-
-    # Calculate the difference
-    delta = end - start
-
-    return delta
+    start = start_time.split(":")
+    end = end_time.split(":")
+    start_secs = int(start[0]) * 3600 + int(start[1]) * 60 + int(start[2])
+    end_secs = int(end[0]) * 3600 + int(end[1]) * 60 + int(end[2])
+    return start_secs / end_secs * 100
 
 
 def media_player_controls(
@@ -96,8 +96,16 @@ def media_player_controls(
             current_episode_number,
         )
 
-        start_time = config.watch_history[str(anime_id_anilist)]["start_time"]
-        print("[green]Continuing from:[/] ", start_time)
+        if (
+            config.watch_history[str(anime_id_anilist)]["episode_no"]
+            == current_episode_number
+        ):
+            start_time = config.watch_history[str(anime_id_anilist)][
+                "episode_stopped_at"
+            ]
+            print("[green]Continuing from:[/] ", start_time)
+        else:
+            start_time = "0"
         custom_args = []
         if config.skip:
             if args := aniskip(
@@ -105,44 +113,64 @@ def media_player_controls(
                 current_episode_number,
             ):
                 custom_args.extend(args)
-        if config.use_mpv_mod:
+        subtitles = move_preferred_subtitle_lang_to_top(
+            selected_server["subtitles"], config.sub_lang
+        )
+        episode_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"]
+                ):
+                    episode_title = episode_detail["title"]
+                    break
+        if config.sync_play:
+            from ..utils.syncplay import SyncPlayer
+
+            stop_time, total_time = SyncPlayer(
+                current_episode_stream_link,
+                episode_title,
+                headers=selected_server["headers"],
+                subtitles=subtitles,
+            )
+        elif config.use_python_mpv:
             from ..utils.player import player
 
-            mpv = player.create_player(
+            player.create_player(
                 current_episode_stream_link,
                 config.anime_provider,
                 fastanime_runtime_state,
                 config,
-                selected_server["episode_title"],
+                episode_title,
+                start_time,
+                headers=selected_server["headers"],
+                subtitles=subtitles,
             )
-
-            # TODO: implement custom aniskip
-            if custom_args and None:
-                chapters_file = custom_args[0].split("=", 1)
-                script_opts = custom_args[1].split("=", 1)
-                mpv._set_property("chapters-file", chapters_file[1])
-                mpv._set_property("script-opts", script_opts[1])
-            if not start_time == "0":
-                mpv.start = start_time
-            mpv.wait_for_shutdown()
-            mpv.terminate()
             stop_time = player.last_stop_time
             total_time = player.last_total_time
         else:
             stop_time, total_time = run_mpv(
                 current_episode_stream_link,
-                selected_server["episode_title"],
+                episode_title,
                 start_time=start_time,
                 custom_args=custom_args,
+                headers=selected_server["headers"],
+                subtitles=subtitles,
+                player=config.player,
             )
 
         # either update the watch history to the next episode or current depending on progress
         if stop_time == "0" or total_time == "0":
             episode = str(int(current_episode_number) + 1)
         else:
-            error = 5 * 60
-            delta = calculate_time_delta(stop_time, total_time)
-            if delta.total_seconds() > error:
+            percentage_completion_of_episode = calculate_percentage_completion(
+                stop_time, total_time
+            )
+            if percentage_completion_of_episode < config.episode_complete_at:
                 episode = current_episode_number
             else:
                 episode = str(int(current_episode_number) + 1)
@@ -150,28 +178,34 @@ def media_player_controls(
                 total_time = "0"
 
         clear()
-        config.update_watch_history(anime_id_anilist, episode, stop_time, total_time)
+        config.media_list_track(
+            anime_id_anilist,
+            episode_no=episode,
+            episode_stopped_at=stop_time,
+            episode_total_length=total_time,
+            progress_tracking=fastanime_runtime_state.progress_tracking,
+        )
         media_player_controls(config, fastanime_runtime_state)
 
     def _next_episode():
         """watch the next episode"""
         # ensures you dont accidentally erase your progress for an in complete episode
         stop_time = config.watch_history.get(str(anime_id_anilist), {}).get(
-            "start_time", "0"
+            "episode_stopped_at", "0"
         )
 
         total_time = config.watch_history.get(str(anime_id_anilist), {}).get(
-            "total_time", "0"
+            "episode_total_length", "0"
         )
 
         # compute if the episode is actually completed
-        error = config.error * 60
         if stop_time == "0" or total_time == "0":
-            dt = 0
+            percentage_completion_of_episode = 0
         else:
-            delta = calculate_time_delta(stop_time, total_time)
-            dt = delta.total_seconds()
-        if dt > error:
+            percentage_completion_of_episode = calculate_percentage_completion(
+                stop_time, total_time
+            )
+        if percentage_completion_of_episode < config.episode_complete_at:
             if config.auto_next:
                 if config.use_rofi:
                     if not Rofi.confirm(
@@ -191,7 +225,7 @@ def media_player_controls(
                     "Are you sure you wish to continue to the next episode, your progress for the current episodes will be erased?",
                     default=True,
                 ):
-                    media_player_controls(config, fastanime_runtime_state)
+                    media_actions_menu(config, fastanime_runtime_state)
                     return
 
         # all checks have passed lets go to the next episode
@@ -205,7 +239,11 @@ def media_player_controls(
         ]
 
         # update user config
-        config.update_watch_history(anime_id_anilist, available_episodes[next_episode])
+        config.media_list_track(
+            anime_id_anilist,
+            episode_no=available_episodes[next_episode],
+            progress_tracking=fastanime_runtime_state.progress_tracking,
+        )
 
         # call interface
         provider_anime_episode_servers_menu(config, fastanime_runtime_state)
@@ -229,7 +267,11 @@ def media_player_controls(
         ]
 
         # update user config
-        config.update_watch_history(anime_id_anilist, available_episodes[prev_episode])
+        config.media_list_track(
+            anime_id_anilist,
+            episode_no=available_episodes[prev_episode],
+            progress_tracking=fastanime_runtime_state.progress_tracking,
+        )
 
         # call interface
         provider_anime_episode_servers_menu(config, fastanime_runtime_state)
@@ -242,7 +284,7 @@ def media_player_controls(
         # prompt for new quality
         if config.use_fzf:
             quality = fzf.run(
-                options, prompt="Select Quality:", header="Quality Options"
+                options, prompt="Select Quality", header="Quality Options"
             )
         elif config.use_rofi:
             quality = Rofi.run(options, "Select Quality")
@@ -260,7 +302,7 @@ def media_player_controls(
         options = ["sub", "dub"]
         if config.use_fzf:
             translation_type = fzf.run(
-                options, prompt="Select Translation Type: ", header="Lang Options"
+                options, prompt="Select Translation Type", header="Lang Options"
             ).lower()
         elif config.use_rofi:
             translation_type = Rofi.run(options, "Select Translation Type")
@@ -306,7 +348,7 @@ def media_player_controls(
     if config.use_fzf:
         action = fzf.run(
             choices,
-            prompt="Select Action:",
+            prompt="Select Action",
         )
     elif config.use_rofi:
         action = Rofi.run(choices, "Select Action")
@@ -316,7 +358,7 @@ def media_player_controls(
 
 
 def provider_anime_episode_servers_menu(
-    config: "Config", fastanime_runtime_state: FastAnimeRuntimeState
+    config: "Config", fastanime_runtime_state: "FastAnimeRuntimeState"
 ):
     """Menu that enables selection of a server either manually or automatically based on user config then plays the stream link of the quality the user prefers
 
@@ -340,15 +382,14 @@ def provider_anime_episode_servers_menu(
     anime_id_anilist: int = fastanime_runtime_state.selected_anime_id_anilist
     provider_anime: "Anime" = fastanime_runtime_state.provider_anime
 
-    server_name = None
+    server_name = ""
     # get streams for episode from provider
     with Progress() as progress:
         progress.add_task("Fetching Episode Streams...", total=None)
         episode_streams_generator = anime_provider.get_episode_streams(
-            provider_anime,
+            provider_anime["id"],
             current_episode_number,
             translation_type,
-            fastanime_runtime_state.selected_anime_anilist,
         )
     if not episode_streams_generator:
         if not config.use_rofi:
@@ -357,27 +398,25 @@ def provider_anime_episode_servers_menu(
         else:
             if not Rofi.confirm("Sth went wrong!!Enter to continue..."):
                 exit(1)
-        provider_anime_episode_servers_menu(config, fastanime_runtime_state)
+        media_actions_menu(config, fastanime_runtime_state)
         return
 
     if config.server == "top":
         # no need to get all servers if top just works
         with Progress() as progress:
             progress.add_task("Fetching top server...", total=None)
-            try:
-                selected_server = next(episode_streams_generator)
-                server_name = "top"
-            except Exception as e:
-                print("Failed to get streams. Reason:", e)
-                if not config.use_rofi:
-                    input("Enter to coninue...")
+            selected_server = next(episode_streams_generator, None)
+        if not selected_server:
+            if config.use_rofi:
+                if Rofi.confirm("Sth went wrong enter to continue"):
+                    media_actions_menu(config, fastanime_runtime_state)
                 else:
-                    if not Rofi.confirm(f"!!Sth went wrong!!: {e} Enter to continue"):
-                        exit_app(1)
-                server_name = None
-                selected_server = ""
+                    exit_app(1)
+            else:
+                print("Sth went wrong")
+                input("Enter to continue...")
                 media_actions_menu(config, fastanime_runtime_state)
-                return
+            return
     else:
         with Progress() as progress:
             progress.add_task("Fetching servers...", total=None)
@@ -386,6 +425,17 @@ def provider_anime_episode_servers_menu(
                 for episode_stream in episode_streams_generator
             }
 
+        if not episode_streams_dict:
+            if config.use_rofi:
+                if Rofi.confirm("Sth went wrong enter to continue"):
+                    media_actions_menu(config, fastanime_runtime_state)
+                else:
+                    exit_app(1)
+            else:
+                print("Sth went wrong")
+                input("Enter to continue...")
+                media_actions_menu(config, fastanime_runtime_state)
+            return
         # check if user server exists and is actually a valid serrver then sets it
         if config.server and config.server in episode_streams_dict.keys():
             server_name = config.server
@@ -396,7 +446,7 @@ def provider_anime_episode_servers_menu(
             if config.use_fzf:
                 server_name = fzf.run(
                     choices,
-                    prompt="Select Server: ",
+                    prompt="Select Server",
                     header="Servers",
                 )
             elif config.use_rofi:
@@ -457,21 +507,17 @@ def provider_anime_episode_servers_menu(
         "[bold magenta] Episode: [/]",
         current_episode_number,
     )
-    # -- update anilist progress if user --
-    if config.user and current_episode_number:
-        AniList.update_anime_list(
-            {
-                "mediaId": anime_id_anilist,
-                "progress": current_episode_number,
-            }
-        )
-
     # try to get the timestamp you left off from if available
     start_time = config.watch_history.get(str(anime_id_anilist), {}).get(
-        "start_time", "0"
+        "episode_stopped_at", "0"
     )
-    if start_time != "0":
+    episode_in_history = config.watch_history.get(str(anime_id_anilist), {}).get(
+        "episode_no", ""
+    )
+    if start_time != "0" and episode_in_history == current_episode_number:
         print("[green]Continuing from:[/] ", start_time)
+    else:
+        start_time = "0"
     custom_args = []
     if config.skip:
         if args := aniskip(
@@ -479,36 +525,59 @@ def provider_anime_episode_servers_menu(
             current_episode_number,
         ):
             custom_args.extend(args)
-    if config.use_mpv_mod:
+    subtitles = move_preferred_subtitle_lang_to_top(
+        selected_server["subtitles"], config.sub_lang
+    )
+    episode_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"]):
+                episode_title = episode_detail["title"]
+                break
+
+    if config.sync_play:
+        from ..utils.syncplay import SyncPlayer
+
+        stop_time, total_time = SyncPlayer(
+            current_stream_link,
+            episode_title,
+            headers=selected_server["headers"],
+            subtitles=subtitles,
+        )
+    elif config.use_python_mpv:
         from ..utils.player import player
 
-        mpv = player.create_player(
+        if start_time == "0" and episode_in_history != current_episode_number:
+            start_time = "0"
+        player.create_player(
             current_stream_link,
             anime_provider,
             fastanime_runtime_state,
             config,
-            selected_server["episode_title"],
+            episode_title,
+            start_time,
+            headers=selected_server["headers"],
+            subtitles=subtitles,
         )
 
-        # TODO: implement custom aniskip intergration
-        if custom_args and None:
-            chapters_file = custom_args[0].split("=", 1)
-            script_opts = custom_args[1].split("=", 1)
-            mpv._set_property("chapters-file", chapters_file[1])
-            mpv._set_property("script-opts", script_opts[1])
-        if not start_time == "0":
-            mpv.start = start_time
-        mpv.wait_for_shutdown()
-        mpv.terminate()
         stop_time = player.last_stop_time
         total_time = player.last_total_time
-
+        current_episode_number = fastanime_runtime_state.provider_current_episode_number
     else:
+        if not episode_in_history == current_episode_number:
+            start_time = "0"
         stop_time, total_time = run_mpv(
             current_stream_link,
-            selected_server["episode_title"],
+            episode_title,
             start_time=start_time,
             custom_args=custom_args,
+            headers=selected_server["headers"],
+            subtitles=subtitles,
+            player=config.player,
         )
     print("Finished at: ", stop_time)
 
@@ -516,21 +585,60 @@ def provider_anime_episode_servers_menu(
     # this will try to update the episode to be the next episode if delta has reached a specific threshhold
     # this update will only apply locally
     # the remote(anilist) is only updated when its certain you are going to open the player
+    available_episodes: list[str] = sorted(
+        fastanime_runtime_state.provider_available_episodes, key=float
+    )
     if stop_time == "0" or total_time == "0":
-        # increment the episode
-        episode = str(int(current_episode_number) + 1)
+        # increment the episodes
+        next_episode = available_episodes.index(current_episode_number) + 1
+        if next_episode >= len(available_episodes):
+            next_episode = len(available_episodes) - 1
+        episode = available_episodes[next_episode]
     else:
-        error = config.error * 60
-        delta = calculate_time_delta(stop_time, total_time)
-        if delta.total_seconds() > error:
+        percentage_completion_of_episode = calculate_percentage_completion(
+            stop_time, total_time
+        )
+        if percentage_completion_of_episode < config.episode_complete_at:
             episode = current_episode_number
         else:
-            episode = str(int(current_episode_number) + 1)
+            # -- update anilist progress if user --
+            remote_progress = (
+                fastanime_runtime_state.selected_anime_anilist["mediaListEntry"] or {}
+            ).get("progress")
+            disable_anilist_update = False
+            if remote_progress:
+                if (
+                    float(remote_progress) > float(current_episode_number)
+                    and config.force_forward_tracking
+                ):
+                    disable_anilist_update = True
+            if (
+                fastanime_runtime_state.progress_tracking == "track"
+                and config.user
+                and not disable_anilist_update
+                and current_episode_number
+            ):
+                AniList.update_anime_list(
+                    {
+                        "mediaId": anime_id_anilist,
+                        "progress": int(float(current_episode_number)),
+                    }
+                )
+
+            # increment the episodes
+            next_episode = available_episodes.index(current_episode_number) + 1
+            if next_episode >= len(available_episodes):
+                next_episode = len(available_episodes) - 1
+            episode = available_episodes[next_episode]
             stop_time = "0"
             total_time = "0"
 
-    config.update_watch_history(
-        anime_id_anilist, episode, start_time=stop_time, total_time=total_time
+    config.media_list_track(
+        anime_id_anilist,
+        episode_no=episode,
+        episode_stopped_at=stop_time,
+        episode_total_length=total_time,
+        progress_tracking=fastanime_runtime_state.progress_tracking,
     )
 
     # switch to controls
@@ -562,7 +670,9 @@ def provider_anime_episodes_menu(
     )
 
     # prompt for episode number
-    total_episodes = provider_anime["availableEpisodesDetail"][translation_type]
+    total_episodes = sorted(
+        provider_anime["availableEpisodesDetail"][translation_type], key=float
+    )
     current_episode_number = ""
 
     # auto select episode if continue from history otherwise prompt episode number
@@ -570,12 +680,22 @@ def provider_anime_episodes_menu(
         # the user watch history thats locally available
         # will be preferred over remote
         if (
-            user_watch_history.get(str(anime_id_anilist), {}).get("episode")
+            user_watch_history.get(str(anime_id_anilist), {}).get("episode_no")
             in total_episodes
         ):
-            current_episode_number = user_watch_history[str(anime_id_anilist)][
-                "episode"
-            ]
+            if (
+                config.preferred_history == "local"
+                or not selected_anime_anilist["mediaListEntry"]
+            ):
+                current_episode_number = user_watch_history[str(anime_id_anilist)][
+                    "episode_no"
+                ]
+            else:
+                current_episode_number = str(
+                    (selected_anime_anilist["mediaListEntry"] or {"progress": 0}).get(
+                        "progress"
+                    )
+                )
             print(
                 f"[bold cyan]Continuing from Episode:[/] [bold]{current_episode_number}[/]"
             )
@@ -597,13 +717,23 @@ def provider_anime_episodes_menu(
             current_episode_number = ""
 
     # prompt for episode number if not set
-    if not current_episode_number:
+    if not current_episode_number or current_episode_number not in total_episodes:
         choices = [*total_episodes, "Back"]
+        preview = None
+        if config.preview:
+            from .utils import get_fzf_episode_preview
+
+            e = fastanime_runtime_state.selected_anime_anilist["episodes"]
+            if e:
+                eps = range(0, e + 1)
+            else:
+                eps = total_episodes
+            preview = get_fzf_episode_preview(
+                fastanime_runtime_state.selected_anime_anilist, eps
+            )
         if config.use_fzf:
             current_episode_number = fzf.run(
-                choices,
-                prompt="Select Episode:",
-                header=anime_title,
+                choices, prompt="Select Episode", header=anime_title, preview=preview
             )
         elif config.use_rofi:
             current_episode_number = Rofi.run(choices, "Select Episode")
@@ -616,14 +746,14 @@ def provider_anime_episodes_menu(
     if current_episode_number == "Back":
         media_actions_menu(config, fastanime_runtime_state)
         return
-
-    # try to get the start time and if not found default to "0"
-    start_time = user_watch_history.get(str(anime_id_anilist), {}).get(
-        "start_time", "0"
-    )
-    config.update_watch_history(
-        anime_id_anilist, current_episode_number, start_time=start_time
-    )
+    #
+    # # try to get the start time and if not found default to "0"
+    # start_time = user_watch_history.get(str(anime_id_anilist), {}).get(
+    #     "start_time", "0"
+    # )
+    # config.update_watch_history(
+    #     anime_id_anilist, current_episode_number, start_time=start_time
+    # )
 
     # update runtime data
     fastanime_runtime_state.provider_available_episodes = total_episodes
@@ -633,8 +763,9 @@ def provider_anime_episodes_menu(
     provider_anime_episode_servers_menu(config, fastanime_runtime_state)
 
 
-# WARNING: Marked for deletion, the function is quite useless and function calls in python are expensive
-def fetch_anime_episode(config, fastanime_runtime_state: "FastAnimeRuntimeState"):
+def fetch_anime_episode(
+    config: "Config", fastanime_runtime_state: "FastAnimeRuntimeState"
+):
     selected_anime: "SearchResult" = (
         fastanime_runtime_state.provider_anime_search_result
     )
@@ -642,7 +773,7 @@ def fetch_anime_episode(config, fastanime_runtime_state: "FastAnimeRuntimeState"
     with Progress() as progress:
         progress.add_task("Fetching Anime Info...", total=None)
         provider_anime = anime_provider.get_anime(
-            selected_anime["id"], fastanime_runtime_state.selected_anime_anilist
+            selected_anime["id"],
         )
     if not provider_anime:
         print(
@@ -653,8 +784,7 @@ def fetch_anime_episode(config, fastanime_runtime_state: "FastAnimeRuntimeState"
         else:
             if not Rofi.confirm("Sth went wrong!!Enter to continue..."):
                 exit(1)
-        fetch_anime_episode(config, fastanime_runtime_state)
-        return
+        return media_actions_menu(config, fastanime_runtime_state)
 
     fastanime_runtime_state.provider_anime = provider_anime
     provider_anime_episodes_menu(config, fastanime_runtime_state)
@@ -663,6 +793,39 @@ def fetch_anime_episode(config, fastanime_runtime_state: "FastAnimeRuntimeState"
 #
 #   ---- ANIME PROVIDER SEARCH RESULTS MENU ----
 #
+
+
+def set_prefered_progress_tracking(
+    config: "Config", fastanime_runtime_state: "FastAnimeRuntimeState", update=False
+):
+    if (
+        fastanime_runtime_state.progress_tracking == ""
+        or update
+        or fastanime_runtime_state.progress_tracking == "prompt"
+    ):
+        if config.default_media_list_tracking == "track":
+            fastanime_runtime_state.progress_tracking = "track"
+        elif config.default_media_list_tracking == "disabled":
+            fastanime_runtime_state.progress_tracking = "disabled"
+        else:
+            options = ["disabled", "track"]
+            if config.use_fzf:
+                fastanime_runtime_state.progress_tracking = fzf.run(
+                    options,
+                    "Enter your preferred progress tracking for the current anime",
+                )
+            elif config.use_rofi:
+                fastanime_runtime_state.progress_tracking = Rofi.run(
+                    options,
+                    "Enter your preferred progress tracking for the current anime",
+                )
+            else:
+                fastanime_runtime_state.progress_tracking = fuzzy_inquirer(
+                    options,
+                    "Enter your preferred progress tracking for the current anime",
+                )
+
+
 def anime_provider_search_results_menu(
     config: "Config", fastanime_runtime_state: "FastAnimeRuntimeState"
 ):
@@ -689,7 +852,6 @@ def anime_provider_search_results_menu(
         provider_search_results = anime_provider.search_for_anime(
             selected_anime_title,
             translation_type,
-            selected_anime_anilist,
         )
     if not provider_search_results:
         print(
@@ -700,8 +862,7 @@ def anime_provider_search_results_menu(
         else:
             if not Rofi.confirm("Sth went wrong!!Enter to continue..."):
                 exit(1)
-        anime_provider_search_results_menu(config, fastanime_runtime_state)
-        return
+        return media_actions_menu(config, fastanime_runtime_state)
 
     provider_search_results = {
         anime["title"]: anime for anime in provider_search_results["results"]
@@ -730,7 +891,7 @@ def anime_provider_search_results_menu(
         if config.use_fzf:
             provider_anime_title = fzf.run(
                 choices,
-                prompt="Select Search Result:",
+                prompt="Select Search Result",
                 header="Anime Search Results",
             )
 
@@ -752,6 +913,11 @@ def anime_provider_search_results_menu(
     fastanime_runtime_state.provider_anime_search_result = provider_search_results[
         provider_anime_title
     ]
+
+    fastanime_runtime_state.progress_tracking = config.watch_history.get(
+        str(fastanime_runtime_state.selected_anime_id_anilist), {}
+    ).get("progress_tracking", "prompt")
+    set_prefered_progress_tracking(config, fastanime_runtime_state)
     fetch_anime_episode(config, fastanime_runtime_state)
 
 
@@ -759,7 +925,7 @@ def anime_provider_search_results_menu(
 #  ---- ANILIST MEDIA ACTIONS MENU ----
 #
 def media_actions_menu(
-    config: "Config", fastanime_runtime_state: FastAnimeRuntimeState
+    config: "Config", fastanime_runtime_state: "FastAnimeRuntimeState"
 ):
     """The menu responsible for handling all media actions such as watching a trailer or streaming it
 
@@ -781,7 +947,7 @@ def media_actions_menu(
     episodes_total = selected_anime_anilist["episodes"] or "Inf"
 
     def _watch_trailer(
-        config: "Config", fastanime_runtime_state: FastAnimeRuntimeState
+        config: "Config", fastanime_runtime_state: "FastAnimeRuntimeState"
     ):
         """Helper function to watch trailers with
 
@@ -795,24 +961,33 @@ def media_actions_menu(
             run_mpv(
                 trailer_url,
                 ytdl_format=config.format,
+                player=config.player,
             )
             media_actions_menu(config, fastanime_runtime_state)
         else:
             if not config.use_rofi:
-                print("no trailer available :confused:")
+                print("no trailer available :confused")
                 input("Enter to continue...")
             else:
                 if not Rofi.confirm("No trailler found!!Enter to continue"):
                     exit(0)
             media_actions_menu(config, fastanime_runtime_state)
 
-    def _add_to_list(config: "Config", fastanime_runtime_state: FastAnimeRuntimeState):
+    def _add_to_list(
+        config: "Config", fastanime_runtime_state: "FastAnimeRuntimeState"
+    ):
         """Helper function to update an anime's media_list_type
 
         Args:
             config: [TODO:description]
             fastanime_runtime_state: [TODO:description]
         """
+        if not config.user:
+            print("You aint logged in")
+            input("Enter to continue")
+            media_actions_menu(config, fastanime_runtime_state)
+            return
+
         anime_lists = {
             "Watching": "CURRENT",
             "Paused": "PAUSED",
@@ -848,18 +1023,25 @@ def media_actions_menu(
             input("Enter to continue...")
         media_actions_menu(config, fastanime_runtime_state)
 
-    def _score_anime(config: "Config", fastanime_runtime_state: FastAnimeRuntimeState):
+    def _score_anime(
+        config: "Config", fastanime_runtime_state: "FastAnimeRuntimeState"
+    ):
         """Helper function to score anime on anilist from terminal or rofi
 
         Args:
             config: [TODO:description]
             fastanime_runtime_state: [TODO:description]
         """
+        if not config.user:
+            print("You aint logged in")
+            input("Enter to continue")
+            media_actions_menu(config, fastanime_runtime_state)
+            return
         if config.use_rofi:
             score = Rofi.ask("Enter Score", is_int=True)
             score = max(100, min(0, score))
         else:
-            score = inquirer.number(
+            score = inquirer.number(  # pyright:ignore
                 message="Enter the score:",
                 min_allowed=0,
                 max_allowed=100,
@@ -879,7 +1061,7 @@ def media_actions_menu(
 
     # FIX: For some reason this fails to delete
     def _remove_from_list(
-        config: "Config", fastanime_runtime_state: FastAnimeRuntimeState
+        config: "Config", fastanime_runtime_state: "FastAnimeRuntimeState"
     ):
         """Remove an anime from  your media list
 
@@ -917,7 +1099,7 @@ def media_actions_menu(
         options = ["Sub", "Dub"]
         if config.use_fzf:
             translation_type = fzf.run(
-                options, prompt="Select Translation Type:", header="Language Options"
+                options, prompt="Select Translation Type", header="Language Options"
             )
         elif config.use_rofi:
             translation_type = Rofi.run(options, "Select Translation Type")
@@ -932,6 +1114,42 @@ def media_actions_menu(
 
         media_actions_menu(config, fastanime_runtime_state)
 
+    def _change_player(
+        config: "Config", fastanime_runtime_state: "FastAnimeRuntimeState"
+    ):
+        """Change the translation type to use
+
+        Args:
+            config: [TODO:description]
+            fastanime_runtime_state: [TODO:description]
+        """
+        # prompt for new translation type
+        options = ["syncplay", "mpv-mod", "default"]
+        if config.use_fzf:
+            player = fzf.run(
+                options,
+                prompt="Select Player",
+            )
+        elif config.use_rofi:
+            player = Rofi.run(options, "Select Player")
+        else:
+            player = fuzzy_inquirer(
+                options,
+                "Select Player",
+            )
+
+        # update internal config
+        if player == "syncplay":
+            config.sync_play = True
+            config.use_python_mpv = False
+        else:
+            config.sync_play = False
+            if player == "mpv-mod":
+                config.use_python_mpv = True
+            else:
+                config.use_python_mpv = False
+        media_actions_menu(config, fastanime_runtime_state)
+
     def _view_info(config: "Config", fastanime_runtime_state: "FastAnimeRuntimeState"):
         """helper function to view info of an anime from terminal
 
@@ -1045,10 +1263,12 @@ def media_actions_menu(
             config: [TODO:description]
             fastanime_runtime_state: [TODO:description]
         """
-        options = ["allanime", "animepahe"]
+        from ...libs.anime_provider import anime_sources
+
+        options = list(anime_sources.keys())
         if config.use_fzf:
             provider = fzf.run(
-                options, prompt="Select Translation Type:", header="Language Options"
+                options, prompt="Select Translation Type", header="Language Options"
             )
         elif config.use_rofi:
             provider = Rofi.run(options, "Select Translation Type")
@@ -1060,7 +1280,7 @@ def media_actions_menu(
 
         config.provider = provider
         config.anime_provider.provider = provider
-        config.anime_provider.lazyload_provider()
+        config.anime_provider.lazyload_provider(provider)
 
         media_actions_menu(config, fastanime_runtime_state)
 
@@ -1087,26 +1307,34 @@ def media_actions_menu(
         config.continue_from_history = False
         anime_provider_search_results_menu(config, fastanime_runtime_state)
 
+    def _set_progress_tracking(
+        config: "Config", fastanime_runtime_state: "FastAnimeRuntimeState"
+    ):
+        set_prefered_progress_tracking(config, fastanime_runtime_state, update=True)
+        media_actions_menu(config, fastanime_runtime_state)
+
     icons = config.icons
     options = {
         f"{'📽️ ' if icons else ''}Stream ({progress}/{episodes_total})": _stream_anime,
         f"{'📽️ ' if icons else ''}Episodes": _select_episode_to_stream,
         f"{'📼 ' if icons else ''}Watch Trailer": _watch_trailer,
         f"{'✨ ' if icons else ''}Score Anime": _score_anime,
+        f"{'✨ ' if icons else ''}Progress Tracking": _set_progress_tracking,
         f"{'📥 ' if icons else ''}Add to List": _add_to_list,
         f"{'📤 ' if icons else ''}Remove from List": _remove_from_list,
         f"{'📖 ' if icons else ''}View Info": _view_info,
         f"{'🎧 ' if icons else ''}Change Translation Type": _change_translation_type,
         f"{'💽 ' if icons else ''}Change Provider": _change_provider,
+        f"{'💽 ' if icons else ''}Change Player": _change_player,
         f"{'🔘 ' if icons else ''}Toggle auto select anime": _toggle_auto_select,  #  WARN: problematic if you choose an anime that doesnt match id
         f"{'💠 ' if icons else ''}Toggle auto next episode": _toggle_auto_next,
         f"{'🔘 ' if icons else ''}Toggle continue from history": _toggle_continue_from_history,
         f"{'🔙 ' if icons else ''}Back": anilist_results_menu,
-        f"{'❌ ' if icons else ''}Exit": exit_app,
+        f"{'❌ ' if icons else ''}Exit": lambda *_: exit_app(),
     }
     choices = list(options.keys())
     if config.use_fzf:
-        action = fzf.run(choices, prompt="Select Action:", header="Anime Menu")
+        action = fzf.run(choices, prompt="Select Action", header="Anime Menu")
     elif config.use_rofi:
         action = Rofi.run(choices, "Select Action")
     else:
@@ -1121,7 +1349,7 @@ def media_actions_menu(
 #   ---- ANILIST RESULTS MENU ----
 #
 def anilist_results_menu(
-    config: "Config", fastanime_runtime_state: FastAnimeRuntimeState
+    config: "Config", fastanime_runtime_state: "FastAnimeRuntimeState"
 ):
     """The menu that handles and displays the results of an anilist action enabling using to select anime of choice
 
@@ -1129,7 +1357,9 @@ def anilist_results_menu(
         config: [TODO:description]
         fastanime_runtime_state: [TODO:description]
     """
-    search_results = fastanime_runtime_state.anilist_data["data"]["Page"]["media"]
+    search_results = fastanime_runtime_state.anilist_results_data["data"]["Page"][
+        "media"
+    ]
 
     anime_data = {}
     for anime in search_results:
@@ -1153,6 +1383,7 @@ def anilist_results_menu(
             anime["status"] == "RELEASING"
             and anime["nextAiringEpisode"]
             and progress > 0
+            and (anime["mediaListEntry"] or {}).get("status", "") == "CURRENT"
         ):
             last_aired_episode = anime["nextAiringEpisode"]["episode"] - 1
             if last_aired_episode - progress > 0:
@@ -1166,19 +1397,19 @@ def anilist_results_menu(
     choices = [*anime_data.keys(), "Back"]
     if config.use_fzf:
         if config.preview:
-            from .utils import get_fzf_preview
+            from .utils import get_fzf_anime_preview
 
-            preview = get_fzf_preview(search_results, anime_data.keys())
+            preview = get_fzf_anime_preview(search_results, anime_data.keys())
             selected_anime_title = fzf.run(
                 choices,
-                prompt="Select Anime: ",
+                prompt="Select Anime",
                 header="Search Results",
                 preview=preview,
             )
         else:
             selected_anime_title = fzf.run(
                 choices,
-                prompt="Select Anime: ",
+                prompt="Select Anime",
                 header="Search Results",
             )
     elif config.use_rofi:
@@ -1288,7 +1519,7 @@ def handle_animelist(
 
 
 def fastanime_main_menu(
-    config: "Config", fastanime_runtime_state: FastAnimeRuntimeState
+    config: "Config", fastanime_runtime_state: "FastAnimeRuntimeState"
 ):
     """The main entry point to the anilist command
 
@@ -1349,6 +1580,9 @@ def fastanime_main_menu(
         else:
             config.load_config()
 
+        config.anime_provider.provider = config.provider
+        config.anime_provider.lazyload_provider(config.provider)
+
         fastanime_main_menu(config, fastanime_runtime_state)
 
     icons = config.icons
@@ -1390,7 +1624,7 @@ def fastanime_main_menu(
     if config.use_fzf:
         action = fzf.run(
             choices,
-            prompt="Select Action: ",
+            prompt="Select Action",
             header="Anilist Menu",
         )
     elif config.use_rofi:
@@ -1404,7 +1638,7 @@ def fastanime_main_menu(
     # anilist data is a (bool,data)
     # the bool indicated success
     if anilist_data[0]:
-        fastanime_runtime_state.anilist_data = anilist_data[1]
+        fastanime_runtime_state.anilist_results_data = anilist_data[1]
         anilist_results_menu(config, fastanime_runtime_state)
 
     else:

fastanime/cli/interfaces/utils.py

@@ -7,94 +7,16 @@ import textwrap
 from threading import Thread
 
 import requests
-from yt_dlp.utils import clean_html
+from yt_dlp.utils import clean_html, sanitize_filename
 
 from ...constants import APP_CACHE_DIR
 from ...libs.anilist.types import AnilistBaseMediaDataSchema
 from ...Utility import anilist_data_helper
+from ..utils.scripts import fzf_preview
 from ..utils.utils import get_true_fg
 
 logger = logging.getLogger(__name__)
 
-# this script was written by the fzf devs as an example on how to preview images
-# its only here for convinience
-fzf_preview = r"""
-#
-# The purpose of this script is to demonstrate how to preview a file or an
-# 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: int, episode: str):
@@ -171,7 +93,7 @@ def write_search_results(
     # NOTE: Will probably make this a configuraable option
     HEADER_COLOR = 215, 0, 95
     SEPARATOR_COLOR = 208, 208, 208
-    SEPARATOR_WIDTH = 45
+    SEPARATOR_WIDTH = 30
     # use concurency to download and write as fast as possible
     with concurrent.futures.ThreadPoolExecutor(max_workers=workers) as executor:
         future_to_task = {}
@@ -182,6 +104,11 @@ def write_search_results(
                 image_url
             )
 
+            mediaListName = "Not in any of your lists"
+            progress = "UNKNOWN"
+            if anime_list := anime["mediaListEntry"]:
+                mediaListName = anime_list["status"]
+                progress = anime_list["progress"]
             # handle the text data
             template = f"""
             {get_true_fg("-"*SEPARATOR_WIDTH,*SEPARATOR_COLOR,bold=False)}
@@ -196,6 +123,9 @@ def write_search_results(
             {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('Media List:',*HEADER_COLOR)} {mediaListName}
+            {get_true_fg('Progress:',*HEADER_COLOR)} {progress}
+            {get_true_fg("-"*SEPARATOR_WIDTH,*SEPARATOR_COLOR,bold=False)}
             {get_true_fg('Description:',*HEADER_COLOR)}
             """
             template = textwrap.dedent(template)
@@ -246,23 +176,120 @@ def get_rofi_icons(
                 logger.error("%r generated an exception: %s" % (url, e))
 
 
-def get_fzf_preview(
-    anilist_results: list[AnilistBaseMediaDataSchema], titles, wait=False
-):
-    """A helper function that constructs data to be used for the fzf preview
+# get rofi icons
+def get_fzf_manga_preview(manga_results, 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]): 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
+        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
     """
-    # ensure images and info exists
+
+    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 manga in manga_results:
+                image_url = manga["poster"]
+                future_to_url[
+                    executor.submit(
+                        save_image_from_url,
+                        image_url,
+                        sanitize_filename(manga["title"]),
+                    )
+                ] = image_url
+
+            # 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=(anilist_results, titles)
+        target=_worker,
     )
+    # ensure images and info exists
+    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
+    """ % (
+        fzf_preview,
+        IMAGES_CACHE_DIR,
+        IMAGES_CACHE_DIR,
+    )
+    if wait:
+        background_worker.join()
+    return preview
+
+
+# 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=_worker,
+    )
+    # ensure images and info exists
     background_worker.daemon = True
     background_worker.start()
 
@@ -286,3 +313,69 @@ def get_fzf_preview(
     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
+    from ...constants import S_PLATFORM
+
+    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"
+    if S_PLATFORM == "win32":
+        preview = """
+            %s
+            title={}
+            dim=${FZF_PREVIEW_COLUMNS}x${FZF_PREVIEW_LINES}
+            if [ -s "%s\\\\\\$title" ]; then 
+            if command -v chafa >/dev/null;then
+            chafa -f kitty -s $dim "%s\\\\\\$title"
+            fi
+            else echo Loading...
+            fi
+            if [ -s "%s\\\\\\$title" ]; then cat "%s\\\\\\$title"
+            else echo Loading...
+            fi
+        """ % (
+            fzf_preview,
+            IMAGES_CACHE_DIR.replace("\\", "\\\\\\"),
+            IMAGES_CACHE_DIR.replace("\\", "\\\\\\"),
+            ANIME_INFO_CACHE_DIR.replace("\\", "\\\\\\"),
+            ANIME_INFO_CACHE_DIR.replace("\\", "\\\\\\"),
+        )
+    else:
+        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,
+        )
+    if wait:
+        background_worker.join()
+    return preview

fastanime/cli/utils/feh.py

@@ -0,0 +1,12 @@
+import shutil
+import subprocess
+from sys import exit
+
+
+def feh_manga_viewer(image_links: list[str], window_title: str):
+    FEH_EXECUTABLE = shutil.which("feh")
+    if not FEH_EXECUTABLE:
+        print("feh not found")
+        exit(1)
+    commands = [FEH_EXECUTABLE, *image_links, "--title", window_title]
+    subprocess.run(commands)

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(
@@ -48,66 +50,140 @@ def stream_video(MPV, url, mpv_args, custom_args):
 
 def run_mpv(
     link: str,
-    title: str | None = "",
+    title: str = "",
     start_time: str = "0",
     ytdl_format="",
     custom_args=[],
+    headers={},
+    subtitles=[],
+    player="",
 ):
-    # Determine if mpv is available
-    MPV = shutil.which("mpv")
-
     # If title is None, set a default value
 
     # Regex to check if the link is a YouTube URL
     youtube_regex = r"(https?://)?(www\.)?(youtube|youtu|youtube-nocookie)\.(com|be)/.+"
 
-    if not MPV:
-        # Determine if the link is a YouTube URL
-        if re.match(youtube_regex, link):
-            # Android specific commands to launch mpv with a YouTube URL
-            args = [
-                "nohup",
-                "am",
-                "start",
-                "--user",
-                "0",
-                "-a",
-                "android.intent.action.VIEW",
-                "-d",
-                link,
-                "-n",
-                "com.google.android.youtube/.UrlActivity",
-            ]
+    if link.endswith(".torrent"):
+        WEBTORRENT_CLI = shutil.which("webtorrent")
+        if not WEBTORRENT_CLI:
+            import time
+
+            print(
+                "webtorrent cli is not installed which is required for downloading and streaming from nyaa\nplease install it or use another provider"
+            )
+            time.sleep(120)
+            return "0", "0"
+        cmd = [WEBTORRENT_CLI, link, f"--{player}"]
+        subprocess.run(cmd)
+        return "0", "0"
+    if player == "vlc":
+        VLC = shutil.which("vlc")
+        if not VLC 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
+                args = [
+                    "nohup",
+                    "am",
+                    "start",
+                    "--user",
+                    "0",
+                    "-a",
+                    "android.intent.action.VIEW",
+                    "-d",
+                    link,
+                    "-n",
+                    "com.google.android.youtube/.UrlActivity",
+                ]
+                return "0", "0"
+            else:
+                args = [
+                    "nohup",
+                    "am",
+                    "start",
+                    "--user",
+                    "0",
+                    "-a",
+                    "android.intent.action.VIEW",
+                    "-d",
+                    link,
+                    "-n",
+                    "org.videolan.vlc/org.videolan.vlc.gui.video.VideoPlayerActivity",
+                    "-e",
+                    "title",
+                    title,
+                ]
+
+            subprocess.run(args)
             return "0", "0"
         else:
-            # Android specific commands to launch mpv with a regular URL
-            args = [
-                "nohup",
-                "am",
-                "start",
-                "--user",
-                "0",
-                "-a",
-                "android.intent.action.VIEW",
-                "-d",
-                link,
-                "-n",
-                "is.xyz.mpv/.MPVActivity",
-            ]
-
-        subprocess.run(args)
-        return "0", "0"
+            args = ["vlc", link]
+            for subtitle in subtitles:
+                args.append("--sub-file")
+                args.append(subtitle["url"])
+                break
+            if title:
+                args.append("--video-title")
+                args.append(title)
+            subprocess.run(args)
+            return "0", "0"
     else:
-        # General mpv command with custom arguments
-        mpv_args = []
-        if start_time != "0":
-            mpv_args.append(f"--start={start_time}")
-        if title:
-            mpv_args.append(f"--title={title}")
-        if ytdl_format:
-            mpv_args.append(f"--ytdl-format={ytdl_format}")
-        stop_time, total_time = stream_video(MPV, link, mpv_args, custom_args)
-        return stop_time, total_time
+        # Determine if mpv is available
+        MPV = shutil.which("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
+                args = [
+                    "nohup",
+                    "am",
+                    "start",
+                    "--user",
+                    "0",
+                    "-a",
+                    "android.intent.action.VIEW",
+                    "-d",
+                    link,
+                    "-n",
+                    "com.google.android.youtube/.UrlActivity",
+                ]
+                return "0", "0"
+            else:
+                # Android specific commands to launch mpv with a regular URL
+                args = [
+                    "nohup",
+                    "am",
+                    "start",
+                    "--user",
+                    "0",
+                    "-a",
+                    "android.intent.action.VIEW",
+                    "-d",
+                    link,
+                    "-n",
+                    "is.xyz.mpv/.MPVActivity",
+                ]
+
+            subprocess.run(args)
+            return "0", "0"
+        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:
+                mpv_args.append(f"--title={title}")
+            if ytdl_format:
+                mpv_args.append(f"--ytdl-format={ytdl_format}")
+            stop_time, total_time = stream_video(MPV, link, mpv_args, custom_args)
+            return stop_time, total_time
 
 
 # Example usage

fastanime/cli/utils/player.py

@@ -3,13 +3,14 @@ from typing import TYPE_CHECKING
 import mpv
 
 from ...anilist import AniList
-from .utils import filter_by_quality
+from .utils import filter_by_quality, move_preferred_subtitle_lang_to_top
 
 if TYPE_CHECKING:
     from typing import Literal
 
     from ...AnimeProvider import AnimeProvider
     from ..config import Config
+    from .tools import FastAnimeRuntimeState
 
 
 def format_time(duration_in_secs: float):
@@ -22,6 +23,7 @@ def format_time(duration_in_secs: float):
 class MpvPlayer(object):
     anime_provider: "AnimeProvider"
     config: "Config"
+    subs = []
     mpv_player: "mpv.MPV"
     last_stop_time: str = "0"
     last_total_time: str = "0"
@@ -66,7 +68,11 @@ class MpvPlayer(object):
             current_episode_number = (
                 fastanime_runtime_state.provider_current_episode_number
             )
-            config.update_watch_history(anime_id_anilist, str(current_episode_number))
+            config.media_list_track(
+                anime_id_anilist,
+                episode_no=str(current_episode_number),
+                progress_tracking=fastanime_runtime_state.progress_tracking,
+            )
         elif type == "reload":
             if current_episode_number not in total_episodes:
                 self.mpv_player.show_text("Episode not available")
@@ -82,7 +88,11 @@ class MpvPlayer(object):
 
             self.mpv_player.show_text(f"Fetching episode {ep_no}")
             current_episode_number = ep_no
-            config.update_watch_history(anime_id_anilist, str(ep_no))
+            config.media_list_track(
+                anime_id_anilist,
+                episode_no=str(ep_no),
+                progress_tracking=fastanime_runtime_state.progress_tracking,
+            )
             fastanime_runtime_state.provider_current_episode_number = str(ep_no)
         else:
             self.mpv_player.show_text("Fetching previous episode...")
@@ -95,29 +105,35 @@ class MpvPlayer(object):
             current_episode_number = (
                 fastanime_runtime_state.provider_current_episode_number
             )
-            config.update_watch_history(anime_id_anilist, str(current_episode_number))
+            config.media_list_track(
+                anime_id_anilist,
+                episode_no=str(current_episode_number),
+                progress_tracking=fastanime_runtime_state.progress_tracking,
+            )
         # update episode progress
         if config.user and current_episode_number:
             AniList.update_anime_list(
                 {
                     "mediaId": anime_id_anilist,
-                    "progress": current_episode_number,
+                    "progress": int(float(current_episode_number)),
                 }
             )
         # get them juicy streams
         episode_streams = anime_provider.get_episode_streams(
-            provider_anime,
+            provider_anime["id"],
             current_episode_number,
             translation_type,
-            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
         if server == "top":
-            selected_server = next(episode_streams)
+            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
@@ -128,25 +144,46 @@ class MpvPlayer(object):
                 self.mpv_player.show_text(
                     f"Invalid server!!; servers available are: {episode_streams_dict.keys()}",
                 )
-                return None
+                return
         self.current_media_title = selected_server["episode_title"]
+        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"]
 
         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,
         stream_link,
         anime_provider: "AnimeProvider",
-        fastanime_runtime_state,
+        fastanime_runtime_state: "FastAnimeRuntimeState",
         config: "Config",
         title,
+        start_time,
+        headers={},
+        subtitles=[],
     ):
+        self.subs = subtitles
         self.anime_provider = anime_provider
         self.fastanime_runtime_state = fastanime_runtime_state
         self.config = config
@@ -165,12 +202,6 @@ class MpvPlayer(object):
             osc=True,
             ytdl=True,
         )
-        mpv_player.force_window = config.force_window
-        # mpv_player.cache = "yes"
-        # mpv_player.cache_pause = "no"
-        mpv_player.title = title
-
-        mpv_player.play(stream_link)
 
         # -- events --
         @mpv_player.event_callback("file-loaded")
@@ -179,6 +210,22 @@ class MpvPlayer(object):
             self.player_fetching = False
             if isinstance(d, float):
                 self.last_total_time = format_time(d)
+            try:
+                if not mpv_player.core_shutdown:
+                    if self.subs:
+                        for i, subtitle in enumerate(self.subs):
+                            if i == 0:
+                                flag = "select"
+                            else:
+                                flag = "auto"
+                            mpv_player.sub_add(
+                                subtitle["url"], flag, None, subtitle["language"]
+                            )
+                        self.subs = []
+            except mpv.ShutdownError:
+                pass
+            except Exception:
+                pass
 
         @mpv_player.property_observer("time-pos")
         def handle_time_start_update(*args):
@@ -207,7 +254,9 @@ class MpvPlayer(object):
         def _next_episode():
             url = self.get_episode("next")
             if url:
-                mpv_player.loadfile(url, options=f"title={self.current_media_title}")
+                mpv_player.loadfile(
+                    url,
+                )
                 mpv_player.title = self.current_media_title
 
         @mpv_player.on_key_press("shift+p")
@@ -230,9 +279,9 @@ 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(
                 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")
@@ -315,7 +364,23 @@ class MpvPlayer(object):
         mpv_player.register_message_handler("select-quality", select_quality)
 
         self.mpv_player = mpv_player
-        return mpv_player
+        mpv_player.force_window = config.force_window
+        # mpv_player.cache = "yes"
+        # mpv_player.cache_pause = "no"
+        mpv_player.title = title
+        mpv_headers = ""
+        if headers:
+            for header_name, header_value in headers.items():
+                mpv_headers += f"{header_name}:{header_value},"
+        mpv_player.http_header_fields = mpv_headers
+
+        mpv_player.play(stream_link)
+
+        if not start_time == "0":
+            mpv_player.start = start_time
+
+        mpv_player.wait_for_shutdown()
+        mpv_player.terminate()
 
 
 player = MpvPlayer()

fastanime/cli/utils/scripts.py

@@ -0,0 +1,53 @@
+fzf_preview = r"""
+#
+# Adapted from the preview script in the fzf repo
+#
+# Dependencies:
+# - https://github.com/hpjansson/chafa
+# - https://iterm2.com/utilities/imgcat
+#
+fzf-preview() {
+	file=${1/#\~\//$HOME/}
+	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
+        case "$(uname -a)" in
+            # termux does not support sixel graphics
+            # and produces weird output
+            *ndroid*) chafa -s "$dim" "$file";;
+            *) chafa -f sixel -s "$dim" "$file";;
+        esac
+		# 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
+        echo install chafa or imgcat or install kitty terminal so you can enjoy image previews
+	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,41 +1,49 @@
-# TODO: add typing
-class FastAnimeRuntimeState(dict):
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typing import Any
+
+    from ...libs.anilist.types import AnilistBaseMediaDataSchema
+    from ...libs.anime_provider.types import Anime, EpisodeStream, SearchResult, Server
+
+
+class FastAnimeRuntimeState(object):
     """A class that manages fastanime runtime during anilist command runtime"""
 
-    def __getattr__(self, attr):
-        try:
-            return self.__getitem__(attr)
-        except KeyError:
-            raise AttributeError(
-                "%r object has no attribute %r" % (self.__class__.__name__, attr)
-            )
+    provider_current_episode_stream_link: str
+    provider_current_server: "Server"
+    provider_current_server_name: str
+    provider_available_episodes: list[str]
+    provider_current_episode_number: str
+    provider_server_episode_streams: list["EpisodeStream"]
+    provider_anime_title: str
+    provider_anime: "Anime"
+    provider_anime_search_result: "SearchResult"
+    progress_tracking: str = ""
 
-    def __setattr__(self, attr, value):
-        self.__setitem__(attr, value)
+    selected_anime_anilist: "AnilistBaseMediaDataSchema"
+    selected_anime_id_anilist: int
+    selected_anime_title_anilist: str
+    # current_anilist_data: "AnilistDataSchema | AnilistMediaList"
+    anilist_results_data: "Any"
 
 
-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():
+    console = Console()
+    if not console.is_terminal:
         try:
-            shutil.get_terminal_size()
-            return (
-                sys.stdin
-                and sys.stdin.isatty()
-                and sys.stdout.isatty()
-                and os.getenv("TERM") is not None
+            from plyer import notification
+        except ImportError:
+            print(
+                "Plyer is not installed; install it for desktop notifications to be enabled"
             )
-        except OSError:
-            return False
-
-    if not is_running_in_terminal():
-        from plyer import notification
-
+            exit(1)
         notification.notify(
             app_name=APP_NAME,
             app_icon=ICON_PATH,
@@ -43,7 +51,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)
+        console.clear()
+        console.print("Have a good day :smile:", USER_NAME)
+    sys.exit(exit_code)

fastanime/cli/utils/utils.py

@@ -19,7 +19,47 @@ BG_GREEN = "\033[48;2;120;233;12;m"
 GREEN = "\033[38;2;45;24;45;m"
 
 
-def filter_by_quality(quality: str, stream_links: "list[EpisodeStream]"):
+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:
@@ -30,8 +70,25 @@ def filter_by_quality(quality: str, stream_links: "list[EpisodeStream]"):
         an EpisodeStream object or None incase the quality was not found
     """
     for stream_link in stream_links:
-        if stream_link["quality"] == quality:
+        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"):
@@ -89,7 +146,7 @@ def fuzzy_inquirer(choices: list, prompt: str, **kwargs):
     from click import clear
 
     clear()
-    action = inquirer.fuzzy(
+    action = inquirer.fuzzy(  # pyright:ignore
         prompt,
         choices,
         height="100%",

fastanime/constants.py

@@ -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,23 +19,68 @@ if PLATFORM == "Windows":
     ICON_PATH = os.path.join(ASSETS_DIR, "logo.ico")
 else:
     ICON_PATH = os.path.join(ASSETS_DIR, "logo.png")
-PREVIEW_IMAGE = os.path.join(ASSETS_DIR, "preview")
+# PREVIEW_IMAGE = os.path.join(ASSETS_DIR, "preview")
 
 
 # ----- user configs and data -----
-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, roaming=False)
+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_WATCH_HISTORY_PATH = os.path.join(APP_DATA_DIR, "watch_history.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

@@ -15,6 +15,7 @@ from .queries_graphql import (
     delete_list_entry_query,
     get_logged_in_user_query,
     get_medialist_item_query,
+    get_user_info,
     media_list_mutation,
     media_list_query,
     most_favourite_query,
@@ -34,8 +35,9 @@ if TYPE_CHECKING:
         AnilistMediaLists,
         AnilistMediaListStatus,
         AnilistNotifications,
-        AnilistUser,
+        AnilistUser_,
         AnilistUserData,
+        AnilistViewerData,
     )
 logger = logging.getLogger(__name__)
 ANILIST_ENDPOINT = "https://graphql.anilist.co"
@@ -77,7 +79,7 @@ class AniListApi:
             return
         if not success or not user:
             return
-        user_info: AnilistUser = user["data"]["Viewer"]
+        user_info: "AnilistUser_" = user["data"]["Viewer"]
         self.user_id = user_info["id"]
         return user_info
 
@@ -91,7 +93,7 @@ class AniListApi:
         """
         return self._make_authenticated_request(notification_query)
 
-    def update_login_info(self, user: "AnilistUser", token: str):
+    def update_login_info(self, user: "AnilistUser_", token: str):
         """method used to login a user enabling authenticated requests
 
         Args:
@@ -103,7 +105,18 @@ class AniListApi:
         self.session.headers.update(self.headers)
         self.user_id = user["id"]
 
-    def get_logged_in_user(self) -> tuple[bool, "AnilistUserData"] | tuple[bool, None]:
+    def get_user_info(self) -> tuple[bool, "AnilistUserData"] | tuple[bool, None]:
+        """get the details of the user who is currently logged in
+
+        Returns:
+            an anilist user
+        """
+
+        return self._make_authenticated_request(get_user_info, {"userId": self.user_id})
+
+    def get_logged_in_user(
+        self,
+    ) -> tuple[bool, "AnilistViewerData"] | tuple[bool, None]:
         """get the details of the user who is currently logged in
 
         Returns:
@@ -309,9 +322,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,
+        on_list: bool | None = None,
         type="ANIME",
         **kwargs,
     ):
@@ -320,7 +338,7 @@ class AniListApi:
         """
         variables = {}
         for key, val in list(locals().items())[1:]:
-            if val is not None and key not in ["variables"]:
+            if (val or val is False) and key not in ["variables"]:
                 variables[key] = val
         search_results = self.get_data(search_query, variables=variables)
         return search_results

fastanime/libs/anilist/queries_graphql.py

@@ -3,7 +3,6 @@ This module contains all the preset queries for the sake of neatness and convini
 Mostly for internal usage
 """
 
-# TODO: Format the queries
 mark_as_read_mutation = """
 mutation{
   UpdateUser{
@@ -17,7 +16,6 @@ query($id:Int){
     pageInfo{
       total
     }
-    
     reviews(mediaId:$id){
       summary
       user{
@@ -35,50 +33,48 @@ query($id:Int){
 
 """
 notification_query = """
-query{
-    Page(perPage:5){
-        pageInfo {
-            total
-        }
-        notifications(resetNotificationCount:true,type:AIRING) {
-            ... on AiringNotification {
-                id
-                type
-                episode
-                contexts
-                createdAt
-                media {
-                    id
-                    idMal
-                    title {
-                        romaji
-                        english
-                    }
-                    coverImage{
-                        medium
-                    }
-                }
-            }
-        }
+query {
+  Page(perPage: 5) {
+    pageInfo {
+      total
     }
+    notifications(resetNotificationCount: true, type: AIRING) {
+      ... on AiringNotification {
+        id
+        type
+        episode
+        contexts
+        createdAt
+        media {
+          id
+          idMal
+          title {
+            romaji
+            english
+          }
+          coverImage {
+            medium
+          }
+        }
+      }
+    }
+  }
 }
-
 """
 
 get_medialist_item_query = """
-query($mediaId:Int){
-    MediaList(mediaId:$mediaId){
-        id
-    }
+query ($mediaId: Int) {
+  MediaList(mediaId: $mediaId) {
+    id
+  }
 }
 """
 
 delete_list_entry_query = """
-mutation($id:Int){
-    DeleteMediaListEntry(id:$id){
-        deleted
-
-    }
+mutation ($id: Int) {
+  DeleteMediaListEntry(id: $id) {
+    deleted
+  }
 }
 """
 
@@ -97,9 +93,85 @@ query{
 }
 """
 
+get_user_info = """
+query ($userId: Int) {
+  User(id: $userId) {
+    name
+    about
+    avatar {
+      large
+      medium
+    }
+    bannerImage
+    statistics {
+      anime {
+        count
+        minutesWatched
+        episodesWatched
+        genres {
+          count
+          meanScore
+          genre
+        }
+        tags {
+          tag {
+            id
+          }
+          count
+          meanScore
+        }
+      }
+      manga {
+        count
+        meanScore
+        chaptersRead
+        volumesRead
+        tags {
+          count
+          meanScore
+        }
+        genres {
+          count
+          meanScore
+        }
+      }
+    }
+    favourites {
+      anime {
+        nodes {
+          title {
+            romaji
+            english
+          }
+        }
+      }
+      manga {
+        nodes {
+          title {
+            romaji
+            english
+          }
+        }
+      }
+    }
+  }
+}
+"""
 media_list_mutation = """
-mutation($mediaId:Int,$scoreRaw:Int,$repeat:Int,$progress:Int,$status:MediaListStatus){
-  SaveMediaListEntry(mediaId:$mediaId,scoreRaw:$scoreRaw,progress:$progress,repeat:$repeat,status:$status){
+mutation (
+  $mediaId: Int
+  $scoreRaw: Int
+  $repeat: Int
+  $progress: Int
+  $status: MediaListStatus
+) {
+  SaveMediaListEntry(
+    mediaId: $mediaId
+    scoreRaw: $scoreRaw
+    progress: $progress
+    repeat: $repeat
+    status: $status
+  ) {
     id
     status
     mediaId
@@ -116,21 +188,19 @@ mutation($mediaId:Int,$scoreRaw:Int,$repeat:Int,$progress:Int,$status:MediaListS
       month
       day
     }
-
   }
 }
 """
 
 media_list_query = """
-query ($userId: Int, $status: MediaListStatus,$type:MediaType) {
+query ($userId: Int, $status: MediaListStatus, $type: MediaType) {
   Page {
     pageInfo {
-        currentPage
-        total
+      currentPage
+      total
     }
     mediaList(userId: $userId, status: $status, type: $type) {
       mediaId
-      
       media {
         id
         idMal
@@ -147,6 +217,10 @@ query ($userId: Int, $status: MediaListStatus,$type:MediaType) {
           id
         }
         popularity
+        streamingEpisodes {
+          title
+          thumbnail
+        }
         favourites
         averageScore
         episodes
@@ -172,9 +246,10 @@ query ($userId: Int, $status: MediaListStatus,$type:MediaType) {
         }
         status
         description
-        mediaListEntry{
-        id
-        progress
+        mediaListEntry {
+          status
+          id
+          progress
         }
         nextAiringEpisode {
           timeUntilAiring
@@ -198,7 +273,6 @@ query ($userId: Int, $status: MediaListStatus,$type:MediaType) {
         day
       }
       createdAt
-      
     }
   }
 }
@@ -220,71 +294,83 @@ $popularity_greater:Int,\
 $popularity_lesser:Int,\
 $averageScore_greater:Int,\
 $averageScore_lesser:Int,\
+$seasonYear:Int,\
 $startDate_greater:FuzzyDateInt,\
 $startDate_lesser:FuzzyDateInt,\
+$startDate:FuzzyDateInt,\
 $endDate_greater:FuzzyDateInt,\
 $endDate_lesser:FuzzyDateInt,\
+$format_in:[MediaFormat],\
 $type:MediaType\
+$season:MediaSeason\
+$on_list:Boolean\
 "
-# FuzzyDateInt = (yyyymmdd)
-# MediaStatus = (FINISHED,RELEASING,NOT_YET_RELEASED,CANCELLED,HIATUS)
+
 search_query = (
     """
 query($query:String,%s){
-  Page(perPage:30,page:$page){
-    pageInfo{
+  Page(perPage: 50, page: $page) {
+    pageInfo {
       total
       currentPage
       hasNextPage
     }
     media(
-      search:$query,
-      id_in:$id_in,
-      genre_in:$genre_in,
-      genre_not_in:$genre_not_in,
-      tag_in:$tag_in,
-      tag_not_in:$tag_not_in,
-      status_in:$status_in,
-      status:$status,
-      status_not_in:$status_not_in,
-      popularity_greater:$popularity_greater,
-      popularity_lesser:$popularity_lesser,
-      averageScore_greater:$averageScore_greater,
-      averageScore_lesser:$averageScore_lesser,
-      startDate_greater:$startDate_greater,
-      startDate_lesser:$startDate_lesser,
-      endDate_greater:$endDate_greater,
-      endDate_lesser:$endDate_lesser,
-      sort:$sort,
-      type:$type
-      )
-    {
+      search: $query
+      id_in: $id_in
+      genre_in: $genre_in
+      genre_not_in: $genre_not_in
+      tag_in: $tag_in
+      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
+      averageScore_greater: $averageScore_greater
+      averageScore_lesser: $averageScore_lesser
+      startDate_greater: $startDate_greater
+      startDate_lesser: $startDate_lesser
+      endDate_greater: $endDate_greater
+      endDate_lesser: $endDate_lesser
+      format_in: $format_in
+      sort: $sort
+      season: $season
+      seasonYear: $seasonYear
+      type: $type
+        onList:$on_list
+    ) {
       id
-        idMal
-      title{
+      idMal
+      title {
         romaji
         english
       }
-      coverImage{
+      coverImage {
         medium
         large
       }
       trailer {
         site
         id
-        
       }
-        mediaListEntry{
+      mediaListEntry {
+        status
         id
         progress
-        }
+      }
       popularity
+      streamingEpisodes {
+        title
+        thumbnail
+      }
       favourites
       averageScore
       episodes
       genres
-      studios{
-        nodes{
+      studios {
+        nodes {
           name
           isAnimationStudio
         }
@@ -317,17 +403,16 @@ query($query:String,%s){
 )
 
 trending_query = """
-query($type:MediaType){  
-  Page(perPage:15){
-    
-    media(sort:TRENDING_DESC,type:$type,genre_not_in:["hentai"]){
+query ($type: MediaType) {
+  Page(perPage: 15) {
+    media(sort: TRENDING_DESC, type: $type, genre_not_in: ["hentai"]) {
       id
-        idMal
-      title{
+      idMal
+      title {
         romaji
         english
       }
-      coverImage{
+      coverImage {
         medium
         large
       }
@@ -336,6 +421,10 @@ query($type:MediaType){
         id
       }
       popularity
+      streamingEpisodes {
+        title
+        thumbnail
+      }
       favourites
       averageScore
       genres
@@ -348,17 +437,18 @@ query($type:MediaType){
         }
       }
       tags {
-        name              
+        name
       }
       startDate {
         year
         month
         day
       }
-        mediaListEntry{
+      mediaListEntry {
+        status
         id
         progress
-        }
+      }
       endDate {
         year
         month
@@ -377,29 +467,37 @@ query($type:MediaType){
 
 # mosts
 most_favourite_query = """
-query($type:MediaType){
-  Page(perPage:15){    
-    media(sort:FAVOURITES_DESC,type:$type,genre_not_in:["hentai"]){
+query ($type: MediaType) {
+  Page(perPage: 15) {
+    media(sort: FAVOURITES_DESC, type: $type, genre_not_in: ["hentai"]) {
       id
-        idMal
-      title{
+      idMal
+      title {
         romaji
         english
       }
-      coverImage{
+      coverImage {
         medium
         large
       }
       trailer {
         site
         id
-        
       }
-        mediaListEntry{
+      mediaListEntry {
+        status
         id
         progress
-        }
+      }
       popularity
+      streamingEpisodes {
+        title
+        thumbnail
+      }
+      streamingEpisodes {
+        title
+        thumbnail
+      }
       favourites
       averageScore
       episodes
@@ -412,7 +510,7 @@ query($type:MediaType){
         }
       }
       tags {
-        name              
+        name
       }
       startDate {
         year
@@ -436,29 +534,33 @@ query($type:MediaType){
 """
 
 most_scored_query = """
-query($type:MediaType){
-  Page(perPage:15){
-    media(sort:SCORE_DESC,type:$type,genre_not_in:["hentai"]){
+query ($type: MediaType) {
+  Page(perPage: 15) {
+    media(sort: SCORE_DESC, type: $type, genre_not_in: ["hentai"]) {
       id
-        idMal
-      title{
+      idMal
+      title {
         romaji
         english
       }
-      coverImage{
+      coverImage {
         medium
         large
       }
       trailer {
         site
         id
-        
       }
-        mediaListEntry{
+      mediaListEntry {
+        status
         id
         progress
-        }
+      }
       popularity
+      streamingEpisodes {
+        title
+        thumbnail
+      }
       episodes
       favourites
       averageScore
@@ -471,7 +573,7 @@ query($type:MediaType){
         }
       }
       tags {
-        name              
+        name
       }
       startDate {
         year
@@ -495,34 +597,38 @@ query($type:MediaType){
 """
 
 most_popular_query = """
-query($type:MediaType){  
-  Page(perPage:15){
-    media(sort:POPULARITY_DESC,type:$type,genre_not_in:["hentai"]){
+query ($type: MediaType) {
+  Page(perPage: 15) {
+    media(sort: POPULARITY_DESC, type: $type, genre_not_in: ["hentai"]) {
       id
-        idMal
-      title{
+      idMal
+      title {
         romaji
         english
       }
-      coverImage{
+      coverImage {
         medium
         large
       }
       trailer {
         site
         id
-        
       }
       popularity
+      streamingEpisodes {
+        title
+        thumbnail
+      }
       favourites
       averageScore
       description
       episodes
       genres
-        mediaListEntry{
+      mediaListEntry {
+        status
         id
         progress
-        }
+      }
       studios {
         nodes {
           name
@@ -530,8 +636,8 @@ query($type:MediaType){
         }
       }
       tags {
-        name              
-      }      
+        name
+      }
       startDate {
         year
         month
@@ -547,35 +653,47 @@ query($type:MediaType){
         timeUntilAiring
         airingAt
         episode
-      }  
+      }
     }
   }
 }
 """
 
 most_recently_updated_query = """
-query($type:MediaType){
-  Page(perPage:15){
-    media(sort:UPDATED_AT_DESC,type:$type,averageScore_greater:50,genre_not_in:["hentai"],status:RELEASING){
+query ($type: MediaType) {
+  Page(perPage: 15) {
+    media(
+      sort: UPDATED_AT_DESC
+      type: $type
+      averageScore_greater: 50
+      genre_not_in: ["hentai"]
+      status: RELEASING
+    ) {
       id
-        idMal
-      title{
+      idMal
+      title {
         romaji
         english
       }
-      coverImage{
+      coverImage {
         medium
         large
       }
       trailer {
         site
-        id     
+        id
       }
-        mediaListEntry{
+      mediaListEntry {
+        status
         id
         progress
-        }
+      }
       popularity
+      streamingEpisodes {
+        title
+        thumbnail
+      }
+
       favourites
       averageScore
       description
@@ -588,7 +706,7 @@ query($type:MediaType){
         }
       }
       tags {
-        name              
+        name
       }
       startDate {
         year
@@ -612,37 +730,41 @@ query($type:MediaType){
 """
 
 recommended_query = """
-query($type:MediaType){
-  Page(perPage:15) {
-    media( type: $type,genre_not_in:["hentai"]) {
-      recommendations(sort:RATING_DESC){
-        nodes{
-          media{
+query ($type: MediaType) {
+  Page(perPage: 15) {
+    media(type: $type, genre_not_in: ["hentai"]) {
+      recommendations(sort: RATING_DESC) {
+        nodes {
+          media {
             id
-        idMal
-            title{
+            idMal
+            title {
               english
               romaji
               native
             }
-            coverImage{
+            coverImage {
               medium
               large
             }
-            mediaListEntry{
-                id
-                progress
+            mediaListEntry {
+              status
+              id
+              progress
             }
             description
             episodes
-            trailer{
+            trailer {
               site
               id
             }
-            
             genres
             averageScore
             popularity
+            streamingEpisodes {
+              title
+              thumbnail
+            }
             favourites
             tags {
               name
@@ -672,9 +794,9 @@ query($type:MediaType){
 """
 
 anime_characters_query = """
-query($id:Int,$type:MediaType){
+query ($id: Int, $type: MediaType) {
   Page {
-    media(id:$id, type: $type) {
+    media(id: $id, type: $type) {
       characters {
         nodes {
           name {
@@ -707,13 +829,18 @@ query($id:Int,$type:MediaType){
 
 
 anime_relations_query = """
-query ($id: Int,$type:MediaType) {
+query ($id: Int, $type: MediaType) {
   Page(perPage: 20) {
-    media(id: $id, sort: POPULARITY_DESC, type: $type,genre_not_in:["hentai"]) {
+    media(
+      id: $id
+      sort: POPULARITY_DESC
+      type: $type
+      genre_not_in: ["hentai"]
+    ) {
       relations {
         nodes {
           id
-        idMal
+          idMal
           title {
             english
             romaji
@@ -723,10 +850,11 @@ query ($id: Int,$type:MediaType) {
             medium
             large
           }
-        mediaListEntry{
-        id
-        progress
-        }
+          mediaListEntry {
+            status
+            id
+            progress
+          }
           description
           episodes
           trailer {
@@ -736,26 +864,30 @@ query ($id: Int,$type:MediaType) {
           genres
           averageScore
           popularity
+          streamingEpisodes {
+            title
+            thumbnail
+          }
           favourites
           tags {
             name
           }
           startDate {
-              year
-              month
-              day
-            }
-            endDate {
-              year
-              month
-              day
-            }
-            status
-            nextAiringEpisode {
-              timeUntilAiring
-              airingAt
-              episode
-            }
+            year
+            month
+            day
+          }
+          endDate {
+            year
+            month
+            day
+          }
+          status
+          nextAiringEpisode {
+            timeUntilAiring
+            airingAt
+            episode
+          }
         }
       }
     }
@@ -781,7 +913,7 @@ query ($id: Int,$type:MediaType) {
 """
 
 upcoming_anime_query = """
-query ($page: Int,$type:MediaType) {
+query ($page: Int, $type: MediaType) {
   Page(page: $page) {
     pageInfo {
       total
@@ -789,9 +921,14 @@ query ($page: Int,$type:MediaType) {
       currentPage
       hasNextPage
     }
-    media(type: $type, 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
+      idMal
       title {
         romaji
         english
@@ -804,11 +941,16 @@ query ($page: Int,$type:MediaType) {
         site
         id
       }
-              mediaListEntry{
+      mediaListEntry {
+        status
         id
         progress
-        }
+      }
       popularity
+      streamingEpisodes {
+        title
+        thumbnail
+      }
       favourites
       averageScore
       genres
@@ -845,19 +987,20 @@ query ($page: Int,$type:MediaType) {
 """
 
 anime_query = """
-query($id:Int){
-  Page{
-    media(id:$id) {
+query ($id: Int) {
+  Page {
+    media(id: $id) {
       id
-        idMal
+      idMal
       title {
         romaji
         english
       }
-              mediaListEntry{
+      mediaListEntry {
+        status
         id
         progress
-        }
+      }
       nextAiringEpisode {
         timeUntilAiring
         airingAt
@@ -871,7 +1014,6 @@ query($id:Int){
           node {
             name {
               full
-              
             }
             gender
             dateOfBirth {
@@ -924,6 +1066,11 @@ query($id:Int){
       countryOfOrigin
       averageScore
       popularity
+      streamingEpisodes {
+        title
+        thumbnail
+      }
+
       favourites
       source
       hashtag

fastanime/libs/anilist/types.py

@@ -19,7 +19,7 @@ class AnilistImage(TypedDict):
     large: str
 
 
-class AnilistUser(TypedDict):
+class AnilistUser_(TypedDict):
     id: int
     name: str
     bannerImage: str | None
@@ -28,11 +28,26 @@ class AnilistUser(TypedDict):
 
 
 class AnilistViewer(TypedDict):
-    Viewer: AnilistUser
+    Viewer: AnilistUser_
+
+
+class AnilistViewerData(TypedDict):
+    data: AnilistViewer
+
+
+class AnilistUser(TypedDict):
+    name: str
+    about: str | None
+    avatar: AnilistImage
+    bannerImage: str | None
+
+
+class AnilistUserInfo(TypedDict):
+    User: AnilistUser
 
 
 class AnilistUserData(TypedDict):
-    data: AnilistViewer
+    data: AnilistUserInfo
 
 
 class AnilistMediaTrailer(TypedDict):
@@ -69,7 +84,7 @@ class AnilistMediaNextAiringEpisode(TypedDict):
 
 class AnilistReview(TypedDict):
     summary: str
-    user: AnilistUser
+    user: AnilistUser_
 
 
 class AnilistReviewNodes(TypedDict):
@@ -114,16 +129,17 @@ class AnilistCharactersEdges(TypedDict):
     edges: list[AnilistCharactersEdge]
 
 
-class AnilistMediaList_(TypedDict):
-    id: int
-    progress: int
-
-
 AnilistMediaListStatus = Literal[
     "CURRENT", "PLANNING", "COMPLETED", "DROPPED", "PAUSED", "REPEATING"
 ]
 
 
+class AnilistMediaList_(TypedDict):
+    id: int
+    progress: int
+    status: AnilistMediaListStatus
+
+
 class AnilistMediaListProperties(TypedDict):
     status: AnilistMediaListStatus
     score: float
@@ -136,6 +152,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 +180,8 @@ class AnilistBaseMediaDataSchema(TypedDict):
     status: str
     nextAiringEpisode: AnilistMediaNextAiringEpisode
     season: str
+    streamingEpisodes: list[StreamingEpisode]
+    chapters: int
     seasonYear: int
     duration: int
     synonyms: list[str]

fastanime/libs/anime_provider/__init__.py

@@ -1,12 +1,11 @@
+from .allanime.constants import SERVERS_AVAILABLE as ALLANIME_SERVERS
+from .animepahe.constants import SERVERS_AVAILABLE as ANIMEPAHE_SERVERS
+from .hianime.constants import SERVERS_AVAILABLE as HIANIME_SERVERS
+
 anime_sources = {
     "allanime": "api.AllAnimeAPI",
     "animepahe": "api.AnimePaheApi",
+    "hianime": "api.HiAnimeApi",
+    "nyaa": "api.NyaaApi",
 }
-SERVERS_AVAILABLE = [
-    "sharepoint",
-    "dropbox",
-    "gogoanime",
-    "weTransfer",
-    "wixmp",
-    "kwik",
-]
+SERVERS_AVAILABLE = [*ALLANIME_SERVERS, *ANIMEPAHE_SERVERS, *HIANIME_SERVERS]

fastanime/libs/anime_provider/allanime/api.py

@@ -7,23 +7,14 @@ import json
 import logging
 from typing import TYPE_CHECKING
 
-from requests.exceptions import Timeout
-
 from ...anime_provider.base_provider import AnimeProvider
-from ..utils import decode_hex_string, give_random_quality
-from .constants import (
-    ALLANIME_API_ENDPOINT,
-    ALLANIME_BASE,
-    ALLANIME_REFERER,
-    USER_AGENT,
-)
+from ..decorators import debug_provider
+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
 
 if TYPE_CHECKING:
-    from typing import Iterator
-
-    from ....libs.anime_provider.allanime.types import AllAnimeEpisode
-    from ....libs.anime_provider.types import Anime, Server
+    from .types import AllAnimeEpisode
 logger = logging.getLogger(__name__)
 
 
@@ -35,7 +26,11 @@ class AllAnimeAPI(AnimeProvider):
     Provides a fast and effective interface to AllAnime site.
     """
 
+    PROVIDER = "allanime"
     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
@@ -47,30 +42,21 @@ class AllAnimeAPI(AnimeProvider):
         Returns:
             [TODO:return]
         """
-        try:
-            response = self.session.get(
-                self.api_endpoint,
-                params={
-                    "variables": json.dumps(variables),
-                    "query": query,
-                },
-                headers={"Referer": ALLANIME_REFERER, "User-Agent": USER_AGENT},
-                timeout=10,
-            )
-            if response.status_code == 200:
-                return response.json()["data"]
-            else:
-                logger.error("allanime(ERROR): ", response.text)
-                return {}
-        except Timeout:
-            logger.error(
-                "allanime(Error):Timeout exceeded this could mean allanime is down or you have lost internet connection"
-            )
-            return {}
-        except Exception as e:
-            logger.error(f"allanime:Error: {e}")
+        response = self.session.get(
+            self.api_endpoint,
+            params={
+                "variables": json.dumps(variables),
+                "query": query,
+            },
+            timeout=10,
+        )
+        if response.ok:
+            return response.json()["data"]
+        else:
+            logger.error("[ALLANIME-ERROR]: ", response.text)
             return {}
 
+    @debug_provider(PROVIDER.upper())
     def search_for_anime(
         self,
         user_query: str,
@@ -103,29 +89,25 @@ class AllAnimeAPI(AnimeProvider):
             "translationtype": translationtype,
             "countryorigin": countryorigin,
         }
-        try:
-            search_results = self._fetch_gql(ALLANIME_SEARCH_GQL, variables)
-            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,
+        search_results = self._fetch_gql(ALLANIME_SEARCH_GQL, variables)
+        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"],
             }
-            return normalized_search_results
+            results.append(normalized_result)
 
-        except Exception as e:
-            logger.error(f"FA(AllAnime): {e}")
-            return {}
+        normalized_search_results = {
+            "pageInfo": page_info,
+            "results": results,
+        }
+        return normalized_search_results
 
+    @debug_provider(PROVIDER.upper())
     def get_anime(self, allanime_show_id: str):
         """get an anime details given its id
 
@@ -136,25 +118,23 @@ class AllAnimeAPI(AnimeProvider):
             [TODO:return]
         """
         variables = {"showId": allanime_show_id}
-        try:
-            anime = self._fetch_gql(ALLANIME_SHOW_GQL, variables)
-            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"AllAnime(get_anime): {e}")
-            return None
+        anime = self._fetch_gql(ALLANIME_SHOW_GQL, variables)
+        id: str = anime["show"]["_id"]
+        title: str = anime["show"]["name"]
+        availableEpisodesDetail = anime["show"]["availableEpisodesDetail"]
+        self.store.set(allanime_show_id, "anime_info", {"title": title})
+        type = anime.get("__typename")
+        normalized_anime = {
+            "id": id,
+            "title": title,
+            "availableEpisodesDetail": availableEpisodesDetail,
+            "type": type,
+        }
+        return normalized_anime
 
+    @debug_provider(PROVIDER.upper())
     def _get_anime_episode(
-        self, allanime_show_id: str, episode_string: str, translation_type: str = "sub"
+        self, allanime_show_id: str, episode, translation_type: str = "sub"
     ) -> "AllAnimeEpisode | dict":
         """get the episode details and sources info
 
@@ -169,18 +149,15 @@ class AllAnimeAPI(AnimeProvider):
         variables = {
             "showId": allanime_show_id,
             "translationType": translation_type,
-            "episodeString": episode_string,
+            "episodeString": episode,
         }
-        try:
-            episode = self._fetch_gql(ALLANIME_EPISODES_GQL, variables)
-            return episode["episode"]
-        except Exception as e:
-            logger.error(f"FA(AllAnime): {e}")
-            return {}
+        episode = self._fetch_gql(ALLANIME_EPISODES_GQL, variables)
+        return episode["episode"]
 
+    @debug_provider(PROVIDER.upper())
     def get_episode_streams(
-        self, anime: "Anime", episode_number: str, translation_type="sub"
-    ) -> "Iterator[Server] | None":
+        self, anime_id, episode_number: str, translation_type="sub"
+    ):
         """get the streams of an episode
 
         Args:
@@ -191,7 +168,10 @@ class AllAnimeAPI(AnimeProvider):
         Yields:
             [TODO:description]
         """
-        anime_id = anime["id"]
+
+        anime_title = (self.store.get(anime_id, "anime_info", "") or {"title": ""})[
+            "title"
+        ]
         allanime_episode = self._get_anime_episode(
             anime_id, episode_number, translation_type
         )
@@ -199,179 +179,117 @@ class AllAnimeAPI(AnimeProvider):
             return []
 
         embeds = allanime_episode["sourceUrls"]
-        try:
-            for embed in embeds:
-                try:
-                    # 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",
-                    ):
-                        continue
-                    url = embed.get("sourceUrl")
 
-                    if not url:
-                        continue
-                    if url.startswith("--"):
-                        url = url[2:]
+        @debug_provider(self.PROVIDER.upper())
+        def _get_server(embed):
+            # 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 (
+                # 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
+            ):
+                return
+            url = embed.get("sourceUrl")
+            #
+            if not url:
+                return
+            if url.startswith("--"):
+                url = url[2:]
+                url = one_digit_symmetric_xor(56, url)
 
-                    # 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')}"
-                    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",
-                                    "episode_title": (
-                                        allanime_episode["notes"] or f'{anime["title"]}'
-                                    )
-                                    + f"; Episode {episode_number}",
-                                    "links": give_random_quality(resp.json()["links"]),
-                                }  # pyright:ignore
-                            case "Kir":
-                                logger.debug("allanime:Found streams from wetransfer")
-                                yield {
-                                    "server": "wetransfer",
-                                    "episode_title": (
-                                        allanime_episode["notes"] or f'{anime["title"]}'
-                                    )
-                                    + f"; Episode {episode_number}",
-                                    "links": give_random_quality(resp.json()["links"]),
-                                }  # pyright:ignore
-                            case "S-mp4":
-                                logger.debug("allanime:Found streams from sharepoint")
-                                yield {
-                                    "server": "sharepoint",
-                                    "episode_title": (
-                                        allanime_episode["notes"] or f'{anime["title"]}'
-                                    )
-                                    + f"; Episode {episode_number}",
-                                    "links": give_random_quality(resp.json()["links"]),
-                                }  # pyright:ignore
-                            case "Sak":
-                                logger.debug("allanime:Found streams from dropbox")
-                                yield {
-                                    "server": "dropbox",
-                                    "episode_title": (
-                                        allanime_episode["notes"] or f'{anime["title"]}'
-                                    )
-                                    + f"; Episode {episode_number}",
-                                    "links": give_random_quality(resp.json()["links"]),
-                                }  # pyright:ignore
-                            case "Default":
-                                logger.debug("allanime:Found streams from wixmp")
-                                yield {
-                                    "server": "wixmp",
-                                    "episode_title": (
-                                        allanime_episode["notes"] or f'{anime["title"]}'
-                                    )
-                                    + f"; Episode {episode_number}",
-                                    "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 "tools.fast4speed.rsvp" in url:
+                return {
+                    "server": "Yt",
+                    "episode_title": f"{anime_title}; Episode {episode_number}",
+                    "headers": {"Referer": f"https://{ALLANIME_BASE}/"},
+                    "subtitles": [],
+                    "links": [
+                        {
+                            "link": url,
+                            "quality": "1080",
+                        }
+                    ],
+                }
 
+            # get the stream url for an episode of the defined source names
+            embed_url = f"https://{ALLANIME_BASE}{url.replace('clock', 'clock.json')}"
+            resp = self.session.get(
+                embed_url,
+                timeout=10,
+            )
 
-if __name__ == "__main__":
-    anime_provider = AllAnimeAPI()
-    # lets see if it works :)
-    import subprocess
-    import sys
+            if resp.ok:
+                match embed["sourceName"]:
+                    case "Luf-mp4":
+                        logger.debug("allanime:Found streams from gogoanime")
+                        return {
+                            "server": "gogoanime",
+                            "headers": {},
+                            "subtitles": [],
+                            "episode_title": (
+                                allanime_episode["notes"] or f"{anime_title}"
+                            )
+                            + f"; Episode {episode_number}",
+                            "links": give_random_quality(resp.json()["links"]),
+                        }
+                    case "Kir":
+                        logger.debug("allanime:Found streams from wetransfer")
+                        return {
+                            "server": "wetransfer",
+                            "headers": {},
+                            "subtitles": [],
+                            "episode_title": (
+                                allanime_episode["notes"] or f"{anime_title}"
+                            )
+                            + f"; Episode {episode_number}",
+                            "links": give_random_quality(resp.json()["links"]),
+                        }
+                    case "S-mp4":
+                        logger.debug("allanime:Found streams from sharepoint")
+                        return {
+                            "server": "sharepoint",
+                            "headers": {},
+                            "subtitles": [],
+                            "episode_title": (
+                                allanime_episode["notes"] or f"{anime_title}"
+                            )
+                            + f"; Episode {episode_number}",
+                            "links": give_random_quality(resp.json()["links"]),
+                        }
+                    case "Sak":
+                        logger.debug("allanime:Found streams from dropbox")
+                        return {
+                            "server": "dropbox",
+                            "headers": {},
+                            "subtitles": [],
+                            "episode_title": (
+                                allanime_episode["notes"] or f"{anime_title}"
+                            )
+                            + f"; Episode {episode_number}",
+                            "links": give_random_quality(resp.json()["links"]),
+                        }
+                    case "Default":
+                        logger.debug("allanime:Found streams from wixmp")
+                        return {
+                            "server": "wixmp",
+                            "headers": {},
+                            "subtitles": [],
+                            "episode_title": (
+                                allanime_episode["notes"] or f"{anime_title}"
+                            )
+                            + f"; Episode {episode_number}",
+                            "links": give_random_quality(resp.json()["links"]),
+                        }
 
-    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,  # pyright: ignore
-            episode,
-            translation.strip(),
-        )
-        if episode_streams_ is None:
-            raise Exception("Episode not found")
-
-        episode_streams = list(episode_streams_)
-        stream_links = []
-        for server in episode_streams:
-            stream_links.extend([link["link"] for link in server["links"]])
-        stream_links.append("back")
-        stream_link = inquirer.fuzzy(
-            "Choose a link to stream",
-            stream_links,
-            validate=validator.EmptyInputValidator(),
-        ).execute()
-        if stream_link == "quit":
-            print("Have a nice day")
-            sys.exit()
-        if not stream_link:
-            raise Exception("No stream was selected")
-
-        title = episode_streams[0].get(
-            "episode_title", "%s: Episode %s" % (anime_data["title"], episode)
-        )
-        subprocess.run(["mpv", f"--title={title}", stream_link])
+        for embed in embeds:
+            if server := _get_server(embed):
+                yield server

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/gql_queries.py

@@ -1,56 +1,56 @@
 ALLANIME_SEARCH_GQL = """
-query(
-        $search: SearchInput
-        $limit: Int
-        $page: Int
-        $translationType: VaildTranslationTypeEnumType
-        $countryOrigin: VaildCountryOriginEnumType
-    ) {
-    shows(
-        search: $search
-        limit: $limit
-        page: $page
-        translationType: $translationType
-        countryOrigin: $countryOrigin
-    ) {
-        pageInfo {
-            total
-        }
-        edges {    
-        _id
-        name
-        availableEpisodes
-        __typename
-        }
+query (
+  $search: SearchInput
+  $limit: Int
+  $page: Int
+  $translationType: VaildTranslationTypeEnumType
+  $countryOrigin: VaildCountryOriginEnumType
+) {
+  shows(
+    search: $search
+    limit: $limit
+    page: $page
+    translationType: $translationType
+    countryOrigin: $countryOrigin
+  ) {
+    pageInfo {
+      total
     }
+    edges {
+      _id
+      name
+      availableEpisodes
+      __typename
+    }
+  }
 }
 """
 
 
 ALLANIME_EPISODES_GQL = """\
-query ($showId: String!, $translationType: VaildTranslationTypeEnumType!, $episodeString: String!) {
-    episode(
-        showId: $showId
-        translationType: $translationType
-        episodeString: $episodeString
-    ) {
-        
-        episodeString
-        sourceUrls
-        notes
-    }
-}"""
+query (
+  $showId: String!
+  $translationType: VaildTranslationTypeEnumType!
+  $episodeString: String!
+) {
+  episode(
+    showId: $showId
+    translationType: $translationType
+    episodeString: $episodeString
+  ) {
+    episodeString
+    sourceUrls
+    notes
+  }
+}
+"""
 
 ALLANIME_SHOW_GQL = """
 query ($showId: String!) {
-    show(
-        _id: $showId
-    ) {
-
-        _id
-        name
-        availableEpisodesDetail
-        
-    }
+  show(_id: $showId) {
+    _id
+    name
+    availableEpisodesDetail
+  }
 }
 """

fastanime/libs/anime_provider/animepahe/api.py

@@ -1,88 +1,130 @@
 import logging
+import random
 import re
-import shutil
-import subprocess
+import time
 from typing import TYPE_CHECKING
 
 from yt_dlp.utils import (
     extract_attributes,
     get_element_by_id,
-    get_element_text_and_html_by_tag,
     get_elements_html_by_class,
 )
 
 from ..base_provider import AnimeProvider
+from ..decorators import debug_provider
 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
+    from .types import AnimePaheAnimePage, AnimePaheSearchPage, AnimePaheSearchResult
 JUICY_STREAM_REGEX = re.compile(r"source='(.*)';")
 logger = logging.getLogger(__name__)
 
+KWIK_RE = re.compile(r"Player\|(.+?)'")
+
 
-# TODO: hack this to completion
 class AnimePaheApi(AnimeProvider):
     search_page: "AnimePaheSearchPage"
     anime: "AnimePaheAnimePage"
+    HEADERS = REQUEST_HEADERS
+    PROVIDER = "animepahe"
 
+    @debug_provider(PROVIDER.upper())
     def search_for_anime(self, user_query: str, *args):
-        try:
-            url = f"{ANIMEPAHE_ENDPOINT}m=search&q={user_query}"
-            headers = {**REQUEST_HEADERS}
-            response = self.session.get(url, headers=headers)
-            if not response.status_code == 200:
-                return
-            data: "AnimePaheSearchPage" = response.json()
-            self.search_page = data
-
-            return {
-                "pageInfo": {
-                    "total": data["total"],
-                    "perPage": data["per_page"],
-                    "currentPage": data["current_page"],
-                },
-                "results": [
-                    {
-                        "availableEpisodes": list(range(result["episodes"])),
-                        "id": result["session"],
-                        "title": result["title"],
-                        "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:
-            logger.error(f"AnimePahe(search): {e}")
-            return {}
-
-    def get_anime(self, session_id: str, *args):
-        try:
-            anime_result: "AnimeSearchResult" = [
-                anime
-                for anime in self.search_page["data"]
-                if anime["session"] == session_id
-            ][0]
-            url = (
-                f"{ANIMEPAHE_ENDPOINT}m=release&id={session_id}&sort=episode_asc&page=1"
+        url = f"{ANIMEPAHE_ENDPOINT}m=search&q={user_query}"
+        response = self.session.get(
+            url,
+        )
+        if not response.ok:
+            return
+        data: "AnimePaheSearchPage" = response.json()
+        self.search_page = data
+        for animepahe_search_result in data["data"]:
+            self.store.set(
+                str(animepahe_search_result["session"]),
+                "search_result",
+                animepahe_search_result,
             )
-            response = self.session.get(url, headers=REQUEST_HEADERS)
-            if not response.status_code == 200:
+
+        return {
+            "pageInfo": {
+                "total": data["total"],
+                "perPage": data["per_page"],
+                "currentPage": data["current_page"],
+            },
+            "results": [
+                {
+                    "availableEpisodes": list(range(result["episodes"])),
+                    "id": result["session"],
+                    "title": result["title"],
+                    "type": result["type"],
+                    "year": result["year"],
+                    "score": result["score"],
+                    "status": result["status"],
+                    "season": result["season"],
+                    "poster": result["poster"],
+                }
+                for result in data["data"]
+            ],
+        }
+
+    @debug_provider(PROVIDER.upper())
+    def get_anime(self, session_id: str, *args):
+        page = 1
+        if d := self.store.get(str(session_id), "search_result"):
+            anime_result: "AnimePaheSearchResult" = d
+            data: "AnimePaheAnimePage" = {}  # pyright:ignore
+
+            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.ok:
+                    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 {}
-            data: "AnimePaheAnimePage" = response.json()
-            self.anime = data
-            episodes = list(map(str, range(data["total"])))
+            data["title"] = anime_result["title"]  # pyright:ignore
+            self.store.set(str(session_id), "anime_info", data)
+            episodes = list(map(str, [episode["episode"] for episode in data["data"]]))
             title = ""
             return {
                 "id": session_id,
@@ -98,7 +140,7 @@ class AnimePaheApi(AnimeProvider):
                 },
                 "episodesInfo": [
                     {
-                        "title": episode["title"] or f"{title};{episode['episode']}",
+                        "title": f"{episode['title'] or title};{episode['episode']}",
                         "episode": episode["episode"],
                         "id": episode["session"],
                         "translation_type": episode["audio"],
@@ -108,29 +150,30 @@ class AnimePaheApi(AnimeProvider):
                     for episode in data["data"]
                 ],
             }
-        except Exception as e:
-            logger.error(f"AnimePahe(anime): {e}")
-            return {}
 
+    @debug_provider(PROVIDER.upper())
     def get_episode_streams(
-        self, anime: "Anime", episode_number: str, translation_type, *args
+        self, anime_id, episode_number: str, translation_type, *args
     ):
+        anime_title = ""
+        episode = None
         # extract episode details from memory
-        episode = [
-            episode
-            for episode in self.anime["data"]
-            if float(episode["episode"]) == float(episode_number)
-        ]
+        if d := self.store.get(str(anime_id), "anime_info"):
+            anime_title = d["title"]
+            episode = [
+                episode
+                for episode in d["data"]
+                if float(episode["episode"]) == float(episode_number)
+            ]
 
         if not episode:
-            logger.error(f"AnimePahe(streams): episode {episode_number} doesn't exist")
+            logger.error(f"[ANIMEPAHE-ERROR]: 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, headers=REQUEST_HEADERS)
+        response = self.session.get(url)
         # get the element containing links to juicy streams
         c = get_element_by_id("resolutionMenu", response.text)
         resolutionMenuItems = get_elements_html_by_class("dropdown-item", c)
@@ -142,10 +185,16 @@ class AnimePaheApi(AnimeProvider):
 
         # get the episode title
         episode_title = (
-            episode["title"] or f"{anime['title']}; Episode {episode['episode']}"
+            f"{episode['title'] or anime_title}; Episode {episode['episode']}"
         )
         # get all links
-        streams = {"server": "kwik", "links": [], "episode_title": episode_title}
+        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"]
@@ -155,55 +204,27 @@ class AnimePaheApi(AnimeProvider):
                 continue
 
             if not embed_url:
-                logger.warn(
-                    "AnimePahe: embed url not found please report to the developers"
+                logger.warning(
+                    "[ANIMEPAHE-WARN]: embed url not found please report to the developers"
                 )
                 return []
             # get embed page
-            embed_response = self.session.get(embed_url, headers=SERVER_HEADERS)
-            embed = embed_response.text
-            # search for the encoded js
-            encoded_js = None
-            for _ in range(7):
-                content, html = get_element_text_and_html_by_tag("script", embed)
-                if not content:
-                    embed = embed.replace(html, "")
-                    continue
-                encoded_js = content
-                break
-            if not encoded_js:
-                logger.warn(
-                    "AnimePahe: Encoded js not found please report to the developers"
-                )
-                return []
-            # execute the encoded js with node for now or maybe forever in odrder to get a more workable info
-            NODE = shutil.which("node")
-            if not NODE:
-                logger.warn(
-                    "AnimePahe: animepahe currently requires node js to extract them juicy streams"
-                )
-                return []
-            result = subprocess.run(
-                [NODE, "-e", encoded_js],
-                text=True,
-                capture_output=True,
+            embed_response = self.session.get(
+                embed_url, headers={"User-Agent": self.USER_AGENT, **SERVER_HEADERS}
             )
-            # decoded js
-            evaluted_js = result.stderr
-            if not evaluted_js:
-                logger.warn(
-                    "AnimePahe: could not decode encoded js using node please report to developers"
-                )
-                return []
-            # get that juicy stream
-            match = JUICY_STREAM_REGEX.search(evaluted_js)
-            if not match:
-                logger.warn(
-                    "AnimePahe: could not find the juicy stream please report to developers"
-                )
-                return []
-            # get the actual hls stream link
-            juicy_stream = match.group(1)
+            if not response.ok:
+                continue
+            embed_page = embed_response.text
+
+            decoded_js = process_animepahe_embed_page(embed_page)
+            if not decoded_js:
+                logger.error("[ANIMEPAHE-ERROR]: failed to decode embed page")
+                return
+            juicy_stream = JUICY_STREAM_REGEX.search(decoded_js)
+            if not juicy_stream:
+                logger.error("[ANIMEPAHE-ERROR]: failed to find juicy stream")
+                return
+            juicy_stream = juicy_stream.group(1)
             # add the link
             streams["links"].append(
                 {

fastanime/libs/anime_provider/animepahe/constants.py

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

fastanime/libs/anime_provider/animepahe/types.py

@@ -1,7 +1,7 @@
 from typing import Literal, TypedDict
 
 
-class AnimeSearchResult(TypedDict):
+class AnimePaheSearchResult(TypedDict):
     id: int
     title: str
     type: str
@@ -21,7 +21,7 @@ class AnimePaheSearchPage(TypedDict):
     last_page: int
     _from: int
     to: int
-    data: list[AnimeSearchResult]
+    data: list[AnimePaheSearchResult]
 
 
 class Episode(TypedDict):

fastanime/libs/anime_provider/animepahe/utils.py

@@ -0,0 +1,75 @@
+# 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,
+    values_to_replace_with_k: list,
+):
+    decode_mapper_d: dict = {}
+    for i in range(no_of_keys_c):
+        key = animepahe_key_creator(i, base_a)
+        val = values_to_replace_with_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__":
+    # Testing time
+    filepath = input("Enter file name: ")
+    if filepath:
+        with open(filepath, "r") as file:
+            data = file.read()
+    else:
+        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,{}))</script>"""
+
+    print(process_animepahe_embed_page(data))

fastanime/libs/anime_provider/base_provider.py

@@ -1,8 +1,38 @@
+import os
+
 import requests
+from yt_dlp.utils.networking import random_user_agent
+
+from ...constants import APP_CACHE_DIR
+from .providers_store import ProviderStore
 
 
 class AnimeProvider:
     session: requests.Session
 
-    def __init__(self) -> None:
-        self.session = requests.session()
+    PROVIDER = ""
+    USER_AGENT = random_user_agent()
+    HEADERS = {}
+
+    def __init__(
+        self,
+        cache_requests=os.environ.get("FASTANIME_CACHE_REQUESTS", "false"),
+        store_type=os.environ.get("FASTANIME_PROVIDER_STORE_TYPE", "persistent"),
+    ) -> None:
+        if cache_requests.lower() == "true":
+            from ..common.requests_cacher import CachedRequestsSession
+
+            self.session = CachedRequestsSession(
+                os.path.join(APP_CACHE_DIR, "cached_requests.db")
+            )
+        else:
+            self.session = requests.session()
+        self.session.headers.update({"User-Agent": self.USER_AGENT, **self.HEADERS})
+        if store_type == "persistent":
+            self.store = ProviderStore(
+                "persistent",
+                self.PROVIDER,
+                os.path.join(APP_CACHE_DIR, "anime_providers_store.db"),
+            )
+        else:
+            self.store = ProviderStore("memory")

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/decorators.py

@@ -0,0 +1,39 @@
+import functools
+import logging
+import os
+
+logger = logging.getLogger(__name__)
+
+
+def debug_provider(provider_name: str):
+    def _provider_function_decorator(provider_function):
+        @functools.wraps(provider_function)
+        def _provider_function_wrapper(*args, **kwargs):
+            if not os.environ.get("FASTANIME_DEBUG"):
+                try:
+                    return provider_function(*args, **kwargs)
+                except Exception as e:
+                    logger.error(f"[{provider_name}@{provider_function.__name__}]: {e}")
+            else:
+                return provider_function(*args, **kwargs)
+
+        return _provider_function_wrapper
+
+    return _provider_function_decorator
+
+
+def ensure_internet_connection(provider_function):
+    @functools.wraps(provider_function)
+    def _wrapper(*args, **kwargs):
+        import requests
+
+        try:
+            requests.get("https://google.com", timeout=5)
+        except requests.ConnectionError:
+            from sys import exit
+
+            print("You are not connected to the internet;Aborting...")
+            exit(1)
+        return provider_function(*args, **kwargs)
+
+    return _wrapper

fastanime/libs/anime_provider/hianime/api.py

@@ -0,0 +1,243 @@
+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 ..decorators import debug_provider
+from ..utils import give_random_quality
+from .constants import SERVERS_AVAILABLE
+from .types import HiAnimeStream
+
+logger = logging.getLogger(__name__)
+
+LINK_TO_STREAMS_REGEX = re.compile(r".*://(.*)/embed-(2|4|6)/e-([0-9])/(.*)\?.*")
+IMAGE_HTML_ELEMENT_REGEX = re.compile(r"<img.*?>")
+
+
+class ParseAnchorAndImgTag(HTMLParser):
+    def __init__(self):
+        super().__init__()
+        self.img_tag = None
+        self.a_tag = None
+
+    def handle_starttag(self, tag, attrs):
+        if tag == "img":
+            self.img_tag = {attr[0]: attr[1] for attr in attrs}
+        if tag == "a":
+            self.a_tag = {attr[0]: attr[1] for attr in attrs}
+
+
+class HiAnimeApi(AnimeProvider):
+    # HEADERS = {"Referer": "https://hianime.to/home"}
+
+    PROVIDER = "hianime"
+
+    @debug_provider(PROVIDER.upper())
+    def search_for_anime(self, anime_title: str, *args):
+        query = quote_plus(anime_title)
+        url = f"https://hianime.to/search?keyword={query}"
+        response = self.session.get(url)
+        if not response.ok:
+            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"]
+
+            result = {
+                "availableEpisodes": list(range(1, episodes)),
+                "id": anime_id,
+                "title": title,
+                "poster": image_link,
+            }
+
+            results.append(result)
+
+            self.store.set(result["id"], "search_result", result)
+        return {"pageInfo": {}, "results": results}
+
+    @debug_provider(PROVIDER.upper())
+    def get_anime(self, hianime_id, *args):
+        anime_result = {}
+        if d := self.store.get(str(hianime_id), "search_result"):
+            anime_result = d
+            anime_url = f"https://hianime.to/ajax/v2/episode/list/{hianime_id}"
+            response = self.session.get(anime_url, timeout=10)
+            if response.ok:
+                response_json = response.json()
+                hianime_anime_page = response_json["html"]
+                episodes_info_container_html = get_element_html_by_class(
+                    "ss-list", hianime_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]
+                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
+                ]
+                self.store.set(
+                    str(hianime_id),
+                    "anime_info",
+                    episodes_info,
+                )
+                return {
+                    "id": hianime_id,
+                    "availableEpisodesDetail": {
+                        "dub": episodes,
+                        "sub": episodes,
+                        "raw": episodes,
+                    },
+                    "poster": anime_result["poster"],
+                    "title": anime_result["title"],
+                    "episodes_info": episodes_info,
+                }
+
+    @debug_provider(PROVIDER.upper())
+    def get_episode_streams(self, anime_id, episode, translation_type, *args):
+        if d := self.store.get(str(anime_id), "anime_info"):
+            episodes_info = d
+            episode_details = [
+                episode_details
+                for episode_details in 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.ok:
+                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.warning("HiAnime: sub not found")
+                    servers_html_sub = None
+
+                # dub servers
+                try:
+                    servers_html_dub = get_elements_html_by_class(
+                        "server-item", servers_containers_html[1]
+                    )
+                except Exception:
+                    logger.warning("HiAnime: 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
+
+                @debug_provider(self.PROVIDER.upper())
+                def _get_server(server_name, server_html):
+                    # 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.ok:
+                        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:
+                            return
+                        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.ok:
+                            juicy_streams_json: "HiAnimeStream" = (
+                                link_to_streams_response.json()
+                            )
+                            # TODO: Hianime decided to fucking encrypt shit
+                            # so got to fix it later
+                            return {
+                                "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"]}
+                                        for link in juicy_streams_json["tracks"]
+                                    ]
+                                ),
+                            }
+
+                for server_name, server_html in zip(
+                    cycle(SERVERS_AVAILABLE), servers_html
+                ):
+                    if server := _get_server(server_name, server_html):
+                        yield server

fastanime/libs/anime_provider/hianime/constants.py

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

fastanime/libs/anime_provider/hianime/types.py

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

fastanime/libs/anime_provider/nyaa/api.py

@@ -0,0 +1,345 @@
+import os
+import re
+from logging import getLogger
+
+from yt_dlp.utils import (
+    extract_attributes,
+    get_element_html_by_attribute,
+    get_element_html_by_class,
+    get_element_text_and_html_by_tag,
+    get_elements_html_by_class,
+)
+
+from ...common.mini_anilist import search_for_anime_with_anilist
+from ..base_provider import AnimeProvider
+from ..decorators import debug_provider
+from ..types import SearchResults
+from .constants import NYAA_ENDPOINT
+
+logger = getLogger(__name__)
+
+EXTRACT_USEFUL_INFO_PATTERN_1 = re.compile(
+    r"\[(\w+)\] (.+) - (\d+) [\[\(](\d+)p[\]\)].*"
+)
+
+EXTRACT_USEFUL_INFO_PATTERN_2 = re.compile(
+    r"\[(\w+)\] (.+)E(\d+) [\[\(]?(\d+)p.*[\]\)]?.*"
+)
+
+
+class NyaaApi(AnimeProvider):
+    search_results: SearchResults
+    PROVIDER = "nyaa"
+
+    @debug_provider(PROVIDER.upper())
+    def search_for_anime(self, user_query: str, *args, **_):
+        self.search_results = search_for_anime_with_anilist(
+            user_query, True
+        )  # pyright: ignore
+        self.user_query = user_query
+        return self.search_results
+
+    @debug_provider(PROVIDER.upper())
+    def get_anime(self, anilist_id: str, *_):
+        for anime in self.search_results["results"]:
+            if anime["id"] == anilist_id:
+                self.titles = [anime["title"], *anime["otherTitles"], self.user_query]
+                return {
+                    "id": anime["id"],
+                    "title": anime["title"],
+                    "poster": anime["poster"],
+                    "availableEpisodesDetail": {
+                        "dub": anime["availableEpisodes"],
+                        "sub": anime["availableEpisodes"],
+                        "raw": anime["availableEpisodes"],
+                    },
+                }
+
+    @debug_provider(PROVIDER.upper())
+    def get_episode_streams(
+        self,
+        anime_id: str,
+        episode_number: str,
+        translation_type: str,
+        trusted_only=bool(int(os.environ.get("FA_NYAA_TRUSTED_ONLY", "0"))),
+        allow_dangerous=bool(int(os.environ.get("FA_NYAA_ALLOW_DANGEROUS", "0"))),
+        sort_by="seeders",
+        *args,
+    ):
+        anime_title = self.titles[0]
+        logger.debug(f"Searching nyaa for query: '{anime_title} {episode_number}'")
+        servers = {}
+
+        torrents_table = ""
+        for title in self.titles:
+            try:
+                url_arguments: dict[str, str] = {
+                    "c": "1_2",  # Language (English)
+                    "q": f"{title} {'0' if len(episode_number)==1 else ''}{episode_number}",  # Search Query
+                }
+                # url_arguments["q"] = anime_title
+
+                # if trusted_only:
+                # url_arguments["f"] = "2"  # Trusted uploaders only
+
+                # What to sort torrents by
+                if sort_by == "seeders":
+                    url_arguments["s"] = "seeders"
+                elif sort_by == "date":
+                    url_arguments["s"] = "id"
+                elif sort_by == "size":
+                    url_arguments["s"] = "size"
+                elif sort_by == "comments":
+                    url_arguments["s"] = "comments"
+
+                logger.debug(f"URL Arguments: {url_arguments}")
+
+                response = self.session.get(NYAA_ENDPOINT, params=url_arguments)
+                if not response.ok:
+                    logger.error(f"[NYAA]: {response.text}")
+                    return
+
+                try:
+                    torrents_table = get_element_text_and_html_by_tag(
+                        "table", response.text
+                    )
+                except Exception as e:
+                    logger.error(f"[NYAA]: {e}")
+                    continue
+
+                if not torrents_table:
+                    continue
+
+                for anime_torrent in get_elements_html_by_class(
+                    "success", torrents_table[1]
+                ):
+                    td_title = get_element_html_by_attribute(
+                        "colspan", "2", anime_torrent
+                    )
+                    if not td_title:
+                        continue
+                    title_anchor_tag = get_element_text_and_html_by_tag("a", td_title)
+
+                    if not title_anchor_tag:
+                        continue
+                    title_anchor_tag_attrs = extract_attributes(title_anchor_tag[1])
+                    if not title_anchor_tag_attrs:
+                        continue
+                    if "class" in title_anchor_tag_attrs:
+                        td_title = td_title.replace(title_anchor_tag[1], "")
+                        title_anchor_tag = get_element_text_and_html_by_tag(
+                            "a", td_title
+                        )
+
+                        if not title_anchor_tag:
+                            continue
+                        title_anchor_tag_attrs = extract_attributes(title_anchor_tag[1])
+                        if not title_anchor_tag_attrs:
+                            continue
+                    anime_title_info = title_anchor_tag_attrs["title"]
+                    if not anime_title_info:
+                        continue
+                    match = EXTRACT_USEFUL_INFO_PATTERN_1.search(
+                        anime_title_info.strip()
+                    )
+                    if not match:
+                        continue
+                    server = match[1]
+                    match[2]
+                    _episode_number = match[3]
+                    quality = match[4]
+                    if float(episode_number) != float(_episode_number):
+                        continue
+
+                    links_td = get_element_html_by_class("text-center", anime_torrent)
+                    if not links_td:
+                        continue
+                    torrent_anchor_tag = get_element_text_and_html_by_tag("a", links_td)
+                    if not torrent_anchor_tag:
+                        continue
+                    torrent_anchor_tag_atrrs = extract_attributes(torrent_anchor_tag[1])
+                    if not torrent_anchor_tag_atrrs:
+                        continue
+                    torrent_file_url = (
+                        f'{NYAA_ENDPOINT}{torrent_anchor_tag_atrrs["href"]}'
+                    )
+                    if server in servers:
+                        link = {
+                            "translation_type": "sub",
+                            "link": torrent_file_url,
+                            "quality": quality,
+                        }
+                        if link not in servers[server]["links"]:
+                            servers[server]["links"].append(link)
+                    else:
+                        servers[server] = {
+                            "server": server,
+                            "headers": {},
+                            "episode_title": f"{anime_title}; Episode {episode_number}",
+                            "subtitles": [],
+                            "links": [
+                                {
+                                    "translation_type": "sub",
+                                    "link": torrent_file_url,
+                                    "quality": quality,
+                                }
+                            ],
+                        }
+                for anime_torrent in get_elements_html_by_class(
+                    "default", torrents_table[1]
+                ):
+                    td_title = get_element_html_by_attribute(
+                        "colspan", "2", anime_torrent
+                    )
+                    if not td_title:
+                        continue
+                    title_anchor_tag = get_element_text_and_html_by_tag("a", td_title)
+
+                    if not title_anchor_tag:
+                        continue
+                    title_anchor_tag_attrs = extract_attributes(title_anchor_tag[1])
+                    if not title_anchor_tag_attrs:
+                        continue
+                    if "class" in title_anchor_tag_attrs:
+                        td_title = td_title.replace(title_anchor_tag[1], "")
+                        title_anchor_tag = get_element_text_and_html_by_tag(
+                            "a", td_title
+                        )
+
+                        if not title_anchor_tag:
+                            continue
+                        title_anchor_tag_attrs = extract_attributes(title_anchor_tag[1])
+                        if not title_anchor_tag_attrs:
+                            continue
+                    anime_title_info = title_anchor_tag_attrs["title"]
+                    if not anime_title_info:
+                        continue
+                    match = EXTRACT_USEFUL_INFO_PATTERN_2.search(
+                        anime_title_info.strip()
+                    )
+                    if not match:
+                        continue
+                    server = match[1]
+                    match[2]
+                    _episode_number = match[3]
+                    quality = match[4]
+                    if float(episode_number) != float(_episode_number):
+                        continue
+
+                    links_td = get_element_html_by_class("text-center", anime_torrent)
+                    if not links_td:
+                        continue
+                    torrent_anchor_tag = get_element_text_and_html_by_tag("a", links_td)
+                    if not torrent_anchor_tag:
+                        continue
+                    torrent_anchor_tag_atrrs = extract_attributes(torrent_anchor_tag[1])
+                    if not torrent_anchor_tag_atrrs:
+                        continue
+                    torrent_file_url = (
+                        f'{NYAA_ENDPOINT}{torrent_anchor_tag_atrrs["href"]}'
+                    )
+                    if server in servers:
+                        link = {
+                            "translation_type": "sub",
+                            "link": torrent_file_url,
+                            "quality": quality,
+                        }
+                        if link not in servers[server]["links"]:
+                            servers[server]["links"].append(link)
+                    else:
+                        servers[server] = {
+                            "server": server,
+                            "headers": {},
+                            "episode_title": f"{anime_title}; Episode {episode_number}",
+                            "subtitles": [],
+                            "links": [
+                                {
+                                    "translation_type": "sub",
+                                    "link": torrent_file_url,
+                                    "quality": quality,
+                                }
+                            ],
+                        }
+                if not allow_dangerous:
+                    break
+                for anime_torrent in get_elements_html_by_class(
+                    "danger", torrents_table[1]
+                ):
+                    td_title = get_element_html_by_attribute(
+                        "colspan", "2", anime_torrent
+                    )
+                    if not td_title:
+                        continue
+                    title_anchor_tag = get_element_text_and_html_by_tag("a", td_title)
+
+                    if not title_anchor_tag:
+                        continue
+                    title_anchor_tag_attrs = extract_attributes(title_anchor_tag[1])
+                    if not title_anchor_tag_attrs:
+                        continue
+                    if "class" in title_anchor_tag_attrs:
+                        td_title = td_title.replace(title_anchor_tag[1], "")
+                        title_anchor_tag = get_element_text_and_html_by_tag(
+                            "a", td_title
+                        )
+
+                        if not title_anchor_tag:
+                            continue
+                        title_anchor_tag_attrs = extract_attributes(title_anchor_tag[1])
+                        if not title_anchor_tag_attrs:
+                            continue
+                    anime_title_info = title_anchor_tag_attrs["title"]
+                    if not anime_title_info:
+                        continue
+                    match = EXTRACT_USEFUL_INFO_PATTERN_2.search(
+                        anime_title_info.strip()
+                    )
+                    if not match:
+                        continue
+                    server = match[1]
+                    match[2]
+                    _episode_number = match[3]
+                    quality = match[4]
+                    if float(episode_number) != float(_episode_number):
+                        continue
+
+                    links_td = get_element_html_by_class("text-center", anime_torrent)
+                    if not links_td:
+                        continue
+                    torrent_anchor_tag = get_element_text_and_html_by_tag("a", links_td)
+                    if not torrent_anchor_tag:
+                        continue
+                    torrent_anchor_tag_atrrs = extract_attributes(torrent_anchor_tag[1])
+                    if not torrent_anchor_tag_atrrs:
+                        continue
+                    torrent_file_url = (
+                        f'{NYAA_ENDPOINT}{torrent_anchor_tag_atrrs["href"]}'
+                    )
+                    if server in servers:
+                        link = {
+                            "translation_type": "sub",
+                            "link": torrent_file_url,
+                            "quality": quality,
+                        }
+                        if link not in servers[server]["links"]:
+                            servers[server]["links"].append(link)
+                    else:
+                        servers[server] = {
+                            "server": server,
+                            "headers": {},
+                            "episode_title": f"{anime_title}; Episode {episode_number}",
+                            "subtitles": [],
+                            "links": [
+                                {
+                                    "translation_type": "sub",
+                                    "link": torrent_file_url,
+                                    "quality": quality,
+                                }
+                            ],
+                        }
+            except Exception as e:
+                logger.error(f"[NYAA]: {e}")
+                continue
+
+        for server in servers:
+            yield servers[server]

fastanime/libs/anime_provider/nyaa/constants.py

@@ -0,0 +1 @@
+NYAA_ENDPOINT = "https://nyaa.si"

fastanime/libs/anime_provider/nyaa/utils.py

@@ -0,0 +1,126 @@
+import logging
+import os
+import sys
+import time
+
+import libtorrent  # pyright: ignore
+from rich import print
+from rich.progress import (
+    BarColumn,
+    DownloadColumn,
+    Progress,
+    TextColumn,
+    TimeRemainingColumn,
+    TransferSpeedColumn,
+)
+
+logger = logging.getLogger("nyaa")
+
+
+def download_torrent(
+    filename: str,
+    result_filename: str | None = None,
+    show_progress: bool = True,
+    base_path: str = "Anime",
+) -> str:
+    session = libtorrent.session({"listen_interfaces": "0.0.0.0:6881"})
+    logger.debug("Started libtorrent session")
+
+    base_path = os.path.expanduser(base_path)
+    logger.debug(f"Downloading output to: '{base_path}'")
+
+    info = libtorrent.torrent_info(filename)
+
+    logger.debug("Started downloading torrent")
+    handle: libtorrent.torrent_handle = session.add_torrent(
+        {"ti": info, "save_path": base_path}
+    )
+
+    status: libtorrent.session_status = handle.status()
+
+    progress_bar = Progress(
+        "[progress.description]{task.description}",
+        BarColumn(bar_width=None),
+        "[progress.percentage]{task.percentage:>3.1f}%",
+        "•",
+        DownloadColumn(),
+        "•",
+        TransferSpeedColumn(),
+        "•",
+        TimeRemainingColumn(),
+        "•",
+        TextColumn("[green]Peers: {task.fields[peers]}[/green]"),
+    )
+
+    if show_progress:
+        with progress_bar:
+            download_task = progress_bar.add_task(
+                "downloading",
+                filename=status.name,
+                total=status.total_wanted,
+                peers=0,
+                start=False,
+            )
+
+            while not status.total_done:
+                # Checking files
+                status = handle.status()
+                description = "[bold yellow]Checking files[/bold yellow]"
+                progress_bar.update(
+                    download_task,
+                    completed=status.total_done,
+                    peers=status.num_peers,
+                    description=description,
+                )
+
+            # Started download
+            progress_bar.start_task(download_task)
+            description = f"[bold blue]Downloading[/bold blue] [bold yellow]{result_filename}[/bold yellow]"
+
+            while not status.is_seeding:
+                status = handle.status()
+
+                progress_bar.update(
+                    download_task,
+                    completed=status.total_done,
+                    peers=status.num_peers,
+                    description=description,
+                )
+
+                alerts = session.pop_alerts()
+
+                alert: libtorrent.alert
+                for alert in alerts:
+                    if (
+                        alert.category()
+                        & libtorrent.alert.category_t.error_notification
+                    ):
+                        logger.debug(f"[Alert] {alert}")
+
+                time.sleep(1)
+
+            progress_bar.update(
+                download_task,
+                description=f"[bold blue]Finished Downloading[/bold blue] [bold green]{result_filename}[/bold green]",
+                completed=status.total_wanted,
+            )
+
+    if result_filename:
+        old_name = f"{base_path}/{status.name}"
+        new_name = f"{base_path}/{result_filename}"
+
+        os.rename(old_name, new_name)
+
+        logger.debug(f"Finished torrent download, renamed '{old_name}' to '{new_name}'")
+
+        return new_name
+
+    return ""
+
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        print("You need to pass in the .torrent file path.")
+        sys.exit(1)
+
+    download_torrent(sys.argv[1])

fastanime/libs/anime_provider/providers_store.py

@@ -0,0 +1,114 @@
+import json
+import logging
+import time
+
+logger = logging.getLogger(__name__)
+
+
+class ProviderStoreDB:
+    def __init__(
+        self,
+        provider_name,
+        cache_db_path: str,
+        max_lifetime: int = 604800,
+        max_size: int = (1024**2) * 10,
+        table_name: str = "fastanime_providers_store",
+        clean_db=False,
+    ):
+        from ..common.sqlitedb_helper import SqliteDB
+
+        self.cache_db_path = cache_db_path
+        self.clean_db = clean_db
+        self.provider_name = provider_name
+        self.max_lifetime = max_lifetime
+        self.max_size = max_size
+        self.table_name = table_name
+        self.sqlite_db_connection = SqliteDB(self.cache_db_path)
+
+        # Prepare the cache table if it doesn't exist
+        self._create_store_table()
+
+    def _create_store_table(self):
+        """Create cache table if it doesn't exist."""
+        with self.sqlite_db_connection as conn:
+            conn.execute(
+                f"""
+                CREATE TABLE IF NOT EXISTS {self.table_name} (
+                    id TEXT, 
+                    data_type TEXT,
+                    provider_name TEXT, 
+                    data TEXT, 
+                    cache_expiry INTEGER
+                )"""
+            )
+
+    def get(self, id: str, data_type: str, default=None):
+        with self.sqlite_db_connection as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                f"""
+                SELECT
+                    data
+                FROM {self.table_name}
+                WHERE
+                    id = ?
+                    AND data_type = ?
+                    AND provider_name = ? 
+                    AND cache_expiry > ?
+                """,
+                (id, data_type, self.provider_name, int(time.time())),
+            )
+            cached_data = cursor.fetchone()
+
+            if cached_data:
+                logger.debug("Found existing request in cache")
+                (json_data,) = cached_data
+                return json.loads(json_data)
+        return default
+
+    def set(self, id: str, data_type: str, data):
+        with self.sqlite_db_connection as connection:
+            cursor = connection.cursor()
+            cursor.execute(
+                f"""
+                INSERT INTO {self.table_name} 
+                VALUES ( ?, ?,?, ?, ?)
+                """,
+                (
+                    id,
+                    data_type,
+                    self.provider_name,
+                    json.dumps(data),
+                    int(time.time()) + self.max_lifetime,
+                ),
+            )
+
+
+class ProviderStoreMem:
+    def __init__(self) -> None:
+        from collections import defaultdict
+
+        self._store = defaultdict(dict)
+
+    def get(self, id: str, data_type: str, default=None):
+        return self._store[id][data_type]
+
+    def set(self, id: str, data_type: str, data):
+        self._store[id][data_type] = data
+
+
+def ProviderStore(store_type, *args, **kwargs):
+    if store_type == "persistent":
+        return ProviderStoreDB(*args, **kwargs)
+    else:
+        return ProviderStoreMem()
+
+
+if __name__ == "__main__":
+    store = ProviderStore("persistent", "test_provider", "provider_store")
+    store.set("123", "test", {"hello": "world"})
+    print(store.get("123", "test"))
+    print("-------------------------------")
+    store = ProviderStore("memory")
+    store.set("1", "test", {"hello": "world"})
+    print(store.get("1", "test"))

fastanime/libs/anime_provider/types.py

@@ -19,6 +19,7 @@ class PageInfo(TypedDict):
 class SearchResult(TypedDict):
     id: str
     title: str
+    otherTitles: list[str]
     availableEpisodes: list[str]
     type: str
     score: int
@@ -39,9 +40,20 @@ class AnimeEpisodeDetails(TypedDict):
     raw: list[str]
 
 
-class AnimeEpisode(TypedDict):
+#
+# class AnimeEpisode(TypedDict):
+#     id: str
+#     title: str
+#
+
+
+class AnimeEpisodeInfo(TypedDict):
     id: str
     title: str
+    episode: str
+    poster: str | None
+    duration: str | None
+    translation_type: str | None
 
 
 class Anime(TypedDict):
@@ -49,7 +61,7 @@ class Anime(TypedDict):
     title: str
     availableEpisodesDetail: AnimeEpisodeDetails
     type: str | None
-    episodesInfo: list[AnimeEpisode] | None
+    episodesInfo: list[AnimeEpisodeInfo] | None
     poster: str
     year: str
 
@@ -60,12 +72,19 @@ class EpisodeStream(TypedDict):
     hls: bool | None
     mp4: bool | None
     priority: int | None
-    headers: dict | 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
     links: list[EpisodeStream]

fastanime/libs/anime_provider/utils.py

@@ -35,15 +35,23 @@ hex_to_char = {
 }
 
 
-def give_random_quality(links: list[dict]):
-    qualities = cycle(["1080", "720", "360"])
+def give_random_quality(links):
+    qualities = cycle(["1080", "720", "480", "360"])
 
     return [
-        {"link": link["link"], "quality": quality}
-        for link, quality in zip(links, qualities)
+        {**episode_stream, "quality": quality}
+        for episode_stream, quality in zip(links, qualities)
     ]
 
 
+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/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/common/mini_anilist.py

@@ -0,0 +1,323 @@
+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_manga_with_anilist(manga_title: str):
+    query = """
+        query ($query: String) {
+        Page(perPage: 50) {
+            pageInfo {
+            currentPage
+            }
+            media(search: $query, type: MANGA,genre_not_in: ["hentai"]) {
+            id
+            idMal
+            title {
+                romaji
+                english
+            }
+            chapters
+            status
+            coverImage {
+                medium
+                large
+            }
+            }
+        }
+        }
+    """
+    response = post(
+        ANILIST_ENDPOINT,
+        json={"query": query, "variables": {"query": manga_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"],
+                    "poster": anime_result["coverImage"]["large"],
+                    "title": (
+                        anime_result["title"]["romaji"]
+                        or anime_result["title"]["english"]
+                    )
+                    + f"  [Chapters: {anime_result['chapters']}]",
+                    "type": "manga",
+                    "availableChapters": list(
+                        range(
+                            1,
+                            (
+                                anime_result["chapters"]
+                                if anime_result["chapters"]
+                                else 0
+                            ),
+                        )
+                    ),
+                }
+                for anime_result in anilist_data["data"]["Page"]["media"]
+            ],
+        }
+
+
+def search_for_anime_with_anilist(anime_title: str, prefer_eng_titles=False):
+    query = """
+query ($query: String) {
+  Page(perPage: 50) {
+    pageInfo {
+      total
+      currentPage
+      hasNextPage
+    }
+    media(search: $query, type: ANIME, genre_not_in: ["hentai"]) {
+      id
+      idMal
+      title {
+        romaji
+        english
+      }
+      episodes
+      status
+      synonyms
+      nextAiringEpisode {
+        timeUntilAiring
+        airingAt
+        episode
+      }
+      coverImage {
+        large
+      }
+    }
+  }
+}
+    """
+    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": str(anime_result["id"]),
+                    "title": (
+                        (
+                            anime_result["title"]["english"]
+                            or anime_result["title"]["romaji"]
+                        )
+                        if prefer_eng_titles
+                        else (
+                            anime_result["title"]["romaji"]
+                            or anime_result["title"]["english"]
+                        )
+                    ),
+                    "otherTitles": [
+                        (
+                            (
+                                anime_result["title"]["romaji"]
+                                or anime_result["title"]["english"]
+                            )
+                            if prefer_eng_titles
+                            else (
+                                anime_result["title"]["english"]
+                                or anime_result["title"]["romaji"]
+                            )
+                        ),
+                        *(anime_result["synonyms"] or []),
+                    ],
+                    "type": "anime",
+                    "poster": anime_result["coverImage"]["large"],
+                    "availableEpisodes": list(
+                        map(
+                            str,
+                            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
+                                        )
+                                        if not anime_result["episodes"]
+                                        else anime_result["episodes"]
+                                    )
+                                )
+                                + 1,
+                            ),
+                        )
+                    ),
+                }
+                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,genre_not_in: ["hentai"]) {
+            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.lower(), str(anime["title"]["romaji"]).lower()
+                        ),
+                        fuzz.ratio(
+                            anime_title.lower(), str(anime["title"]["english"]).lower()
+                        ),
+                    )
+                ),
+            )
+            return {
+                "idAnilist": 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/common/requests_cacher.py

@@ -0,0 +1,212 @@
+import json
+import logging
+import re
+import time
+from datetime import datetime
+from urllib.parse import urlencode
+
+import requests
+
+from .sqlitedb_helper import SqliteDB
+
+logger = logging.getLogger(__name__)
+
+caching_mimetypes = {
+    "application": {
+        "json",
+        "xml",
+        "x-www-form-urlencoded",
+        "x-javascript",
+        "javascript",
+    },
+    "text": {"html", "css", "javascript", "plain", "xml", "xsl", "x-javascript"},
+}
+
+
+class CachedRequestsSession(requests.Session):
+    __request_functions__ = (
+        "get",
+        "options",
+        "head",
+        "post",
+        "put",
+        "patch",
+        "delete",
+    )
+
+    def __new__(cls, *args, **kwargs):
+        def caching_params(name: str):
+            def wrapper(self, *args, **kwargs):
+                return cls.request(self, name, *args, **kwargs)
+
+            return wrapper
+
+        for func in cls.__request_functions__:
+            setattr(cls, func, caching_params(func))
+
+        return super().__new__(cls)
+
+    def __init__(
+        self,
+        cache_db_path: str,
+        max_lifetime: int = 604800,
+        max_size: int = (1024**2) * 10,
+        table_name: str = "fastanime_requests_cache",
+        clean_db=False,
+        *args,
+        **kwargs,
+    ):
+        super().__init__(*args, **kwargs)
+
+        self.cache_db_path = cache_db_path
+        self.max_lifetime = max_lifetime
+        self.max_size = max_size
+        self.table_name = table_name
+        self.sqlite_db_connection = SqliteDB(self.cache_db_path)
+
+        # Prepare the cache table if it doesn't exist
+        self._create_cache_table()
+
+    def _create_cache_table(self):
+        """Create cache table if it doesn't exist."""
+        with self.sqlite_db_connection as conn:
+            conn.execute(
+                f"""
+                CREATE TABLE IF NOT EXISTS {self.table_name} (
+                    url TEXT, 
+                    status_code INTEGER, 
+                    request_headers TEXT, 
+                    response_headers TEXT, 
+                    data BLOB,
+                    redirection_policy INT,
+                    cache_expiry INTEGER
+                )"""
+            )
+
+    def request(
+        self,
+        method,
+        url,
+        params=None,
+        force_caching=False,
+        fresh=False,
+        *args,
+        **kwargs,
+    ):
+        if fresh:
+            logger.debug("Executing fresh request")
+            return super().request(method, url, params=params, *args, **kwargs)
+
+        if params:
+            url += "?" + urlencode(params)
+
+        redirection_policy = int(kwargs.get("force_redirects", False))
+
+        with self.sqlite_db_connection as conn:
+            cursor = conn.cursor()
+            time_before_access_db = datetime.now()
+
+            logger.debug("Checking for existing request in cache")
+            cursor.execute(
+                f"""
+                SELECT
+                    status_code,
+                    request_headers,
+                    response_headers,
+                    data,
+                    redirection_policy
+                FROM {self.table_name}
+                WHERE
+                    url = ? 
+                    AND redirection_policy = ? 
+                    AND cache_expiry > ?
+                """,
+                (url, redirection_policy, int(time.time())),
+            )
+            cached_request = cursor.fetchone()
+            time_after_access_db = datetime.now()
+
+            if cached_request:
+                logger.debug("Found existing request in cache")
+                (
+                    status_code,
+                    request_headers,
+                    response_headers,
+                    data,
+                    redirection_policy,
+                ) = cached_request
+
+                response = requests.Response()
+                response.headers.update(json.loads(response_headers))
+                response.status_code = status_code
+                response._content = data
+
+                if "timeout" in kwargs:
+                    kwargs.pop("timeout")
+                if "headers" in kwargs:
+                    kwargs.pop("headers")
+                _request = requests.Request(
+                    method, url, headers=json.loads(request_headers), *args, **kwargs
+                )
+                response.request = _request.prepare()
+                response.elapsed = time_after_access_db - time_before_access_db
+
+                return response
+
+            # Perform the request and cache it
+            response = super().request(method, url, *args, **kwargs)
+            if response.ok and (
+                force_caching
+                or self.is_content_type_cachable(
+                    response.headers.get("content-type"), caching_mimetypes
+                )
+                and len(response.content) < self.max_size
+            ):
+                logger.debug("Caching the current request")
+                cursor.execute(
+                    f"""
+                    INSERT INTO {self.table_name} 
+                    VALUES (?, ?, ?, ?, ?, ?, ?)
+                    """,
+                    (
+                        url,
+                        response.status_code,
+                        json.dumps(dict(response.request.headers)),
+                        json.dumps(dict(response.headers)),
+                        response.content,
+                        redirection_policy,
+                        int(time.time()) + self.max_lifetime,
+                    ),
+                )
+
+            return response
+
+    @staticmethod
+    def is_content_type_cachable(content_type, caching_mimetypes):
+        """Checks whether the given encoding is supported by the cacher"""
+        if content_type is None:
+            return True
+
+        mime, contents = content_type.split("/")
+
+        contents = re.sub(r";.*$", "", contents)
+
+        return mime in caching_mimetypes and any(
+            content in caching_mimetypes[mime] for content in contents.split("+")
+        )
+
+
+if __name__ == "__main__":
+    with CachedRequestsSession("cache.db") as session:
+        response = session.get(
+            "https://google.com",
+        )
+
+        response_b = session.get(
+            "https://google.com",
+        )
+
+        print("A: ", response.elapsed)
+        print("B: ", response_b.elapsed)
+
+        print(response_b.text[0:30])

fastanime/libs/common/sqlitedb_helper.py

@@ -0,0 +1,34 @@
+import logging
+import sqlite3
+import time
+
+logger = logging.getLogger(__name__)
+
+
+class SqliteDB:
+    def __init__(self, db_path: str) -> None:
+        self.db_path = db_path
+        self.connection = sqlite3.connect(self.db_path)
+        logger.debug("Enabling WAL mode for concurrent access")
+        self.connection.execute("PRAGMA journal_mode=WAL;")
+        self.connection.close()
+        self.connection = None
+
+    def __enter__(self):
+        logger.debug("Starting new connection...")
+        start_time = time.time()
+        self.connection = sqlite3.connect(self.db_path)
+        logger.debug(
+            "Successfully got a new connection in {} seconds".format(
+                time.time() - start_time
+            )
+        )
+        return self.connection
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if self.connection:
+            logger.debug("Closing connection to cache db")
+            self.connection.commit()
+            self.connection.close()
+            self.connection = None
+            logger.debug("Successfully closed connection to cache db")

fastanime/libs/fzf/__init__.py

@@ -5,7 +5,6 @@ import subprocess
 import sys
 from typing import Callable, List
 
-# TODO: will probably scrap art not to useful
 from click import clear
 from rich import print
 
@@ -123,7 +122,9 @@ class FZF:
             [self.FZF_EXECUTABLE, *commands],
             input=fzf_input,
             stdout=subprocess.PIPE,
+            universal_newlines=True,
             text=True,
+            encoding="utf-8",
         )
         if not result or result.returncode != 0 or not result.stdout:
             print("sth went wrong:confused:")
@@ -162,7 +163,7 @@ class FZF:
             HEADER,
             "--header-first",
             "--prompt",
-            prompt.title(),
+            f"{prompt.title()}: ",
         ]  # pyright:ignore
 
         if preview:

fastanime/libs/manga_provider/__init__.py

@@ -0,0 +1 @@
+manga_sources = {"mangadex": "api.MangaDexApi"}

fastanime/libs/manga_provider/base_provider.py

@@ -0,0 +1,13 @@
+import requests
+from yt_dlp.utils.networking import random_user_agent
+
+
+class MangaProvider:
+    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/manga_provider/common.py

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

fastanime/libs/manga_provider/mangadex/api.py

@@ -0,0 +1,51 @@
+import logging
+
+from ...common.mini_anilist import search_for_manga_with_anilist
+from ..base_provider import MangaProvider
+from ..common import fetch_manga_info_from_bal
+
+logger = logging.getLogger(__name__)
+
+
+class MangaDexApi(MangaProvider):
+    def search_for_manga(self, title: str, *args):
+        try:
+            search_results = search_for_manga_with_anilist(title)
+            return search_results
+        except Exception as e:
+            logger.error(f"[MANGADEX-ERROR]: {e}")
+
+    def get_manga(self, anilist_manga_id: str):
+        bal_data = fetch_manga_info_from_bal(anilist_manga_id)
+        if not bal_data:
+            return
+        manga_id, MangaDexManga = next(iter(bal_data["Sites"]["Mangadex"].items()))
+        return {
+            "id": manga_id,
+            "title": MangaDexManga["title"],
+            "poster": MangaDexManga["image"],
+            "availableChapters": [],
+        }
+
+    def get_chapter_thumbnails(self, manga_id, chapter):
+        chapter_info_url = f"https://api.mangadex.org/chapter?manga={manga_id}&translatedLanguage[]=en&chapter={chapter}&includeEmptyPages=0"
+        chapter_info_response = self.session.get(chapter_info_url)
+        if not chapter_info_response.ok:
+            return
+        chapter_info = next(iter(chapter_info_response.json()["data"]))
+        chapters_thumbnails_url = (
+            f"https://api.mangadex.org/at-home/server/{chapter_info['id']}"
+        )
+        chapter_thumbnails_response = self.session.get(chapters_thumbnails_url)
+        if not chapter_thumbnails_response.ok:
+            return
+        chapter_thumbnails_info = chapter_thumbnails_response.json()
+        base_url = chapter_thumbnails_info["baseUrl"]
+        hash = chapter_thumbnails_info["chapter"]["hash"]
+        return {
+            "thumbnails": [
+                f"{base_url}/data/{hash}/{chapter_thumbnail}"
+                for chapter_thumbnail in chapter_thumbnails_info["chapter"]["data"]
+            ],
+            "title": chapter_info["attributes"]["title"],
+        }

fastanime/libs/rofi/__init__.py

@@ -2,8 +2,6 @@ import subprocess
 from shutil import which
 from sys import exit
 
-from plyer import notification
-
 from fastanime import APP_NAME
 
 from ...constants import ICON_PATH
@@ -25,7 +23,7 @@ class RofiApi:
         args = [self.ROFI_EXECUTABLE]
         if self.rofi_theme:
             args.extend(["-no-config", "-theme", self.rofi_theme])
-        args.extend(["-p", prompt_text, "-i", "-show-icons", "-dmenu"])
+        args.extend(["-p", f"{prompt_text.title()}", "-i", "-show-icons", "-dmenu"])
         result = subprocess.run(
             args,
             input=rofi_input,
@@ -35,6 +33,13 @@ class RofiApi:
 
         choice = result.stdout.strip()
         if not choice:
+            try:
+                from plyer import notification
+            except ImportError:
+                print(
+                    "Plyer is not installed; install it for desktop notifications to be enabled"
+                )
+                exit(1)
             notification.notify(
                 app_name=APP_NAME,
                 app_icon=ICON_PATH,
@@ -64,6 +69,13 @@ class RofiApi:
 
         choice = result.stdout.strip()
         if not choice or choice not in options:
+            try:
+                from plyer import notification
+            except ImportError:
+                print(
+                    "Plyer is not installed; install it for desktop notifications to be enabled"
+                )
+                exit(1)
             notification.notify(
                 app_name=APP_NAME,
                 app_icon=ICON_PATH,
@@ -91,6 +103,13 @@ class RofiApi:
 
         choice = result.stdout.strip()
         if not choice:
+            try:
+                from plyer import notification
+            except ImportError:
+                print(
+                    "Plyer is not installed; install it for desktop notifications to be enabled"
+                )
+                exit(1)
             notification.notify(
                 app_name=APP_NAME,
                 app_icon=ICON_PATH,
@@ -120,6 +139,13 @@ class RofiApi:
 
         user_input = result.stdout.strip()
         if not user_input:
+            try:
+                from plyer import notification
+            except ImportError:
+                print(
+                    "Plyer is not installed; install it for desktop notifications to be enabled"
+                )
+                exit(1)
             notification.notify(
                 app_name=APP_NAME,
                 app_icon=ICON_PATH,

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "fastanime"
-version = "1.0.0"
+version = "2.5.8"
 description = "A browser anime site experience from the terminal"
 authors = ["Benextempest <benextempest@gmail.com>"]
 license = "UNLICENSE"
@@ -9,17 +9,20 @@ readme = "README.md"
 [tool.poetry.dependencies]
 python = "^3.10"
 yt-dlp = "^2024.5.27"
-rich = "^13.7.1"
-click = "^8.1.7"
-inquirerpy = "^0.3.4"
-platformdirs = "^4.2.2"
-python-dotenv = "^1.0.1"
 thefuzz = "^0.22.1"
 requests = "^2.32.3"
-plyer = "^2.1.0"
-pyshortcuts = "^1.9.0"
+rich = { version = "^13.7.1", optional = false }
+click = { version = "^8.1.7", optional = false }
+inquirerpy = { version = "^0.3.4", optional = false }
+mpv = { version = "^1.0.7", optional = true }
+plyer = { version = "^2.1.0", optional = true }
+
+[tool.poetry.extras]
+full = ["plyer", "mpv"]
+# cli = ["rich", "click", "inquirerpy"]
+mpv = ["mpv"]
+notifications = ["plyer"]
 
-mpv = "^1.0.7"
 [tool.poetry.group.dev.dependencies]
 black = "^24.4.2"
 isort = "^5.13.2"

pyrightconfig.json

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

tests/test_all_commands.py

@@ -1,4 +1,3 @@
-# TODO: Write tests to make sure all click commands work
 import pytest
 from click.testing import CliRunner
 
@@ -7,7 +6,7 @@ from fastanime.cli import run_cli
 
 @pytest.fixture
 def runner():
-    return CliRunner()
+    return CliRunner(env={"FASTANIME_CACHE_REQUESTS": "false"})
 
 
 def test_main_help(runner: CliRunner):
@@ -60,6 +59,11 @@ def test_update_help(runner: CliRunner):
     assert result.exit_code == 0
 
 
+def test_grab_help(runner: CliRunner):
+    result = runner.invoke(run_cli, ["grab", "--help"])
+    assert result.exit_code == 0
+
+
 def test_anilist_help(runner: CliRunner):
     result = runner.invoke(run_cli, ["anilist", "--help"])
     assert result.exit_code == 0

tox.ini

@@ -7,7 +7,7 @@ env_list = lint, pyright, py{310,311}
 description = run unit tests
 deps =poetry
 commands =
-    poetry install
+    poetry install --all-extras
     poetry run pytest
 
 [testenv:lint]
@@ -15,7 +15,7 @@ description = run linters
 skip_install = true
 deps =poetry
 commands = 
-    poetry install
+    poetry install --all-extras
     poetry run black .
 
 [testenv:pyright]
@@ -23,5 +23,5 @@ description = run type checking
 skip_install = true
 deps =poetry
 commands = 
-    poetry install --no-root
+    poetry install --no-root --all-extras
     poetry run pyright