Upload 14 files

Dockerfile

@@ -0,0 +1,19 @@
+# syntax=docker/dockerfile:1
+
+FROM python:3.10-bullseye
+
+EXPOSE 6969
+
+WORKDIR /app
+
+RUN apt update && apt install -y -qq ffmpeg aria2 && apt clean
+
+RUN pip3 install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+VOLUME [ "/app/logs/weights", "/app/opt" ]
+
+ENTRYPOINT [ "python3" ]
+
+CMD ["app.py"]

LICENSE

@@ -0,0 +1,26 @@
+MIT License (Non-Commercial)
+
+Copyright (c) 2023 AI Hispano
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to use,
+copy, modify, merge, publish and/or distribute Applio-RVC-Fork, subject to the following conditions:
+
+1. The software and its derivatives may only be used for non-commercial
+   purposes.
+
+2. Any commercial use, sale, or distribution of the software or its derivatives
+   is strictly prohibited.
+
+3. The above copyright notice and this permission notice shall be included in
+   all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS," WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT, OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+Please note that under this license, the software and its derivatives can only be used for non-commercial purposes, and any commercial use, sale, or distribution is prohibited.

Makefile

@@ -0,0 +1,24 @@
+.PHONY:
+.ONESHELL:
+
+# Show help message
+help:
+	@grep -hE '^[A-Za-z0-9_ \-]*?:.*##.*$$' $(MAKEFILE_LIST) | sort | awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m%-30s\033[0m %s\n", $$1, $$2}'
+
+# Install dependencies
+run-install:
+	apt-get -y install build-essential python3-dev ffmpeg
+	pip install --upgrade setuptools wheel
+	pip install --upgrade pip
+	pip install faiss-gpu fairseq gradio ffmpeg ffmpeg-python praat-parselmouth pyworld numpy==1.23.5 numba==0.56.4 librosa==0.9.1
+	pip install -r requirements.txt
+	pip install --upgrade lxml
+	apt-get update
+
+# Run Applio
+run-applio:
+	python app.py
+
+# Run Tensorboard
+run-tensorboard:
+	python core.py tensorboard

README.md

@@ -1,12 +1,110 @@
----
-title: ApplioTest
-emoji: 🦀
-colorFrom: blue
-colorTo: blue
-sdk: gradio
-sdk_version: 4.15.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Applio
+Welcome to **Applio**, the ultimate voice cloning tool meticulously optimized for unrivaled power, modularity, and a user-friendly experience.
+
+![GitHub Release](https://img.shields.io/github/v/release/iahispano/applio-rvc-fork?style=flat-square)
+![GitHub Repo stars](https://img.shields.io/github/stars/iahispano/applio-rvc-fork?style=flat-square)
+![GitHub forks](https://img.shields.io/github/forks/iahispano/applio-rvc-fork?style=flat-square)
+[![Support Discord](https://img.shields.io/discord/1096877223765606521?style=flat-square)](https://discord.gg/iahispano)
+[![Downloads](https://img.shields.io/github/downloads/iahispano/applio-rvc-fork/total?style=flat-square)](https://github.com/IAHispano/Applio-RVC-Fork/releases)
+[![Issues](https://img.shields.io/github/issues/iahispano/applio-rvc-fork?style=flat-square)](https://github.com/IAHispano/Applio-RVC-Fork/issues)
+<!-- WORKING ON THIS
+[![Open In Collab](https://img.shields.io/badge/google_colab-F9AB00?style=flat-square&logo=googlecolab&logoColor=white)](https://colab.research.google.com/github/iahispano/applio/blob/master/assets/Applio.ipynb)
+-->
+
+## Content Table
+- [**Installation**](#installation)
+  - [Windows](#windows)
+  - [Linux](#linux)
+  - [Using Makefile](#using-makefile-for-platforms-such-as-paperspace)
+- [**Usage**](#usage)
+  - [Windows](#windows-1)
+  - [Linux](#linux-1)
+  - [Using Makefile](#using-makefile-for-platforms-such-as-paperspace-1)
+- [**Repository Enhancements**](#repository-enhancements)
+- [**Credits**](#credits)
+  - [Contributors](#contributors)
+
+## Installation
+Download the latest version from [GitHub Releases](https://github.com/IAHispano/Applio-RVC-Fork/releases).
+
+### Windows
+```bash
+./run-install.bat
+```
+
+### Linux
+```bash
+chmod +x run-install.sh
+./run-install.sh
+```
+
+### Using Makefile (for platforms such as [Paperspace](https://www.paperspace.com/))
+```
+make run-install
+```
+
+## Usage
+Visit [Applio Documentation](https://docs.applio.org/) for a detailed UI usage explanation.
+
+### Windows
+```bash
+./run-applio.bat
+```
+
+### Linux
+```bash
+chmod +x run-applio.sh
+./run-applio.sh
+```
+
+### Using Makefile (for platforms such as [Paperspace](https://www.paperspace.com/))
+```
+make run-applio
+```
+
+## Repository Enhancements
+
+This repository has undergone significant improvements to enhance its functionality and maintainability:
+
+- **Code Modularization:** The codebase has been restructured to follow a modular approach. This ensures better organization, readability, and ease of maintenance.
+- **Hop Length Implementation:** Special thanks to [@Mangio621](https://github.com/Mangio621/Mangio-RVC-Fork) for introducing hop length implementation. This enhancement enhances the efficiency and performance on Crepe (previously known as Mangio-Crepe).
+- **Translations to +30 Languages:** The repository now supports translations in over 30 languages, making it more accessible to a global audience.
+- **Cross-Platform Compatibility:** With multiplatform compatibility, this repository can seamlessly operate across various platforms, providing a consistent experience to users.
+- **Optimized Requirements:** The project's requirements have been fine-tuned for improved performance and resource utilization.
+- **Simple Installation:** The installation process has been streamlined, ensuring a straightforward and user-friendly experience for setup.
+
+These enhancements contribute to a more robust and scalable codebase, making the repository more accessible for contributors and users alike.
+
+## Contributions
+- **Backend Contributions:** If you want to contribute to the backend, make your pull requests [here](https://github.com/blaise-tk/RVC_CLI).
+- **Frontend Contributions:** For interface or script-related contributions, feel free to contribute to this repository.
+
+We appreciate all contributions ❤️
+
+## Planned Features
+- Implement: Support for Apple Devices ([Issue Link](https://github.com/pytorch/pytorch/issues/77764))
+- Implement: rmvpe_gpu
+- Implement: Theme selector
+- Fix: Save on every weight
+- Fix: Model fusion
+
+## Credits
+- [VITS](https://github.com/jaywalnut310/vits) by jaywalnut310
+- [Retrieval-based-Voice-Conversion-WebUI](https://github.com/RVC-Project/Retrieval-based-Voice-Conversion-WebUI) by RVC-Project
+- [Mangio-RVC-Fork](https://github.com/Mangio621/Mangio-RVC-Fork) by Mangio621
+- [Mangio-RVC-Tweaks](https://github.com/alexlnkp/Mangio-RVC-Tweaks) by alexlnkp
+- [RVG_tts](https://github.com/Foxify52/RVG_tts) by Foxify52
+- [RMVPE](https://github.com/Dream-High/RMVPE) by Dream-High
+- [ContentVec](https://github.com/auspicious3000/contentvec/) by auspicious3000
+- [HIFIGAN](https://github.com/jik876/hifi-gan) by jik876
+- [Gradio](https://github.com/gradio-app/gradio) by gradio-app
+- [FFmpeg](https://github.com/FFmpeg/FFmpeg) by FFmpeg
+- [audio-slicer](https://github.com/openvpi/audio-slicer) by openvpi
+- [Ilaria-Audio-Analyzer](https://github.com/TheStingerX/Ilaria-Audio-Analyzer) by TheStingerX
+- [gradio-screen-recorder](https://huggingface.co/spaces/gstaff/gradio-screen-recorder) by gstaff
+- [RVC_CLI](https://github.com/blaise-tk/RVC_CLI) by blaise-tk
+
+### Contributors
+<a href="https://github.com/IAHispano/Applio/graphs/contributors" target="_blank">
+  <img src="https://contrib.rocks/image?repo=IAHispano/Applio" />
+</a>

app.py

@@ -0,0 +1,58 @@
+import gradio as gr
+import sys
+import os
+
+now_dir = os.getcwd()
+sys.path.append(now_dir)
+
+from assets.i18n.i18n import I18nAuto
+
+i18n = I18nAuto()
+
+from tabs.inference.inference import inference_tab
+from tabs.train.train import train_tab
+from tabs.extra.extra import extra_tab
+from tabs.report.report import report_tab
+from tabs.download.download import download_tab
+from tabs.tts.tts import tts_tab
+from assets.discord_presence import rich_presence
+
+rich_presence()
+
+with gr.Blocks(theme="ParityError/Interstellar", title="Applio") as Applio:
+    gr.Markdown("# Applio")
+    gr.Markdown(
+        i18n(
+            "Ultimate voice cloning tool, meticulously optimized for unrivaled power, modularity, and user-friendly experience."
+        )
+    )
+    gr.Markdown(
+        i18n(
+            "[Support](https://discord.gg/IAHispano) — [Discord Bot](https://discord.com/oauth2/authorize?client_id=1144714449563955302&permissions=1376674695271&scope=bot%20applications.commands) — [Find Voices](https://applio.org/models) — [GitHub](https://github.com/IAHispano/Applio)"
+        )
+    )
+    with gr.Tab(i18n("Inference")):
+        inference_tab()
+
+    with gr.Tab(i18n("Train")):
+        train_tab()
+
+    with gr.Tab(i18n("TTS")):
+        tts_tab()
+
+    with gr.Tab(i18n("Extra")):
+        extra_tab()
+
+    with gr.Tab(i18n("Download")):
+        download_tab()
+
+    with gr.Tab(i18n("Report a Bug")):
+        report_tab()
+
+if __name__ == "__main__":
+    Applio.launch(
+        favicon_path="assets/ICON.ico",
+        share="--share" in sys.argv,
+        inbrowser="--open" in sys.argv,
+        server_port=6969,
+    )

core.py

@@ -0,0 +1,764 @@
+import os
+import sys
+import argparse
+import subprocess
+
+now_dir = os.getcwd()
+sys.path.append(now_dir)
+
+from rvc.configs.config import Config
+from rvc.lib.tools.validators import (
+    validate_sampling_rate,
+    validate_f0up_key,
+    validate_f0method,
+    validate_true_false,
+    validate_tts_voices,
+)
+
+from rvc.train.extract.preparing_files import generate_config, generate_filelist
+from rvc.lib.tools.pretrained_selector import pretrained_selector
+
+from rvc.lib.process.model_fusion import model_fusion
+from rvc.lib.process.model_information import model_information
+
+config = Config()
+current_script_directory = os.path.dirname(os.path.realpath(__file__))
+logs_path = os.path.join(current_script_directory, "logs")
+subprocess.run(
+    ["python", os.path.join("rvc", "lib", "tools", "prerequisites_download.py")]
+)
+
+
+# Infer
+def run_infer_script(
+    f0up_key,
+    filter_radius,
+    index_rate,
+    hop_length,
+    f0method,
+    input_path,
+    output_path,
+    pth_file,
+    index_path,
+    split_audio,
+):
+    infer_script_path = os.path.join("rvc", "infer", "infer.py")
+    command = [
+        "python",
+        infer_script_path,
+        str(f0up_key),
+        str(filter_radius),
+        str(index_rate),
+        str(hop_length),
+        f0method,
+        input_path,
+        output_path,
+        pth_file,
+        index_path,
+        str(split_audio),
+    ]
+    subprocess.run(command)
+    return f"File {input_path} inferred successfully.", output_path
+
+
+# Batch infer
+def run_batch_infer_script(
+    f0up_key,
+    filter_radius,
+    index_rate,
+    hop_length,
+    f0method,
+    input_folder,
+    output_folder,
+    pth_file,
+    index_path,
+):
+    infer_script_path = os.path.join("rvc", "infer", "infer.py")
+
+    audio_files = [
+        f for f in os.listdir(input_folder) if f.endswith((".mp3", ".wav", ".flac"))
+    ]
+    print(f"Detected {len(audio_files)} audio files for inference.")
+
+    for audio_file in audio_files:
+        if "_output" in audio_file:
+            pass
+        else:
+            input_path = os.path.join(input_folder, audio_file)
+            output_file_name = os.path.splitext(os.path.basename(audio_file))[0]
+            output_path = os.path.join(
+                output_folder,
+                f"{output_file_name}_output{os.path.splitext(audio_file)[1]}",
+            )
+            print(f"Inferring {input_path}...")
+
+        command = [
+            "python",
+            infer_script_path,
+            str(f0up_key),
+            str(filter_radius),
+            str(index_rate),
+            str(hop_length),
+            f0method,
+            input_path,
+            output_path,
+            pth_file,
+            index_path,
+        ]
+        subprocess.run(command)
+
+    return f"Files from {input_folder} inferred successfully."
+
+
+# TTS
+def run_tts_script(
+    tts_text,
+    tts_voice,
+    f0up_key,
+    filter_radius,
+    index_rate,
+    hop_length,
+    f0method,
+    output_tts_path,
+    output_rvc_path,
+    pth_file,
+    index_path,
+):
+    tts_script_path = os.path.join("rvc", "lib", "tools", "tts.py")
+    infer_script_path = os.path.join("rvc", "infer", "infer.py")
+
+    if os.path.exists(output_tts_path):
+        os.remove(output_tts_path)
+
+    command_tts = [
+        "python",
+        tts_script_path,
+        tts_text,
+        tts_voice,
+        output_tts_path,
+    ]
+
+    command_infer = [
+        "python",
+        infer_script_path,
+        str(f0up_key),
+        str(filter_radius),
+        str(index_rate),
+        str(hop_length),
+        f0method,
+        output_tts_path,
+        output_rvc_path,
+        pth_file,
+        index_path,
+    ]
+    subprocess.run(command_tts)
+    subprocess.run(command_infer)
+    return f"Text {tts_text} synthesized successfully.", output_rvc_path
+
+
+# Preprocess
+def run_preprocess_script(model_name, dataset_path, sampling_rate):
+    per = 3.0 if config.is_half else 3.7
+    preprocess_script_path = os.path.join("rvc", "train", "preprocess", "preprocess.py")
+    command = [
+        "python",
+        preprocess_script_path,
+        os.path.join(logs_path, str(model_name)),
+        dataset_path,
+        str(sampling_rate),
+        str(per),
+    ]
+
+    os.mkdir(os.path.join(logs_path, str(model_name)))
+    subprocess.run(command)
+    return f"Model {model_name} preprocessed successfully."
+
+
+# Extract
+def run_extract_script(model_name, rvc_version, f0method, hop_length, sampling_rate):
+    model_path = os.path.join(logs_path, str(model_name))
+    extract_f0_script_path = os.path.join(
+        "rvc", "train", "extract", "extract_f0_print.py"
+    )
+    extract_feature_script_path = os.path.join(
+        "rvc", "train", "extract", "extract_feature_print.py"
+    )
+
+    command_1 = [
+        "python",
+        extract_f0_script_path,
+        model_path,
+        f0method,
+        str(hop_length),
+    ]
+    command_2 = [
+        "python",
+        extract_feature_script_path,
+        config.device,
+        "1",
+        "0",
+        "0",
+        model_path,
+        rvc_version,
+        "True",
+    ]
+    subprocess.run(command_1)
+    subprocess.run(command_2)
+
+    generate_config(rvc_version, sampling_rate, model_path)
+    generate_filelist(f0method, model_path, rvc_version, sampling_rate)
+    return f"Model {model_name} extracted successfully."
+
+
+# Train
+def run_train_script(
+    model_name,
+    rvc_version,
+    save_every_epoch,
+    save_only_latest,
+    save_every_weights,
+    total_epoch,
+    sampling_rate,
+    batch_size,
+    gpu,
+    pitch_guidance,
+    pretrained,
+    custom_pretrained,
+    g_pretrained_path=None,
+    d_pretrained_path=None,
+):
+    f0 = 1 if pitch_guidance == "True" else 0
+    latest = 1 if save_only_latest == "True" else 0
+    save_every = 1 if save_every_weights == "True" else 0
+
+    if pretrained == "True":
+        if custom_pretrained == "False":
+            pg, pd = pretrained_selector(f0)[rvc_version][sampling_rate]
+        else:
+            if g_pretrained_path is None or d_pretrained_path is None:
+                raise ValueError(
+                    "Please provide the path to the pretrained G and D models."
+                )
+            pg, pd = g_pretrained_path, d_pretrained_path
+    else:
+        pg, pd = "", ""
+
+    train_script_path = os.path.join("rvc", "train", "train.py")
+    command = [
+        "python",
+        train_script_path,
+        "-se",
+        str(save_every_epoch),
+        "-te",
+        str(total_epoch),
+        "-pg",
+        pg,
+        "-pd",
+        pd,
+        "-sr",
+        str(sampling_rate),
+        "-bs",
+        str(batch_size),
+        "-g",
+        gpu,
+        "-e",
+        os.path.join(logs_path, str(model_name)),
+        "-v",
+        rvc_version,
+        "-l",
+        str(latest),
+        "-c",
+        "0",
+        "-sw",
+        str(save_every),
+        "-f0",
+        str(f0),
+    ]
+
+    subprocess.run(command)
+    run_index_script(model_name, rvc_version)
+    return f"Model {model_name} trained successfully."
+
+
+# Index
+def run_index_script(model_name, rvc_version):
+    index_script_path = os.path.join("rvc", "train", "index_generator.py")
+    command = [
+        "python",
+        index_script_path,
+        os.path.join(logs_path, str(model_name)),
+        rvc_version,
+    ]
+
+    subprocess.run(command)
+    return f"Index file for {model_name} generated successfully."
+
+
+# Model information
+def run_model_information_script(pth_path):
+    print(model_information(pth_path))
+
+
+# Model fusion
+def run_model_fusion_script(model_name, pth_path_1, pth_path_2):
+    model_fusion(model_name, pth_path_1, pth_path_2)
+
+
+# Tensorboard
+def run_tensorboard_script():
+    tensorboard_script_path = os.path.join(
+        "rvc", "lib", "tools", "launch_tensorboard.py"
+    )
+    command = [
+        "python",
+        tensorboard_script_path,
+    ]
+    subprocess.run(command)
+
+
+# Download
+def run_download_script(model_link):
+    download_script_path = os.path.join("rvc", "lib", "tools", "model_download.py")
+    command = [
+        "python",
+        download_script_path,
+        model_link,
+    ]
+    subprocess.run(command)
+    return f"Model downloaded successfully."
+
+
+# Parse arguments
+def parse_arguments():
+    parser = argparse.ArgumentParser(
+        description="Run the main.py script with specific parameters."
+    )
+    subparsers = parser.add_subparsers(
+        title="subcommands", dest="mode", help="Choose a mode"
+    )
+
+    # Parser for 'infer' mode
+    infer_parser = subparsers.add_parser("infer", help="Run inference")
+    infer_parser.add_argument(
+        "f0up_key",
+        type=validate_f0up_key,
+        help="Value for f0up_key (-12 to +12)",
+    )
+    infer_parser.add_argument(
+        "filter_radius",
+        type=str,
+        help="Value for filter_radius (0 to 10)",
+    )
+    infer_parser.add_argument(
+        "index_rate",
+        type=str,
+        help="Value for index_rate (0.0 to 1)",
+    )
+    infer_parser.add_argument(
+        "hop_length",
+        type=str,
+        help="Value for hop_length (1 to 512)",
+    )
+    infer_parser.add_argument(
+        "f0method",
+        type=validate_f0method,
+        help="Value for f0method (pm, dio, crepe, crepe-tiny, harvest, rmvpe)",
+    )
+    infer_parser.add_argument(
+        "input_path", type=str, help="Input path (enclose in double quotes)"
+    )
+    infer_parser.add_argument(
+        "output_path", type=str, help="Output path (enclose in double quotes)"
+    )
+    infer_parser.add_argument(
+        "pth_file", type=str, help="Path to the .pth file (enclose in double quotes)"
+    )
+    infer_parser.add_argument(
+        "index_path",
+        type=str,
+        help="Path to the .index file (enclose in double quotes)",
+    )
+    infer_parser.add_argument(
+        "split_audio",
+        type=str,
+        help="Enable split audio ( better results )",
+    )
+
+    # Parser for 'batch_infer' mode
+    batch_infer_parser = subparsers.add_parser(
+        "batch_infer", help="Run batch inference"
+    )
+    batch_infer_parser.add_argument(
+        "f0up_key",
+        type=validate_f0up_key,
+        help="Value for f0up_key (-12 to +12)",
+    )
+    batch_infer_parser.add_argument(
+        "filter_radius",
+        type=str,
+        help="Value for filter_radius (0 to 10)",
+    )
+    batch_infer_parser.add_argument(
+        "index_rate",
+        type=str,
+        help="Value for index_rate (0.0 to 1)",
+    )
+    batch_infer_parser.add_argument(
+        "hop_length",
+        type=str,
+        help="Value for hop_length (1 to 512)",
+    )
+    batch_infer_parser.add_argument(
+        "f0method",
+        type=validate_f0method,
+        help="Value for f0method (pm, dio, crepe, crepe-tiny, harvest, rmvpe)",
+    )
+    batch_infer_parser.add_argument(
+        "input_folder", type=str, help="Input folder (enclose in double quotes)"
+    )
+    batch_infer_parser.add_argument(
+        "output_folder", type=str, help="Output folder (enclose in double quotes)"
+    )
+    batch_infer_parser.add_argument(
+        "pth_file", type=str, help="Path to the .pth file (enclose in double quotes)"
+    )
+    batch_infer_parser.add_argument(
+        "index_path",
+        type=str,
+        help="Path to the .index file (enclose in double quotes)",
+    )
+
+    # Parser for 'tts' mode
+    tts_parser = subparsers.add_parser("tts", help="Run TTS")
+    tts_parser.add_argument(
+        "tts_text",
+        type=str,
+        help="Text to be synthesized (enclose in double quotes)",
+    )
+    tts_parser.add_argument(
+        "tts_voice",
+        type=validate_tts_voices,
+        help="Voice to be used (enclose in double quotes)",
+    )
+    tts_parser.add_argument(
+        "f0up_key",
+        type=validate_f0up_key,
+        help="Value for f0up_key (-12 to +12)",
+    )
+    tts_parser.add_argument(
+        "filter_radius",
+        type=str,
+        help="Value for filter_radius (0 to 10)",
+    )
+    tts_parser.add_argument(
+        "index_rate",
+        type=str,
+        help="Value for index_rate (0.0 to 1)",
+    )
+    tts_parser.add_argument(
+        "hop_length",
+        type=str,
+        help="Value for hop_length (1 to 512)",
+    )
+    tts_parser.add_argument(
+        "f0method",
+        type=validate_f0method,
+        help="Value for f0method (pm, dio, crepe, crepe-tiny, harvest, rmvpe)",
+    )
+    tts_parser.add_argument(
+        "output_tts_path", type=str, help="Output tts path (enclose in double quotes)"
+    )
+    tts_parser.add_argument(
+        "output_rvc_path", type=str, help="Output rvc path (enclose in double quotes)"
+    )
+    tts_parser.add_argument(
+        "pth_file", type=str, help="Path to the .pth file (enclose in double quotes)"
+    )
+    tts_parser.add_argument(
+        "index_path",
+        type=str,
+        help="Path to the .index file (enclose in double quotes)",
+    )
+
+    # Parser for 'preprocess' mode
+    preprocess_parser = subparsers.add_parser("preprocess", help="Run preprocessing")
+    preprocess_parser.add_argument(
+        "model_name", type=str, help="Name of the model (enclose in double quotes)"
+    )
+    preprocess_parser.add_argument(
+        "dataset_path",
+        type=str,
+        help="Path to the dataset (enclose in double quotes)",
+    )
+    preprocess_parser.add_argument(
+        "sampling_rate",
+        type=validate_sampling_rate,
+        help="Sampling rate (32000, 40000 or 48000)",
+    )
+
+    # Parser for 'extract' mode
+    extract_parser = subparsers.add_parser("extract", help="Run extract")
+    extract_parser.add_argument(
+        "model_name",
+        type=str,
+        help="Name of the model (enclose in double quotes)",
+    )
+    extract_parser.add_argument(
+        "rvc_version",
+        type=str,
+        help="Version of the model (v1 or v2)",
+    )
+    extract_parser.add_argument(
+        "f0method",
+        type=validate_f0method,
+        help="Value for f0method (pm, dio, crepe, crepe-tiny, mangio-crepe, mangio-crepe-tiny, harvest, rmvpe)",
+    )
+    extract_parser.add_argument(
+        "hop_length",
+        type=str,
+        help="Value for hop_length (1 to 512)",
+    )
+    extract_parser.add_argument(
+        "sampling_rate",
+        type=validate_sampling_rate,
+        help="Sampling rate (32000, 40000 or 48000)",
+    )
+
+    # Parser for 'train' mode
+    train_parser = subparsers.add_parser("train", help="Run training")
+    train_parser.add_argument(
+        "model_name",
+        type=str,
+        help="Name of the model (enclose in double quotes)",
+    )
+    train_parser.add_argument(
+        "rvc_version",
+        type=str,
+        help="Version of the model (v1 or v2)",
+    )
+    train_parser.add_argument(
+        "save_only_latest",
+        type=str,
+        help="Save weight only at last epoch",
+    )
+    train_parser.add_argument(
+        "save_every_weights",
+        type=str,
+        help="Save weight every epoch",
+    )
+    train_parser.add_argument(
+        "save_every_epoch",
+        type=str,
+        help="Save every epoch",
+    )
+    train_parser.add_argument(
+        "total_epoch",
+        type=str,
+        help="Total epoch",
+    )
+    train_parser.add_argument(
+        "sampling_rate",
+        type=validate_sampling_rate,
+        help="Sampling rate (32000, 40000, or 48000)",
+    )
+    train_parser.add_argument(
+        "batch_size",
+        type=str,
+        help="Batch size",
+    )
+    train_parser.add_argument(
+        "gpu",
+        type=str,
+        help="GPU number (0 to 10 separated by -)",
+    )
+    train_parser.add_argument(
+        "pitch_guidance",
+        type=validate_true_false,
+        help="Pitch guidance (True or False)",
+    )
+    train_parser.add_argument(
+        "pretrained",
+        type=validate_true_false,
+        help="Pretrained (True or False)",
+    )
+    train_parser.add_argument(
+        "custom_pretrained",
+        type=validate_true_false,
+        help="Custom pretrained (True or False)",
+    )
+    train_parser.add_argument(
+        "g_pretrained_path",
+        type=str,
+        nargs="?",
+        default=None,
+        help="Path to the pretrained G file (enclose in double quotes)",
+    )
+    train_parser.add_argument(
+        "d_pretrained_path",
+        type=str,
+        nargs="?",
+        default=None,
+        help="Path to the pretrained D file (enclose in double quotes)",
+    )
+
+    # Parser for 'index' mode
+    index_parser = subparsers.add_parser("index", help="Generate index file")
+    index_parser.add_argument(
+        "model_name",
+        type=str,
+        help="Name of the model (enclose in double quotes)",
+    )
+    index_parser.add_argument(
+        "rvc_version",
+        type=str,
+        help="Version of the model (v1 or v2)",
+    )
+
+    # Parser for 'model_information' mode
+    model_information_parser = subparsers.add_parser(
+        "model_information", help="Print model information"
+    )
+    model_information_parser.add_argument(
+        "pth_path",
+        type=str,
+        help="Path to the .pth file (enclose in double quotes)",
+    )
+
+    # Parser for 'model_fusion' mode
+    model_fusion_parser = subparsers.add_parser("model_fusion", help="Fuse two models")
+    model_fusion_parser.add_argument(
+        "model_name",
+        type=str,
+        help="Name of the model (enclose in double quotes)",
+    )
+    model_fusion_parser.add_argument(
+        "pth_path_1",
+        type=str,
+        help="Path to the first .pth file (enclose in double quotes)",
+    )
+    model_fusion_parser.add_argument(
+        "pth_path_2",
+        type=str,
+        help="Path to the second .pth file (enclose in double quotes)",
+    )
+
+    # Parser for 'tensorboard' mode
+    subparsers.add_parser("tensorboard", help="Run tensorboard")
+
+    # Parser for 'download' mode
+    download_parser = subparsers.add_parser("download", help="Download models")
+    download_parser.add_argument(
+        "model_link",
+        type=str,
+        help="Link of the model (enclose in double quotes)",
+    )
+
+    return parser.parse_args()
+
+
+def main():
+    if len(sys.argv) == 1:
+        print("Please run the script with '-h' for more information.")
+        sys.exit(1)
+
+    args = parse_arguments()
+
+    try:
+        if args.mode == "infer":
+            run_infer_script(
+                args.f0up_key,
+                args.filter_radius,
+                args.index_rate,
+                args.hop_length,
+                args.f0method,
+                args.input_path,
+                args.output_path,
+                args.pth_file,
+                args.index_path,
+                args.split_audio,
+            )
+        elif args.mode == "batch_infer":
+            run_batch_infer_script(
+                args.f0up_key,
+                args.filter_radius,
+                args.index_rate,
+                args.hop_length,
+                args.f0method,
+                args.input_folder,
+                args.output_folder,
+                args.pth_file,
+                args.index_path,
+            )
+        elif args.mode == "tts":
+            run_tts_script(
+                args.tts_text,
+                args.tts_voice,
+                args.f0up_key,
+                args.filter_radius,
+                args.index_rate,
+                args.hop_length,
+                args.f0method,
+                args.output_tts_path,
+                args.output_rvc_path,
+                args.pth_file,
+                args.index_path,
+            )
+        elif args.mode == "preprocess":
+            run_preprocess_script(
+                args.model_name,
+                args.dataset_path,
+                str(args.sampling_rate),
+            )
+
+        elif args.mode == "extract":
+            run_extract_script(
+                args.model_name,
+                args.rvc_version,
+                args.f0method,
+                args.hop_length,
+                args.sampling_rate,
+            )
+        elif args.mode == "train":
+            run_train_script(
+                args.model_name,
+                args.rvc_version,
+                args.save_every_epoch,
+                args.save_only_latest,
+                args.save_every_weights,
+                args.total_epoch,
+                args.sampling_rate,
+                args.batch_size,
+                args.gpu,
+                args.pitch_guidance,
+                args.pretrained,
+                args.custom_pretrained,
+                args.g_pretrained_path,
+                args.d_pretrained_path,
+            )
+        elif args.mode == "index":
+            run_index_script(
+                args.model_name,
+                args.rvc_version,
+            )
+        elif args.mode == "model_information":
+            run_model_information_script(
+                args.pth_path,
+            )
+        elif args.mode == "model_fusion":
+            run_model_fusion_script(
+                args.model_name,
+                args.pth_path_1,
+                args.pth_path_2,
+            )
+        elif args.mode == "tensorboard":
+            run_tensorboard_script()
+        elif args.mode == "download":
+            run_download_script(
+                args.model_link,
+            )
+    except Exception as error:
+        print(f"Error: {error}")
+
+
+if __name__ == "__main__":
+    main()

docker-compose.yaml

@@ -0,0 +1,16 @@
+version: '1'
+
+services:
+  applio:
+    build:
+      context: ./
+      dockerfile: Dockerfile
+    ports:
+      - "6969"
+    deploy:
+      resources:
+        reservations:
+          devices:
+            - driver: nvidia
+              count: 1
+              capabilities: [gpu]

requirements.txt

@@ -0,0 +1,35 @@
+# General dependencies
+ffmpeg-python>=0.2.0
+numpy==1.23.5
+requests
+tqdm
+wget
+
+# Audio processing
+faiss-cpu==1.7.3
+librosa==0.9.1
+pyworld==0.3.4
+scipy==1.11.1
+soundfile==0.12.1
+praat-parselmouth
+
+# Machine learning
+fairseq==0.12.2
+numba; sys_platform == 'linux'
+numba==0.56.4; sys_platform == 'win32'
+torch==2.1.1
+torchcrepe==0.0.21
+torchvision==0.16.1
+
+# Visualization
+matplotlib==3.7.2
+tensorboard
+gradio==4.14.0
+
+# Miscellaneous
+ffmpy==0.3.1
+git+https://github.com/lanpa/tensorboardX
+requests==2.31.0
+edge-tts==6.1.9
+pypresence
+beautifulsoup4

run-applio.bat

@@ -0,0 +1,12 @@
+@echo off
+setlocal
+title Applio
+
+if not exist env (
+    echo Please run 'run-install.bat' first to set up the environment.
+    pause
+    exit /b 1
+)
+
+env\python.exe app.py --open
+pause

run-applio.sh

@@ -0,0 +1,6 @@
+#!/bin/sh
+printf "\033]0;Applio\007"
+. .venv/bin/activate
+
+clear
+python app.py --open

run-install.bat

@@ -0,0 +1,73 @@
+@echo off
+setlocal
+title Installer
+
+set "principal=%cd%"
+set "URL_EXTRA=https://huggingface.co/IAHispano/applio/resolve/main"
+set "CONDA_ROOT_PREFIX=%UserProfile%\Miniconda3"
+set "INSTALL_ENV_DIR=%principal%\env"
+set "MINICONDA_DOWNLOAD_URL=https://repo.anaconda.com/miniconda/Miniconda3-py39_23.9.0-0-Windows-x86_64.exe"
+set "CONDA_EXECUTABLE=%CONDA_ROOT_PREFIX%\Scripts\conda.exe"
+
+del Makefile
+del Dockerfile
+del docker-compose.yaml
+del /q *.sh
+
+if not exist "%cd%\env.zip" (
+    echo Downloading the fairseq build...
+    curl -s -LJO %URL_EXTRA%/env.zip -o env.zip
+)
+
+if not exist "%cd%\env.zip" (
+    echo Download failed, trying with the powershell method
+    powershell -Command "& {Invoke-WebRequest -Uri '%URL_EXTRA%/env.zip' -OutFile 'mingit.zip'}"
+)
+
+if not exist "%cd%\env" (
+    echo Extracting the file...
+    powershell -command "& { Add-Type -AssemblyName System.IO.Compression.FileSystem ; [System.IO.Compression.ZipFile]::ExtractToDirectory('%cd%\env.zip', '%cd%') }"
+)
+
+if not exist "%cd%\env" (
+    echo Extracting failed trying with the tar method...
+    tar -xf %cd%\env.zip
+)
+
+if exist "%cd%\env" (
+    del env.zip
+) else (
+    echo Theres a problem extracting the file please download the file and extract it manually.
+    echo https://huggingface.co/IAHispano/applio/resolve/main/env.zip
+    pause
+    exit
+)
+
+if not exist "%CONDA_EXECUTABLE%" (
+    echo Downloading Miniconda from %MINICONDA_DOWNLOAD_URL%...
+    curl %MINICONDA_DOWNLOAD_URL% -o miniconda.exe
+
+    if not exist "%principal%\miniconda.exe" (
+        echo Download failed trying with the powershell method.
+        powershell -Command "& {Invoke-WebRequest -Uri '%MINICONDA_DOWNLOAD_URL%' -OutFile 'miniconda.exe'}"
+    )
+
+    echo Installing Miniconda to %CONDA_ROOT_PREFIX%...
+    start /wait "" miniconda.exe /InstallationType=JustMe /RegisterPython=0 /S /D=%CONDA_ROOT_PREFIX%
+    del miniconda.exe
+)
+
+call "%CONDA_ROOT_PREFIX%\_conda.exe" create --no-shortcuts -y -k --prefix "%INSTALL_ENV_DIR%" python=3.9
+
+echo Installing the dependencies...
+call "%CONDA_ROOT_PREFIX%\condabin\conda.bat" activate "%INSTALL_ENV_DIR%"
+pip install --upgrade setuptools
+pip install -r "%principal%\requirements.txt"
+pip uninstall torch torchvision torchaudio -y
+pip install torch==2.1.1 torchvision==0.16.1 torchaudio==2.1.1 --index-url https://download.pytorch.org/whl/cu121
+call "%CONDA_ROOT_PREFIX%\condabin\conda.bat" deactivate
+echo.
+
+echo Applio has been installed successfully, run 'run-applio.bat' to start it!
+pause
+cls

run-install.sh

@@ -0,0 +1,87 @@
+#!/bin/sh
+printf "\033]0;Installer\007"
+clear
+rm *.bat
+
+# Function to create or activate a virtual environment
+prepare_install() {
+    if [ -d ".venv" ]; then
+        echo "Venv found. This implies Applio has been already installed or this is a broken install"
+        printf "Do you want to execute run-applio.sh? (Y/N): " >&2
+        read -r r
+        r=$(echo "$r" | tr '[:upper:]' '[:lower:]')
+        if [ "$r" = "y" ]; then
+            ./run-applio.sh && exit 1
+        else
+            echo "Ok! The installation will continue. Good luck!"
+        fi
+        . .venv/bin/activate
+    else
+        echo "Creating venv..."
+        requirements_file="requirements.txt"
+        echo "Checking if python exists"
+        if command -v python3 > /dev/null 2>&1; then
+            py=$(which python3)
+            echo "Using python3"
+        else
+            if python --version | grep -q 3.; then
+                py=$(which python)
+                echo "Using python"
+            else
+                echo "Please install Python3 or 3.11 manually."
+                exit 1
+            fi
+        fi
+
+        $py -m venv .venv
+        . .venv/bin/activate
+        python -m ensurepip
+        # Update pip within the virtual environment
+        pip3 install --upgrade pip
+        echo
+        echo "Installing Applio dependencies..."
+        python -m pip install -r requirements.txt
+        python -m pip uninstall torch torchvision torchaudio -y
+        python -m pip install torch==2.0.0 torchvision==0.15.1 torchaudio==2.0.1 --index-url https://download.pytorch.org/whl/cu117
+        finish
+    fi
+}
+
+# Function to finish installation (this should install missing dependencies)
+finish() {
+    # Check if required packages are installed and install them if not
+    if [ -f "${requirements_file}" ]; then
+        installed_packages=$(python -m pip freeze)
+        while IFS= read -r package; do
+            expr "${package}" : "^#.*" > /dev/null && continue
+            package_name=$(echo "${package}" | sed 's/[<>=!].*//')
+            if ! echo "${installed_packages}" | grep -q "${package_name}"; then
+                echo "${package_name} not found. Attempting to install..."
+                python -m pip install --upgrade "${package}"
+            fi
+        done < "${requirements_file}"
+    else
+        echo "${requirements_file} not found. Please ensure the requirements file with required packages exists."
+        exit 1
+    fi
+    clear
+    echo "Applio has been successfully downloaded. Run the file run-applio.sh to run the web interface!"
+    exit 0
+}
+
+# Loop to the main menu
+if [ "$(uname)" = "Darwin" ]; then
+    if ! command -v brew >/dev/null 2>&1; then
+        /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
+    else
+        brew install python
+        export PYTORCH_ENABLE_MPS_FALLBACK=1
+        export PYTORCH_MPS_HIGH_WATERMARK_RATIO=0.0
+    fi
+elif [ "$(uname)" != "Linux" ]; then
+    echo "Unsupported operating system. Are you using Windows...?"
+    echo "If yes, use the batch (.bat) file instead of this one!"
+    exit 1
+fi
+
+prepare_install

run-tensorboard.bat

@@ -0,0 +1,6 @@
+@echo off
+setlocal
+title Tensorboard
+
+env\python.exe core.py tensorboard
+pause

run-tensorboard.sh

@@ -0,0 +1,6 @@
+#!/bin/sh
+printf "\033]0;Tensorboard\007"
+. .venv/bin/activate
+
+clear
+python core.py tensorboard