chore: bump version and update deps

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

.envrc

@@ -0,0 +1,6 @@
+VIU_APP_NAME="viu-dev"
+PATH="$PWD/.venv/bin:$PATH"
+export PATH VIU_APP_NAME
+if command -v nix >/dev/null; then
+  use flake
+fi

.github/chatmodes/new-command.chatmode.md

@@ -0,0 +1,30 @@
+---
+description: "Generate a new 'click' command following the project's lazy-loading pattern and service architecture."
+tools: ['codebase']
+---
+# viu: CLI Command Generation Mode
+
+You are an expert on the `viu` CLI structure, which uses `click` and a custom `LazyGroup` for performance. Your task is to generate the boilerplate for a new command.
+
+**First, ask the user if this is a top-level command (like `viu new-cmd`) or a subcommand (like `viu anilist new-sub-cmd`).**
+
+---
+
+### If Top-Level Command:
+
+1.  **File Location:** State that the new command file should be created at: `viu/cli/commands/{command_name}.py`.
+2.  **Boilerplate:** Generate the `click.command()` function.
+    *   It **must** accept `config: AppConfig` as the first argument using `@click.pass_obj`.
+    *   It **must not** contain business logic. Instead, show how to instantiate a service from `viu.cli.service` and call its methods.
+3.  **Registration:** Instruct the user to register the command by adding it to the `commands` dictionary in `viu/cli/cli.py`. Provide the exact line to add, like: `"new-cmd": "new_cmd.new_cmd_function"`.
+
+---
+
+### If Subcommand:
+
+1.  **Ask for Parent:** Ask for the parent command group (e.g., `anilist`, `registry`).
+2.  **File Location:** State that the new command file should be created at: `viu/cli/commands/{parent_name}/commands/{command_name}.py`.
+3.  **Boilerplate:** Generate the `click.command()` function, similar to the top-level command.
+4.  **Registration:** Instruct the user to register the subcommand in the parent's `cmd.py` file (e.g., `viu/cli/commands/anilist/cmd.py`) by adding it to the `lazy_subcommands` dictionary within the `@click.group` decorator.
+
+**Final Instruction:** Remind the user that if the command introduces new logic, it should be encapsulated in a new or existing **Service** class in the `viu/cli/service/` directory. The CLI command function should only handle argument parsing and calling the service.

.github/chatmodes/new-component.chatmode.md

@@ -0,0 +1,34 @@
+---
+description: "Scaffold the necessary files and code for a new Player or Selector component, including configuration."
+tools: ['codebase', 'search']
+---
+# viu: New Component Generation Mode
+
+You are an expert on `viu`'s modular architecture. Your task is to help the developer add a new **Player** or **Selector** component.
+
+**First, ask the user whether they want to create a 'Player' or a 'Selector'.** Then, follow the appropriate path below.
+
+---
+
+### If the user chooses 'Player':
+
+1.  **Scaffold Directory:** Create a directory at `viu/libs/player/{player_name}/`.
+2.  **Implement `BasePlayer`:** Create a `player.py` file with a class `NewPlayer` that inherits from `viu.libs.player.base.BasePlayer`. Implement the `play` and `play_with_ipc` methods. The `play` method should use `subprocess` to call the player's executable.
+3.  **Add Configuration:**
+    *   Instruct to create a new Pydantic model `NewPlayerConfig(OtherConfig)` in `viu/core/config/model.py`.
+    *   Add the new config model to the main `AppConfig`.
+    *   Add defaults in `viu/core/config/defaults.py` and descriptions in `viu/core/config/descriptions.py`.
+4.  **Register Player:** Instruct to modify `viu/libs/player/player.py` by:
+    *   Adding the player name to the `PLAYERS` list.
+    *   Adding the instantiation logic to the `PlayerFactory.create` method.
+
+---
+
+### If the user chooses 'Selector':
+
+1.  **Scaffold Directory:** Create a directory at `viu/libs/selectors/{selector_name}/`.
+2.  **Implement `BaseSelector`:** Create a `selector.py` file with a class `NewSelector` that inherits from `viu.libs.selectors.base.BaseSelector`. Implement the `choose`, `confirm`, and `ask` methods.
+3.  **Add Configuration:** (Follow the same steps as for a Player).
+4.  **Register Selector:**
+    *   Instruct to modify `viu/libs/selectors/selector.py` by adding the selector name to the `SELECTORS` list and the factory logic to `SelectorFactory.create`.
+    *   Instruct to update the `Literal` type hint for the `selector` field in `GeneralConfig` (`viu/core/config/model.py`).

.github/chatmodes/new-provider.chatmode.md

@@ -0,0 +1,27 @@
+---
+description: "Scaffold and implement a new anime provider, following all architectural patterns of the viu project."
+tools: ['codebase', 'search', 'fetch']
+---
+# viu: New Provider Generation Mode
+
+You are an expert on the `viu` codebase, specializing in its provider architecture. Your task is to guide the developer in creating a new anime provider. You must strictly adhere to the project's structure and coding conventions.
+
+**Your process is as follows:**
+
+1.  **Ask for the Provider's Name:** First, ask the user for the name of the new provider (e.g., `gogoanime`, `crunchyroll`). Use this name (in lowercase) for all subsequent file and directory naming.
+
+2.  **Scaffold the Directory Structure:** Based on the name, state the required directory structure that needs to be created:
+    `viu/libs/provider/anime/{provider_name}/`
+
+3.  **Scaffold the Core Files:** Generate the initial code for the following files inside the new directory. Ensure all code is fully type-hinted.
+
+    *   **`__init__.py`**: Can be an empty file.
+    *   **`types.py`**: Create placeholder `TypedDict` models for the provider's specific API responses (e.g., `GogoAnimeSearchResult`, `GogoAnimeEpisode`).
+    *   **`mappers.py`**: Create empty mapping functions that will convert the provider-specific types into the generic types from `viu.libs.provider.anime.types`. For example: `map_to_search_results(data: GogoAnimeSearchPage) -> SearchResults:`.
+    *   **`provider.py`**: Generate the main provider class. It **MUST** inherit from `viu.libs.provider.anime.base.BaseAnimeProvider`. Include stubs for the required abstract methods: `search`, `get`, and `episode_streams`. Remind the user to use `httpx.Client` for requests and to call the mapper functions.
+
+4.  **Instruct on Registration:** Clearly state the two files that **must** be modified to register the new provider:
+    *   **`viu/libs/provider/anime/types.py`**: Add the new provider's name to the `ProviderName` enum.
+    *   **`viu/libs/provider/anime/provider.py`**: Add an entry to the `PROVIDERS_AVAILABLE` dictionary.
+
+5.  **Final Guidance:** Remind the developer to add any title normalization rules to `viu/assets/normalizer.json` if the provider uses different anime titles than AniList.

.github/chatmodes/plan.chatmode.md

@@ -0,0 +1,73 @@
+---
+description: "Plan new features or bug fixes with architectural guidance for the viu project. Does not write implementation code."
+tools: ['codebase', 'search', 'githubRepo', 'fetch']
+model: "gpt-4o" 
+---
+# viu: Feature & Fix Planner Mode
+
+You are a senior software architect and project planner for the `viu` project. You are an expert in its layered architecture (`Core`, `Libs`, `Service`, `CLI`) and its commitment to modular, testable code.
+
+Your primary goal is to help the user break down a feature request or bug report into a clear, actionable implementation plan.
+
+**Crucially, you MUST NOT write the full implementation code.** Your output is the plan itself, which will then guide the developer (or another AI agent in "Edit" mode) to write the code.
+
+### Your Process:
+
+1.  **Understand the Goal:** Start by asking the user to describe the feature they want to build or the bug they want to fix. If they reference a GitHub issue, use the `githubRepo` tool to get the context.
+
+2.  **Analyze the Codebase:** Use the `codebase` and `search` tools to understand how the request fits into the existing architecture. Identify all potentially affected modules, classes, and layers.
+
+3.  **Ask Clarifying Questions:** Ask questions to refine the requirements. For example:
+    *   "Will this feature need a new configuration option? If so, what should the default be?"
+    *   "How should this behave in the interactive TUI versus the direct CLI command?"
+    *   "Which architectural layer does the core logic for this fix belong in?"
+
+4.  **Generate the Implementation Plan:** Once you have enough information, produce a comprehensive plan in the following Markdown format:
+
+---
+
+### Implementation Plan: [Feature/Fix Name]
+
+**1. Overview**
+> A brief, one-sentence summary of the goal.
+
+**2. Architectural Impact Analysis**
+> This is the most important section. Detail which parts of the codebase will be touched and why.
+> - **Core Layer (`viu/core`):**
+>   - *Config (`config/model.py`):* Will a new Pydantic model or field be needed?
+>   - *Utils (`utils/`):* Are any new low-level, reusable functions required?
+>   - *Exceptions (`exceptions.py`):* Does this introduce a new failure case that needs a custom exception?
+> - **Libs Layer (`viu/libs`):**
+>   - *Media API (`media_api/`):* Does this involve a new call to the AniList API?
+>   - *Provider (`provider/`):* Does this affect how data is scraped?
+>   - *Player/Selector (`player/`, `selectors/`):* Does this change how we interact with external tools?
+> - **Service Layer (`viu/cli/service`):**
+>   - Which service will orchestrate this logic? (e.g., `DownloadService`, `PlayerService`). Will a new service be needed?
+> - **CLI Layer (`viu/cli`):**
+>   - *Commands (`commands/`):* Which `click` command(s) will expose this feature?
+>   - *Interactive UI (`interactive/`):* Which TUI menu(s) need to be added or modified?
+
+**3. Implementation Steps**
+> A step-by-step checklist for the developer.
+> 1.  [ ] **Config:** Add `new_setting` to `GeneralConfig` in `core/config/model.py`.
+> 2.  [ ] **Core:** Implement `new_util()` in `core/utils/helpers.py`.
+> 3.  [ ] **Service:** Add method `handle_new_feature()` to `MyService`.
+> 4.  [ ] **CLI:** Add `--new-feature` option to the `viu anilist search` command.
+> 5.  [ ] **Tests:** Write a unit test for `new_util()` and an integration test for the service method.
+
+**4. Configuration Changes**
+> If new settings are needed, list them here and specify which files to update.
+> - **`core/config/model.py`:** Add field `new_setting: bool`.
+> - **`core/config/defaults.py`:** Add `GENERAL_NEW_SETTING = False`.
+> - **`core/config/descriptions.py`:** Add `GENERAL_NEW_SETTING = "Description of the new setting."`
+
+**5. Testing Strategy**
+> Briefly describe how to test this change.
+> - A unit test for the pure logic in the `Core` or `Libs` layer.
+> - An integration test for the `Service` layer.
+> - Manual verification steps for the CLI and interactive UI.
+
+**6. Potential Risks & Open Questions**
+> - Will this change impact the performance of the provider scraping?
+> - Do we need to handle a case where the external API does not support this feature?
+---

.github/copilot-instructions.md

@@ -0,0 +1,101 @@
+# GitHub Copilot Instructions for the viu Repository
+
+Hello, Copilot! This document provides instructions and context to help you understand the `viu` codebase. Following these guidelines will help you generate code that is consistent, maintainable, and aligned with the project's architecture.
+
+## 1. High-Level Project Goal
+
+`viu` is a command-line tool that brings the anime browsing, streaming, and management experience to the terminal. It integrates with metadata providers like AniList and scrapes streaming links from various anime provider websites. The core goals are efficiency, extensibility, and providing a powerful, scriptable user experience.
+
+## 2. Core Architectural Concepts
+
+The project follows a clean, layered architecture. When generating code, please adhere to this structure.
+
+#### Layer 1: CLI (`viu/cli`)
+*   **Purpose:** Handles user interaction, command parsing, and displaying output.
+*   **Key Libraries:** `click` for command structure, `rich` for styled output.
+*   **Interactive Mode:** The interactive TUI is managed by the `Session` object in `viu/cli/interactive/session.py`. It's a state machine where each menu is a function that returns the next `State` or an `InternalDirective` (like `BACK` or `EXIT`).
+*   **Guideline:** **CLI files should not contain complex business logic.** They should parse arguments and delegate tasks to the Service Layer.
+
+#### Layer 2: Service (`viu/cli/service`)
+*   **Purpose:** Contains the core application logic. Services act as orchestrators, connecting the CLI layer with the various library components.
+*   **Examples:** `DownloadService`, `PlayerService`, `MediaRegistryService`, `WatchHistoryService`.
+*   **Guideline:** When adding new functionality (e.g., a new way to manage downloads), it should likely be implemented in a service or an existing service should be extended. Services are the "brains" of the application.
+
+#### Layer 3: Libraries (`viu/libs`)
+*   **Purpose:** A collection of independent, reusable modules with well-defined contracts (Abstract Base Classes).
+*   **`media_api`:** Interfaces with metadata services like AniList. All new metadata clients **must** inherit from `BaseApiClient`.
+*   **`provider`:** Interfaces with anime streaming websites. All new providers **must** inherit from `BaseAnimeProvider`.
+*   **`player`:** Wrappers around external media players like MPV. All new players **must** inherit from `BasePlayer`.
+*   **`selectors`:** Wrappers for interactive UI tools like FZF or Rofi. All new selectors **must** inherit from `BaseSelector`.
+*   **Guideline:** Libraries should be self-contained and not depend on the CLI or Service layers. They receive configuration and perform their specific task.
+
+#### Layer 4: Core (`viu/core`)
+*   **Purpose:** Foundational code shared across the entire application.
+*   **`config`:** Pydantic models defining the application's configuration structure. **This is the single source of truth for all settings.**
+*   **`downloader`:** The underlying logic for downloading files (using `yt-dlp` or `httpx`).
+*   **`exceptions`:** Custom exception classes used throughout the project.
+*   **`utils`:** Common, low-level utility functions.
+*   **Guideline:** Code in `core` should be generic and have no dependencies on other layers except for other `core` modules.
+
+## 3. Key Technologies
+*   **Dependency Management:** `uv` is used for all package management and task running. Refer to `pyproject.toml` for dependencies.
+*   **Configuration:** **Pydantic** is used exclusively. The entire configuration is defined in `viu/core/config/model.py`.
+*   **CLI Framework:** `click`. We use a custom `LazyGroup` to load commands on demand for faster startup.
+*   **HTTP Client:** `httpx` is the standard for all network requests.
+
+## 4. How to Add New Features
+
+Follow these patterns to ensure your contributions fit the existing architecture.
+
+### How to Add a New Provider
+1.  **Create Directory:** Add a new folder in `viu/libs/provider/anime/newprovider/`.
+2.  **Implement `BaseAnimeProvider`:** In `provider.py`, create a class `NewProvider` that inherits from `BaseAnimeProvider` and implement the `search`, `get`, and `episode_streams` methods.
+3.  **Create Mappers:** In `mappers.py`, write functions to convert the provider's API/HTML data into the generic Pydantic models from `viu/libs/provider/anime/types.py` (e.g., `SearchResult`, `Anime`, `Server`).
+4.  **Register Provider:**
+    *   Add the provider's name to the `ProviderName` enum in `viu/libs/provider/anime/types.py`.
+    *   Add it to the `PROVIDERS_AVAILABLE` dictionary in `viu/libs/provider/anime/provider.py`.
+
+### How to Add a New Player
+1.  **Create Directory:** Add a new folder in `viu/libs/player/newplayer/`.
+2.  **Implement `BasePlayer`:** In `player.py`, create a class `NewPlayer` that inherits from `BasePlayer` and implement the `play` method. It should call the player's executable via `subprocess`.
+3.  **Add Configuration:** If the player has settings, add a `NewPlayerConfig` Pydantic model in `viu/core/config/model.py`, and add it to the main `AppConfig`. Also add defaults and descriptions.
+4.  **Register Player:** Add the player's name to the `PLAYERS` list and the factory logic in `viu/libs/player/player.py`.
+
+### How to Add a New Selector
+1.  **Create Directory:** Add a new folder in `viu/libs/selectors/newselector/`.
+2.  **Implement `BaseSelector`:** In `selector.py`, create a class `NewSelector` that inherits from `BaseSelector` and implement `choose`, `confirm`, and `ask`.
+3.  **Add Configuration:** If needed, add a `NewSelectorConfig` to `viu/core/config/model.py`.
+4.  **Register Selector:** Add the selector's name to the `SELECTORS` list and the factory logic in `viu/libs/selectors/selector.py`. Update the `Literal` type hint for `selector` in `GeneralConfig`.
+
+### How to Add a New CLI Command
+*   **Top-Level Command (`viu my-command`):**
+    1.  Create `viu/cli/commands/my_command.py` with your `click.command()`.
+    2.  Register it in the `commands` dictionary in `viu/cli/cli.py`.
+*   **Subcommand (`viu anilist my-subcommand`):**
+    1.  Create `viu/cli/commands/anilist/commands/my_subcommand.py`.
+    2.  Register it in the `lazy_subcommands` dictionary of the parent `click.group()` (e.g., in `viu/cli/commands/anilist/cmd.py`).
+
+### How to Add a New Configuration Option
+1.  **Add to Model:** Add the field to the appropriate Pydantic model in `viu/core/config/model.py`.
+2.  **Add Default:** Add a default value in `viu/core/config/defaults.py`.
+3.  **Add Description:** Add a user-friendly description in `viu/core/config/descriptions.py`.
+4.  The config loader and CLI option generation will handle the rest automatically.
+
+## 5. Code Style and Conventions
+*   **Style:** `ruff` for formatting, `ruff` for linting. The `pre-commit` hooks handle this.
+*   **Types:** Full type hinting is mandatory. All code must pass `pyright`.
+*   **Commits:** Adhere to the [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/) standard.
+*   **Logging:** Use Python's `logging` module. Do not use `print()` for debugging or informational messages in library or service code.
+
+## 6. Do's and Don'ts
+
+*   ✅ **DO** use the abstract base classes (`BaseProvider`, `BasePlayer`, etc.) as contracts.
+*   ✅ **DO** place business logic in the `service` layer.
+*   ✅ **DO** use the Pydantic models in `viu/core/config/model.py` as the single source of truth for configuration.
+*   ✅ **DO** use the `Context` object in interactive menus to access services and configuration.
+
+*   ❌ **DON'T** hardcode configuration values. Access them via the `config` object.
+*   ❌ **DON'T** put complex logic directly into `click` command functions. Delegate to a service.
+*   ❌ **DON'T** make direct `httpx` calls outside of a `provider` or `media_api` library.
+*   ❌ **DON'T** introduce new dependencies without updating `pyproject.toml` and discussing it first.
+

.github/workflows/build.yml

@@ -1,38 +1,43 @@
-name: debug_build
+name: build
 on:
   workflow_run:
     workflows: ["Test Workflow"]
     types:
       - completed
 jobs:
-  debug_build:
+  build:
     if: ${{ github.event.workflow_run.conclusion == 'success' }}
     runs-on: ubuntu-latest
+
     steps:
       - uses: actions/checkout@v4
-      - name: Install Python
+
+      - name: "Set up Python"
         uses: actions/setup-python@v5
-      - name: Install poetry
-        uses: abatilo/actions-poetry@v2
-      - name: Setup a local virtual environment (if no poetry.toml file)
-        run: |
-          poetry config virtualenvs.create true --local
-          poetry config virtualenvs.in-project true --local
-      - uses: actions/cache@v3
-        name: Define a cache for the virtual environment based on the dependencies lock file
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v3
         with:
-          path: ./.venv
-          key: venv-${{ hashFiles('poetry.lock') }}
-      - name: Install the project dependencies
-        run: poetry install
-      - name: build app
-        run: poetry build
+          enable-cache: true
+
+      - name: Build viu
+        run: uv build
+
       - name: Archive production artifacts
         uses: actions/upload-artifact@v4
         with:
-          name: fastanime_debug_build
+          name: viu_debug_build
           path: |
             dist
-            !dist/*.whl
-      # - name: Run the automated tests (for example)
-      # run: poetry run pytest -v
+
+      - name: Install nix
+        uses: DeterminateSystems/nix-installer-action@main
+
+      - name: Use GitHub Action built-in cache
+        uses: DeterminateSystems/magic-nix-cache-action@main
+
+      - name: Nix Flake check (evaluation + tests)
+        run: nix flake check
+
+      - name: Build the nix derivation
+        run: nix build

.github/workflows/publish.yml

@@ -1,12 +1,3 @@
-# This workflow uses actions that are not certified by GitHub.
-# They are provided by a third-party and are governed by
-# separate terms of service, privacy policy, and support
-# documentation.
-
-# GitHub recommends pinning actions to a commit SHA.
-# To get a newer version, you will need to update the SHA.
-# You can also reference a tag or branch, but the action may change without warning.
-
 name: Upload Python Package
 
 on:
@@ -27,11 +18,13 @@ jobs:
         with:
           python-version: "3.10"
 
-      - name: Build release distributions
-        run: |
-          # NOTE: put your own distribution build steps here.
-          python -m pip install build
-          python -m build
+      - name: Install uv
+        uses: astral-sh/setup-uv@v3
+        with:
+          enable-cache: true
+
+      - name: Build viu
+        run: uv build
 
       - name: Upload distributions
         uses: actions/upload-artifact@v4

.github/workflows/stale.yml

@@ -0,0 +1,57 @@
+name: Mark Stale Issues and Pull Requests
+
+on:
+  schedule:
+    # Runs every day at 6:30 UTC
+    - cron: "30 6 * * *"
+  # Allows you to run this workflow manually from the Actions tab for testing
+  workflow_dispatch:
+
+jobs:
+  stale:
+    runs-on: ubuntu-latest
+    permissions:
+      issues: write
+      pull-requests: write
+
+    steps:
+      - uses: actions/stale@v5
+        with:
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
+
+          stale-issue-message: |
+            Greetings @{{author}},
+
+            This bug report is like an ancient scroll detailing a legendary beast. Our small guild of developers is often on many quests at once, so our response times can be slower than a tortoise in a time-stop spell. We deeply appreciate your patience!
+
+            **Seeking Immediate Help or Discussion?**
+            Our **[Discord Tavern](https://discord.gg/HBEmAwvbHV)** is the best place to get a quick response from the community for general questions or setup help!
+
+            **Want to Be the Hero?**
+            You could try to tame this beast yourself! With modern grimoires (like AI coding assistants) and our **[Contribution Guide](https://github.com/viu-media/Viu/blob/master/CONTRIBUTIONS.md)**, you might just be the hero we're waiting for. We would be thrilled to review your solution!
+
+            ---
+            To keep our quest board tidy, we need to know if this creature is still roaming the lands in the latest version of `viu`. If we don't get an update within **7 days**, we'll assume it has vanished and archive the scroll.
+
+            Thanks for being our trusted scout!
+
+          stale-pr-message: |
+            Hello @{{author}}, it looks like this powerful contribution has been left in the middle of its training arc! 💪
+
+            Our review dojo is managed by just a few senseis who are sometimes away on long missions, so thank you for your patience as we work through the queue.
+
+            We were excited to see this new technique being developed. Are you still planning to complete its training, or have you embarked on a different quest? If you need a sparring partner (reviewer) or some guidance from a senpai, just let us know!
+
+            To keep our dojo tidy, we'll be archiving unfinished techniques. If we don't hear back within **7 days**, we'll assume it's time to close this PR for now. You can always resume your training and reopen it when you're ready.
+
+            Thank you for your incredible effort!
+
+          # --- Labels and Timing ---
+          stale-issue-label: "stale"
+          stale-pr-label: "stale"
+
+          # How many days of inactivity before an issue/PR is marked as stale.
+          days-before-stale: 14
+
+          # How many days of inactivity to wait before closing a stale issue/PR.
+          days-before-close: 7

.github/workflows/test.yml

@@ -6,37 +6,42 @@ on:
   pull_request:
     branches:
       - master
+
 jobs:
   test:
     runs-on: ubuntu-latest
+
     strategy:
       matrix:
-        python-version: ["3.10", "3.11"] # List the Python versions you want to test
+        python-version: ["3.11", "3.12"]
+
     steps:
       - uses: actions/checkout@v4
       - name: Install Python ${{ matrix.python-version }}
         uses: actions/setup-python@v5
         with:
           python-version: ${{ matrix.python-version }}
-      - name: Install poetry
-        uses: abatilo/actions-poetry@v2
-      - name: Setup a local virtual environment (if no poetry.toml file)
+
+      - name: Install dbus-python build dependencies
         run: |
-          poetry config virtualenvs.create true --local
-          poetry config virtualenvs.in-project true --local
-      - uses: actions/cache@v3
-        name: Define a cache for the virtual environment based on the dependencies lock file
+          sudo apt-get update
+          sudo apt-get -y install libdbus-1-dev libglib2.0-dev
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v3
         with:
-          path: ./.venv
-          key: venv-${{ hashFiles('poetry.lock') }}
-      - name: Install the project dependencies
-        run: poetry install
-      - name: run linter, formatters and sort imports
-        run: |
-          poetry run black .
-          poetry run ruff check --output-format=github . --fix
-          poetry run isort . --profile black
-      - name: run type checking
-        run: poetry run pyright
-      - name: run tests
-        run: poetry run pytest
+          enable-cache: true
+
+      - name: Install the project
+        run: uv sync --all-extras --dev
+
+      - name: Run linter and formater
+        run: uv run ruff check --output-format=github
+
+      - name: Run type checking
+        run: uv run pyright
+
+      # TODO: write tests
+
+      # - name: Run tests
+      #   run: uv run pytest tests

.gitignore

@@ -1,25 +1,16 @@
-# mine
-*.mp4
-*.mp3
-*.ass
-vids
-data/
-.project/
-fastanime.ini
-crashdump.txt
 # Byte-compiled / optimized / DLL files
 __pycache__/
-*.py[cod]
+*.py[codz]
 *$py.class
-anixstream.ini
+
 # C extensions
 *.so
+
 # Distribution / packaging
 .Python
 build/
 develop-eggs/
 dist/
-bin/
 downloads/
 eggs/
 .eggs/
@@ -39,7 +30,7 @@ MANIFEST
 #  Usually these files are written by a python script from a template
 #  before PyInstaller builds the exe, so as to inject date/other infos into it.
 *.manifest
-# *.spec
+*.spec
 
 # Installer logs
 pip-log.txt
@@ -55,7 +46,7 @@ htmlcov/
 nosetests.xml
 coverage.xml
 *.cover
-*.py,cover
+*.py.cover
 .hypothesis/
 .pytest_cache/
 cover/
@@ -103,23 +94,36 @@ ipython_config.py
 #   install all needed dependencies.
 #Pipfile.lock
 
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
 # poetry
 #   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
 #   This is especially recommended for binary packages to ensure reproducibility, and is more
 #   commonly ignored for libraries.
 #   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
 #poetry.lock
+#poetry.toml
 
 # pdm
 #   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
 #pdm.lock
-#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
-#   in version control.
-#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
-.pdm.toml
+#pdm.toml
 .pdm-python
 .pdm-build/
 
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+#pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
 # PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
 __pypackages__/
 
@@ -168,11 +172,41 @@ cython_debug/
 #  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
 #  and can be added to the global gitignore or merged into this file.  For a more nuclear
 #  option (not recommended) you can uncomment the following to ignore the entire idea folder.
-.idea/
-app/anixstream.ini
-app/settings.json
-app/user_data.json
-app/View/SearchScreen/.search_screen.py.un~
-app/View/SearchScreen/search_screen.py~
-app/user_data.json
-.buildozer
+#.idea/
+
+# Abstra
+# Abstra is an AI-powered process automation framework.
+# Ignore directories containing user credentials, local state, and settings.
+# Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#  Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#  that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#  and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#  you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Cursor
+#  Cursor is an AI-powered code editor. `.cursorignore` specifies files/directories to
+#  exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
+#  refer to https://docs.cursor.com/context/ignore-files
+.cursorignore
+.cursorindexingignore
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/
+
+# custom
+repomix-output.xml
+.project/
+result
+.direnv

.pre-commit-config.yaml

@@ -1,35 +1,10 @@
-default_language_version:
-  python: python3.10
-
 repos:
-  - repo: https://github.com/pycqa/isort
-    rev: 5.12.0
-    hooks:
-      - id: isort
-        name: isort (python)
-        args: ["--profile", "black"] # Ensure compatibility with Black
-
-  - repo: https://github.com/PyCQA/autoflake
-    rev: v2.2.1
-    hooks:
-      - id: autoflake
-        args:
-          [
-            "--in-place",
-            "--remove-unused-variables",
-            "--remove-all-unused-imports",
-          ]
   - repo: https://github.com/astral-sh/ruff-pre-commit
     # Ruff version.
-    rev: v0.4.10
+    rev: v0.14.2
     hooks:
       # Run the linter.
-      - id: ruff
+      - id: ruff-check
         args: [--fix]
-
-  - repo: https://github.com/psf/black-pre-commit-mirror
-    rev: 24.4.2
-    hooks:
-      - id: black
-        name: black
-        language_version: python3.10 # to ensure compatibilty
+      # Run the formatter.
+      - id: ruff-format

.python-version

@@ -0,0 +1 @@
+3.11

.repomixignore

@@ -0,0 +1 @@
+**/generated/**/*

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+  "python.analysis.autoImportCompletions": true
+}

CONTRIBUTIONS.md

@@ -0,0 +1,208 @@
+# Contributing to Viu
+
+First off, thank you for considering contributing to Viu! We welcome any help, whether it's reporting a bug, proposing a feature, or writing code. This document will guide you through the process.
+
+## How Can I Contribute?
+
+There are many ways to contribute to the Viu project:
+
+*   **Reporting Bugs:** If you find a bug, please create an issue in our [issue tracker](https://github.com/viu-media/Viu/issues).
+*   **Suggesting Enhancements:** Have an idea for a new feature or an improvement to an existing one? We'd love to hear it.
+*   **Writing Code:** Help us fix bugs or implement new features.
+*   **Improving Documentation:** Enhance our README, add examples, or clarify our contribution guidelines.
+*   **Adding a Provider, Player, or Selector:** Extend Viu's capabilities by integrating new tools and services.
+
+## Contribution Workflow
+
+We follow the standard GitHub Fork & Pull Request workflow.
+
+1.  **Create an Issue:** Before starting work on a new feature or a significant bug fix, please [create an issue](https://github.com/viu-media/Viu/issues/new/choose) to discuss your idea. This allows us to give feedback and prevent duplicate work. For small bugs or documentation typos, you can skip this step.
+
+2.  **Fork the Repository:** Create your own fork of the Viu repository.
+
+3.  **Clone Your Fork:**
+    ```bash
+    git clone https://github.com/YOUR_USERNAME/Viu.git
+    cd Viu
+    ```
+
+4.  **Create a Branch:** Create a new branch for your changes. Use a descriptive name.
+    ```bash
+    # For a new feature
+    git checkout -b feat/my-new-feature
+
+    # For a bug fix
+    git checkout -b fix/bug-description
+    ```
+
+5.  **Make Your Changes:** Write your code, following the guidelines below.
+
+6.  **Run Quality Checks:** Before committing, ensure your code passes all quality checks.
+    ```bash
+    # Format, lint, and sort imports
+    uv run ruff check --fix .
+    uv run ruff format .
+
+    # Run type checking
+    uv run pyright
+
+    # Run tests
+    uv run pytest
+    ```
+
+7.  **Commit Your Changes:** We follow the [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/) specification. This helps us automate releases and makes the commit history more readable.
+    ```bash
+    # Example commit messages
+    git commit -m "feat: add support for XYZ provider"
+    git commit -m "fix(anilist): correctly parse episode numbers with decimals"
+    git commit -m "docs: update installation instructions in README"
+    git commit -m "chore: upgrade httpx to version 0.28.1"
+    ```
+
+8.  **Push to Your Fork:**
+    ```bash
+    git push origin feat/my-new-feature
+    ```
+
+9.  **Submit a Pull Request:** Open a pull request from your branch to the `master` branch of the main Viu repository. Provide a clear title and description of your changes.
+
+## Setting Up Your Development Environment
+
+### Prerequisites
+*   Git
+*   Python 3.10+
+*   [uv](https://github.com/astral-sh/uv) (recommended)
+*   **External Tools (for full functionality):** `mpv`, `fzf`, `rofi`, `webtorrent-cli`, `ffmpeg`.
+
+### Nix / NixOS Users
+The easiest way to get a development environment with all dependencies is to use our Nix flake.
+```bash
+nix develop
+```
+This command will drop you into a shell with all the necessary tools and a Python environment ready to go.
+
+### Standard Setup (uv + venv)
+
+1.  **Clone your fork** (as described above).
+
+2.  **Create and activate a virtual environment:**
+    ```bash
+    uv venv
+    source .venv/bin/activate
+    ```
+
+3.  **Install all dependencies:** This command installs both runtime and development dependencies, including all optional extras.
+    ```bash
+    uv sync --all-extras --dev
+    ```
+
+4.  **Set up pre-commit hooks:** This will automatically run linters and formatters before each commit, ensuring your code meets our quality standards.
+    ```bash
+    pre-commit install
+    ```
+
+## Coding Guidelines
+
+To maintain code quality and consistency, please adhere to the following guidelines.
+
+*   **Formatting:** We use **Black** for code formatting and **isort** (via Ruff) for import sorting. The pre-commit hooks will handle this for you.
+*   **Linting:** We use **Ruff** for linting. Please ensure your code has no linting errors before submitting a PR.
+*   **Type Hinting:** All new code should be fully type-hinted and pass `pyright` checks. We rely on Pydantic for data validation and configuration, so leverage it where possible.
+*   **Modularity and Architecture:**
+    *   **Services:** Business logic is organized into services (e.g., `PlayerService`, `DownloadService`).
+    *   **Factories:** Use factory patterns (`create_provider`, `create_selector`) for creating instances of different implementations.
+    *   **Configuration:** All configuration is managed through Pydantic models in `viu/core/config/model.py`. When adding new config options, update the model, defaults, and descriptions.
+*   **Commit Messages:** Follow the [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/) standard.
+*   **Testing:** New features should be accompanied by tests. Bug fixes should ideally include a regression test.
+
+## How to Add a New Provider
+
+Adding a new anime provider is a great way to contribute. Here are the steps:
+
+1.  **Create a New Provider Directory:** Inside `viu/libs/provider/anime/`, create a new directory with the provider's name (e.g., `viu/libs/provider/anime/newprovider/`).
+
+2.  **Implement the Provider:**
+    *   Create a `provider.py` file.
+    *   Define a class (e.g., `NewProviderApi`) that inherits from `BaseAnimeProvider`.
+    *   Implement the abstract methods: `search`, `get`, and `episode_streams`.
+    *   Create `mappers.py` to convert the provider's data structures into the generic types defined in `viu/libs/provider/anime/types.py`.
+    *   Create `types.py` for any provider-specific data structures you need.
+    *   If the provider requires complex scraping, place extractor logic in an `extractors/` subdirectory.
+
+3.  **Register the Provider:**
+    *   Add your new provider to the `ProviderName` enum in `viu/libs/provider/anime/types.py`.
+    *   Register it in the `PROVIDERS_AVAILABLE` dictionary in `viu/libs/provider/anime/provider.py`.
+
+4.  **Add Normalization Rules (Optional):** If the provider uses different anime titles than AniList, add mappings to `viu/assets/normalizer.json`.
+
+## How to Add a New Player
+
+1.  **Create a New Player Directory:** Inside `viu/libs/player/`, create a directory for your player (e.g., `viu/libs/player/myplayer/`).
+
+2.  **Implement the Player Class:**
+    *   In `myplayer/player.py`, create a class (e.g., `MyPlayer`) that inherits from `BasePlayer`.
+    *   Implement the required abstract methods: `play(self, params: PlayerParams)` and `play_with_ipc(self, params: PlayerParams, socket_path: str)`. The IPC method is optional but recommended for advanced features.
+    *   The `play` method should handle launching the player as a subprocess and return a `PlayerResult`.
+
+3.  **Add Configuration (if needed):**
+    *   If your player has configurable options, add a new Pydantic model (e.g., `MyPlayerConfig`) in `viu/core/config/model.py`. It should inherit from `OtherConfig`.
+    *   Add this new config model as a field in the main `AppConfig` model.
+    *   Add default values in `defaults.py` and descriptions in `descriptions.py`.
+
+4.  **Register the Player:**
+    *   Add your player's name to the `PLAYERS` list in `viu/libs/player/player.py`.
+    *   Add the logic to instantiate your player class within the `PlayerFactory.create` method.
+
+## How to Add a New Selector
+
+1.  **Create a New Selector Directory:** Inside `viu/libs/selectors/`, create a new directory (e.g., `viu/libs/selectors/myselector/`).
+
+2.  **Implement the Selector Class:**
+    *   In `myselector/selector.py`, create a class (e.g., `MySelector`) that inherits from `BaseSelector`.
+    *   Implement the abstract methods: `choose`, `confirm`, and `ask`.
+    *   Optionally, you can override `choose_multiple` and `search` for more advanced functionality.
+
+3.  **Add Configuration (if needed):** Follow the same configuration steps as for adding a new player.
+
+4.  **Register the Selector:**
+    *   Add your selector's name to the `SELECTORS` list in `viu/libs/selectors/selector.py`.
+    *   Add the instantiation logic to the `SelectorFactory.create` method.
+    *   Update the `Literal` type hint for the `selector` field in `GeneralConfig` (`viu/core/config/model.py`).
+
+## How to Add a New CLI Command or Service
+
+Our CLI uses `click` and a `LazyGroup` class to load commands on demand.
+
+### Adding a Top-Level Command (e.g., `viu my-command`)
+
+1.  **Create the Command File:** Create a new Python file in `viu/cli/commands/` (e.g., `my_command.py`). This file should contain your `click.command()` function.
+
+2.  **Register the Command:** In `viu/cli/cli.py`, add your command to the `commands` dictionary.
+    ```python
+    commands = {
+        # ... existing commands
+        "my-command": "my_command.my_command_function",
+    }
+    ```
+
+### Adding a Subcommand (e.g., `viu anilist my-subcommand`)
+
+1.  **Create the Command File:** Place your new command file inside the appropriate subdirectory, for example, `viu/cli/commands/anilist/commands/my_subcommand.py`.
+
+2.  **Register the Subcommand:** In the parent command's entry point file (e.g., `viu/cli/commands/anilist/cmd.py`), add your subcommand to the `commands` dictionary within the `LazyGroup`.
+    ```python
+    @click.group(
+        cls=LazyGroup,
+        # ... other options
+        lazy_subcommands={
+            # ... existing subcommands
+            "my-subcommand": "my_subcommand.my_subcommand_function",
+        }
+    )
+    ```
+
+### Creating a Service
+If your command involves complex logic, consider creating a service in `viu/cli/service/` to keep the business logic separate from the command-line interface. This service can then be instantiated and used within your `click` command function. This follows the existing pattern for services like `DownloadService` and `PlayerService`.
+
+---
+Thank you for contributing to Viu

DISCLAIMER.md

@@ -0,0 +1,38 @@
+<h1 align="center">Disclaimer</h1>
+
+<div align="center">
+
+<h2>This project: viu</h2>
+
+<br>
+
+The core aim of this project is to co-relate automation and efficiency to extract what is provided to a user on the internet. All content available through the project is hosted by external non-affiliated sources.
+
+<br>
+
+<b>All content served through this project is publicly accessible. If your site is listed in this project, the code is pretty much public. Take necessary measures to counter the exploits used to extract content in your site.</b>
+
+Think of this project as your normal browser, but a bit more straight-forward and specific. While an average browser makes hundreds of requests to get everything from a site, this project goes on to only make requests associated with getting the content served by the sites.
+
+<b>
+
+This project is to be used at the user's own risk, based on their government and laws.
+
+This project has no control on the content it is serving, using copyrighted content from the providers is not going to be accounted for by the developer. It is the user's own risk.
+
+</b>
+
+<br>
+
+<h2>DMCA and Copyright Infrigements</h3>
+
+<br>
+
+<b>
+
+A browser is a tool, and the maliciousness of the tool is directly based on the user.
+</b>
+
+This project uses client-side content access mechanisms. Hence, the copyright infrigements or DMCA in this project's regards are to be forwarded to the associated site by the associated notifier of any such claims. This is one of the main reasons the sites are listed in this project.
+
+<b>Do not harass the developer. Any personal information about the developer is intentionally not made public. Exploiting such information without consent in regards to this topic will lead to legal actions by the developer themselves.</b>

Dockerfile

@@ -1,10 +0,0 @@
-FROM ubuntu 
-RUN apt-get update
-RUN apt-get -y install python3
-RUN apt-get update
-RUN apt-get -y install pipx
-RUN pipx ensurepath
-COPY . /fastanime
-WORKDIR /fastanime
-RUN pipx install .
-CMD ["bash"]

README.md

@@ -1,515 +1,334 @@
-# FastAnime
+<p align="center">
+  <h1 align="center">Viu</h1>
+</p>
+<p align="center">
+  <sup>
+  Your browser anime experience, from the terminal.
+  </sup>
+</p>
+<div align="center">
 
-Welcome to **FastAnime**, anime site experience from the terminal.
+[![PyPI - Version](https://img.shields.io/pypi/v/viu-media)](https://pypi.org/project/viu-media/)
+[![PyPI - Downloads](https://img.shields.io/pypi/dm/viu-media)](https://pypi.org/project/viu-media/)
+[![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/viu-media/Viu/test.yml?label=Tests)](https://github.com/viu-media/Viu/actions)
+[![Discord](https://img.shields.io/discord/1250887070906323096?label=Discord&logo=discord)](https://discord.gg/HBEmAwvbHV)
+[![GitHub Issues](https://img.shields.io/github/issues/viu-media/Viu)](https://github.com/viu-media/Viu/issues)
+[![PyPI - License](https://img.shields.io/pypi/l/viu)](https://github.com/viu-media/Viu/blob/master/LICENSE)
 
-**fzf mode**
+</div>
 
-[fa_fzf_demo.webm](https://github.com/user-attachments/assets/b1fecf25-e358-4e8b-a144-bcb7947210cf)
+<p align="center">
+  <a href="https://discord.gg/HBEmAwvbHV">
+    <img src="https://invidget.switchblade.xyz/C4rhMA4mmK" alt="Discord Server Invite">
+  </a>
+</p>
 
-**other modes:**
+[viu-showcase.webm](https://github.com/user-attachments/assets/5da0ec87-7780-4310-9ca2-33fae7cadd5f)
 
 <details>
-<summary><b>rofi mode</b></summary>
-
-[fa_rofi_mode.webm](https://github.com/user-attachments/assets/2ce669bf-b62f-4c44-bd79-cf0dcaddf37a)
-
-</details>
-
-<details>
-<summary><b>Default mode</b></summary>
+<summary>Rofi</summary>
   
-[fa_default_mode.webm](https://github.com/user-attachments/assets/1ce3a23d-f4a0-4bc1-8518-426ec7b3b69e)
+  [viu-showcase-rofi.webm](https://github.com/user-attachments/assets/01f197d9-5ac9-45e6-a00b-8e8cd5ab459c)
 
 </details>
 
-Heavily inspired by [animdl](https://github.com/justfoolingaround/animdl), [magic-tape](https://gitlab.com/christosangel/magic-tape/-/tree/main?ref_type=heads) and [ani-cli](https://github.com/pystardust/ani-cli).
-
-<!--toc:start-->
-
-- [FastAnime](#fastanime)
-  - [Installation](#installation)
-    - [Installation using your favourite package manager](#installation-using-your-favourite-package-manager)
-      - [Using pipx](#using-pipx)
-      - [Using pip](#using-pip)
-    - [Installing the bleeding edge version](#installing-the-bleeding-edge-version)
-    - [Building from the source](#building-from-the-source)
-    - [External Dependencies](#external-dependencies)
-  - [Usage](#usage)
-    - [The Commandline interface :fire:](#the-commandline-interface-fire)
-      - [The anilist command :fire: :fire: :fire:](#the-anilist-command-fire-fire-fire)
-        - [Running without any subcommand](#running-without-any-subcommand)
-        - [Subcommands](#subcommands)
-      - [download subcommand](#download-subcommand)
-      - [search subcommand](#search-subcommand)
-      - [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)
-  - [Configuration](#configuration)
-  - [Contributing](#contributing)
-  - [Receiving Support](#receiving-support)
-  - [Supporting the Project](#supporting-the-project)
-  <!--toc:end-->
-
 > [!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 scrapes public-facing websites for its streaming / downloading capabilities and primarily acts as an anilist, jikan and many other media apis tui client. The developer(s) of this application have no affiliation with these content providers. This application hosts zero content and is intended for educational and personal use only. Use at your own risk.
+> 
+> [**Read the Full Disclaimer**](DISCLAIMER.md)
+
+## Core Features
+
+*   📺 **Interactive TUI:** Browse, search, and manage your AniList library in a rich terminal interface powered by `fzf`, `rofi`, or a built-in selector.
+*   ⚡ **Powerful Search:** Filter the entire AniList database with over 20 different criteria, including genres, tags, year, status, and score.
+*   💾 **Local Registry:** Maintain a fast, local database of your anime for offline access, detailed stats, and robust data management.
+*   ⚙️ **Background Downloader:** Queue episodes for download and let a persistent background worker handle the rest.
+*   📜 **Scriptable CLI:** Automate streaming and downloading with powerful, non-interactive commands perfect for scripting.
+*   🔧 **Highly Customizable:** Tailor every aspect—from UI colors and providers to playback behavior—via a simple, well-documented configuration file.
+*   🔌 **Extensible Architecture:** Easily add new providers, media players, and UI selectors to fit your workflow.
 
 ## Installation
 
-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)
+Viu runs on any platform with Python 3.10+, including Windows, macOS, Linux, and Android (via Termux).
 
-### Installation using your favourite package manager
+### Prerequisites
 
-Currently the app is only published on [pypi](https://pypi.org/project/fastanime/).
+For the best experience, please install these external tools:
 
-#### Using pipx
+*   **Required for Streaming:**
+    *   [**mpv**](https://mpv.io/installation/) - The primary and recommended media player.
+*   **Recommended for UI & Previews:**
+    *   [**fzf**](https://github.com/junegunn/fzf) - For the best fuzzy-finder interface.
+    *   [**chafa**](https://github.com/hpjansson/chafa) or [**kitty's icat**](https://sw.kovidgoyal.net/kitty/kittens/icat/) - For image previews in the terminal.
+*   **Recommended for Downloads & Advanced Features:**
+    *   [**ffmpeg**](https://www.ffmpeg.org/) - Required for downloading HLS streams and merging subtitles.
+    *   [**webtorrent-cli**](https://github.com/webtorrent/webtorrent-cli) - For streaming torrents directly.
 
-Preferred method of installation since [Pipx](https://github.com/pypa/pipx) creates an isolated environment for each app it installs.
+### Recommended Installation (uv)
+
+The best way to install Viu is with [**uv**](https://github.com/astral-sh/uv), a lightning-fast Python package manager.
 
 ```bash
+# Install with all optional features for the full experience
+uv tool install "viu-media[standard]"
 
-pipx install fastanime
-# -- or for the development version --
-pipx install 'fastanime==<latest-pre-release-tag>.dev1'
-# example
-# pipx install 'fastanime==0.60.1.dev1'
-
+# Or, pick and choose the extras you need:
+uv tool install viu-media  # Core functionality only
+uv tool install "viu-media[download]"  # For advanced downloading with yt-dlp
+uv tool install "viu-media[discord]"   # For Discord Rich Presence
+uv tool install "viu-media[notifications]" # For desktop notifications
 ```
 
-#### Using pip
+### Other Installation Methods
+
+<details>
+  <summary><b>Platform-Specific and Alternative Installers</b></summary>
+  
+  #### Nix / NixOS
+  ##### Ephemeral / One-Off Run (No Installation)
+  ```bash
+  nix run github:viu-media/viu
+  ```
+  ##### Imperative Installation
+  ```bash
+  nix profile install github:viu-media/viu
+  ```
+  ##### Declarative Installation
+  ###### in your flake.nix
+  ```nix
+  viu.url = "github:viu-media/viu";
+  ```
+  ###### in your system or home-manager packages
+  ```nix
+  inputs.viu.packages.${pkgs.system}.default
+  ```
+
+  #### Arch Linux (AUR)
+  Use an AUR helper like `yay` or `paru`.
+  ```bash
+  # Stable version (recommended)
+  yay -S viu-media
+
+  # Git version (latest commit)
+  yay -S viu-media-git
+  ```
+
+  #### Using pipx (for isolated environments)
+  ```bash
+  pipx install "viu-media[standard]"
+  ```
+  
+  #### Using pip
+  ```bash
+  pip install "viu-media[standard]"
+  ```
+</details>
+
+<details>
+  <summary><b>Building from Source</b></summary>
+  
+  Requires [Git](https://git-scm.com/), [Python 3.10+](https://www.python.org/), and [uv](https://astral.sh/blog/uv).
+  ```bash
+  git clone https://github.com/viu-media/Viu.git --depth 1
+  cd Viu
+  uv tool install .
+  viu --version
+  ```
+</details>
+
+> [!TIP]
+> Enable shell completions for a much better experience by running `viu completions` and following the on-screen instructions for your shell.
+
+## Getting Started: Quick Start
+
+Get up and running in three simple steps:
+
+1.  **Authenticate with AniList:**
+    ```bash
+    viu anilist auth
+    ```
+    This will open your browser. Authorize the app and paste the obtained token back into the terminal.
+
+2.  **Launch the Interactive TUI:**
+    ```bash
+    viu anilist
+    ```
+
+3.  **Browse & Play:** Use your arrow keys to navigate the menus, select an anime, and choose an episode to stream instantly.
+
+## Usage Guide
+
+### The Interactive TUI (`viu anilist`)
+
+This is the main, user-friendly way to use Viu. It provides a rich terminal experience where you can:
+*   Browse trending, popular, and seasonal anime.
+*   Manage your personal lists (Watching, Completed, Paused, etc.).
+*   Search for any anime in the AniList database.
+*   View detailed information, characters, recommendations, reviews, and airing schedules.
+*   Stream or download episodes directly from the menus.
+
+### Powerful Searching (`viu anilist search`)
+
+Filter the entire AniList database with powerful command-line flags.
 
 ```bash
-pip install fastanime
-# -- or for the development version --
-pip install 'fastanime==<latest-pre-release-tag>.dev1'
-# example
-# pip install 'fastanime==0.60.1.dev1'
+# Search for anime from 2024, sorted by popularity, that is releasing and not on your list
+viu anilist search -y 2024 -s POPULARITY_DESC --status RELEASING --not-on-list
+
+# Find the most popular movies with the "Fantasy" genre
+viu anilist search -g Fantasy -f MOVIE -s POPULARITY_DESC
+
+# Dump search results as JSON instead of launching the TUI
+viu anilist search -t "Demon Slayer" --dump-json
 ```
 
-### Installing the bleeding edge version
+### Background Downloads (`viu queue` & `worker`)
 
-To install the latest build which are created on every push by GitHub actions, download the [fastanime_debug_build](https://github.com/Benex254/FastAnime/actions) of your choosing from the GitHub actions page.
-Then:
+Viu includes a robust background downloading system.
 
+1.  **Add episodes to the queue:**
+    ```bash
+    # Add episodes 1-12 of Jujutsu Kaisen to the download queue
+    viu queue add -t "Jujutsu Kaisen" -r "0:12"
+    ```
+2.  **Start the worker process:**
+    ```bash
+    # Run the worker in the foreground (press Ctrl+C to stop)
+    viu worker
+
+    # Or run it as a background process
+    viu worker &
+    ```The worker will now process the queue, download your episodes, and check for notifications.
+
+### Scriptable Commands (`download` & `search`)
+
+These commands are designed for automation and quick, non-interactive tasks.
+
+#### `download` Examples
 ```bash
-unzip fastanime_debug_build
+# Download the latest 5 episodes of One Piece
+viu download -t "One Piece" -r "-5"
 
-# outputs fastanime<version>.tar.gz
-
-pipx install fastanime<version>.tar.gz
-
-# --- or ---
-
-pip install fastanime<version>.tar.gz
+# Download episodes 1 to 24, merge subtitles, and clean up original files
+viu download -t "Jujutsu Kaisen" -r "0:24" --merge --clean
 ```
 
-### Building from the source
-
-Requirements:
-
-- [git](https://git-scm.com/)
-- [python 3.10 and above](https://www.python.org/)
-- [poetry](https://python-poetry.org/docs/#installation)
-
-To build from the source, follow these steps:
-
-1. Clone the repository: `git clone https://github.com/Benex254/FastAnime.git`
-2. Navigate into the folder: `cd FastAnime`
-3. Then build and Install the app:
-
+#### `search` (Binging) Examples
 ```bash
-# Normal Installation
-poetry build
-cd dist
-pip install fastanime<version>.whl
+# Start binging an anime from the first episode
+viu search -t "Attack on Titan" -r ":"
 
-# Editable installation (easiest for updates)
-# just do a git pull in the Project dir
-# the latter will require rebuilding the app
-pip install -e .
+# Watch the latest episode directly
+viu search -t "My Hero Academia" -r "-1"
 ```
 
-4. Enjoy! Verify installation with:
+### Local Data Management (`viu registry`)
 
-```bash
-fastanime --version
-```
+Viu maintains a local database of your anime for offline access and enhanced performance.
 
-> [!Tip]
->
-> Download the completions from [here](https://github.com/Benex254/FastAnime/tree/master/completions) for your shell.
-> To add completions:
->
-> - Fish Users: `cp $FASTANIME_PATH/completions/fastanime.fish ~/.config/fish/completions/`
-> - Bash Users: Add `source $FASTANIME_PATH/completions/fastanime.bash` to your `.bashrc`
-> - Zsh Users: Add `source $FASTANIME_PATH/completions/fastanime.zsh` to your `.zshrc`
-
-### External Dependencies
-
-The only required external dependency, unless you won't be streaming, is [MPV](https://mpv.io/installation/), which i recommend installing with [uosc](https://github.com/tomasklaen/uosc) :fire: and [thumbfast](https://github.com/po5/thumbfast) for the best experience since they add a better interface to it.
-
-> [!NOTE]
->
-> The project currently sees no reason to support any other video
-> 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.
-
-**Other external dependencies that will just make your experience better:**
-
-- [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
-
-## 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 Commandline interface :fire:
-
-Designed for power users who prefer efficiency over browser-based streaming and still want the experience in their terminal.
-
-Overview of main commands:
-
-- `fastanime anilist`: Powerful command for browsing and exploring anime due to AniList integration.
-- `fastanime download`: Download anime.
-- `fastanime search`: Powerful command meant for binging since it doesn't require the interfaces
-- `fastanime downloads`: View downloaded anime and watch with MPV.
-- `fastanime config`: Quickly edit configuration settings.
-- `fastanime cache`: Quickly manage the cache fastanime uses
-
-Configuration is directly passed into this command at run time to override your config.
-
-Available options include:
-
-- `--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
-- `--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`
-- `--icons/--no-icons` toggle the visibility of the icons
-- `--skip/--no-skip` whether to skip the opening and ending theme songs.
-- `--rofi` use rofi for the ui
-- `--rofi-theme <path>` theme to use with rofi
-- `--rofi-theme-input <path>` theme to use with rofi input
-- `--rofi-theme-confirm <path>` theme to use with rofi confirm
-- `--log` allow logging to stdout
-- `--log-file` allow logging to a file
-- `--rich-traceback` allow rich traceback
-- `--use-mpv-mod/--use-default-player` whether to use python-mpv
-
-#### The anilist command :fire: :fire: :fire:
-
-Stream, browse, and discover anime efficiently from the terminal using the [AniList API](https://github.com/AniList/ApiV2-GraphQL-Docs).
-
-##### Running without any subcommand
-
-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.
-
-- `fastanime anilist trending`: Top 15 trending anime.
-- `fastanime anilist recent`: Top 15 recently updated anime.
-- `fastanime anilist search`: Search for anime (top 50 results).
-- `fastanime anilist upcoming`: Top 15 upcoming anime.
-- `fastanime anilist popular`: Top 15 popular anime.
-- `fastanime anilist favourites`: Top 15 favorite anime.
-- `fastanime anilist random`: get random anime
-
-The following are commands you can only run if you are signed in to your AniList account:
-
-- `fastanime anilist watching`
-- `fastanime anilist planning`
-- `fastanime anilist rewatching`
-- `fastanime anilist dropped`
-- `fastanime anilist paused`
-- `fastanime anilist completed`
-
-Plus: `fastanime anilist notifier` :fire:
-
-```bash
-# basic form
-fastanime anilist notifier
-
-# with logging to stdout
-fastanime --log anilist notifier
-
-# with logging to a file. stored in the same place as your config
-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 notification will consist of a cover image of the anime in none windows systems.
-
-You can place the command among your machines startup scripts.
-
-For fish users for example you can decide to put this in your `~/.config/fish/config.fish`:
-
-```fish
-if ! ps aux | grep -q '[f]astanime .* notifier'
-  echo initializing fastanime anilist notifier
-  nohup fastanime --log-file anilist notifier>/dev/null &
-end
-```
-
-> [!NOTE]
-> To sign in just run `fastanime anilist login` and follow the instructions.
-> To view your login status `fastanime anilist login --status`
-
-#### download subcommand
-
-Download anime to watch later dub or sub with this one command.
-Its optimized for scripting due to fuzzy matching.
-So every step of the way has been and can be automated.
-
-> [!NOTE]
->
-> The download feature is powered by [yt-dlp](https://github.com/yt-dlp/yt-dlp) so all the bells and whistles that it provides are readily available in the project.
-> Like continuing from where you left of while downloading, after lets say you lost your internet connection.
-
-**Syntax:**
-
-```bash
-# Download all available episodes
-fastanime download <anime-title>
-
-# Download specific episode range
-# be sure to observe the range Syntax
-fastanime download <anime-title> -r <episodes-start>-<episodes-end>
-```
-
-#### search subcommand
-
-Powerful command mainly aimed at binging anime. Since it doesn't require interaction with the interfaces.
-
-**Syntax:**
-
-```bash
-# basic form where you will still be prompted for the episode number
-fastanime search <anime-title>
-
-# binge all episodes with this command
-fastanime search <anime-title> -r -
-
-# binge a specific episode range with this command
-# be sure to observe the range Syntax
-fastanime search <anime-title> -r <episodes-start>-<episodes-end>
-```
-
-#### downloads subcommand
-
-View and stream the anime you downloaded using MPV.
-
-**Syntax:**
-
-```bash
-fastanime downloads
-
-# 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
-
-Edit FastAnime configuration settings using your preferred editor (based on `$EDITOR` environment variable so be sure to set it).
-
-**Syntax:**
-
-```bash
-fastanime config
-
-# to get config path which is useful if you want to use it for another program.
-fastanime config --path
-
-# add a desktop entry
-fastanime config --desktop-entry
-
-# view current contents of your configuration or can be used to get an example config
-fastanime config --view
-```
-
-> [!Note]
->
-> If it opens [vim](https://www.vim.org/download.php) you can exit by typing `:q` .
-
-#### cache subcommand
-
-Easily manage the data fastanime has cached; for the previews.
-
-**Syntax:**
-
-```bash
-# delete everything in the cache dir
-fastanime cache --clean
-
-# print the path to the cache dir and exit
-fastanime cache --path
-
-# print the current size of the cache dir and exit
-fastanime cache --size
-
-# open the cache dir and exit
-fastanime cache
-```
-
-#### update subcommand
-
-Easily update fastanime to latest
-
-**Syntax:**
-
-```bash
-# update fastanime to latest
-fastanime update
-
-# check for latest release
-fastanime update --check
-```
-
-#### completions subcommand
-
-Helper command to setup shell completions
-
-**Syntax:**
-
-```bash
-# try to detect your shell and print completions
-fastanime completions
-# print fish completions
-fastanime completions --fish
-# print bash completions
-fastanime completions --bash
-# print zsh completions
-fastanime completions --zsh
-```
-
-## MPV specific commands
-
-The project now allows on the fly media controls directly from mpv. This means you can go to the next or previous episode without the window ever closing thus offering a seamless experience.
-This is all powered with [python-mpv]() which enables writing mpv scripts with python just like how it would be done in lua.
-
-### Added keybindings
-
-`<shift>+n` fetch the next episode
-
-`<shift>+p` fetch the previous episode
-
-`<shift>+t` toggle the translation type from dub to sub
-
-`<shift>+a` toggle auto next episode
-
-`<shit>+r` reload episode
-
-### Added script messages
-
-Examples:
-
-```bash
-# to select episode from mpv without window closing
-script-message select-episode <episode-number>
-# to select server from mpv without window closing
-script-message select-server <server-name>
-```
+*   `registry sync`: Synchronize your local data with your remote AniList account.
+*   `registry stats`: Show detailed statistics about your viewing habits.
+*   `registry backup`: Create a compressed backup of your entire registry.
+*   `registry restore`: Restore your data from a backup file.
+*   `registry export/import`: Export/import your data to JSON/CSV for use in other applications.
+*   `registry clean`: Clean up orphaned or invalid entries from your local database.
 
 ## 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`.
+Viu is highly customizable. A default configuration file with detailed comments is created on the first run.
+
+*   **Find your config file:** `viu config --path`
+*   **Edit in your default editor:** `viu config`
+*   **Use the interactive wizard:** `viu config --interactive`
+
+Most settings in the config file can be temporarily overridden with command-line flags (e.g., `viu --provider animepahe anilist`).
+
+<details>
+  <summary><b>Default Configuration (`config.ini`) Explained</b></summary>
 
 ```ini
-[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
-# 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
-
-# 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
-
+# [general] Section: Controls overall application behavior.
 [general]
-# can be [allanime,animepahe]
-provider = allanime
+provider = allanime          ; The default anime provider (allanime, animepahe).
+selector = fzf               ; The interactive UI tool (fzf, rofi, default).
+preview = full               ; Preview type in selectors (full, text, image, none).
+image_renderer = icat        ; Tool for terminal image previews (icat, chafa).
+icons = True                 ; Display emoji icons in the UI.
+auto_select_anime_result = True ; Automatically select the best search match.
+...
 
-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
+# [stream] Section: Controls playback and streaming.
+[stream]
+player = mpv                 ; The media player to use (mpv, vlc).
+quality = 1080               ; Preferred stream quality (1080, 720, 480, 360).
+translation_type = sub       ; Preferred audio/subtitle type (sub, dub).
+auto_next = False            ; Automatically play the next episode.
+continue_from_watch_history = True ; Resume playback from where you left off.
+use_ipc = True               ; Enable in-player controls via MPV's IPC.
+...
 
-use_fzf=False # whether to use fzf as the interface for the anilist command and others.
+# [downloads] Section: Controls the downloader.
+[downloads]
+downloader = auto            ; Downloader to use (auto, default, yt-dlp).
+downloads_dir = ...          ; Directory to save downloaded anime.
+max_concurrent_downloads = 3 ; Number of parallel downloads in the worker.
+merge_subtitles = True       ; Automatically merge subtitles into the video file.
+cleanup_after_merge = True   ; Delete original files after merging.
+...
 
-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
+# [worker] Section: Controls the background worker process.
+[worker]
+enabled = True
+notification_check_interval = 15 ; How often to check for new episodes (minutes).
+download_check_interval = 5      ; How often to process the download queue (minutes).
+...
 ```
+</details>
+
+## Advanced Features
+
+### MPV IPC Integration
+
+When `use_ipc = True` is set in your config, Viu provides powerful in-player controls without needing to close MPV.
+
+**Key Bindings:**
+*   `Shift+N`: Play the next episode.
+*   `Shift+P`: Play the previous episode.
+*   `Shift+R`: Reload the current episode.
+*   `Shift+A`: Toggle auto-play for the next episode.
+*   `Shift+T`: Toggle between `dub` and `sub`.
+
+**Script Messages (For MPV Console):**
+*   `script-message select-episode <number>`: Jump to a specific episode.
+*   `script-message select-server <name>`: Switch to a different streaming server.
+
+### Running as a Service (Linux/systemd)
+
+You can run the background worker as a systemd service for persistence.
+
+1.  Create a service file at `~/.config/systemd/user/viu-worker.service`:
+    ```ini
+    [Unit]
+    Description=Viu Background Worker
+    After=network-online.target
+
+    [Service]
+    Type=simple
+    ExecStart=/path/to/your/viu worker --log
+    Restart=always
+    RestartSec=30
+
+    [Install]
+    WantedBy=default.target
+    ```
+    *Replace `/path/to/your/viu` with the output of `which viu`.*
+
+2.  Enable and start the service:
+    ```bash
+    systemctl --user daemon-reload
+    systemctl --user enable --now viu-worker.service
+    ```
 
 ## Contributing
 
-We welcome your issues and feature requests. However, due to time constraints, we currently do not plan to add another provider.
-
-If you wish to contribute directly, please first open an issue describing your proposed changes so it can be discussed or if you are in a rush for the feature to be merged just open a pr.
-
-## Receiving Support
-
-For inquiries, join our [Discord Server](https://discord.gg/4NUTj5Pt).
-
-<p align="center">
-<a href="https://discord.gg/C4rhMA4mmK">
-<img src="https://invidget.switchblade.xyz/C4rhMA4mmK">
-</a>
-</p>
-
-## Supporting the Project
-
-Show your support by starring our GitHub repository or [buying us a coffee](https://ko-fi.com/benex254).
+Contributions are welcome! Whether it's reporting a bug, proposing a feature, or writing code, your help is appreciated. Please read our [**Contributing Guidelines**](CONTRIBUTIONS.md) to get started.

bundle/Dockerfile

@@ -0,0 +1,7 @@
+FROM python:3.12-slim-bookworm
+COPY --from=ghcr.io/astral-sh/uv:latest /uv /uvx /bin/
+COPY . /viu
+ENV PATH=/root/.local/bin:$PATH
+WORKDIR /viu
+RUN uv tool install .
+CMD ["bash"]

bundle/pyinstaller.spec

@@ -0,0 +1,65 @@
+# -*- mode: python ; coding: utf-8 -*-
+from PyInstaller.utils.hooks import collect_data_files, collect_submodules
+
+block_cipher = None
+
+# Collect all required data files
+datas = [
+    ('viu/assets/*', 'viu/assets'),
+]
+
+# Collect all required hidden imports
+hiddenimports = [
+    'click',
+    'rich',
+    'requests',
+    'yt_dlp',
+    'python_mpv',
+    'fuzzywuzzy',
+    'viu',
+] + collect_submodules('viu')
+
+a = Analysis(
+    ['./viu/viu.py'],  # Changed entry point
+    pathex=[],
+    binaries=[],
+    datas=datas,
+    hiddenimports=hiddenimports,
+    hookspath=[],
+    hooksconfig={},
+    runtime_hooks=[],
+    excludes=[],
+    win_no_prefer_redirects=False,
+    win_private_assemblies=False,
+    cipher=block_cipher,
+     strip=True,  # Strip debug information
+    optimize=2   # Optimize bytecode   noarchive=False
+)
+
+pyz = PYZ(
+    a.pure,
+    a.zipped_data,
+      optimize=2  # Optimize bytecode  cipher=block_cipher
+)
+
+exe = EXE(
+    pyz,
+    a.scripts,
+    a.binaries,
+    a.zipfiles,
+    a.datas,
+    [],
+    name='viu',
+    debug=False,
+    bootloader_ignore_signals=False,
+    strip=True,
+    upx=True,
+    upx_exclude=[],
+    runtime_tmpdir=None,
+    console=True,
+    disable_windowed_traceback=False,
+    target_arch=None,
+    codesign_identity=None,
+    entitlements_file=None,
+    icon='viu/assets/logo.ico'
+)

completions/viu.bash

@@ -1,8 +1,8 @@
-_fastanime_completion() {
+_viu_completion() {
     local IFS=$'\n'
     local response
 
-    response=$(env COMP_WORDS="${COMP_WORDS[*]}" COMP_CWORD=$COMP_CWORD _FASTANIME_COMPLETE=bash_complete $1)
+    response=$(env COMP_WORDS="${COMP_WORDS[*]}" COMP_CWORD=$COMP_CWORD _VIU_COMPLETE=bash_complete $1)
 
     for completion in $response; do
         IFS=',' read type value <<< "$completion"
@@ -21,9 +21,9 @@ _fastanime_completion() {
     return 0
 }
 
-_fastanime_completion_setup() {
-    complete -o nosort -F _fastanime_completion fastanime
+_viu_completion_setup() {
+    complete -o nosort -F _viu_completion viu
 }
 
-_fastanime_completion_setup;
+_viu_completion_setup;
 

completions/viu.fish

@@ -1,5 +1,5 @@
-function _fastanime_completion;
-    set -l response (env _FASTANIME_COMPLETE=fish_complete COMP_WORDS=(commandline -cp) COMP_CWORD=(commandline -t) fastanime);
+function _viu_completion;
+    set -l response (env _VIU_COMPLETE=fish_complete COMP_WORDS=(commandline -cp) COMP_CWORD=(commandline -t) viu);
 
     for completion in $response;
         set -l metadata (string split "," $completion);
@@ -14,5 +14,5 @@ function _fastanime_completion;
     end;
 end;
 
-complete --no-files --command fastanime --arguments "(_fastanime_completion)";
+complete --no-files --command viu --arguments "(_viu_completion)";
 

completions/viu.zsh

@@ -1,12 +1,12 @@
-#compdef fastanime
+#compdef viu
 
-_fastanime_completion() {
+_viu_completion() {
     local -a completions
     local -a completions_with_descriptions
     local -a response
-    (( ! $+commands[fastanime] )) && return 1
+    (( ! $+commands[viu] )) && return 1
 
-    response=("${(@f)$(env COMP_WORDS="${words[*]}" COMP_CWORD=$((CURRENT-1)) _FASTANIME_COMPLETE=zsh_complete fastanime)}")
+    response=("${(@f)$(env COMP_WORDS="${words[*]}" COMP_CWORD=$((CURRENT-1)) _VIU_COMPLETE=zsh_complete viu)}")
 
     for type key descr in ${response}; do
         if [[ "$type" == "plain" ]]; then
@@ -33,9 +33,9 @@ _fastanime_completion() {
 
 if [[ $zsh_eval_context[-1] == loadautofunc ]]; then
     # autoload from fpath, call function directly
-    _fastanime_completion "$@"
+    _viu_completion "$@"
 else
     # eval/source/. command, register function for later
-    compdef _fastanime_completion fastanime
+    compdef _viu_completion viu
 fi
 

dev/generate_anilist_media_tags.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env -S uv run --script
+import json
+from collections import defaultdict
+from pathlib import Path
+
+import httpx
+from viu_media.core.utils.graphql import execute_graphql
+
+DEV_DIR = Path(__file__).resolve().parent
+media_tags_type_py = (
+    DEV_DIR.parent / "viu_media" / "libs" / "media_api" / "_media_tags.py"
+)
+media_tags_gql = DEV_DIR / "graphql" / "anilist" / "media_tags.gql"
+generated_tags_json = DEV_DIR / "generated" / "anilist" / "tags.json"
+
+media_tags_response = execute_graphql(
+    "https://graphql.anilist.co", httpx.Client(), media_tags_gql, {}
+)
+media_tags_response.raise_for_status()
+
+template = """\
+# DO NOT EDIT THIS FILE !!! ( ｡ •̀ ᴖ •́ ｡)
+# ITS AUTOMATICALLY GENERATED BY RUNNING ./dev/generate_anilist_media_tags.py
+# FROM THE PROJECT ROOT
+# SO RUN THAT INSTEAD TO UPDATE THE FILE WITH THE LATEST MEDIA TAGS :)
+
+
+from enum import Enum
+
+
+class MediaTag(Enum):\
+"""
+
+# 4 spaces
+tab = "    "
+tags = defaultdict(list)
+for tag in media_tags_response.json()["data"]["MediaTagCollection"]:
+    tags[tag["category"]].append(
+        {
+            "name": tag["name"],
+            "description": tag["description"],
+            "is_adult": tag["isAdult"],
+        }
+    )
+# save copy of data used to generate the class
+json.dump(tags, generated_tags_json.open("w", encoding="utf-8"), indent=2)
+
+for key, value in tags.items():
+    template = f"{template}\n{tab}#\n{tab}# {key.upper()}\n{tab}#\n"
+    for tag in value:
+        name = tag["name"]
+        _tag_name = name.replace("-", "_").replace(" ", "_").upper()
+        if _tag_name.startswith(("0", "1", "2", "3", "4", "5", "6", "7", "8", "9")):
+            _tag_name = f"_{_tag_name}"
+
+        tag_name = ""
+        # sanitize invalid characters for attribute names
+        for char in _tag_name:
+            if char.isidentifier() or char.isdigit():
+                tag_name += char
+
+        desc = tag["description"].replace("\n", "")
+        is_adult = tag["is_adult"]
+        template = f'{template}\n{tab}# {desc} (is_adult: {is_adult})\n{tab}{tag_name} = "{name}"\n'
+
+media_tags_type_py.write_text(template, "utf-8")

dev/generate_completions.sh

@@ -0,0 +1,14 @@
+#!/usr/bin/env bash
+APP_DIR="$(
+  cd -- "$(dirname "$0")" >/dev/null 2>&1
+  pwd -P
+)"
+
+# fish shell completions
+_VIU_COMPLETE=fish_source viu >"$APP_DIR/completions/viu.fish"
+
+# zsh completions
+_VIU_COMPLETE=zsh_source viu >"$APP_DIR/completions/viu.zsh"
+
+# bash completions
+_VIU_COMPLETE=bash_source viu >"$APP_DIR/completions/viu.bash"

dev/graphql/anilist/media_tags.gql

@@ -0,0 +1,8 @@
+query {
+  MediaTagCollection {
+    name
+    description
+    category
+    isAdult
+  }
+}

dev/make_release

@@ -0,0 +1,16 @@
+#! /usr/bin/env sh
+CLI_DIR="$(dirname "$(realpath "$0")")"
+VERSION=$1
+[ -z "$VERSION" ] && echo no version provided && exit 1
+[ "$VERSION" = "current" ] && viu --version && exit 0
+sed -i "s/^version.*/version = \"$VERSION\"/" "$CLI_DIR/pyproject.toml" &&
+  sed -i "s/__version__.*/__version__ = \"v$VERSION\"/" "$CLI_DIR/viu/__init__.py" &&
+  sed -i "s/version = .*/version = \"$VERSION\";/" "$CLI_DIR/flake.nix" &&
+  git stage "$CLI_DIR/pyproject.toml" "$CLI_DIR/viu/__init__.py" "$CLI_DIR/flake.nix" &&
+  git commit -m "chore: bump version (v$VERSION)" &&
+  # nix flake lock &&
+  uv lock &&
+  git stage "$CLI_DIR/flake.lock" "$CLI_DIR/uv.lock" &&
+  git commit -m "chore: update lock files" &&
+  git push &&
+  gh release create "v$VERSION"

fa

@@ -1,4 +0,0 @@
-#!/usr/bin/env sh
-# exec "${PYTHON:-python3}" -Werror -Xdev -m "$(dirname "$(realpath "$0")")/fastanime" "$@"
-cd "$(dirname "$(realpath "$0")")" || exit 1
-exec python -m fastanime "$@"

fastanime/AnimeProvider.py

@@ -1,128 +0,0 @@
-"""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.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__)
-
-
-# TODO: improve performance of this class and add cool features like auto retry
-class AnimeProvider:
-    """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]
-        anime_provider: [TODO:attribute]
-    """
-
-    PROVIDERS = list(anime_sources.keys())
-    provider = PROVIDERS[0]
-
-    def __init__(self, provider, dynamic=False, retries=0) -> None:
-        self.provider = provider
-        self.dynamic = dynamic
-        self.retries = retries
-        self.lazyload_provider()
-
-    def lazyload_provider(self):
-        """updates the current provider being used"""
-        _, anime_provider_cls_name = anime_sources[self.provider].split(".", 1)
-        package = f"fastanime.libs.anime_provider.{self.provider}"
-        provider_api = importlib.import_module(".api", package)
-        anime_provider = getattr(provider_api, anime_provider_cls_name)
-        self.anime_provider = anime_provider()
-
-    def search_for_anime(
-        self,
-        user_query,
-        translation_type,
-        anilist_obj: "AnilistBaseMediaDataSchema | None" = None,
-        nsfw=True,
-        unknown=True,
-    ) -> "SearchResults | None":
-        """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]
-            unknown ([TODO:parameter]): [TODO:description]
-            anilist_obj: [TODO:description]
-
-        Returns:
-            [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
-        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
-
-        Args:
-            anime_id: [TODO:description]
-            anilist_obj: [TODO:description]
-
-        Returns:
-            [TODO:return]
-        """
-        anime_provider = self.anime_provider
-        try:
-            results = anime_provider.get_anime(anime_id)
-        except Exception as e:
-            logging.error(e)
-            results = None
-        return results
-
-    def get_episode_streams(
-        self,
-        anime,
-        episode: str,
-        translation_type: str,
-        anilist_obj: "AnilistBaseMediaDataSchema|None" = None,
-    ) -> "Iterator[Server] | None":
-        """core abstractions for getting juicy streams from all providers
-
-        Args:
-            anime ([TODO:parameter]): [TODO:description]
-            episode: [TODO:description]
-            translation_type: [TODO:description]
-            anilist_obj: [TODO:description]
-
-        Returns:
-            [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

fastanime/Utility/__init__.py

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

fastanime/Utility/anilist_data_helper.py

@@ -1,34 +0,0 @@
-from datetime import datetime
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from ..libs.anilist.types import AnilistDateObject, AnilistMediaNextAiringEpisode
-
-
-# TODO: Add formating options for the final date
-def format_anilist_date_object(anilist_date_object: "AnilistDateObject"):
-    if anilist_date_object:
-        return f"{anilist_date_object['day']}/{anilist_date_object['month']}/{anilist_date_object['year']}"
-    else:
-        return "Unknown"
-
-
-def format_anilist_timestamp(anilist_timestamp: int | None):
-    if anilist_timestamp:
-        return datetime.fromtimestamp(anilist_timestamp).strftime("%d/%m/%Y %H:%M:%S")
-    else:
-        return "Unknown"
-
-
-def format_list_data_with_comma(data: list | None):
-    if data:
-        return ", ".join(data)
-    else:
-        return "None"
-
-
-def extract_next_airing_episode(airing_episode: "AnilistMediaNextAiringEpisode"):
-    if airing_episode:
-        return f"{airing_episode['episode']} on {format_anilist_timestamp(airing_episode['airingAt'])}"
-    else:
-        return "Completed"

fastanime/Utility/data.py

@@ -1,14 +0,0 @@
-"""
-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",
-}
-
-
-anilist_sort_normalizer = {"search match": "SEARCH_MATCH"}

fastanime/Utility/downloader/downloader.py

@@ -1,74 +0,0 @@
-import logging
-from queue import Queue
-from threading import Thread
-
-import yt_dlp
-from yt_dlp.utils import sanitize_filename
-
-logger = logging.getLogger(__name__)
-
-
-class YtDLPDownloader:
-    downloads_queue = Queue()
-
-    def _worker(self):
-        while True:
-            task, args = self.downloads_queue.get()
-            try:
-                task(*args)
-            except Exception as e:
-                logger.error(f"Something went wrong {e}")
-            self.downloads_queue.task_done()
-
-    def __init__(self):
-        self._thread = Thread(target=self._worker)
-        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,
-        anime_title: str,
-        episode_title: str,
-        download_dir: str,
-        silent: bool,
-        vid_format: str = "best",
-    ):
-        """Helper function that downloads anime given url and path details
-
-        Args:
-            url: [TODO:description]
-            anime_title: [TODO:description]
-            episode_title: [TODO:description]
-            download_dir: [TODO:description]
-            silent: [TODO:description]
-            vid_format: [TODO:description]
-        """
-        anime_title = sanitize_filename(anime_title)
-        episode_title = sanitize_filename(episode_title)
-        ydl_opts = {
-            # Specify the output path and template
-            "outtmpl": f"{download_dir}/{anime_title}/{episode_title}.%(ext)s",
-            "silent": silent,
-            "verbose": False,
-            "format": vid_format,
-        }
-
-        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
-            ydl.download([url])
-
-    # WARN: May remove this legacy functionality
-    def download_file(self, url: str, title, silent=True):
-        """A helper that just does things in the background
-
-        Args:
-            title ([TODO:parameter]): [TODO:description]
-            silent ([TODO:parameter]): [TODO:description]
-            url: [TODO:description]
-        """
-        self.downloads_queue.put((self._download_file, (url, title, silent)))
-
-
-downloader = YtDLPDownloader()

fastanime/Utility/utils.py

@@ -1,38 +0,0 @@
-import logging
-from typing import TYPE_CHECKING
-
-from thefuzz import fuzz
-
-from .data import anime_normalizer
-
-if TYPE_CHECKING:
-    from ..libs.anilist.types import AnilistBaseMediaDataSchema
-
-logger = logging.getLogger(__name__)
-
-
-def anime_title_percentage_match(
-    possible_user_requested_anime_title: str, anime: "AnilistBaseMediaDataSchema"
-) -> float:
-    """Returns the percentage match between the possible title and user title
-
-    Args:
-        possible_user_requested_anime_title (str): an Animdl search result title
-        title (str): the anime title the user wants
-
-    Returns:
-        int: the percentage match
-    """
-    if normalized_anime_title := anime_normalizer.get(
-        possible_user_requested_anime_title
-    ):
-        possible_user_requested_anime_title = normalized_anime_title
-    # compares both the romaji and english names and gets highest Score
-    title_a = str(anime["title"]["romaji"])
-    title_b = str(anime["title"]["english"])
-    percentage_ratio = max(
-        fuzz.ratio(title_a.lower(), possible_user_requested_anime_title.lower()),
-        fuzz.ratio(title_b.lower(), possible_user_requested_anime_title.lower()),
-    )
-    logger.info(f"{locals()}")
-    return percentage_ratio

fastanime/__init__.py

@@ -1,20 +0,0 @@
-import sys
-
-if sys.version_info < (3, 10):
-    raise ImportError(
-        "You are using an unsupported version of Python. Only Python versions 3.8 and above are supported by yt-dlp"
-    )  # noqa: F541
-
-
-__version__ = "v1.1.6"
-
-APP_NAME = "FastAnime"
-AUTHOR = "Benex254"
-GIT_REPO = "github.com"
-REPO = f"{GIT_REPO}/{AUTHOR}/{APP_NAME}"
-
-
-def FastAnime():
-    from .cli import run_cli
-
-    run_cli()

fastanime/anilist.py

@@ -1,3 +0,0 @@
-from .libs.anilist.api import AniListApi
-
-AniList = AniListApi()

fastanime/cli/__init__.py

@@ -1,256 +0,0 @@
-import signal
-
-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 = {
-    "search": "search.search",
-    "download": "download.download",
-    "anilist": "anilist.anilist",
-    "config": "config.config",
-    "downloads": "downloads.downloads",
-    "cache": "cache.cache",
-    "completions": "completions.completions",
-    "update": "update.update",
-}
-
-
-# handle keyboard interupt
-def handle_exit(signum, frame):
-    from click import clear
-
-    from .utils.tools import exit_app
-
-    clear()
-
-    exit_app()
-
-
-signal.signal(signal.SIGINT, handle_exit)
-
-
-@click.group(
-    lazy_subcommands=commands,
-    cls=LazyGroup,
-    help="A command line application for streaming anime that provides a complete and featureful interface",
-    short_help="Stream Anime",
-)
-@click.version_option(__version__, "--version")
-@click.option("--log", help="Allow logging to stdout", is_flag=True)
-@click.option("--log-file", help="Allow logging to a file", is_flag=True)
-@click.option("--rich-traceback", help="Use rich to output tracebacks", is_flag=True)
-@click.option(
-    "-p",
-    "--provider",
-    type=click.Choice(list(anime_sources.keys()), case_sensitive=False),
-    help="Provider of your choice",
-)
-@click.option(
-    "-s",
-    "--server",
-    type=click.Choice([*SERVERS_AVAILABLE, "top"]),
-    help="Server of choice",
-)
-@click.option(
-    "-f",
-    "--format",
-    type=str,
-    help="yt-dlp format to use",
-)
-@click.option(
-    "-c/-no-c",
-    "--continue/--no-continue",
-    "continue_",
-    type=bool,
-    help="Continue from last episode?",
-)
-@click.option(
-    "--skip/--no-skip",
-    type=bool,
-    help="Skip opening and ending theme songs?",
-)
-@click.option(
-    "-q",
-    "--quality",
-    type=click.Choice(["360", "720", "1080", "unknown"]),
-    help="set the quality of the stream",
-)
-@click.option(
-    "-t",
-    "--translation-type",
-    type=click.Choice(["dub", "sub"]),
-    help="Anime language[dub/sub]",
-)
-@click.option(
-    "-A/-no-A",
-    "--auto-next/--no-auto-next",
-    type=bool,
-    help="Auto select next episode?",
-)
-@click.option(
-    "-a/-no-a",
-    "--auto-select/--no-auto-select",
-    type=bool,
-    help="Auto select anime title?",
-)
-@click.option(
-    "-S",
-    "--sort-by",
-    type=click.Choice(anilist_sort_normalizer.keys()),  # pyright: ignore
-)
-@click.option("-d", "--downloads-dir", type=click.Path(), help="Downloads location")
-@click.option("--fzf", is_flag=True, help="Use fzf for the ui")
-@click.option("--default", is_flag=True, help="Use the default interface")
-@click.option("--preview", is_flag=True, help="Show preview when using fzf")
-@click.option("--no-preview", is_flag=True, help="Dont show preview when using fzf")
-@click.option(
-    "--icons/--no-icons",
-    type=bool,
-    help="Use icons in the interfaces",
-)
-@click.option("--dub", help="Set the translation type to dub", is_flag=True)
-@click.option("--sub", help="Set the translation type to sub", is_flag=True)
-@click.option("--rofi", help="Use rofi for the ui", is_flag=True)
-@click.option("--rofi-theme", help="Rofi theme to use", type=click.Path())
-@click.option(
-    "--rofi-theme-confirm",
-    help="Rofi theme to use for the confirm prompt",
-    type=click.Path(),
-)
-@click.option(
-    "--rofi-theme-input",
-    help="Rofi theme to use for the user input prompt",
-    type=click.Path(),
-)
-@click.option(
-    "--use-mpv-mod/--use-default-player", help="Whether to use python-mpv", type=bool
-)
-@click.pass_context
-def run_cli(
-    ctx: click.Context,
-    log,
-    log_file,
-    rich_traceback,
-    provider,
-    server,
-    format,
-    continue_,
-    skip,
-    translation_type,
-    quality,
-    auto_next,
-    auto_select,
-    sort_by,
-    downloads_dir,
-    fzf,
-    default,
-    preview,
-    no_preview,
-    icons,
-    dub,
-    sub,
-    rofi,
-    rofi_theme,
-    rofi_theme_confirm,
-    rofi_theme_input,
-    use_mpv_mod,
-):
-    from .config import Config
-
-    ctx.obj = Config()
-    if log:
-        import logging
-
-        from rich.logging import RichHandler
-
-        FORMAT = "%(message)s"
-
-        logging.basicConfig(
-            level="NOTSET", 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
-
-        format = "%(asctime)s%(levelname)s: %(message)s"
-        logging.basicConfig(
-            level=logging.DEBUG,
-            filename=NOTIFIER_LOG_FILE_PATH,
-            format=format,
-            datefmt="[%d/%m/%Y@%H:%M:%S]",
-            filemode="w",
-        )
-    if rich_traceback:
-        from rich.traceback import install
-
-        install()
-
-    if provider:
-        ctx.obj.provider = provider
-    if server:
-        ctx.obj.server = server
-    if format:
-        ctx.obj.format = format
-    if ctx.get_parameter_source("continue_") == click.core.ParameterSource.COMMANDLINE:
-        ctx.obj.continue_from_history = continue_
-    if ctx.get_parameter_source("skip") == click.core.ParameterSource.COMMANDLINE:
-        ctx.obj.skip = skip
-
-    if quality:
-        ctx.obj.quality = quality
-    if ctx.get_parameter_source("auto_next") == click.core.ParameterSource.COMMANDLINE:
-        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("auto_select")
-        == click.core.ParameterSource.COMMANDLINE
-    ):
-        ctx.obj.auto_select = auto_select
-    if (
-        ctx.get_parameter_source("use_mpv_mod")
-        == click.core.ParameterSource.COMMANDLINE
-    ):
-        ctx.obj.use_mpv_mod = use_mpv_mod
-    if sort_by:
-        ctx.obj.sort_by = sort_by
-    if downloads_dir:
-        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
-    if preview:
-        ctx.obj.preview = True
-    if no_preview:
-        ctx.obj.preview = False
-    if dub:
-        ctx.obj.translation_type = "dub"
-    if sub:
-        ctx.obj.translation_type = "sub"
-    if rofi:
-        ctx.obj.use_fzf = False
-        ctx.obj.use_rofi = True
-    if rofi:
-        from ..libs.rofi import Rofi
-
-        if rofi_theme:
-            ctx.obj.rofi_theme = rofi_theme
-            Rofi.rofi_theme = rofi_theme
-
-        if rofi_theme_input:
-            ctx.obj.rofi_theme_input = rofi_theme_input
-            Rofi.rofi_theme_input = rofi_theme_input
-
-        if rofi_theme_confirm:
-            ctx.obj.rofi_theme_confirm = rofi_theme_confirm
-            Rofi.rofi_theme_confirm = rofi_theme_confirm

fastanime/cli/app_updater.py

@@ -1,105 +0,0 @@
-import pathlib
-import re
-import shlex
-import shutil
-import subprocess
-import sys
-
-import requests
-from rich import print
-
-from .. import APP_NAME, AUTHOR, GIT_REPO, __version__
-
-API_URL = f"https://api.{GIT_REPO}/repos/{AUTHOR}/{APP_NAME}/releases/latest"
-
-
-def check_for_updates():
-    USER_AGENT = f"{APP_NAME} user"
-    request = requests.get(
-        API_URL,
-        headers={
-            "User-Agent": USER_AGENT,
-            "X-GitHub-Api-Version": "2022-11-28",
-            "Accept": "application/vnd.github+json",
-        },
-    )
-
-    if request.status_code == 200:
-        release_json = request.json()
-        return (release_json["tag_name"] == __version__, release_json)
-    else:
-        print(request.text)
-        return (False, {})
-
-
-def is_git_repo(author, repository):
-    # Check if the current directory contains a .git folder
-    git_dir = pathlib.Path(".git")
-    if not git_dir.exists() or not git_dir.is_dir():
-        return False
-
-    # Check if the config file exists
-    config_path = git_dir / "config"
-    if not config_path.exists():
-        return False
-
-    try:
-        # Read the .git/config file to find the remote repository URL
-        with config_path.open("r") as git_config:
-            git_config_content = git_config.read()
-    except (FileNotFoundError, PermissionError):
-        return False
-
-    # Use regex to find the repository URL in the config file
-    repo_name_pattern = r"url\s*=\s*.+/([^/]+/[^/]+)\.git"
-    match = re.search(repo_name_pattern, git_config_content)
-
-    # Return True if match found and repository name matches
-    return bool(match) and match.group(1) == f"{author}/{repository}"
-
-
-def update_app():
-    is_latest, release_json = check_for_updates()
-    if is_latest:
-        print("[green]App is up to date[/]")
-        return False, release_json
-    tag_name = release_json["tag_name"]
-
-    print("[cyan]Updating app to version %s[/]" % tag_name)
-    if is_git_repo(AUTHOR, APP_NAME):
-        GIT_EXECUTABLE = shutil.which("git")
-        args = [
-            GIT_EXECUTABLE,
-            "pull",
-        ]
-
-        print(f"Pulling latest changes from the repository via git: {shlex.join(args)}")
-
-        if not GIT_EXECUTABLE:
-            print("[red]Cannot find git please install it.[/]")
-            return False, release_json
-
-        process = subprocess.run(
-            args,
-        )
-
-    else:
-        if PIPX_EXECUTABLE := shutil.which("pipx"):
-            process = subprocess.run([PIPX_EXECUTABLE, "upgrade", APP_NAME])
-        else:
-            PYTHON_EXECUTABLE = sys.executable
-
-            args = [
-                PYTHON_EXECUTABLE,
-                "-m",
-                "pip",
-                "install",
-                APP_NAME,
-                "--user",
-                "--no-warn-script-location",
-            ]
-            process = subprocess.run(args)
-    if process.returncode == 0:
-        return True, release_json
-    else:
-        return False, release_json

fastanime/cli/commands/anilist/__init__.py

@@ -1,51 +0,0 @@
-import click
-
-from ...utils.tools import FastAnimeRuntimeState
-from .__lazyloader__ import LazyGroup
-
-commands = {
-    "trending": "trending.trending",
-    "recent": "recent.recent",
-    "search": "search.search",
-    "upcoming": "upcoming.upcoming",
-    "scores": "scores.scores",
-    "popular": "popular.popular",
-    "favourites": "favourites.favourites",
-    "random": "random_anime.random_anime",
-    "login": "login.login",
-    "watching": "watching.watching",
-    "paused": "paused.paused",
-    "rewatching": "rewatching.rewatching",
-    "dropped": "dropped.dropped",
-    "completed": "completed.completed",
-    "planning": "planning.planning",
-    "notifier": "notifier.notifier",
-}
-
-
-@click.group(
-    lazy_subcommands=commands,
-    cls=LazyGroup,
-    invoke_without_command=True,
-    help="A beautiful interface that gives you access to a commplete streaming experience",
-    short_help="Access all streaming options",
-)
-@click.pass_context
-def anilist(ctx: click.Context):
-    from typing import TYPE_CHECKING
-
-    from ....anilist import AniList
-    from ....AnimeProvider import AnimeProvider
-    from ...interfaces.anilist_interfaces import (
-        fastanime_main_menu as anilist_interface,
-    )
-
-    if TYPE_CHECKING:
-        from ...config import Config
-    config: Config = ctx.obj
-    config.anime_provider = AnimeProvider(config.provider)
-    if user := ctx.obj.user:
-        AniList.update_login_info(user, user["token"])
-    if ctx.invoked_subcommand is None:
-        fastanime_runtime_state = FastAnimeRuntimeState()
-        anilist_interface(ctx.obj, fastanime_runtime_state)

fastanime/cli/commands/anilist/__lazyloader__.py

@@ -1,42 +0,0 @@
-# in lazy_group.py
-import importlib
-
-import click
-
-
-class LazyGroup(click.Group):
-    def __init__(self, *args, lazy_subcommands=None, **kwargs):
-        super().__init__(*args, **kwargs)
-        # lazy_subcommands is a map of the form:
-        #
-        #   {command-name} -> {module-name}.{command-object-name}
-        #
-        self.lazy_subcommands = lazy_subcommands or {}
-
-    def list_commands(self, ctx):
-        base = super().list_commands(ctx)
-        lazy = sorted(self.lazy_subcommands.keys())
-        return base + lazy
-
-    def get_command(self, ctx, cmd_name):  # pyright:ignore
-        if cmd_name in self.lazy_subcommands:
-            return self._lazy_load(cmd_name)
-        return super().get_command(ctx, cmd_name)
-
-    def _lazy_load(self, cmd_name: str):
-        # lazily loading a command, first get the module name and attribute name
-        import_path: str = self.lazy_subcommands[cmd_name]
-        modname, cmd_object_name = import_path.rsplit(".", 1)
-        # do the import
-        mod = importlib.import_module(
-            f".{modname}", package="fastanime.cli.commands.anilist"
-        )
-        # get the Command object from that module
-        cmd_object = getattr(mod, cmd_object_name)
-        # check the result to make debugging easier
-        if not isinstance(cmd_object, click.BaseCommand):
-            raise ValueError(
-                f"Lazy loading of {import_path} failed by returning "
-                "a non-command object"
-            )
-        return cmd_object

fastanime/cli/commands/anilist/completed.py

@@ -1,32 +0,0 @@
-from typing import TYPE_CHECKING
-
-import click
-
-if TYPE_CHECKING:
-    from ...config import Config
-
-
-@click.command(help="View anime you completed")
-@click.pass_obj
-def completed(config: "Config"):
-    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()
-    anime_list = AniList.get_anime_list("COMPLETED")
-    if not anime_list or not anime_list[1]:
-        return
-    if not anime_list[0]:
-        return
-    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)

fastanime/cli/commands/anilist/dropped.py

@@ -1,32 +0,0 @@
-from typing import TYPE_CHECKING
-
-import click
-
-if TYPE_CHECKING:
-    from fastanime.cli.config import Config
-
-
-@click.command(help="View anime you dropped")
-@click.pass_obj
-def dropped(config: "Config"):
-    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()
-    anime_list = AniList.get_anime_list("DROPPED")
-    if not anime_list:
-        return
-    if not anime_list[0] or not anime_list[1]:
-        return
-    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)

fastanime/cli/commands/anilist/favourites.py

@@ -1,18 +0,0 @@
-import click
-
-
-@click.command(
-    help="Fetch the top 15 most favourited anime from anilist",
-    short_help="View most favourited anime",
-)
-@click.pass_obj
-def favourites(config):
-    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)

fastanime/cli/commands/anilist/login.py

@@ -1,48 +0,0 @@
-from typing import TYPE_CHECKING
-
-import click
-
-if TYPE_CHECKING:
-    from ...config import Config
-
-
-@click.command(help="Login to your anilist account")
-@click.option("--status", "-s", help="Whether you are logged in or not", is_flag=True)
-@click.pass_obj
-def login(config: "Config", status):
-    from click import launch
-    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"
-        )
-        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()

fastanime/cli/commands/anilist/notifier.py

@@ -1,124 +0,0 @@
-from typing import TYPE_CHECKING
-
-import click
-
-if TYPE_CHECKING:
-    from ...config import Config
-
-
-@click.command(help="Check for notifications on anime you currently watching")
-@click.pass_obj
-def notifier(config: "Config"):
-    import json
-    import logging
-    import os
-    import time
-
-    import requests
-    from plyer import notification
-
-    from ....anilist import AniList
-    from ....constants import APP_CACHE_DIR, APP_DATA_DIR, APP_NAME, ICON_PATH, PLATFORM
-
-    logger = logging.getLogger(__name__)
-
-    notified = os.path.join(APP_DATA_DIR, "last_notification.json")
-    anime_image_path = os.path.join(APP_CACHE_DIR, "notification_image")
-    notification_duration = config.notification_duration * 60
-    notification_image_path = ""
-
-    if not config.user:
-        print("Not Authenticated")
-        print("Run the following to get started: fastanime anilist loggin")
-        return
-    run = True
-    # WARNING: Mess around with this value at your own risk
-    timeout = 2  # time is in minutes
-    if os.path.exists(notified):
-        with open(notified, "r") as f:
-            past_notifications = json.load(f)
-    else:
-        past_notifications = {}
-        with open(notified, "w") as f:
-            json.dump(past_notifications, f)
-
-    while run:
-        try:
-            logger.info("checking for notifications")
-            result = AniList.get_notification()
-            if not result[0]:
-                logger.warning(
-                    "Something went wrong this could mean anilist is down or you have lost internet connection"
-                )
-                logger.info("sleeping...")
-                time.sleep(timeout * 60)
-                continue
-            data = result[1]
-            if not data:
-                logger.warning(
-                    "Something went wrong this could mean anilist is down or you have lost internet connection"
-                )
-                logger.info("sleeping...")
-                time.sleep(timeout * 60)
-                continue
-
-            notifications = data["data"]["Page"]["notifications"]
-            if not notifications:
-                logger.info("Nothing to notify")
-            else:
-                for notification_ in notifications:
-                    anime_episode = notification_["episode"]
-                    anime_title = notification_["media"]["title"][
-                        config.preferred_language
-                    ]
-                    title = f"{anime_title} Episode {anime_episode} just aired"
-                    # pyright:ignore
-                    message = "Be sure to watch so you are not left out of the loop."
-                    # message = str(textwrap.wrap(message, width=50))
-
-                    id = notification_["media"]["id"]
-                    if past_notifications.get(str(id)) == notification_["episode"]:
-                        logger.info(
-                            f"skipping id={id} title={anime_title} episode={anime_episode} already notified"
-                        )
-
-                    else:
-                        # windows only supports ico,
-                        # and you still ask why linux
-                        if PLATFORM != "Windows":
-                            image_link = notification_["media"]["coverImage"]["medium"]
-                            logger.info("Downloading image...")
-
-                            resp = requests.get(image_link)
-                            if resp.status_code == 200:
-                                with open(anime_image_path, "wb") as f:
-                                    f.write(resp.content)
-                                notification_image_path = anime_image_path
-                            else:
-                                logger.warn(
-                                    f"Failed to get image response_status={resp.status_code} response_content={resp.content}"
-                                )
-                                notification_image_path = ICON_PATH
-                        else:
-                            notification_image_path = ICON_PATH
-
-                        past_notifications[f"{id}"] = notification_["episode"]
-                        with open(notified, "w") as f:
-                            json.dump(past_notifications, f)
-                        logger.info(message)
-                        notification.notify(  # pyright:ignore
-                            title=title,
-                            message=message,
-                            app_name=APP_NAME,
-                            app_icon=notification_image_path,
-                            hints={
-                                "image-path": notification_image_path,
-                                "desktop-entry": f"{APP_NAME}.desktop",
-                            },
-                            timeout=notification_duration,
-                        )
-                        time.sleep(30)
-        except Exception as e:
-            logger.error(e)
-        logger.info("sleeping...")
-        time.sleep(timeout * 60)

fastanime/cli/commands/anilist/paused.py

@@ -1,32 +0,0 @@
-from typing import TYPE_CHECKING
-
-import click
-
-if TYPE_CHECKING:
-    from ...config import Config
-
-
-@click.command(help="View anime you paused on watching")
-@click.pass_obj
-def paused(config: "Config"):
-    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()
-    anime_list = AniList.get_anime_list("PAUSED")
-    if not anime_list:
-        return
-    if not anime_list[0] or not anime_list[1]:
-        return
-    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)

fastanime/cli/commands/anilist/planning.py

@@ -1,32 +0,0 @@
-from typing import TYPE_CHECKING
-
-import click
-
-if TYPE_CHECKING:
-    from ...config import Config
-
-
-@click.command(help="View anime you are planning on watching")
-@click.pass_obj
-def planning(config: "Config"):
-    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()
-    anime_list = AniList.get_anime_list("PLANNING")
-    if not anime_list:
-        return
-    if not anime_list[0] or not anime_list[1]:
-        return
-    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)

fastanime/cli/commands/anilist/popular.py

@@ -1,17 +0,0 @@
-import click
-
-
-@click.command(
-    help="Fetch the top 15 most popular anime", short_help="View most popular anime"
-)
-@click.pass_obj
-def popular(config):
-    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)

fastanime/cli/commands/anilist/random_anime.py

@@ -1,27 +0,0 @@
-import click
-
-
-@click.command(
-    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.pass_obj
-def random_anime(config):
-    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 = 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)
-    else:
-        print(anime_data[1])

fastanime/cli/commands/anilist/recent.py

@@ -1,18 +0,0 @@
-import click
-
-
-@click.command(
-    help="Fetch the 15 most recently updated anime from anilist that are currently releasing",
-    short_help="View recently updated anime",
-)
-@click.pass_obj
-def recent(config):
-    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)

fastanime/cli/commands/anilist/rewatching.py

@@ -1,32 +0,0 @@
-from typing import TYPE_CHECKING
-
-import click
-
-if TYPE_CHECKING:
-    from ...config import Config
-
-
-@click.command(help="View anime you are rewatching")
-@click.pass_obj
-def rewatching(config: "Config"):
-    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()
-    anime_list = AniList.get_anime_list("REPEATING")
-    if not anime_list:
-        return
-    if not anime_list[0] or not anime_list[1]:
-        return
-    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)

fastanime/cli/commands/anilist/scores.py

@@ -1,17 +0,0 @@
-import click
-
-
-@click.command(
-    help="Fetch the 15 most scored anime", short_help="View most scored anime"
-)
-@click.pass_obj
-def scores(config):
-    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)

fastanime/cli/commands/anilist/search.py

@@ -1,21 +0,0 @@
-import click
-
-
-@click.command(
-    help="Search for anime using anilists api and get top ~50 results",
-    short_help="Search for anime",
-)
-@click.argument(
-    "title",
-)
-@click.pass_obj
-def search(config, title):
-    from ....anilist import AniList
-    from ...interfaces.anilist_interfaces import anilist_results_menu
-    from ...utils.tools import FastAnimeRuntimeState
-
-    success, search_results = AniList.search(title)
-    if success:
-        fastanime_runtime_state = FastAnimeRuntimeState()
-        fastanime_runtime_state.anilist_data = search_results
-        anilist_results_menu(config, fastanime_runtime_state)

fastanime/cli/commands/anilist/trending.py

@@ -1,18 +0,0 @@
-import click
-
-
-@click.command(
-    help="Fetch the top 15 anime that are currently trending",
-    short_help="Trending anime 🔥🔥🔥",
-)
-@click.pass_obj
-def trending(config):
-    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)

fastanime/cli/commands/anilist/upcoming.py

@@ -1,17 +0,0 @@
-import click
-
-
-@click.command(
-    help="Fetch the 15 most anticipited anime", short_help="View upcoming anime"
-)
-@click.pass_obj
-def upcoming(config):
-    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)

fastanime/cli/commands/anilist/watching.py

@@ -1,32 +0,0 @@
-from typing import TYPE_CHECKING
-
-import click
-
-if TYPE_CHECKING:
-    from ...config import Config
-
-
-@click.command(help="View anime you are watching")
-@click.pass_obj
-def watching(config: "Config"):
-    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()
-    anime_list = AniList.get_anime_list("CURRENT")
-    if not anime_list:
-        return
-    if not anime_list[0] or not anime_list[1]:
-        return
-    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)

fastanime/cli/commands/cache.py

@@ -1,39 +0,0 @@
-import click
-
-
-@click.command(help="Helper command to manage 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)
-def cache(clean, path, size):
-    from ...constants import APP_CACHE_DIR
-
-    if path:
-        print(APP_CACHE_DIR)
-    elif clean:
-        import shutil
-
-        from rich.prompt import Confirm
-
-        if Confirm.ask(
-            f"Are you sure you want to clean the following path: {APP_CACHE_DIR};(NOTE: !!The action is irreversible and will clean your cache!!)",
-            default=False,
-        ):
-            print("Cleaning...")
-            shutil.rmtree(APP_CACHE_DIR)
-            print("Successfully removed: ", APP_CACHE_DIR)
-    elif size:
-        import os
-
-        from ..utils.utils import format_bytes_to_human
-
-        total_size = 0
-        for dirpath, dirnames, filenames in os.walk(APP_CACHE_DIR):
-            for f in filenames:
-                fp = os.path.join(dirpath, f)
-                total_size += os.path.getsize(fp)
-        print("Total Size: ", format_bytes_to_human(total_size))
-    else:
-        import click
-
-        click.launch(APP_CACHE_DIR)

fastanime/cli/commands/config.py

@@ -1,93 +0,0 @@
-from typing import TYPE_CHECKING
-
-import click
-
-if TYPE_CHECKING:
-    from ..config import Config
-
-
-@click.command(
-    help="Opens up your fastanime config in your preferred editor",
-    short_help="Edit your config",
-)
-@click.option("--path", "-p", help="Print the config location and exit", is_flag=True)
-@click.option(
-    "--view", "-v", help="View the current contents of your config", is_flag=True
-)
-@click.option(
-    "--desktop-entry",
-    "-d",
-    help="Configure the desktop entry of fastanime",
-    is_flag=True,
-)
-@click.pass_obj
-def config(config: "Config", path, view, desktop_entry):
-    import sys
-
-    from rich import print
-
-    from ... import __version__
-    from ...constants import APP_NAME, ICON_PATH, S_PLATFORM, USER_CONFIG_PATH
-
-    if path:
-        print(USER_CONFIG_PATH)
-    elif view:
-        print(config)
-    elif desktop_entry:
-        import os
-        import shutil
-        from pathlib import Path
-        from textwrap import dedent
-
-        from rich import print
-        from rich.prompt import Confirm
-
-        from ..utils.tools import exit_app
-
-        FASTANIME_EXECUTABLE = shutil.which("fastanime")
-        if FASTANIME_EXECUTABLE:
-            cmds = f"{FASTANIME_EXECUTABLE} --rofi anilist"
-        else:
-            cmds = 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)
-    else:
-        import click
-
-        click.edit(filename=USER_CONFIG_PATH)

fastanime/cli/commands/download.py

@@ -1,164 +0,0 @@
-import time
-from typing import TYPE_CHECKING
-
-import click
-
-if TYPE_CHECKING:
-    from ..config import Config
-
-
-@click.command(
-    help="Download anime using the anime provider for a specified range",
-    short_help="Download anime",
-)
-@click.argument(
-    "anime-title",
-    required=True,
-)
-@click.option(
-    "--episode-range",
-    "-r",
-    help="A range of episodes to download",
-)
-@click.option(
-    "--highest_priority",
-    "-h",
-    help="Choose stream indicated as highest priority",
-    is_flag=True,
-)
-@click.pass_obj
-def download(config: "Config", anime_title, episode_range, highest_priority):
-    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 ...Utility.downloader.downloader import downloader
-    from ..utils.tools import exit_app
-    from ..utils.utils import filter_by_quality, fuzzy_inquirer
-
-    anime_provider = AnimeProvider(config.provider)
-
-    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 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
-    }
-
-    if config.auto_select:
-        search_result = max(
-            search_results_.keys(), key=lambda title: fuzz.ratio(title, anime_title)
-        )
-        print("[cyan]Auto selecting:[/] ", search_result)
-    else:
-        choices = list(search_results_.keys())
-        if config.use_fzf:
-            search_result = fzf.run(choices, "Please Select title: ", "FastAnime")
-        else:
-            search_result = fuzzy_inquirer(
-                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
-                )
-                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, None)
-                    if not server:
-                        print("Sth went wrong when fetching the server")
-                        continue
-                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"]
-                )
-                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,
-            )
-        except Exception as e:
-            print(e)
-            time.sleep(1)
-            print("Continuing")
-            clear()
-    print("Done Downloading")
-    exit_app()

fastanime/cli/commands/downloads.py

@@ -1,50 +0,0 @@
-from typing import TYPE_CHECKING
-
-import click
-
-if TYPE_CHECKING:
-    from ..config import Config
-
-
-@click.command(
-    help="View and watch your downloads using mpv", short_help="Watch downloads"
-)
-@click.option("--path", "-p", help="print the downloads folder and exit", is_flag=True)
-@click.pass_obj
-def downloads(config: "Config", path: bool):
-    import os
-
-    from ...cli.utils.mpv import run_mpv
-    from ...libs.fzf import fzf
-    from ...libs.rofi import Rofi
-    from ..utils.tools import exit_app
-    from ..utils.utils import fuzzy_inquirer
-
-    USER_VIDEOS_DIR = config.downloads_dir
-    if path:
-        print(USER_VIDEOS_DIR)
-        return
-    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")
-
-    def stream():
-        if config.use_fzf:
-            playlist_name = fzf.run(playlists, "Enter Playlist Name", "Downloads")
-        elif config.use_rofi:
-            playlist_name = Rofi.run(playlists, "Enter Playlist Name")
-        else:
-            playlist_name = fuzzy_inquirer(
-                playlists,
-                "Enter Playlist Name: ",
-            )
-        if playlist_name == "Exit":
-            exit_app()
-            return
-        playlist = os.path.join(USER_VIDEOS_DIR, playlist_name)
-        run_mpv(playlist)
-        stream()
-
-    stream()

fastanime/cli/commands/search.py

@@ -1,180 +0,0 @@
-import click
-
-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",
-)
-@click.option(
-    "--episode-range",
-    "-r",
-    help="A range of episodes to binge",
-)
-@click.argument("anime_title", required=True, type=str)
-@click.pass_obj
-def search(config: Config, anime_title: 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
-
-    anime_provider = AnimeProvider(config.provider)
-
-    # ---- search for anime ----
-    with Progress() as progress:
-        progress.add_task("Fetching Search Results...", total=None)
-        search_results = anime_provider.search_for_anime(
-            anime_title, config.translation_type
-        )
-    if not search_results:
-        print("Search results not found")
-        input("Enter to retry")
-        search(config, anime_title, episode_range)
-        return
-    search_results = search_results["results"]
-    if not search_results:
-        print("Anime not found :cry:")
-        exit_app()
-    search_results_ = {
-        search_result["title"]: search_result for search_result in search_results
-    }
-
-    if config.auto_select:
-        search_result = max(
-            search_results_.keys(), key=lambda title: fuzz.ratio(title, anime_title)
-        )
-        print("[cyan]Auto Selecting:[/] ", search_result)
-
-    else:
-        choices = list(search_results_.keys())
-        if config.use_fzf:
-            search_result = fzf.run(choices, "Please Select title: ", "FastAnime")
-        elif config.use_rofi:
-            search_result = Rofi.run(choices, "Please Select Title")
-        else:
-            search_result = fuzzy_inquirer(
-                choices,
-                "Please Select Title",
-            )
-
-    # ---- fetch selected anime ----
-    with Progress() as progress:
-        progress.add_task("Fetching Anime...", total=None)
-        anime: Anime | None = anime_provider.get_anime(
-            search_results_[search_result]["id"]
-        )
-
-    if not anime:
-        print("Sth went wring anime no found")
-        input("Enter to continue...")
-        search(config, anime_title, episode_range)
-        return
-    episode_range_ = None
-    episodes = anime["availableEpisodesDetail"][config.translation_type]
-    if episode_range:
-        episodes_start, episodes_end = episode_range.split("-")
-        if episodes_start and episodes_end:
-            episode_range_ = iter(
-                range(round(float(episodes_start)), round(float(episodes_end)) + 1)
-            )
-        else:
-            episode_range_ = iter(sorted(episodes, key=float))
-
-    def stream_anime():
-        clear()
-        episode = None
-
-        if episode_range_:
-            try:
-                episode = str(next(episode_range_))
-                print(
-                    f"[cyan]Auto selecting:[/] {search_result} [cyan]Episode:[/] {episode}"
-                )
-            except StopIteration:
-                print("[green]Completed binge sequence[/]:smile:")
-                input("Enter to continue...")
-
-        if not episode or episode not in episodes:
-            if config.use_fzf:
-                episode = fzf.run(episodes, "Select an episode: ", header=search_result)
-            elif config.use_rofi:
-                episode = Rofi.run(episodes, "Select an episode")
-            else:
-                episode = fuzzy_inquirer(
-                    episodes,
-                    "Select episode",
-                )
-
-        # ---- fetch streams ----
-        with Progress() as progress:
-            progress.add_task("Fetching Episode Streams...", total=None)
-            streams = anime_provider.get_episode_streams(
-                anime, episode, config.translation_type
-            )
-            if not streams:
-                print("Failed to get streams")
-                return
-
-        try:
-            # ---- fetch servers ----
-            if config.server == "top":
-                with Progress() as progress:
-                    progress.add_task("Fetching top server...", total=None)
-                    server = next(streams, None)
-                    if not server:
-                        print("Sth went wrong when fetching the episode")
-                        input("Enter to continue")
-                        stream_anime()
-                        return
-                stream_link = filter_by_quality(config.quality, server["links"])
-                if not stream_link:
-                    print("Quality not found")
-                    input("Enter to continue")
-                    stream_anime()
-                    return
-                link = stream_link["link"]
-                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"]
-                )
-                if not stream_link:
-                    print("Quality not found")
-                    input("Enter to continue")
-                    stream_anime()
-                    return
-                link = stream_link["link"]
-                episode_title = servers[server]["episode_title"]
-            print(f"[purple]Now Playing:[/] {search_result} Episode {episode}")
-
-            run_mpv(link, episode_title)
-        except Exception as e:
-            print(e)
-            input("Enter to continue")
-        stream_anime()
-
-    stream_anime()

fastanime/cli/commands/update.py

@@ -1,37 +0,0 @@
-import click
-
-
-@click.command(help="Helper command to update fastanime to latest")
-@click.option("--check", "-c", help="Check for the latest release", is_flag=True)
-def update(
-    check,
-):
-    from rich.console import Console
-    from rich.markdown import Markdown
-
-    from ..app_updater import check_for_updates, update_app
-
-    def _print_release(release_data):
-        console = Console()
-        body = Markdown(release_data["body"])
-        tag = github_release_data["tag_name"]
-        tag_title = release_data["name"]
-        github_page_url = release_data["html_url"]
-        console.print(f"Release Page: {github_page_url}")
-        console.print(f"Tag: {tag}")
-        console.print(f"Title: {tag_title}")
-        console.print(body)
-
-    if check:
-        is_update, github_release_data = check_for_updates()
-        if is_update:
-            print(
-                "You are running an older 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_release(github_release_data)
-    else:
-        success, github_release_data = update_app()
-        _print_release(github_release_data)

fastanime/cli/config.py

@@ -1,342 +0,0 @@
-import json
-import logging
-import os
-from configparser import ConfigParser
-from typing import TYPE_CHECKING
-
-from rich import print
-
-from ..constants import USER_CONFIG_PATH, USER_DATA_PATH, USER_VIDEOS_DIR
-from ..libs.rofi import Rofi
-
-logger = logging.getLogger(__name__)
-if TYPE_CHECKING:
-    from ..AnimeProvider import AnimeProvider
-
-
-class Config(object):
-    """class that handles and manages configuration and user data throughout the clis lifespan
-
-    Attributes:
-        anime_list: [TODO:attribute]
-        watch_history: [TODO:attribute]
-        fastanime_anilist_app_login_url: [TODO:attribute]
-        anime_provider: [TODO:attribute]
-        user_data: [TODO:attribute]
-        configparser: [TODO:attribute]
-        downloads_dir: [TODO:attribute]
-        provider: [TODO:attribute]
-        use_fzf: [TODO:attribute]
-        use_rofi: [TODO:attribute]
-        skip: [TODO:attribute]
-        icons: [TODO:attribute]
-        preview: [TODO:attribute]
-        translation_type: [TODO:attribute]
-        sort_by: [TODO:attribute]
-        continue_from_history: [TODO:attribute]
-        auto_next: [TODO:attribute]
-        auto_select: [TODO:attribute]
-        use_mpv_mod: [TODO:attribute]
-        quality: [TODO:attribute]
-        notification_duration: [TODO:attribute]
-        error: [TODO:attribute]
-        server: [TODO:attribute]
-        format: [TODO:attribute]
-        force_window: [TODO:attribute]
-        preferred_language: [TODO:attribute]
-        rofi_theme: [TODO:attribute]
-        rofi_theme: [TODO:attribute]
-        rofi_theme_input: [TODO:attribute]
-        rofi_theme_input: [TODO:attribute]
-        rofi_theme_confirm: [TODO:attribute]
-        rofi_theme_confirm: [TODO:attribute]
-        watch_history: [TODO:attribute]
-        anime_list: [TODO:attribute]
-        user: [TODO:attribute]
-    """
-
-    anime_list: list
-    watch_history: dict
-    fastanime_anilist_app_login_url = (
-        "https://anilist.co/api/v2/oauth/authorize?client_id=20148&response_type=token"
-    )
-    anime_provider: "AnimeProvider"
-    user_data = {"watch_history": {}, "animelist": [], "user": {}}
-
-    def __init__(self) -> None:
-        self.initialize_user_data()
-        self.load_config()
-
-    def load_config(self):
-        self.configparser = ConfigParser(
-            {
-                "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.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 ---
-        self.downloads_dir = self.get_downloads_dir()
-        self.provider = self.get_provider()
-        self.use_fzf = self.get_use_fzf()
-        self.use_rofi = self.get_use_rofi()
-        self.skip = self.get_skip()
-        self.icons = self.get_icons()
-        self.preview = self.get_preview()
-        self.translation_type = self.get_translation_type()
-        self.sort_by = self.get_sort_by()
-        self.continue_from_history = self.get_continue_from_history()
-        self.auto_next = self.get_auto_next()
-        self.auto_select = self.get_auto_select()
-        self.use_mpv_mod = self.get_use_mpv_mod()
-        self.quality = self.get_quality()
-        self.notification_duration = self.get_notification_duration()
-        self.error = self.get_error()
-        self.server = self.get_server()
-        self.format = self.get_format()
-        self.force_window = self.get_force_window()
-        self.preferred_language = self.get_preferred_language()
-        self.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
-        # ---- 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", {})
-
-    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"
-    ):
-        self.watch_history.update(
-            {
-                str(anime_id): {
-                    "episode": episode,
-                    "start_time": start_time,
-                    "total_time": total_time,
-                }
-            }
-        )
-        self.user_data["watch_history"] = self.watch_history
-        self._update_user_data()
-
-    def initialize_user_data(self):
-        try:
-            if os.path.isfile(USER_DATA_PATH):
-                with open(USER_DATA_PATH, "r") as f:
-                    user_data = json.load(f)
-                    self.user_data.update(user_data)
-        except Exception as e:
-            logger.error(e)
-
-    def _update_user_data(self):
-        """method that updates the actual user data file"""
-        with open(USER_DATA_PATH, "w") as f:
-            json.dump(self.user_data, f)
-
-    # getters for user configuration
-
-    # --- general section ---
-    def get_provider(self):
-        return self.configparser.get("general", "provider")
-
-    def get_preferred_language(self):
-        return self.configparser.get("general", "preferred_language")
-
-    def get_downloads_dir(self):
-        return self.configparser.get("general", "downloads_dir")
-
-    def get_icons(self):
-        return self.configparser.getboolean("general", "icons")
-
-    def get_preview(self):
-        return self.configparser.getboolean("general", "preview")
-
-    def get_use_fzf(self):
-        return self.configparser.getboolean("general", "use_fzf")
-
-    # rofi conifiguration
-    def get_use_rofi(self):
-        return self.configparser.getboolean("general", "use_rofi")
-
-    def get_rofi_theme(self):
-        return self.configparser.get("general", "rofi_theme")
-
-    def get_rofi_theme_input(self):
-        return self.configparser.get("general", "rofi_theme_input")
-
-    def get_rofi_theme_confirm(self):
-        return self.configparser.get("general", "rofi_theme_confirm")
-
-    # --- stream section ---
-    def get_skip(self):
-        return self.configparser.getboolean("stream", "skip")
-
-    def get_auto_next(self):
-        return self.configparser.getboolean("stream", "auto_next")
-
-    def get_auto_select(self):
-        return self.configparser.getboolean("stream", "auto_select")
-
-    def get_continue_from_history(self):
-        return self.configparser.getboolean("stream", "continue_from_history")
-
-    def get_use_mpv_mod(self):
-        return self.configparser.getboolean("stream", "use_mpv_mod")
-
-    def get_notification_duration(self):
-        return self.configparser.getint("general", "notification_duration")
-
-    def get_error(self):
-        return self.configparser.getint("stream", "error")
-
-    def get_force_window(self):
-        return self.configparser.get("stream", "force_window")
-
-    def get_translation_type(self):
-        return self.configparser.get("stream", "translation_type")
-
-    def get_quality(self):
-        return self.configparser.get("stream", "quality")
-
-    def get_server(self):
-        return self.configparser.get("stream", "server")
-
-    def get_format(self):
-        return self.configparser.get("stream", "format")
-
-    def get_sort_by(self):
-        return self.configparser.get("anilist", "sort_by")
-
-    def update_config(self, section: str, key: str, value: str):
-        self.configparser.set(section, key, value)
-        with open(USER_CONFIG_PATH, "w") as config:
-            self.configparser.write(config)
-
-    def __repr__(self):
-        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}
-
-[general]
-
-# can be [allanime,animepahe]
-provider = {self.provider}
-
-# Display language (options: english, romaji)
-preferred_language = {self.preferred_language}
-
-# Download directory
-downloads_dir = {self.downloads_dir}
-
-# whether to show a preview window when using fzf or rofi
-preview = {self.preview} 
-
-# whether to use fzf as the interface for the anilist command and others.
-use_fzf = {self.use_fzf} 
-
-# whether to use rofi for the ui
-use_rofi = {self.use_rofi}
-
-# rofi theme to use
-rofi_theme = {self.rofi_theme}
-rofi_theme_input = {self.rofi_theme_input}
-rofi_theme_confirm = {self.rofi_theme_confirm}
-
-# whether to show the icons
-icons = {self.icons}
-
-# the duration in minutes a notification will stay in the screen
-# used by notifier command
-notification_duration = {self.notification_duration}
-        """
-        return current_config_state
-
-    def __str__(self):
-        return self.__repr__()
-
-    # WARNING: depracated and will probably be removed
-    def update_anime_list(self, anime_id: int, remove=False):
-        if remove:
-            try:
-                self.anime_list.remove(anime_id)
-                print("Succesfully removed :cry:")
-            except Exception:
-                print(anime_id, "Nothing to remove :confused:")
-        else:
-            self.anime_list.append(anime_id)
-            self.user_data["animelist"] = list(set(self.anime_list))
-            self._update_user_data()
-            print("Succesfully added :smile:")
-            input("Enter to continue...")

fastanime/cli/interfaces/utils.py

@@ -1,288 +0,0 @@
-import concurrent.futures
-import logging
-import os
-import shutil
-import subprocess
-import textwrap
-from threading import Thread
-
-import requests
-from yt_dlp.utils import clean_html
-
-from ...constants import APP_CACHE_DIR
-from ...libs.anilist.types import AnilistBaseMediaDataSchema
-from ...Utility import anilist_data_helper
-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):
-    """helper function to be used for setting and getting skip data
-
-    Args:
-        mal_id: mal id of the anime
-        episode: episode number
-
-    Returns:
-        mpv chapter options
-    """
-    ANISKIP = shutil.which("ani-skip")
-    if not ANISKIP:
-        print("Aniskip not found, please install and try again")
-        return
-    args = [ANISKIP, "-q", str(mal_id), "-e", str(episode)]
-    aniskip_result = subprocess.run(args, text=True, stdout=subprocess.PIPE)
-    if aniskip_result.returncode != 0:
-        return
-    mpv_skip_args = aniskip_result.stdout.strip()
-    return mpv_skip_args.split(" ")
-
-
-# ---- prevew stuff ----
-# import tempfile
-
-# NOTE: May change this to a temp dir but there were issues so later
-WORKING_DIR = APP_CACHE_DIR  # tempfile.gettempdir()
-
-IMAGES_CACHE_DIR = os.path.join(WORKING_DIR, "images")
-if not os.path.exists(IMAGES_CACHE_DIR):
-    os.mkdir(IMAGES_CACHE_DIR)
-ANIME_INFO_CACHE_DIR = os.path.join(WORKING_DIR, "info")
-if not os.path.exists(ANIME_INFO_CACHE_DIR):
-    os.mkdir(ANIME_INFO_CACHE_DIR)
-
-
-def save_image_from_url(url: str, file_name: str):
-    """Helper function that downloads an image to the FastAnime images cache dir given its url and filename
-
-    Args:
-        url: image url to download
-        file_name: filename to use
-    """
-    image = requests.get(url)
-    with open(f"{IMAGES_CACHE_DIR}/{file_name}", "wb") as f:
-        f.write(image.content)
-
-
-def save_info_from_str(info: str, file_name: str):
-    """Helper function that writes text (anime details and info) to a file given  its filename
-
-    Args:
-        info: the information anilist has on the anime
-        file_name: the filename to use
-    """
-    with open(f"{ANIME_INFO_CACHE_DIR}/{file_name}", "w") as f:
-        f.write(info)
-
-
-def write_search_results(
-    anilist_results: list[AnilistBaseMediaDataSchema],
-    titles: list[str],
-    workers: int | None = None,
-):
-    """A helper function used by and run in a background thread by get_fzf_preview function inorder to get the actual preview data to be displayed by fzf
-
-    Args:
-        anilist_results: the anilist results from an anilist action
-        titles: sanitized anime titles
-        workers:number of threads to use defaults to as many as possible
-    """
-    # NOTE: Will probably make this a configuraable option
-    HEADER_COLOR = 215, 0, 95
-    SEPARATOR_COLOR = 208, 208, 208
-    SEPARATOR_WIDTH = 45
-    # use concurency to download and write as fast as possible
-    with concurrent.futures.ThreadPoolExecutor(max_workers=workers) as executor:
-        future_to_task = {}
-        for anime, title in zip(anilist_results, titles):
-            # actual image url
-            image_url = anime["coverImage"]["large"]
-            future_to_task[executor.submit(save_image_from_url, image_url, title)] = (
-                image_url
-            )
-
-            # handle the text data
-            template = f"""
-            {get_true_fg("-"*SEPARATOR_WIDTH,*SEPARATOR_COLOR,bold=False)}
-            {get_true_fg('Title(jp):',*HEADER_COLOR)} {anime['title']['romaji']}
-            {get_true_fg('Title(eng):',*HEADER_COLOR)} {anime['title']['english']}
-            {get_true_fg('Popularity:',*HEADER_COLOR)} {anime['popularity']}
-            {get_true_fg('Favourites:',*HEADER_COLOR)} {anime['favourites']}
-            {get_true_fg('Status:',*HEADER_COLOR)} {anime['status']}
-            {get_true_fg('Episodes:',*HEADER_COLOR)} {anime['episodes']}
-            {get_true_fg('Genres:',*HEADER_COLOR)} {anilist_data_helper.format_list_data_with_comma(anime['genres'])}
-            {get_true_fg('Next Episode:',*HEADER_COLOR)} {anilist_data_helper.extract_next_airing_episode(anime['nextAiringEpisode'])}
-            {get_true_fg('Start Date:',*HEADER_COLOR)} {anilist_data_helper.format_anilist_date_object(anime['startDate'])}
-            {get_true_fg('End Date:',*HEADER_COLOR)} {anilist_data_helper.format_anilist_date_object(anime['endDate'])}
-            {get_true_fg("-"*SEPARATOR_WIDTH,*SEPARATOR_COLOR,bold=False)}
-            {get_true_fg('Description:',*HEADER_COLOR)}
-            """
-            template = textwrap.dedent(template)
-            template = f"""
-            {template}
-            {textwrap.fill(clean_html(
-                str(anime['description'])), width=45)}
-            """
-            future_to_task[executor.submit(save_info_from_str, template, title)] = title
-
-        # execute the jobs
-        for future in concurrent.futures.as_completed(future_to_task):
-            task = future_to_task[future]
-            try:
-                future.result()
-            except Exception as exc:
-                logger.error("%r generated an exception: %s" % (task, exc))
-
-
-# get rofi icons
-def get_rofi_icons(
-    anilist_results: list[AnilistBaseMediaDataSchema], titles, workers=None
-):
-    """A helper function to make sure that the images are downloaded so they can be used as icons
-
-    Args:
-        titles (list[str]): sanitized titles of the anime; NOTE: its important that they are sanitized since they are used as the filenames of the images
-        workers ([TODO:parameter]): Number of threads to use to download the images; defaults to as many as possible
-        anilist_results: the anilist results from an anilist action
-    """
-    # use concurrency to download the images as fast as possible
-    with concurrent.futures.ThreadPoolExecutor(max_workers=workers) as executor:
-        # load the jobs
-        future_to_url = {}
-        for anime, title in zip(anilist_results, titles):
-            # actual link to download image from
-            image_url = anime["coverImage"]["large"]
-            future_to_url[executor.submit(save_image_from_url, image_url, title)] = (
-                image_url
-            )
-
-        # 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))
-
-
-def get_fzf_preview(
-    anilist_results: list[AnilistBaseMediaDataSchema], titles, wait=False
-):
-    """A helper function that constructs data to be used for the fzf preview
-
-    Args:
-        titles (list[str]): The sanitized titles to use, NOTE: its important that they are sanitized since thay will be used as filenames
-        wait (bool): whether to block the ui as we wait for preview defaults to false
-        anilist_results: the anilist results got from an anilist action
-
-    Returns:
-        THe fzf preview script to use
-    """
-    # ensure images and info exists
-    background_worker = Thread(
-        target=write_search_results, args=(anilist_results, titles)
-    )
-    background_worker.daemon = True
-    background_worker.start()
-
-    # the preview script is in bash so making sure fzf doesnt use any other shell lang to process the preview script
-    os.environ["SHELL"] = shutil.which("bash") or "bash"
-    preview = """
-        %s
-        if [ -s %s/{} ]; then fzf-preview %s/{}
-        else echo Loading...
-        fi
-        if [ -s %s/{} ]; then cat %s/{}
-        else echo Loading...
-        fi
-    """ % (
-        fzf_preview,
-        IMAGES_CACHE_DIR,
-        IMAGES_CACHE_DIR,
-        ANIME_INFO_CACHE_DIR,
-        ANIME_INFO_CACHE_DIR,
-    )
-    if wait:
-        background_worker.join()
-    return preview

fastanime/cli/utils/mpv.py

@@ -1,120 +0,0 @@
-import re
-import shutil
-import subprocess
-
-
-def stream_video(MPV, url, mpv_args, custom_args):
-    process = subprocess.Popen(
-        [MPV, url, *mpv_args, *custom_args],
-        stdout=subprocess.PIPE,
-        stderr=subprocess.PIPE,
-        text=True,
-    )
-
-    last_time = None
-    av_time_pattern = re.compile(r"AV: ([0-9:]*) / ([0-9:]*) \(([0-9]*)%\)")
-    last_time = "0"
-    total_time = "0"
-
-    try:
-        while True:
-            if not process.stderr:
-                continue
-            output = process.stderr.readline()
-
-            if output:
-                # Match the timestamp in the output
-                match = av_time_pattern.search(output.strip())
-                if match:
-                    current_time = match.group(1)
-                    total_time = match.group(2)
-                    match.group(3)
-                    last_time = current_time
-                    # print(f"Current stream time: {current_time}, Total time: {total_time}, Progress: {percentage}%")
-
-            # Check if the process has terminated
-            retcode = process.poll()
-            if retcode is not None:
-                print("Finshed at: ", last_time)
-                break
-
-    except Exception as e:
-        print(f"An error occurred: {e}")
-    finally:
-        process.terminate()
-
-    return last_time, total_time
-
-
-def run_mpv(
-    link: str,
-    title: str | None = "",
-    start_time: str = "0",
-    ytdl_format="",
-    custom_args=[],
-):
-    # 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",
-            ]
-            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 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
-if __name__ == "__main__":
-    run_mpv(
-        "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
-        "Example Video",
-        "--fullscreen",
-        "--volume=50",
-    )

fastanime/cli/utils/player.py

@@ -1,326 +0,0 @@
-from typing import TYPE_CHECKING
-
-import mpv
-
-from ...anilist import AniList
-from .utils import filter_by_quality
-
-if TYPE_CHECKING:
-    from typing import Literal
-
-    from ...AnimeProvider import AnimeProvider
-    from ..config import Config
-
-
-def format_time(duration_in_secs: float):
-    h = duration_in_secs // 3600
-    m = duration_in_secs // 60
-    s = duration_in_secs - ((h * 3600) + (m * 60))
-    return f"{int(h):2d}:{int(m):2d}:{int(s):2d}".replace(" ", "0")
-
-
-class MpvPlayer(object):
-    anime_provider: "AnimeProvider"
-    config: "Config"
-    mpv_player: "mpv.MPV"
-    last_stop_time: str = "0"
-    last_total_time: str = "0"
-    last_stop_time_secs = 0
-    last_total_time_secs = 0
-    current_media_title = ""
-    player_fetching = False
-
-    def get_episode(
-        self,
-        type: "Literal['next','previous','reload','custom']",
-        ep_no=None,
-        server="top",
-    ):
-        fastanime_runtime_state = self.fastanime_runtime_state
-        config = self.config
-        current_episode_number: str = (
-            fastanime_runtime_state.provider_current_episode_number
-        )
-        quality = config.quality
-        total_episodes: list = sorted(
-            fastanime_runtime_state.provider_available_episodes, key=float
-        )
-        anime_id_anilist: int = fastanime_runtime_state.selected_anime_id_anilist
-        provider_anime = fastanime_runtime_state.provider_anime
-        translation_type = config.translation_type
-        anime_provider = config.anime_provider
-        self.last_stop_time: str = "0"
-        self.last_total_time: str = "0"
-        self.last_stop_time_secs = 0
-        self.last_total_time_secs = 0
-
-        # next or prev
-        if type == "next":
-            self.mpv_player.show_text("Fetching next episode...")
-            next_episode = total_episodes.index(current_episode_number) + 1
-            if next_episode >= len(total_episodes):
-                next_episode = len(total_episodes) - 1
-            fastanime_runtime_state.provider_current_episode_number = total_episodes[
-                next_episode
-            ]
-            current_episode_number = (
-                fastanime_runtime_state.provider_current_episode_number
-            )
-            config.update_watch_history(anime_id_anilist, str(current_episode_number))
-        elif type == "reload":
-            if current_episode_number not in total_episodes:
-                self.mpv_player.show_text("Episode not available")
-                return
-            self.mpv_player.show_text("Replaying Episode...")
-        elif type == "custom":
-            if not ep_no or ep_no not in total_episodes:
-                self.mpv_player.show_text("Episode number not specified or invalid")
-                self.mpv_player.show_text(
-                    f"Acceptable episodes are:  {total_episodes}",
-                )
-                return
-
-            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))
-            fastanime_runtime_state.provider_current_episode_number = str(ep_no)
-        else:
-            self.mpv_player.show_text("Fetching previous episode...")
-            prev_episode = total_episodes.index(current_episode_number) - 1
-            if prev_episode <= 0:
-                prev_episode = 0
-            fastanime_runtime_state.provider_current_episode_number = total_episodes[
-                prev_episode
-            ]
-            current_episode_number = (
-                fastanime_runtime_state.provider_current_episode_number
-            )
-            config.update_watch_history(anime_id_anilist, str(current_episode_number))
-        # update episode progress
-        if config.user and current_episode_number:
-            AniList.update_anime_list(
-                {
-                    "mediaId": anime_id_anilist,
-                    "progress": current_episode_number,
-                }
-            )
-        # get them juicy streams
-        episode_streams = anime_provider.get_episode_streams(
-            provider_anime,
-            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
-
-        # always select the first
-        if server == "top":
-            selected_server = next(episode_streams, None)
-            if not selected_server:
-                self.mpv_player.show_text("Sth went wrong when loading the episode")
-                return
-        else:
-            episode_streams_dict = {
-                episode_stream["server"]: episode_stream
-                for episode_stream in episode_streams
-            }
-            selected_server = episode_streams_dict.get(server)
-            if selected_server is None:
-                self.mpv_player.show_text(
-                    f"Invalid server!!; servers available are: {episode_streams_dict.keys()}",
-                )
-                return None
-        self.current_media_title = selected_server["episode_title"]
-        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"]
-        return stream_link
-
-    def create_player(
-        self,
-        stream_link,
-        anime_provider: "AnimeProvider",
-        fastanime_runtime_state,
-        config: "Config",
-        title,
-    ):
-        self.anime_provider = anime_provider
-        self.fastanime_runtime_state = fastanime_runtime_state
-        self.config = config
-        self.last_stop_time: str = "0"
-        self.last_total_time: str = "0"
-        self.last_stop_time_secs = 0
-        self.last_total_time_secs = 0
-        self.current_media_title = ""
-
-        mpv_player = mpv.MPV(
-            log_handler=print,
-            loglevel="error",
-            config=True,
-            input_default_bindings=True,
-            input_vo_keyboard=True,
-            osc=True,
-            ytdl=True,
-        )
-        mpv_player.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")
-        def set_total_time(event, *args):
-            d = mpv_player._get_property("duration")
-            self.player_fetching = False
-            if isinstance(d, float):
-                self.last_total_time = format_time(d)
-
-        @mpv_player.property_observer("time-pos")
-        def handle_time_start_update(*args):
-            if len(args) > 1:
-                value = args[1]
-                if value is not None:
-                    self.last_stop_time = format_time(value)
-
-        @mpv_player.property_observer("time-remaining")
-        def handle_time_remaining_update(
-            property, time_remaining: float | None = None, *args
-        ):
-            if time_remaining is not None:
-                if time_remaining < 1 and config.auto_next and not self.player_fetching:
-                    print("Auto Fetching Next Episode")
-                    self.player_fetching = True
-                    url = self.get_episode("next")
-                    if url:
-                        mpv_player.loadfile(
-                            url,
-                        )
-                        mpv_player.title = self.current_media_title
-
-        # -- keybindings --
-        @mpv_player.on_key_press("shift+n")
-        def _next_episode():
-            url = self.get_episode("next")
-            if url:
-                mpv_player.loadfile(url, options=f"title={self.current_media_title}")
-                mpv_player.title = self.current_media_title
-
-        @mpv_player.on_key_press("shift+p")
-        def _previous_episode():
-            url = self.get_episode("previous")
-            if url:
-                mpv_player.loadfile(
-                    url,
-                )
-                mpv_player.title = self.current_media_title
-
-        @mpv_player.on_key_press("shift+a")
-        def _toggle_auto_next():
-            config.auto_next = not config.auto_next
-            if config.auto_next:
-                mpv_player.show_text("Auto next enabled")
-            else:
-                mpv_player.show_text("Auto next disabled")
-
-        @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")
-                return
-            fastanime_runtime_state.provider_available_episodes = anime[
-                "availableEpisodesDetail"
-            ][translation_type]
-            config.translation_type = translation_type
-
-            if config.translation_type == "dub":
-                mpv_player.show_text("Translation Type set to dub")
-            else:
-                mpv_player.show_text("Translation Type set to sub")
-
-        @mpv_player.on_key_press("shift+r")
-        def _reload():
-            url = self.get_episode("reload")
-            if url:
-                mpv_player.loadfile(
-                    url,
-                )
-                mpv_player.title = self.current_media_title
-
-        # -- script messages --
-        @mpv_player.message_handler("select-episode")
-        def select_episode(episode: bytes | None = None, *args):
-            if not episode:
-                mpv_player.show_text("No episode was selected")
-                return
-            url = self.get_episode("custom", episode.decode())
-            if url:
-                mpv_player.loadfile(
-                    url,
-                )
-                mpv_player.title = self.current_media_title
-
-        @mpv_player.message_handler("select-server")
-        def select_server(server: bytes | None = None, *args):
-            if not server:
-                mpv_player.show_text("No server was selected")
-                return
-            url = self.get_episode("reload", server=server.decode())
-            if url:
-                mpv_player.loadfile(
-                    url,
-                )
-                mpv_player.title = self.current_media_title
-            else:
-                pass
-
-        @mpv_player.message_handler("select-quality")
-        def select_quality(quality_raw: bytes | None = None, *args):
-            if not quality_raw:
-                mpv_player.show_text("No quality was selected")
-                return
-            q = ["360", "720", "1080"]
-            quality = quality_raw.decode()
-            links: list = fastanime_runtime_state.provider_server_episode_streams
-            q = [link["quality"] for link in links]
-            if quality in q:
-                config.quality = quality
-                stream_link_ = filter_by_quality(quality, links)
-                if not stream_link_:
-                    mpv_player.show_text("Quality not found")
-                    return
-                mpv_player.show_text(f"Changing to stream of quality {quality}")
-                stream_link = stream_link_["link"]
-                mpv_player.loadfile(stream_link)
-            else:
-                mpv_player.show_text(f"invalid quality!! Valid quality includes: {q}")
-
-        # -- events --
-        mpv_player.observe_property("time-pos", handle_time_start_update)
-        mpv_player.observe_property("time-remaining", handle_time_remaining_update)
-        mpv_player.register_event_callback(set_total_time)
-
-        # --script-messages --
-        mpv_player.register_message_handler("select-episode", select_episode)
-        mpv_player.register_message_handler("select-server", select_server)
-        mpv_player.register_message_handler("select-quality", select_quality)
-
-        self.mpv_player = mpv_player
-        return mpv_player
-
-
-player = MpvPlayer()

fastanime/cli/utils/print_img.py

@@ -1,27 +0,0 @@
-import shutil
-import subprocess
-
-import requests
-
-
-def print_img(url: str):
-    """helper funtion to print an image given its url
-
-    Args:
-        url: [TODO:description]
-    """
-    if EXECUTABLE := shutil.which("icat"):
-        subprocess.run([EXECUTABLE, url])
-    else:
-        EXECUTABLE = shutil.which("chafa")
-
-        if EXECUTABLE is None:
-            print("chafanot found")
-            return
-
-        res = requests.get(url)
-        if res.status_code != 200:
-            print("Error fetching image")
-            return
-        img_bytes = res.content
-        subprocess.run([EXECUTABLE, url, "--size=15x15"], input=img_bytes)

fastanime/cli/utils/tools.py

@@ -1,49 +0,0 @@
-# TODO: add typing
-class FastAnimeRuntimeState(dict):
-    """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)
-            )
-
-    def __setattr__(self, attr, value):
-        self.__setitem__(attr, value)
-
-
-def exit_app(exit_code=0, *args):
-    import os
-    import shutil
-    import sys
-
-    from ...constants import APP_NAME, ICON_PATH, USER_NAME
-
-    def is_running_in_terminal():
-        try:
-            shutil.get_terminal_size()
-            return (
-                sys.stdin
-                and sys.stdin.isatty()
-                and sys.stdout.isatty()
-                and os.getenv("TERM") is not None
-            )
-        except OSError:
-            return False
-
-    if not is_running_in_terminal():
-        from plyer import notification
-
-        notification.notify(
-            app_name=APP_NAME,
-            app_icon=ICON_PATH,
-            message=f"Have a good day {USER_NAME}",
-            title="Shutting down",
-        )  # pyright:ignore
-    else:
-        from rich import print
-
-        print("Have a good day :smile:", USER_NAME)
-    sys.exit(exit_code)

fastanime/cli/utils/utils.py

@@ -1,112 +0,0 @@
-import logging
-from typing import TYPE_CHECKING
-
-from InquirerPy import inquirer
-
-logger = logging.getLogger(__name__)
-if TYPE_CHECKING:
-    from ...libs.anime_provider.types import EpisodeStream
-
-# Define ANSI escape codes as constants
-RESET = "\033[0m"
-BOLD = "\033[1m"
-INVISIBLE_CURSOR = "\033[?25l"
-VISIBLE_CURSOR = "\033[?25h"
-UNDERLINE = "\033[4m"
-
-# ESC[38;2;{r};{g};{b}m
-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]", default=True):
-    """Helper function used to filter a list of EpisodeStream objects to one that has a corresponding quality
-
-    Args:
-        quality: the quality to use
-        stream_links: a list of EpisodeStream objects
-
-    Returns:
-        an EpisodeStream object or None incase the quality was not found
-    """
-    for stream_link in stream_links:
-        q = float(quality)
-        Q = float(stream_link["quality"])
-        # some providers have inaccurate eg qualities 718 instead of 720
-        if Q < q + 80 and Q > q - 80:
-            return stream_link
-    else:
-        if stream_links and default:
-            try:
-                print("Qualities were: ", stream_links)
-                print("Using default of quality: ", stream_links[0]["quality"])
-                return stream_links[0]
-            except Exception as e:
-                print(e)
-                return
-
-
-def format_bytes_to_human(num_of_bytes: float, suffix: str = "B"):
-    """Helper function usedd to format bytes to human
-
-    Args:
-        num_of_bytes: the number of bytes to format
-        suffix: the suffix to use
-
-    Returns:
-        formated bytes
-    """
-    for unit in ("", "K", "M", "G", "T", "P", "E", "Z"):
-        if abs(num_of_bytes) < 1024.0:
-            return f"{num_of_bytes:3.1f}{unit}{suffix}"
-        num_of_bytes /= 1024.0
-    return f"{num_of_bytes:.1f}Yi{suffix}"
-
-
-def get_true_fg(string: str, r: int, g: int, b: int, bold: bool = True) -> str:
-    """Custom helper function that enables colored text in the terminal
-
-    Args:
-        bold: whether to bolden the text
-        string: string to color
-        r: red
-        g: green
-        b: blue
-
-    Returns:
-        colored string
-    """
-    # NOTE: Currently only supports terminals that support true color
-    if bold:
-        return f"{BOLD}\033[38;2;{r};{g};{b};m{string}{RESET}"
-    else:
-        return f"\033[38;2;{r};{g};{b};m{string}{RESET}"
-
-
-def get_true_bg(string, r: int, g: int, b: int) -> str:
-    return f"\033[48;2;{r};{g};{b};m{string}{RESET}"
-
-
-def fuzzy_inquirer(choices: list, prompt: str, **kwargs):
-    """helper function that enables easier interaction with InquirerPy lib
-
-    Args:
-        choices: the choices to prompt
-        prompt: the prompt string to use
-        **kwargs: other options to pass to fuzzy_inquirer
-
-    Returns:
-        a choice
-    """
-    from click import clear
-
-    clear()
-    action = inquirer.fuzzy(
-        prompt,
-        choices,
-        height="100%",
-        border=True,
-        validate=lambda result: result in choices,
-        **kwargs,
-    ).execute()
-    return action

fastanime/constants.py

@@ -1,84 +0,0 @@
-import os
-import sys
-from pathlib import Path
-from platform import system
-
-from . import APP_NAME, AUTHOR, __version__
-
-PLATFORM = system()
-
-# ---- 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")
-
-
-# --- icon stuff ---
-if PLATFORM == "Windows":
-    ICON_PATH = os.path.join(ASSETS_DIR, "logo.ico")
-else:
-    ICON_PATH = os.path.join(ASSETS_DIR, "logo.png")
-PREVIEW_IMAGE = os.path.join(ASSETS_DIR, "preview")
-
-
-# ----- user configs and data -----
-
-S_PLATFORM = sys.platform
-
-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.expanduser("~/Videos")
-    USER_VIDEOS_DIR = os.path.join(video_dir_base, APP_NAME)
-
-elif S_PLATFORM == "darwin":
-    # app data
-    app_data_dir_base = os.path.expanduser("~/Library/Application Support")
-    APP_DATA_DIR = os.path.join(app_data_dir_base, APP_NAME, __version__)
-
-    # cache dir
-    cache_dir_base = os.path.expanduser("~/Library/Caches")
-    APP_CACHE_DIR = os.path.join(cache_dir_base, APP_NAME, __version__)
-
-    # videos dir
-    video_dir_base = os.path.expanduser("~/Movies")
-    USER_VIDEOS_DIR = os.path.join(video_dir_base, APP_NAME)
-else:
-    # app data
-    app_data_dir_base = os.environ.get("XDG_CONFIG_HOME", "")
-    if not app_data_dir_base.strip():
-        app_data_dir_base = os.path.expanduser("~/.config")
-    APP_DATA_DIR = os.path.join(app_data_dir_base, APP_NAME)
-
-    # cache dir
-    cache_dir_base = os.environ.get("XDG_CACHE_HOME", "")
-    if not cache_dir_base.strip():
-        cache_dir_base = os.path.expanduser("~/.cache")
-    APP_CACHE_DIR = os.path.join(cache_dir_base, APP_NAME)
-
-    # videos dir
-    video_dir_base = os.environ.get("XDG_VIDEOS_DIR", "")
-    if not video_dir_base.strip():
-        video_dir_base = os.path.expanduser("~/Videos")
-    USER_VIDEOS_DIR = os.path.join(video_dir_base, APP_NAME)
-
-# ensure paths exist
-Path(APP_DATA_DIR).mkdir(parents=True, exist_ok=True)
-Path(APP_CACHE_DIR).mkdir(parents=True, exist_ok=True)
-Path(USER_VIDEOS_DIR).mkdir(parents=True, exist_ok=True)
-
-# useful paths
-USER_DATA_PATH = os.path.join(APP_DATA_DIR, "user_data.json")
-USER_CONFIG_PATH = os.path.join(APP_DATA_DIR, "config.ini")
-NOTIFIER_LOG_FILE_PATH = os.path.join(APP_DATA_DIR, "notifier.log")
-
-
-USER_NAME = os.environ.get("USERNAME", "Anime fun")

fastanime/libs/anilist/__init__.py

@@ -1,3 +0,0 @@
-"""
-his module contains an abstraction for interaction with the anilist api making it easy and efficient
-"""

fastanime/libs/anilist/api.py

@@ -1,405 +0,0 @@
-"""
-This is the core module availing all the abstractions of the anilist api
-"""
-
-import logging
-from typing import TYPE_CHECKING
-
-import requests
-
-from .queries_graphql import (
-    airing_schedule_query,
-    anime_characters_query,
-    anime_query,
-    anime_relations_query,
-    delete_list_entry_query,
-    get_logged_in_user_query,
-    get_medialist_item_query,
-    media_list_mutation,
-    media_list_query,
-    most_favourite_query,
-    most_popular_query,
-    most_recently_updated_query,
-    most_scored_query,
-    notification_query,
-    recommended_query,
-    search_query,
-    trending_query,
-    upcoming_anime_query,
-)
-
-if TYPE_CHECKING:
-    from .types import (
-        AnilistDataSchema,
-        AnilistMediaLists,
-        AnilistMediaListStatus,
-        AnilistNotifications,
-        AnilistUser,
-        AnilistUserData,
-    )
-logger = logging.getLogger(__name__)
-ANILIST_ENDPOINT = "https://graphql.anilist.co"
-
-
-class AniListApi:
-    """An abstraction over the anilist api offering an easy and simple interface
-
-    Attributes:
-        session: [TODO:attribute]
-        session: [TODO:attribute]
-        token: [TODO:attribute]
-        headers: [TODO:attribute]
-        user_id: [TODO:attribute]
-        token: [TODO:attribute]
-        headers: [TODO:attribute]
-        user_id: [TODO:attribute]
-    """
-
-    session: requests.Session
-
-    def __init__(self) -> None:
-        self.session = requests.session()
-
-    def login_user(self, token: str):
-        """methosd used to login a new user enabling authenticated requests
-
-        Args:
-            token: anilist app token
-
-        Returns:
-            the logged in user
-        """
-        self.token = token
-        self.headers = {"Authorization": f"Bearer {self.token}"}
-        self.session.headers.update(self.headers)
-        success, user = self.get_logged_in_user()
-        if not user:
-            return
-        if not success or not user:
-            return
-        user_info: AnilistUser = user["data"]["Viewer"]
-        self.user_id = user_info["id"]
-        return user_info
-
-    def get_notification(
-        self,
-    ) -> tuple[bool, "AnilistNotifications"] | tuple[bool, None]:
-        """get the top five latest notifications for anime thats airing
-
-        Returns:
-            airing notifications
-        """
-        return self._make_authenticated_request(notification_query)
-
-    def update_login_info(self, user: "AnilistUser", token: str):
-        """method used to login a user enabling authenticated requests
-
-        Args:
-            user: an anilist user object
-            token: the login token
-        """
-        self.token = token
-        self.headers = {"Authorization": f"Bearer {self.token}"}
-        self.session.headers.update(self.headers)
-        self.user_id = user["id"]
-
-    def get_logged_in_user(self) -> tuple[bool, "AnilistUserData"] | tuple[bool, None]:
-        """get the details of the user who is currently logged in
-
-        Returns:
-            an anilist user
-        """
-        if not self.headers:
-            return (False, None)
-        return self._make_authenticated_request(get_logged_in_user_query)
-
-    def update_anime_list(self, values_to_update: dict):
-        """a powerful method for managing mediaLists giving full power to the user
-
-        Args:
-            values_to_update: a dict containing valid media list options
-
-        Returns:
-            an anilist object indicating success
-        """
-        variables = {"userId": self.user_id, **values_to_update}
-        return self._make_authenticated_request(media_list_mutation, variables)
-
-    def get_anime_list(
-        self,
-        status: "AnilistMediaListStatus",
-        type="ANIME",
-    ) -> tuple[bool, "AnilistMediaLists"] | tuple[bool, None]:
-        """gets an anime list from your media list given the list status
-
-        Args:
-            status: the mediaListStatus of the anime list
-
-        Returns:
-            a media list
-        """
-        variables = {"status": status, "userId": self.user_id, "type": type}
-        return self._make_authenticated_request(media_list_query, variables)
-
-    def get_medialist_entry(
-        self, mediaId: int
-    ) -> tuple[bool, dict] | tuple[bool, None]:
-        """Get the id entry of the items in an Anilist MediaList
-
-        Args:
-            mediaId: The mediaList item entry mediaId
-
-        Returns:
-            a boolean indicating whether the request succeeded and either a dict object containing the id of the media list entry
-        """
-        variables = {"mediaId": mediaId}
-        return self._make_authenticated_request(get_medialist_item_query, variables)
-
-    def delete_medialist_entry(self, mediaId: int):
-        """Deletes a mediaList item given its mediaId
-
-        Args:
-            mediaId: the media id of the anime
-
-        Returns:
-            a tuple containing a boolean whether the operation was successful and either an anilist object or none depending on success
-        """
-        result = self.get_medialist_entry(mediaId)
-        data = result[1]
-        if not result[0] or not data:
-            return result
-        id = data["data"]["MediaList"]["id"]
-        variables = {"id": id}
-        return self._make_authenticated_request(delete_list_entry_query, variables)
-
-    # TODO: unify the _make_authenticated_request with original since sessions are now in use
-    def _make_authenticated_request(self, query: str, variables: dict = {}):
-        """the abstraction over all authenticated requests
-
-        Args:
-            query: the anilist query to make
-            variables: the anilist variables to use
-
-        Returns:
-            an anilist object containing the queried data or none and a boolean indicating whether the request was successful
-        """
-        try:
-            response = self.session.post(
-                ANILIST_ENDPOINT,
-                json={"query": query, "variables": variables},
-                timeout=10,
-                headers=self.headers,
-            )
-            anilist_data = response.json()
-
-            # ensuring you dont get blocked
-            if (
-                int(response.headers.get("X-RateLimit-Remaining", 0)) < 30
-                and not response.status_code == 500
-            ):
-                print(
-                    "Warning you are exceeding the allowed number of calls per minute"
-                )
-                logger.warning(
-                    "You are exceeding the allowed number of calls per minute for the AniList api enforcing timeout"
-                )
-                print("Forced timeout will now be initiated")
-                import time
-
-                print("sleeping...")
-                time.sleep(1 * 60)
-            if response.status_code == 200:
-                return (True, anilist_data)
-            else:
-                return (False, anilist_data)
-        except requests.exceptions.Timeout:
-            logger.warning(
-                "Timeout has been exceeded this could mean anilist is down or you have lost internet connection"
-            )
-            return (False, None)
-        except requests.exceptions.ConnectionError:
-            logger.warning(
-                "ConnectionError this could mean anilist is down or you have lost internet connection"
-            )
-            return (False, None)
-
-        except Exception as e:
-            logger.error(f"Something unexpected occured {e}")
-            return (False, None)  # type: ignore
-
-    def get_data(
-        self, query: str, variables: dict = {}
-    ) -> tuple[bool, "AnilistDataSchema"]:
-        """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
-        """
-        try:
-            response = self.session.post(
-                ANILIST_ENDPOINT,
-                json={"query": query, "variables": variables},
-                timeout=10,
-            )
-            anilist_data: AnilistDataSchema = response.json()
-
-            # ensuring you dont get blocked
-            if (
-                int(response.headers.get("X-RateLimit-Remaining", 0)) < 30
-                and not response.status_code == 500
-            ):
-                print(
-                    "Warning you are exceeding the allowed number of calls per minute"
-                )
-                logger.warning(
-                    "You are exceeding the allowed number of calls per minute for the AniList api enforcing timeout"
-                )
-                print("Forced timeout will now be initiated")
-                import time
-
-                print("sleeping...")
-                time.sleep(1 * 60)
-            if response.status_code == 200:
-                return (True, anilist_data)
-            else:
-                return (False, anilist_data)
-        except requests.exceptions.Timeout:
-            logger.warning(
-                "Timeout has been exceeded this could mean anilist is down or you have lost internet connection"
-            )
-            return (
-                False,
-                {
-                    "Error": "Timeout Exceeded for connection there might be a problem with your internet or anilist is down."
-                },
-            )  # type: ignore
-        except requests.exceptions.ConnectionError:
-            logger.warning(
-                "ConnectionError this could mean anilist is down or you have lost internet connection"
-            )
-            return (
-                False,
-                {
-                    "Error": "There might be a problem with your internet or anilist is down."
-                },
-            )  # type: ignore
-        except Exception as e:
-            logger.error(f"Something unexpected occured {e}")
-            return (False, {"Error": f"{e}"})  # type: ignore
-
-    def search(
-        self,
-        query: str | None = None,
-        sort: str | None = None,
-        genre_in: list[str] | None = None,
-        id_in: list[int] | None = None,
-        genre_not_in: list[str] = ["hentai"],
-        popularity_greater: int | None = None,
-        popularity_lesser: int | None = None,
-        averageScore_greater: int | None = None,
-        averageScore_lesser: int | None = None,
-        tag_in: list[str] | None = None,
-        tag_not_in: list[str] | None = None,
-        status: str | None = None,
-        status_in: list[str] | None = None,
-        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,
-        page: int | None = None,
-        type="ANIME",
-        **kwargs,
-    ):
-        """
-        A powerful method abstracting all of anilist media queries
-        """
-        variables = {}
-        for key, val in list(locals().items())[1:]:
-            if val is not None and key not in ["variables"]:
-                variables[key] = val
-        search_results = self.get_data(search_query, variables=variables)
-        return search_results
-
-    def get_anime(self, id: int):
-        """
-        Gets a single anime by a valid anilist anime id
-        """
-        variables = {"id": id}
-        return self.get_data(anime_query, variables)
-
-    def get_trending(self, type="ANIME", *_, **kwargs):
-        """
-        Gets the currently trending anime
-        """
-        variables = {"type": type}
-        trending = self.get_data(trending_query, variables)
-        return trending
-
-    def get_most_favourite(self, type="ANIME", *_, **kwargs):
-        """
-        Gets the most favoured anime on anilist
-        """
-        variables = {"type": type}
-        most_favourite = self.get_data(most_favourite_query, variables)
-        return most_favourite
-
-    def get_most_scored(self, type="ANIME", *_, **kwargs):
-        """
-        Gets most scored anime on anilist
-        """
-        variables = {"type": type}
-        most_scored = self.get_data(most_scored_query, variables)
-        return most_scored
-
-    def get_most_recently_updated(self, type="ANIME", *_, **kwargs):
-        """
-        Gets most recently updated anime from anilist
-        """
-        variables = {"type": type}
-        most_recently_updated = self.get_data(most_recently_updated_query, variables)
-        return most_recently_updated
-
-    def get_most_popular(
-        self,
-        type="ANIME",
-    ):
-        """
-        Gets most popular anime on anilist
-        """
-        variables = {"type": type}
-        most_popular = self.get_data(most_popular_query, variables)
-        return most_popular
-
-    def get_upcoming_anime(self, type="ANIME", page: int = 1, *_, **kwargs):
-        """
-        Gets upcoming anime from anilist
-        """
-        variables = {"page": page, "type": type}
-        upcoming_anime = self.get_data(upcoming_anime_query, variables)
-        return upcoming_anime
-
-    # NOTE: THe following methods will probably be scraped soon
-    def get_recommended_anime_for(self, id: int, type="ANIME", *_, **kwargs):
-        variables = {"type": type}
-        recommended_anime = self.get_data(recommended_query, variables)
-        return recommended_anime
-
-    def get_charcters_of(self, id: int, type="ANIME", *_, **kwargs):
-        variables = {"id": id}
-        characters = self.get_data(anime_characters_query, variables)
-        return characters
-
-    def get_related_anime_for(self, id: int, type="ANIME", *_, **kwargs):
-        variables = {"id": id}
-        related_anime = self.get_data(anime_relations_query, variables)
-        return related_anime
-
-    def get_airing_schedule_for(self, id: int, type="ANIME", *_, **kwargs):
-        variables = {"id": id}
-        airing_schedule = self.get_data(airing_schedule_query, variables)
-        return airing_schedule

fastanime/libs/anilist/queries_graphql.py

@@ -1,980 +0,0 @@
-"""
-This module contains all the preset queries for the sake of neatness and convinience
-Mostly for internal usage
-"""
-
-# TODO: Format the queries
-mark_as_read_mutation = """
-mutation{
-  UpdateUser{
-    unreadNotificationCount
-  }
-}
-"""
-reviews_query = """
-query($id:Int){
-  Page{
-    pageInfo{
-      total
-    }
-    
-    reviews(mediaId:$id){
-      summary
-      user{
-        name
-        avatar {
-          large
-          medium
-        }
-      }
-      body
-      
-    }
-  }
-}
-
-"""
-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
-                    }
-                }
-            }
-        }
-    }
-}
-
-"""
-
-get_medialist_item_query = """
-query($mediaId:Int){
-    MediaList(mediaId:$mediaId){
-        id
-    }
-}
-"""
-
-delete_list_entry_query = """
-mutation($id:Int){
-    DeleteMediaListEntry(id:$id){
-        deleted
-
-    }
-}
-"""
-
-get_logged_in_user_query = """
-query{
-  Viewer{
-    id
-    name
-    bannerImage
-    avatar {
-      large
-      medium
-    }
-    
-  }
-}
-"""
-
-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){
-    id
-    status
-    mediaId
-    score
-    progress
-    repeat
-    startedAt {
-      year
-      month
-      day
-    }
-    completedAt {
-      year
-      month
-      day
-    }
-
-  }
-}
-"""
-
-media_list_query = """
-query ($userId: Int, $status: MediaListStatus,$type:MediaType) {
-  Page {
-    pageInfo {
-        currentPage
-        total
-    }
-    mediaList(userId: $userId, status: $status, type: $type) {
-      mediaId
-      
-      media {
-        id
-        idMal
-        title {
-          romaji
-          english
-        }
-        coverImage {
-          medium
-          large
-        }
-        trailer {
-          site
-          id
-        }
-        popularity
-        favourites
-        averageScore
-        episodes
-        genres
-        studios {
-          nodes {
-            name
-            isAnimationStudio
-          }
-        }
-        tags {
-          name
-        }
-        startDate {
-          year
-          month
-          day
-        }
-        endDate {
-          year
-          month
-          day
-        }
-        status
-        description
-        mediaListEntry{
-        id
-        progress
-        }
-        nextAiringEpisode {
-          timeUntilAiring
-          airingAt
-          episode
-        }
-      }
-      status
-      progress
-      score
-      repeat
-      notes
-      startedAt {
-        year
-        month
-        day
-      }
-      completedAt {
-        year
-        month
-        day
-      }
-      createdAt
-      
-    }
-  }
-}
-"""
-
-
-optional_variables = "\
-$page:Int,\
-$sort:[MediaSort],\
-$id_in:[Int],\
-$genre_in:[String],\
-$genre_not_in:[String],\
-$tag_in:[String],\
-$tag_not_in:[String],\
-$status_in:[MediaStatus],\
-$status:MediaStatus,\
-$status_not_in:[MediaStatus],\
-$popularity_greater:Int,\
-$popularity_lesser:Int,\
-$averageScore_greater:Int,\
-$averageScore_lesser:Int,\
-$startDate_greater:FuzzyDateInt,\
-$startDate_lesser:FuzzyDateInt,\
-$endDate_greater:FuzzyDateInt,\
-$endDate_lesser:FuzzyDateInt,\
-$type:MediaType\
-"
-# FuzzyDateInt = (yyyymmdd)
-# MediaStatus = (FINISHED,RELEASING,NOT_YET_RELEASED,CANCELLED,HIATUS)
-search_query = (
-    """
-query($query:String,%s){
-  Page(perPage:30,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
-      )
-    {
-      id
-        idMal
-      title{
-        romaji
-        english
-      }
-      coverImage{
-        medium
-        large
-      }
-      trailer {
-        site
-        id
-        
-      }
-        mediaListEntry{
-        id
-        progress
-        }
-      popularity
-      favourites
-      averageScore
-      episodes
-      genres
-      studios{
-        nodes{
-          name
-          isAnimationStudio
-        }
-      }
-      tags {
-        name
-      }
-      startDate {
-        year
-        month
-        day
-      }
-      endDate {
-        year
-        month
-        day
-      }
-      status
-      description
-      nextAiringEpisode {
-        timeUntilAiring
-        airingAt
-        episode
-      }
-    }
-  }
-}
-"""
-    % optional_variables
-)
-
-trending_query = """
-query($type:MediaType){  
-  Page(perPage:15){
-    
-    media(sort:TRENDING_DESC,type:$type,genre_not_in:["hentai"]){
-      id
-        idMal
-      title{
-        romaji
-        english
-      }
-      coverImage{
-        medium
-        large
-      }
-      trailer {
-        site
-        id
-      }
-      popularity
-      favourites
-      averageScore
-      genres
-      episodes
-      description
-      studios {
-        nodes {
-          name
-          isAnimationStudio
-        }
-      }
-      tags {
-        name              
-      }
-      startDate {
-        year
-        month
-        day
-      }
-        mediaListEntry{
-        id
-        progress
-        }
-      endDate {
-        year
-        month
-        day
-      }
-      status
-      nextAiringEpisode {
-        timeUntilAiring
-        airingAt
-        episode
-      }
-    }
-  }
-}
-"""
-
-# mosts
-most_favourite_query = """
-query($type:MediaType){
-  Page(perPage:15){    
-    media(sort:FAVOURITES_DESC,type:$type,genre_not_in:["hentai"]){
-      id
-        idMal
-      title{
-        romaji
-        english
-      }
-      coverImage{
-        medium
-        large
-      }
-      trailer {
-        site
-        id
-        
-      }
-        mediaListEntry{
-        id
-        progress
-        }
-      popularity
-      favourites
-      averageScore
-      episodes
-      description
-      genres
-      studios {
-        nodes {
-          name
-          isAnimationStudio
-        }
-      }
-      tags {
-        name              
-      }
-      startDate {
-        year
-        month
-        day
-      }
-      endDate {
-        year
-        month
-        day
-      }
-      status
-      nextAiringEpisode {
-        timeUntilAiring
-        airingAt
-        episode
-      }
-    }
-  }
-}
-"""
-
-most_scored_query = """
-query($type:MediaType){
-  Page(perPage:15){
-    media(sort:SCORE_DESC,type:$type,genre_not_in:["hentai"]){
-      id
-        idMal
-      title{
-        romaji
-        english
-      }
-      coverImage{
-        medium
-        large
-      }
-      trailer {
-        site
-        id
-        
-      }
-        mediaListEntry{
-        id
-        progress
-        }
-      popularity
-      episodes
-      favourites
-      averageScore
-      description
-      genres
-      studios {
-        nodes {
-          name
-          isAnimationStudio
-        }
-      }
-      tags {
-        name              
-      }
-      startDate {
-        year
-        month
-        day
-      }
-      endDate {
-        year
-        month
-        day
-      }
-      status
-      nextAiringEpisode {
-        timeUntilAiring
-        airingAt
-        episode
-      }
-    }
-  }
-}
-"""
-
-most_popular_query = """
-query($type:MediaType){  
-  Page(perPage:15){
-    media(sort:POPULARITY_DESC,type:$type,genre_not_in:["hentai"]){
-      id
-        idMal
-      title{
-        romaji
-        english
-      }
-      coverImage{
-        medium
-        large
-      }
-      trailer {
-        site
-        id
-        
-      }
-      popularity
-      favourites
-      averageScore
-      description
-      episodes
-      genres
-        mediaListEntry{
-        id
-        progress
-        }
-      studios {
-        nodes {
-          name
-          isAnimationStudio
-        }
-      }
-      tags {
-        name              
-      }      
-      startDate {
-        year
-        month
-        day
-      }
-      endDate {
-        year
-        month
-        day
-      }
-      status
-      nextAiringEpisode {
-        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){
-      id
-        idMal
-      title{
-        romaji
-        english
-      }
-      coverImage{
-        medium
-        large
-      }
-      trailer {
-        site
-        id     
-      }
-        mediaListEntry{
-        id
-        progress
-        }
-      popularity
-      favourites
-      averageScore
-      description
-      genres
-      episodes
-      studios {
-        nodes {
-          name
-          isAnimationStudio
-        }
-      }
-      tags {
-        name              
-      }
-      startDate {
-        year
-        month
-        day
-      }
-      endDate {
-        year
-        month
-        day
-      }
-      status
-      nextAiringEpisode {
-        timeUntilAiring
-        airingAt
-        episode
-      }
-    }
-  }
-}
-"""
-
-recommended_query = """
-query($type:MediaType){
-  Page(perPage:15) {
-    media( type: $type,genre_not_in:["hentai"]) {
-      recommendations(sort:RATING_DESC){
-        nodes{
-          media{
-            id
-        idMal
-            title{
-              english
-              romaji
-              native
-            }
-            coverImage{
-              medium
-              large
-            }
-            mediaListEntry{
-                id
-                progress
-            }
-            description
-            episodes
-            trailer{
-              site
-              id
-            }
-            
-            genres
-            averageScore
-            popularity
-            favourites
-            tags {
-              name
-            }
-            startDate {
-              year
-              month
-              day
-            }
-            endDate {
-              year
-              month
-              day
-            }
-            status
-            nextAiringEpisode {
-              timeUntilAiring
-              airingAt
-              episode
-            }
-          }
-        }
-      }
-    }
-  }
-}
-"""
-
-anime_characters_query = """
-query($id:Int,$type:MediaType){
-  Page {
-    media(id:$id, type: $type) {
-      characters {
-        nodes {
-          name {
-            first
-            middle
-            last
-            full
-            native
-          }
-          image {
-            medium
-            large
-          }
-          description
-          gender
-          dateOfBirth {
-            year
-            month
-            day
-          }
-          age
-          bloodType
-          favourites
-        }
-      }
-    }
-  }
-}
-"""
-
-
-anime_relations_query = """
-query ($id: Int,$type:MediaType) {
-  Page(perPage: 20) {
-    media(id: $id, sort: POPULARITY_DESC, type: $type,genre_not_in:["hentai"]) {
-      relations {
-        nodes {
-          id
-        idMal
-          title {
-            english
-            romaji
-            native
-          }
-          coverImage {
-            medium
-            large
-          }
-        mediaListEntry{
-        id
-        progress
-        }
-          description
-          episodes
-          trailer {
-            site
-            id
-          }
-          genres
-          averageScore
-          popularity
-          favourites
-          tags {
-            name
-          }
-          startDate {
-              year
-              month
-              day
-            }
-            endDate {
-              year
-              month
-              day
-            }
-            status
-            nextAiringEpisode {
-              timeUntilAiring
-              airingAt
-              episode
-            }
-        }
-      }
-    }
-  }
-}
-"""
-
-airing_schedule_query = """
-query ($id: Int,$type:MediaType) {
-  Page {
-    media(id: $id, sort: POPULARITY_DESC, type: $type) {
-      airingSchedule(notYetAired:true){
-        nodes{
-          airingAt
-          timeUntilAiring
-          episode
-          
-        }
-      }
-    }
-  }
-}
-"""
-
-upcoming_anime_query = """
-query ($page: Int,$type:MediaType) {
-  Page(page: $page) {
-    pageInfo {
-      total
-      perPage
-      currentPage
-      hasNextPage
-    }
-    media(type: $type, status: NOT_YET_RELEASED,sort:POPULARITY_DESC,genre_not_in:["hentai"]) {
-      id
-        idMal
-      title {
-        romaji
-        english
-      }
-      coverImage {
-        medium
-        large
-      }
-      trailer {
-        site
-        id
-      }
-              mediaListEntry{
-        id
-        progress
-        }
-      popularity
-      favourites
-      averageScore
-      genres
-      episodes
-      description
-      studios {
-        nodes {
-          name
-          isAnimationStudio
-        }
-      }
-      tags {
-        name
-      }
-      startDate {
-        year
-        month
-        day
-      }
-      endDate {
-        year
-        month
-        day
-      }
-      status
-      nextAiringEpisode {
-        timeUntilAiring
-        airingAt
-        episode
-      }
-    }
-  }
-}
-"""
-
-anime_query = """
-query($id:Int){
-  Page{
-    media(id:$id) {
-      id
-        idMal
-      title {
-        romaji
-        english
-      }
-              mediaListEntry{
-        id
-        progress
-        }
-      nextAiringEpisode {
-        timeUntilAiring
-        airingAt
-        episode
-      }
-      coverImage {
-        extraLarge
-      }
-      characters(perPage: 5, sort: FAVOURITES_DESC) {
-        edges {
-          node {
-            name {
-              full
-              
-            }
-            gender
-            dateOfBirth {
-              year
-              month
-              day
-            }
-            age
-            image {
-              medium
-              large
-            }
-            description
-          }
-          voiceActors {
-            name {
-              full
-            }
-            image {
-              medium
-              large
-            }
-          }
-        }
-      }
-      studios {
-        nodes {
-          name
-          isAnimationStudio
-        }
-      }
-      season
-      format
-      status
-      seasonYear
-      description
-      genres
-      synonyms
-      startDate {
-        year
-        month
-        day
-      }
-      endDate {
-        year
-        month
-        day
-      }
-      duration
-      countryOfOrigin
-      averageScore
-      popularity
-      favourites
-      source
-      hashtag
-      siteUrl
-      tags {
-        name
-        rank
-      }
-      reviews(sort: SCORE_DESC, perPage: 3) {
-        nodes {
-          summary
-          user {
-            name
-            avatar {
-              medium
-              large
-            }
-          }
-        }
-      }
-      recommendations(sort: RATING_DESC, perPage: 10) {
-        nodes {
-          mediaRecommendation {
-            title {
-              romaji
-              english
-            }
-          }
-        }
-      }
-      relations {
-        nodes {
-          title {
-            romaji
-            english
-            native
-          }
-        }
-      }
-      externalLinks {
-        url
-        site
-        icon
-      }
-      rankings {
-        rank
-        context
-      }
-      bannerImage
-      episodes
-    }
-  }
-}
-"""

fastanime/libs/anime_provider/__init__.py

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

fastanime/libs/anime_provider/allanime/api.py

@@ -1,377 +0,0 @@
-"""a module that handles the scraping of allanime
-
-abstraction over allanime api
-"""
-
-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 .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
-logger = logging.getLogger(__name__)
-
-
-# TODO: create tests for the api
-#
-# ** Based on ani-cli **
-class AllAnimeAPI(AnimeProvider):
-    """
-    Provides a fast and effective interface to AllAnime site.
-    """
-
-    api_endpoint = ALLANIME_API_ENDPOINT
-
-    def _fetch_gql(self, query: str, variables: dict):
-        """main abstraction over all requests to the allanime api
-
-        Args:
-            query: [TODO:description]
-            variables: [TODO:description]
-
-        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}")
-            return {}
-
-    def search_for_anime(
-        self,
-        user_query: str,
-        translation_type: str = "sub",
-        nsfw=True,
-        unknown=True,
-        **kwargs,
-    ):
-        """search for an anime title using allanime provider
-
-        Args:
-            nsfw ([TODO:parameter]): [TODO:description]
-            unknown ([TODO:parameter]): [TODO:description]
-            user_query: [TODO:description]
-            translation_type: [TODO:description]
-            **kwargs: [TODO:args]
-
-        Returns:
-            [TODO:return]
-        """
-        search = {"allowAdult": nsfw, "allowUnknown": unknown, "query": user_query}
-        limit = 40
-        translationtype = translation_type
-        countryorigin = "all"
-        page = 1
-        variables = {
-            "search": search,
-            "limit": limit,
-            "page": page,
-            "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,
-            }
-            return normalized_search_results
-
-        except Exception as e:
-            logger.error(f"FA(AllAnime): {e}")
-            return {}
-
-    def get_anime(self, allanime_show_id: str):
-        """get an anime details given its id
-
-        Args:
-            allanime_show_id: [TODO:description]
-
-        Returns:
-            [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
-
-    def _get_anime_episode(
-        self, allanime_show_id: str, episode_string: str, translation_type: str = "sub"
-    ) -> "AllAnimeEpisode | dict":
-        """get the episode details and sources info
-
-        Args:
-            allanime_show_id: [TODO:description]
-            episode_string: [TODO:description]
-            translation_type: [TODO:description]
-
-        Returns:
-            [TODO:return]
-        """
-        variables = {
-            "showId": allanime_show_id,
-            "translationType": translation_type,
-            "episodeString": episode_string,
-        }
-        try:
-            episode = self._fetch_gql(ALLANIME_EPISODES_GQL, variables)
-            return episode["episode"]
-        except Exception as e:
-            logger.error(f"FA(AllAnime): {e}")
-            return {}
-
-    def get_episode_streams(
-        self, anime: "Anime", episode_number: str, translation_type="sub"
-    ) -> "Iterator[Server] | None":
-        """get the streams of an episode
-
-        Args:
-            translation_type ([TODO:parameter]): [TODO:description]
-            anime: [TODO:description]
-            episode_number: [TODO:description]
-
-        Yields:
-            [TODO:description]
-        """
-        anime_id = anime["id"]
-        allanime_episode = self._get_anime_episode(
-            anime_id, episode_number, translation_type
-        )
-        if not allanime_episode:
-            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:]
-
-                    # 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 __name__ == "__main__":
-    anime_provider = AllAnimeAPI()
-    # lets see if it works :)
-    import subprocess
-    import sys
-
-    from InquirerPy import inquirer, validator
-
-    anime = input("Enter the anime name: ")
-    translation = input("Enter the translation type: ")
-
-    search_results = anime_provider.search_for_anime(
-        anime, translation_type=translation.strip()
-    )
-
-    if not search_results:
-        raise Exception("No results found")
-
-    search_results = search_results["results"]
-    options = {show["title"]: show for show in search_results}
-    anime = inquirer.fuzzy(
-        "Enter the anime title",
-        list(options.keys()),
-        validate=validator.EmptyInputValidator(),
-    ).execute()
-    if anime is None:
-        print("No anime was selected")
-        sys.exit(1)
-
-    anime_result = options[anime]
-    anime_data = anime_provider.get_anime(anime_result["id"])
-    if not anime_data:
-        raise Exception("Anime not found")
-    availableEpisodesDetail = anime_data["availableEpisodesDetail"]
-    if not availableEpisodesDetail.get(translation.strip()):
-        raise Exception("No episodes found")
-
-    stream_link = True
-    while stream_link != "quit":
-        print("select episode")
-        episode = inquirer.fuzzy(
-            "Choose an episode",
-            availableEpisodesDetail[translation.strip()],
-            validate=validator.EmptyInputValidator(),
-        ).execute()
-        if episode is None:
-            print("No episode was selected")
-            sys.exit(1)
-
-        if not anime_data:
-            print("Sth went wrong")
-            break
-        episode_streams_ = anime_provider.get_episode_streams(
-            anime_data,  # pyright: ignore
-            episode,
-            translation.strip(),
-        )
-        if episode_streams_ is None:
-            raise Exception("Episode not found")
-
-        episode_streams = list(episode_streams_)
-        stream_links = []
-        for server in episode_streams:
-            stream_links.extend([link["link"] for link in server["links"]])
-        stream_links.append("back")
-        stream_link = inquirer.fuzzy(
-            "Choose a link to stream",
-            stream_links,
-            validate=validator.EmptyInputValidator(),
-        ).execute()
-        if stream_link == "quit":
-            print("Have a nice day")
-            sys.exit()
-        if not stream_link:
-            raise Exception("No stream was selected")
-
-        title = episode_streams[0].get(
-            "episode_title", "%s: Episode %s" % (anime_data["title"], episode)
-        )
-        subprocess.run(["mpv", f"--title={title}", stream_link])

fastanime/libs/anime_provider/allanime/constants.py

@@ -1,7 +0,0 @@
-from yt_dlp.utils.networking import random_user_agent
-
-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 +0,0 @@
-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
-        }
-    }
-}
-"""
-
-
-ALLANIME_EPISODES_GQL = """\
-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
-        
-    }
-}
-"""

fastanime/libs/anime_provider/allanime/types.py

@@ -1,73 +0,0 @@
-from typing import Literal, TypedDict
-
-
-class AllAnimeEpisodesInfo(TypedDict):
-    dub: int
-    sub: int
-    raw: int
-
-
-class AllAnimePageInfo(TypedDict):
-    total: int
-
-
-class AllAnimeShow(TypedDict):
-    _id: str
-    name: str
-    availableEpisodesDetail: AllAnimeEpisodesInfo
-    __typename: str
-
-
-class AllAnimeSearchResult(TypedDict):
-    _id: str
-    name: str
-    availableEpisodes: list[str]
-    __typename: str | None
-
-
-class AllAnimeShows(TypedDict):
-    pageInfo: AllAnimePageInfo
-    edges: list[AllAnimeSearchResult]
-
-
-class AllAnimeSearchResults(TypedDict):
-    shows: AllAnimeShows
-
-
-class AllAnimeSourcesDownloads(TypedDict):
-    sourceName: str
-    dowloadUrl: str
-
-
-class AllAnimeSources(TypedDict):
-    sourceUrl: str
-    priority: float
-    sandbox: str
-    sourceName: str
-    type: str
-    className: str
-    streamerId: str
-    downloads: AllAnimeSourcesDownloads
-
-
-Server = Literal["gogoanime", "dropbox", "wetransfer", "sharepoint"]
-
-
-class AllAnimeEpisode(TypedDict):
-    episodeString: str
-    sourceUrls: list[AllAnimeSources]
-    notes: str | None
-
-
-class AllAnimeStream:
-    link: str
-    mp4: bool
-    hls: bool | None
-    resolutionStr: str
-    fromCache: str
-    priority: int
-    headers: dict | None
-
-
-class AllAnimeStreams:
-    links: list[AllAnimeStream]

fastanime/libs/anime_provider/animepahe/api.py

@@ -1,252 +0,0 @@
-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 .constants import (
-    ANIMEPAHE_BASE,
-    ANIMEPAHE_ENDPOINT,
-    REQUEST_HEADERS,
-    SERVER_HEADERS,
-)
-
-if TYPE_CHECKING:
-    from ..types import Anime
-    from .types import AnimePaheAnimePage, AnimePaheSearchPage, AnimeSearchResult
-JUICY_STREAM_REGEX = re.compile(r"source='(.*)';")
-logger = logging.getLogger(__name__)
-
-
-# TODO: hack this to completion
-class AnimePaheApi(AnimeProvider):
-    search_page: "AnimePaheSearchPage"
-    anime: "AnimePaheAnimePage"
-
-    def search_for_anime(self, user_query: str, *args):
-        try:
-            url = f"{ANIMEPAHE_ENDPOINT}m=search&q={user_query}"
-            headers = {**REQUEST_HEADERS}
-            response = 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):
-        page = 1
-        try:
-            anime_result: "AnimeSearchResult" = [
-                anime
-                for anime in self.search_page["data"]
-                if anime["session"] == session_id
-            ][0]
-            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, headers=REQUEST_HEADERS)
-                if response.status_code == 200:
-                    if not data:
-                        data.update(response.json())
-                    if ep_data := response.json().get("data"):
-                        data["data"].extend(ep_data)
-                        if data["next_page_url"]:
-                            # TODO: Refine this
-                            time.sleep(
-                                random.choice(
-                                    [
-                                        0.25,
-                                        0.1,
-                                        0.5,
-                                        0.75,
-                                        1,
-                                    ]
-                                )
-                            )
-                            page += 1
-                            url = f"{ANIMEPAHE_ENDPOINT}m=release&id={session_id}&sort=episode_asc&page={page}"
-                            _pages_loader(
-                                url,
-                                page,
-                            )
-
-            _pages_loader(
-                url,
-                page,
-            )
-
-            if not data:
-                return {}
-            self.anime = data  # pyright:ignore
-            episodes = list(map(str, range(data["total"])))
-            title = ""
-            return {
-                "id": session_id,
-                "title": anime_result["title"],
-                "year": anime_result["year"],
-                "season": anime_result["season"],
-                "poster": anime_result["poster"],
-                "score": anime_result["score"],
-                "availableEpisodesDetail": {
-                    "sub": episodes,
-                    "dub": episodes,
-                    "raw": episodes,
-                },
-                "episodesInfo": [
-                    {
-                        "title": episode["title"] or f"{title};{episode['episode']}",
-                        "episode": episode["episode"],
-                        "id": episode["session"],
-                        "translation_type": episode["audio"],
-                        "duration": episode["duration"],
-                        "poster": episode["snapshot"],
-                    }
-                    for episode in data["data"]
-                ],
-            }
-        except Exception as e:
-            logger.error(f"AnimePahe(anime): {e}")
-            return {}
-
-    def get_episode_streams(
-        self, anime: "Anime", episode_number: str, translation_type, *args
-    ):
-        # extract episode details from memory
-        episode = [
-            episode
-            for episode in self.anime["data"]
-            if float(episode["episode"]) == float(episode_number)
-        ]
-
-        if not episode:
-            logger.error(f"AnimePahe(streams): episode {episode_number} doesn't exist")
-            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)
-        # get the element containing links to juicy streams
-        c = get_element_by_id("resolutionMenu", response.text)
-        resolutionMenuItems = get_elements_html_by_class("dropdown-item", c)
-        # convert the elements containing embed links to a neat dict containing:
-        # data-src
-        # data-audio
-        # data-resolution
-        res_dicts = [extract_attributes(item) for item in resolutionMenuItems]
-
-        # get the episode title
-        episode_title = (
-            episode["title"] or f"{anime['title']}; Episode {episode['episode']}"
-        )
-        # get all links
-        streams = {"server": "kwik", "links": [], "episode_title": episode_title}
-        for res_dict in res_dicts:
-            # get embed url
-            embed_url = res_dict["data-src"]
-            data_audio = "dub" if res_dict["data-audio"] == "eng" else "sub"
-            # filter streams by translation_type
-            if data_audio != translation_type:
-                continue
-
-            if not embed_url:
-                logger.warn(
-                    "AnimePahe: embed url not found please report to the developers"
-                )
-                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,
-            )
-            # 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)
-            # add the link
-            streams["links"].append(
-                {
-                    "quality": res_dict["data-resolution"],
-                    "translation_type": data_audio,
-                    "link": juicy_stream,
-                }
-            )
-        yield streams

fastanime/libs/anime_provider/animepahe/types.py

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

fastanime/libs/anime_provider/base_provider.py

@@ -1,8 +0,0 @@
-import requests
-
-
-class AnimeProvider:
-    session: requests.Session
-
-    def __init__(self) -> None:
-        self.session = requests.session()

fastanime/libs/anime_provider/types.py

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

fastanime/libs/anime_provider/utils.py

@@ -1,62 +0,0 @@
-import re
-from itertools import cycle
-
-# Dictionary to map hex values to characters
-hex_to_char = {
-    "01": "9",
-    "08": "0",
-    "05": "=",
-    "0a": "2",
-    "0b": "3",
-    "0c": "4",
-    "07": "?",
-    "00": "8",
-    "5c": "d",
-    "0f": "7",
-    "5e": "f",
-    "17": "/",
-    "54": "l",
-    "09": "1",
-    "48": "p",
-    "4f": "w",
-    "0e": "6",
-    "5b": "c",
-    "5d": "e",
-    "0d": "5",
-    "53": "k",
-    "1e": "&",
-    "5a": "b",
-    "59": "a",
-    "4a": "r",
-    "4c": "t",
-    "4e": "v",
-    "57": "o",
-    "51": "i",
-}
-
-
-def give_random_quality(links: list[dict]):
-    qualities = cycle(["1080", "720", "360"])
-
-    return [
-        {"link": link["link"], "quality": quality}
-        for link, quality in zip(links, qualities)
-    ]
-
-
-def decode_hex_string(hex_string):
-    """some of the sources encrypt the urls into hex codes this function decrypts the urls
-
-    Args:
-        hex_string ([TODO:parameter]): [TODO:description]
-
-    Returns:
-        [TODO:return]
-    """
-    # Split the hex string into pairs of characters
-    hex_pairs = re.findall("..", hex_string)
-
-    # Decode each hex pair
-    decoded_chars = [hex_to_char.get(pair.lower(), pair) for pair in hex_pairs]
-
-    return "".join(decoded_chars)

fastanime/libs/aniskip/api.py

@@ -1,22 +0,0 @@
-import requests
-
-ANISKIP_ENDPOINT = "https://api.aniskip.com/v1/skip-times"
-
-
-# TODO: Finish own implementation of aniskip script
-class AniSkip:
-    @classmethod
-    def get_skip_times(
-        cls, mal_id: int, episode_number: float | int, types=["op", "ed"]
-    ):
-        url = f"{ANISKIP_ENDPOINT}/{mal_id}/{episode_number}?types=op&types=ed"
-        response = requests.get(url)
-        print(response.text)
-        return response.json()
-
-
-if __name__ == "__main__":
-    mal_id = input("Mal id: ")
-    episode_number = input("episode_number: ")
-    skip_times = AniSkip.get_skip_times(int(mal_id), float(episode_number))
-    print(skip_times)

fastanime/libs/fzf/__init__.py

@@ -1,191 +0,0 @@
-import logging
-import os
-import shutil
-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
-
-logger = logging.getLogger(__name__)
-
-
-FZF_DEFAULT_OPTS = """ 
-    --color=fg:#d0d0d0,fg+:#d0d0d0,bg:#121212,bg+:#262626
-    --color=hl:#5f87af,hl+:#5fd7ff,info:#afaf87,marker:#87ff00
-    --color=prompt:#d7005f,spinner:#af5fff,pointer:#af5fff,header:#87afaf
-    --color=border:#262626,label:#aeaeae,query:#d9d9d9
-    --border="rounded" --border-label="" --preview-window="border-rounded" --prompt="> "
-    --marker=">" --pointer="◆" --separator="─" --scrollbar="│"
-"""
-
-HEADER = """
-
-███████╗░█████╗░░██████╗████████╗░█████╗░███╗░░██╗██╗███╗░░░███╗███████╗
-██╔════╝██╔══██╗██╔════╝╚══██╔══╝██╔══██╗████╗░██║██║████╗░████║██╔════╝
-█████╗░░███████║╚█████╗░░░░██║░░░███████║██╔██╗██║██║██╔████╔██║█████╗░░
-██╔══╝░░██╔══██║░╚═══██╗░░░██║░░░██╔══██║██║╚████║██║██║╚██╔╝██║██╔══╝░░
-██║░░░░░██║░░██║██████╔╝░░░██║░░░██║░░██║██║░╚███║██║██║░╚═╝░██║███████╗
-╚═╝░░░░░╚═╝░░╚═╝╚═════╝░░░░╚═╝░░░╚═╝░░╚═╝╚═╝░░╚══╝╚═╝╚═╝░░░░░╚═╝╚══════╝
-
-"""
-
-
-class FZF:
-    """an abstraction over the fzf commandline utility
-
-    Attributes:
-        FZF_EXECUTABLE: [TODO:attribute]
-        default_options: [TODO:attribute]
-        stdout: [TODO:attribute]
-    """
-
-    if not os.getenv("FZF_DEFAULT_OPTS"):
-        os.environ["FZF_DEFAULT_OPTS"] = FZF_DEFAULT_OPTS
-    FZF_EXECUTABLE = shutil.which("fzf")
-    default_options = [
-        "--cycle",
-        "--info=hidden",
-        "--layout=reverse",
-        "--height=100%",
-        "--bind=right:accept",
-        "--no-margin",
-        "+m",
-        "-i",
-        "--exact",
-        "--tabstop=1",
-        "--preview-window=left,35%,wrap",
-        "--wrap",
-    ]
-
-    def _with_filter(self, command: str, work: Callable) -> List[str]:
-        """ported from the fzf docs demo
-
-        Args:
-            command: [TODO:description]
-            work: [TODO:description]
-
-        Returns:
-            [TODO:return]
-        """
-        try:
-            process = subprocess.Popen(
-                command,
-                stdin=subprocess.PIPE,
-                stdout=subprocess.PIPE,
-                text=True,
-                shell=True,
-            )
-        except subprocess.SubprocessError as e:
-            print(f"Failed to start subprocess: {e}", file=sys.stderr)
-            return []
-
-        original_stdout = sys.stdout
-        sys.stdout = process.stdin
-
-        try:
-            work()
-            if process.stdin:
-                process.stdin.close()
-        except Exception as e:
-            print(f"Exception during work execution: {e}", file=sys.stderr)
-        finally:
-            sys.stdout = original_stdout
-
-        output = []
-        if process.stdout:
-            output = process.stdout.read().splitlines()
-            process.stdout.close()
-
-        return output
-
-    def _run_fzf(self, commands: list[str], _fzf_input) -> str:
-        """core abstraction
-
-        Args:
-            _fzf_input ([TODO:parameter]): [TODO:description]
-            commands: [TODO:description]
-
-        Raises:
-            Exception: [TODO:throw]
-
-        Returns:
-            [TODO:return]
-        """
-        fzf_input = "\n".join(_fzf_input)
-
-        if not self.FZF_EXECUTABLE:
-            raise Exception("fzf executable not found")
-
-        result = subprocess.run(
-            [self.FZF_EXECUTABLE, *commands],
-            input=fzf_input,
-            stdout=subprocess.PIPE,
-            text=True,
-        )
-        if not result or result.returncode != 0 or not result.stdout:
-            print("sth went wrong:confused:")
-            input("press enter to try again...")
-            clear()
-            return self._run_fzf(commands, _fzf_input)
-        clear()
-
-        return result.stdout.strip()
-
-    def run(
-        self,
-        fzf_input: list[str],
-        prompt: str,
-        header: str = HEADER,
-        preview: str | None = None,
-        expect: str | None = None,
-        validator: Callable | None = None,
-    ) -> str:
-        """a helper method that wraps common use cases over the fzf utility
-
-        Args:
-            fzf_input: [TODO:description]
-            prompt: [TODO:description]
-            header: [TODO:description]
-            preview: [TODO:description]
-            expect: [TODO:description]
-            validator: [TODO:description]
-
-        Returns:
-            [TODO:return]
-        """
-        _commands = [
-            *self.default_options,
-            "--header",
-            HEADER,
-            "--header-first",
-            "--prompt",
-            prompt.title(),
-        ]  # pyright:ignore
-
-        if preview:
-            _commands.append(f"--preview={preview}")
-        if expect:
-            _commands.append(f"--expect={expect}")
-
-        result = self._run_fzf(_commands, fzf_input)  # pyright:ignore
-        if not result:
-            print("Please enter a value")
-            input("Enter to do it right")
-            return self.run(fzf_input, prompt, header, preview, expect, validator)
-        elif validator:
-            success, info = validator(result)
-            if not success:
-                print(info)
-                input("Enter to try again")
-                return self.run(fzf_input, prompt, header, preview, expect, validator)
-        return result
-
-
-fzf = FZF()
-
-if __name__ == "__main__":
-    action = fzf.run([*os.listdir(), "exit"], "Prompt: ", "Header", preview="bat {}")
-    print(action)

fastanime/libs/rofi/__init__.py

@@ -1,138 +0,0 @@
-import subprocess
-from shutil import which
-from sys import exit
-
-from plyer import notification
-
-from fastanime import APP_NAME
-
-from ...constants import ICON_PATH
-
-
-class RofiApi:
-    ROFI_EXECUTABLE = which("rofi")
-
-    rofi_theme = ""
-    rofi_theme_confirm = ""
-    rofi_theme_input = ""
-
-    def run_with_icons(self, options: list[str], prompt_text: str) -> str:
-        rofi_input = "\n".join(options)
-
-        if not self.ROFI_EXECUTABLE:
-            raise Exception("Rofi not found")
-
-        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"])
-        result = subprocess.run(
-            args,
-            input=rofi_input,
-            stdout=subprocess.PIPE,
-            text=True,
-        )
-
-        choice = result.stdout.strip()
-        if not choice:
-            notification.notify(
-                app_name=APP_NAME,
-                app_icon=ICON_PATH,
-                message="FastAnime is shutting down",
-                title="No Valid Input Provided",
-            )  # pyright:ignore
-            exit(1)
-
-        return choice
-
-    def run(self, options: list[str], prompt_text: str) -> str:
-        rofi_input = "\n".join(options)
-
-        if not self.ROFI_EXECUTABLE:
-            raise Exception("Rofi not found")
-
-        args = [self.ROFI_EXECUTABLE]
-        if self.rofi_theme:
-            args.extend(["-no-config", "-theme", self.rofi_theme])
-        args.extend(["-p", prompt_text, "-i", "-dmenu"])
-        result = subprocess.run(
-            args,
-            input=rofi_input,
-            stdout=subprocess.PIPE,
-            text=True,
-        )
-
-        choice = result.stdout.strip()
-        if not choice or choice not in options:
-            notification.notify(
-                app_name=APP_NAME,
-                app_icon=ICON_PATH,
-                message="FastAnime is shutting down",
-                title="No Valid Input Provided",
-            )  # pyright:ignore
-            exit(1)
-
-        return choice
-
-    def confirm(self, prompt_text: str) -> bool:
-        rofi_choices = "Yes\nNo"
-        if not self.ROFI_EXECUTABLE:
-            raise Exception("Rofi not found")
-        args = [self.ROFI_EXECUTABLE]
-        if self.rofi_theme_confirm:
-            args.extend(["-no-config", "-theme", self.rofi_theme_confirm])
-        args.extend(["-p", prompt_text, "-i", "", "-no-fixed-num-lines", "-dmenu"])
-        result = subprocess.run(
-            args,
-            input=rofi_choices,
-            stdout=subprocess.PIPE,
-            text=True,
-        )
-
-        choice = result.stdout.strip()
-        if not choice:
-            notification.notify(
-                app_name=APP_NAME,
-                app_icon=ICON_PATH,
-                message="FastAnime is shutting down",
-                title="No Valid Input Provided",
-            )  # pyright:ignore
-            exit(1)
-        if choice == "Yes":
-            return True
-        else:
-            return False
-
-    def ask(
-        self, prompt_text: str, is_int: bool = False, is_float: bool = False
-    ) -> str | float | int:
-        if not self.ROFI_EXECUTABLE:
-            raise Exception("Rofi not found")
-        args = [self.ROFI_EXECUTABLE]
-        if self.rofi_theme_input:
-            args.extend(["-no-config", "-theme", self.rofi_theme_input])
-        args.extend(["-p", prompt_text, "-i", "-no-fixed-num-lines", "-dmenu"])
-        result = subprocess.run(
-            args,
-            stdout=subprocess.PIPE,
-            text=True,
-        )
-
-        user_input = result.stdout.strip()
-        if not user_input:
-            notification.notify(
-                app_name=APP_NAME,
-                app_icon=ICON_PATH,
-                message="FastAnime is shutting down",
-                title="No Valid Input Provided",
-            )  # pyright:ignore
-            exit(1)
-        if is_float:
-            user_input = float(user_input)
-        elif is_int:
-            user_input = int(user_input)
-
-        return user_input
-
-
-Rofi = RofiApi()

flake.lock

@@ -0,0 +1,61 @@
+{
+  "nodes": {
+    "flake-utils": {
+      "inputs": {
+        "systems": "systems"
+      },
+      "locked": {
+        "lastModified": 1731533236,
+        "narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=",
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "rev": "11707dc2f618dd54ca8739b309ec4fc024de578b",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "type": "github"
+      }
+    },
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1756386758,
+        "narHash": "sha256-1wxxznpW2CKvI9VdniaUnTT2Os6rdRJcRUf65ZK9OtE=",
+        "owner": "nixos",
+        "repo": "nixpkgs",
+        "rev": "dfb2f12e899db4876308eba6d93455ab7da304cd",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nixos",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "flake-utils": "flake-utils",
+        "nixpkgs": "nixpkgs"
+      }
+    },
+    "systems": {
+      "locked": {
+        "lastModified": 1681028828,
+        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
+        "owner": "nix-systems",
+        "repo": "default",
+        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-systems",
+        "repo": "default",
+        "type": "github"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}

flake.nix

@@ -0,0 +1,101 @@
+{
+  description = "Viu Project Flake";
+
+  inputs = {
+    nixpkgs.url = "github:nixos/nixpkgs/nixos-unstable";
+    flake-utils.url = "github:numtide/flake-utils";
+  };
+
+  outputs =
+    {
+      self,
+      nixpkgs,
+      flake-utils,
+    }:
+    flake-utils.lib.eachDefaultSystem (
+      system:
+      let
+        pkgs = nixpkgs.legacyPackages.${system};
+        inherit (pkgs) lib python312Packages;
+
+        version = "3.1.0";
+      in
+      {
+        packages.default = python312Packages.buildPythonApplication {
+          pname = "viu";
+          inherit version;
+          pyproject = true;
+
+          src = self;
+
+          build-system = with python312Packages; [ hatchling ];
+
+          dependencies = with python312Packages; [
+            click
+            inquirerpy
+            requests
+            rich
+            thefuzz
+            yt-dlp
+            dbus-python
+            hatchling
+            plyer
+            mpv
+            fastapi
+            pycryptodome
+            pypresence
+            httpx
+          ];
+
+          postPatch = ''
+            substituteInPlace pyproject.toml \
+              --replace-fail "pydantic>=2.11.7" "pydantic>=2.11.4"
+          '';
+
+          makeWrapperArgs = [
+            "--prefix PATH : ${
+              lib.makeBinPath (
+                with pkgs;
+                [
+                  mpv
+                ]
+              )
+            }"
+          ];
+
+          # Needs to be adapted for the nix derivation build
+          doCheck = false;
+
+          meta = {
+            description = "Your browser anime experience from the terminal";
+            homepage = "https://github.com/viu-media/Viu";
+            changelog = "https://github.com/viu-media/Viu/releases/tag/v${version}";
+            mainProgram = "viu";
+            license = lib.licenses.unlicense;
+            maintainers = with lib.maintainers; [ theobori ];
+          };
+        };
+
+        devShells.default = pkgs.mkShell {
+          venvDir = ".venv";
+
+          env.LD_LIBRARY_PATH = pkgs.lib.makeLibraryPath [ pkgs.libxcrypt-legacy ];
+
+          packages =
+            with pkgs;
+            [
+              mpv
+              fzf
+              rofi
+              uv
+              pyright
+            ]
+            ++ (with python3Packages; [
+              venvShellHook
+              hatchling
+            ])
+            ++ self.packages.${system}.default.dependencies;
+        };
+      }
+    );
+}

generate_completions.sh

@@ -1,14 +0,0 @@
-#!/usr/bin/env bash
-APP_DIR="$(
-  cd -- "$(dirname "$0")" >/dev/null 2>&1
-  pwd -P
-)"
-
-# fish shell completions
-_FASTANIME_COMPLETE=fish_source fastanime >"$APP_DIR/completions/fastanime.fish"
-
-# zsh completions
-_FASTANIME_COMPLETE=zsh_source fastanime >"$APP_DIR/completions/fastanime.zsh"
-
-# bash completions
-_FASTANIME_COMPLETE=bash_source fastanime >"$APP_DIR/completions/fastanime.bash"

pyproject.toml

@@ -1,35 +1,65 @@
-[tool.poetry]
-name = "fastanime"
-version = "1.1.6.dev1"
+[project]
+name = "viu-media"
+version = "3.3.0"
 description = "A browser anime site experience from the terminal"
-authors = ["Benextempest <benextempest@gmail.com>"]
 license = "UNLICENSE"
 readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+  "click>=8.1.7",
+  "httpx>=0.28.1",
+  "inquirerpy>=0.3.4",
+  "pydantic>=2.11.7",
+  "rich>=13.9.2",
+]
 
-[tool.poetry.dependencies]
-python = "^3.10"
-yt-dlp = "^2024.5.27"
-rich = "^13.7.1"
-click = "^8.1.7"
-inquirerpy = "^0.3.4"
-thefuzz = "^0.22.1"
-requests = "^2.32.3"
-plyer = "^2.1.0"
+[project.scripts]
+viu = 'viu_media:Cli'
 
-mpv = "^1.0.7"
-[tool.poetry.group.dev.dependencies]
-black = "^24.4.2"
-isort = "^5.13.2"
-pytest = "^8.2.2"
-ruff = "^0.4.10"
-pre-commit = "^3.7.1"
-autoflake = "^2.3.1"
-tox = "^4.16.0"
+[project.optional-dependencies]
+standard = [
+ "thefuzz>=0.22.1",
+ "yt-dlp>=2025.7.21",
+ "pycryptodomex>=3.23.0",
+ "pypiwin32; sys_platform == 'win32'", # For Windows-specific functionality
+ "pyobjc; sys_platform == 'darwin'", # For macOS-specific functionality
+ "dbus-python; sys_platform == 'linux'", # For Linux-specific functionality (e.g., notifications),
+ "plyer>=2.1.0",
+ "lxml>=6.0.0"
+]
+notifications = [
+    "dbus-python>=1.4.0",
+    "plyer>=2.1.0",
+]
+mpv = [
+    "mpv>=1.0.7",
+]
+torrent = ["libtorrent>=2.0.11"]
+lxml = ["lxml>=6.0.0"]
+discord = ["pypresence>=4.3.0"]
+download = [
+    "pycryptodomex>=3.23.0",
+    "yt-dlp>=2025.7.21",
+]
+torrents = [
+    "libtorrent>=2.0.11",
+]
 
-pyright = "^1.1.374"
 [build-system]
-requires = ["poetry-core"]
-build-backend = "poetry.core.masonry.api"
+requires = ["hatchling"]
+build-backend = "hatchling.build"
 
-[tool.poetry.scripts]
-fastanime = 'fastanime:FastAnime'
+[dependency-groups]
+dev = [
+  "pre-commit>=4.0.1",
+  "pyinstaller>=6.11.1",
+  "pyright>=1.1.384",
+  "pytest>=8.3.3",
+  "pytest-httpx>=0.35.0",
+  "ruff>=0.6.9",
+]
+
+[tool.pytest.ini_options]
+markers = [
+    "integration: marks tests as integration tests that require a live network connection",
+]

pyrightconfig.json

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

tests/test_all_commands.py

@@ -1,145 +0,0 @@
-# TODO: Write tests to make sure all click commands work
-import pytest
-from click.testing import CliRunner
-
-from fastanime.cli import run_cli
-
-
-@pytest.fixture
-def runner():
-    return CliRunner()
-
-
-def test_main_help(runner: CliRunner):
-    result = runner.invoke(run_cli, ["--help"])
-    assert result.exit_code == 0
-
-
-def test_config_help(runner: CliRunner):
-    result = runner.invoke(run_cli, ["config", "--help"])
-    assert result.exit_code == 0
-
-
-def test_config_path(runner: CliRunner):
-    result = runner.invoke(run_cli, ["config", "--path"])
-    assert result.exit_code == 0
-
-
-def test_downloads_help(runner: CliRunner):
-    result = runner.invoke(run_cli, ["downloads", "--help"])
-    assert result.exit_code == 0
-
-
-def test_downloads_path(runner: CliRunner):
-    result = runner.invoke(run_cli, ["downloads", "--path"])
-    assert result.exit_code == 0
-
-
-def test_download_help(runner: CliRunner):
-    result = runner.invoke(run_cli, ["download", "--help"])
-    assert result.exit_code == 0
-
-
-def test_search_help(runner: CliRunner):
-    result = runner.invoke(run_cli, ["search", "--help"])
-    assert result.exit_code == 0
-
-
-def test_cache_help(runner: CliRunner):
-    result = runner.invoke(run_cli, ["cache", "--help"])
-    assert result.exit_code == 0
-
-
-def test_completions_help(runner: CliRunner):
-    result = runner.invoke(run_cli, ["completions", "--help"])
-    assert result.exit_code == 0
-
-
-def test_update_help(runner: CliRunner):
-    result = runner.invoke(run_cli, ["update", "--help"])
-    assert result.exit_code == 0
-
-
-def test_anilist_help(runner: CliRunner):
-    result = runner.invoke(run_cli, ["anilist", "--help"])
-    assert result.exit_code == 0
-
-
-def test_anilist_completed_help(runner: CliRunner):
-    result = runner.invoke(run_cli, ["anilist", "completed", "--help"])
-    assert result.exit_code == 0
-
-
-def test_anilist_dropped_help(runner: CliRunner):
-    result = runner.invoke(run_cli, ["anilist", "dropped", "--help"])
-    assert result.exit_code == 0
-
-
-def test_anilist_favourites_help(runner: CliRunner):
-    result = runner.invoke(run_cli, ["anilist", "favourites", "--help"])
-    assert result.exit_code == 0
-
-
-def test_anilist_login_help(runner: CliRunner):
-    result = runner.invoke(run_cli, ["anilist", "login", "--help"])
-    assert result.exit_code == 0
-
-
-def test_anilist_notifier_help(runner: CliRunner):
-    result = runner.invoke(run_cli, ["anilist", "notifier", "--help"])
-    assert result.exit_code == 0
-
-
-def test_anilist_paused_help(runner: CliRunner):
-    result = runner.invoke(run_cli, ["anilist", "paused", "--help"])
-    assert result.exit_code == 0
-
-
-def test_anilist_planning_help(runner: CliRunner):
-    result = runner.invoke(run_cli, ["anilist", "planning", "--help"])
-    assert result.exit_code == 0
-
-
-def test_anilist_popular_help(runner: CliRunner):
-    result = runner.invoke(run_cli, ["anilist", "popular", "--help"])
-    assert result.exit_code == 0
-
-
-def test_anilist_random_anime_help(runner: CliRunner):
-    result = runner.invoke(run_cli, ["anilist", "random", "--help"])
-    assert result.exit_code == 0
-
-
-def test_anilist_recent_help(runner: CliRunner):
-    result = runner.invoke(run_cli, ["anilist", "recent", "--help"])
-    assert result.exit_code == 0
-
-
-def test_anilist_rewatching_help(runner: CliRunner):
-    result = runner.invoke(run_cli, ["anilist", "rewatching", "--help"])
-    assert result.exit_code == 0
-
-
-def test_anilist_scores_help(runner: CliRunner):
-    result = runner.invoke(run_cli, ["anilist", "scores", "--help"])
-    assert result.exit_code == 0
-
-
-def test_anilist_search_help(runner: CliRunner):
-    result = runner.invoke(run_cli, ["anilist", "search", "--help"])
-    assert result.exit_code == 0
-
-
-def test_anilist_trending_help(runner: CliRunner):
-    result = runner.invoke(run_cli, ["anilist", "trending", "--help"])
-    assert result.exit_code == 0
-
-
-def test_anilist_upcoming_help(runner: CliRunner):
-    result = runner.invoke(run_cli, ["anilist", "upcoming", "--help"])
-    assert result.exit_code == 0
-
-
-def test_anilist_watching_help(runner: CliRunner):
-    result = runner.invoke(run_cli, ["anilist", "watching", "--help"])
-    assert result.exit_code == 0

tox.ini

@@ -1,27 +1,27 @@
 [tox]
 requires =
     tox>=4
-env_list = lint, pyright, py{310,311}
+env_list = lint, pyright, py{311,312}
 
 [testenv]
 description = run unit tests
-deps =poetry
+deps =uv
 commands =
-    poetry install
-    poetry run pytest
+    uv sync --dev --all-extras
+    uv run pytest
 
 [testenv:lint]
 description = run linters
 skip_install = true
-deps =poetry
+deps =uv
 commands = 
-    poetry install
-    poetry run black .
+    uv sync --dev --all-extras
+    uv run ruff format .
 
 [testenv:pyright]
 description = run type checking
 skip_install = true
-deps =poetry
+deps =uv
 commands = 
-    poetry install --no-root
-    poetry run pyright
+    uv sync --dev --all-extras
+    uv run pyright