Upload 6 files

.gitignore

@@ -0,0 +1,12 @@
+*.exe
+*.pt
+*.onnx
+*pth
+*.pyc
+*.pth
+*.index
+*.wav
+
+logs
+env
+venv

app.py

@@ -0,0 +1,95 @@
+import gradio as gr
+import sys
+import os
+import logging
+
+now_dir = os.getcwd()
+sys.path.append(now_dir)
+
+# Tabs
+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 tabs.settings.presence import presence_tab, load_config_presence
+from tabs.settings.flask_server import flask_server_tab
+from tabs.settings.themes import theme_tab
+from tabs.plugins.plugins import plugins_tab
+from tabs.settings.version import version_tab
+from tabs.settings.lang import lang_tab
+from tabs.settings.restart import restart_tab
+
+# Assets
+import assets.themes.loadThemes as loadThemes
+from assets.i18n.i18n import I18nAuto
+import assets.installation_checker as installation_checker
+from assets.discord_presence import RPCManager
+from assets.flask.server import start_flask, load_config_flask
+
+i18n = I18nAuto()
+if load_config_presence() == True:
+    RPCManager.start_presence()
+installation_checker.check_installation()
+logging.getLogger("uvicorn").disabled = True
+logging.getLogger("fairseq").disabled = True
+if load_config_flask() == True:
+    print("Starting Flask server")
+    start_flask()
+
+my_applio = loadThemes.load_json()
+if my_applio:
+    pass
+else:
+    my_applio = "ParityError/Interstellar"
+
+with gr.Blocks(theme=my_applio, title="Applio & KanoyoTweaks") as Applio:
+    gr.Markdown("# Applio & KanoyoTweaks")
+    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("Plugins")):
+        plugins_tab()
+
+    with gr.Tab(i18n("Download")):
+        download_tab()
+
+    with gr.Tab(i18n("Report a Bug")):
+        report_tab()
+
+    with gr.Tab(i18n("Settings")):
+        presence_tab()
+        flask_server_tab()
+        theme_tab()
+        version_tab()
+        lang_tab()
+        restart_tab()
+
+
+if __name__ == "__main__":
+    Applio.launch(
+        favicon_path="assets/ICON.ico",
+        share="--share" in sys.argv,
+        inbrowser="--open" in sys.argv,
+        server_port=6969,
+    )

assets/i18n/i18n.py

@@ -0,0 +1,50 @@
+import os, sys
+import json
+from pathlib import Path
+from locale import getdefaultlocale
+
+now_dir = os.getcwd()
+sys.path.append(now_dir)
+
+
+class I18nAuto:
+    LANGUAGE_PATH = os.path.join(now_dir, "assets", "i18n", "languages")
+
+    def __init__(self, language=None):
+        with open(os.path.join(now_dir, "assets", "config.json"), "r") as f:
+            config = json.load(f)
+            override = config["lang"]["override"]
+            lang_prefix = config["lang"]["selected_lang"]
+
+        self.language = lang_prefix
+
+        if override == False:
+            language = 'ru_RU' or getdefaultlocale()[0]
+            lang_prefix = language[:2] if language is not None else "en"
+            available_languages = self._get_available_languages()
+            matching_languages = [
+                lang for lang in available_languages if lang.startswith(lang_prefix)
+            ]
+            self.language = matching_languages[0] if matching_languages else "en_US"
+
+        self.language_map = self._load_language_list()
+
+    def _load_language_list(self):
+        try:
+            file_path = Path(self.LANGUAGE_PATH) / f"{self.language}.json"
+            with open(file_path, "r", encoding="utf-8") as f:
+                return json.load(f)
+        except FileNotFoundError:
+            raise FileNotFoundError(
+                f"Failed to load language file for {self.language}. Check if the correct .json file exists."
+            )
+
+    def _get_available_languages(self):
+        language_files = [path.stem for path in Path(self.LANGUAGE_PATH).glob("*.json")]
+        return language_files
+
+    def _language_exists(self, language):
+        return (Path(self.LANGUAGE_PATH) / f"{language}.json").exists()
+
+    def __call__(self, key):
+        return self.language_map.get(key, key)

requirements.txt

@@ -0,0 +1,37 @@
+# Machine learning
+fairseq==0.12.2
+numba; sys_platform == 'linux'
+numba==0.56.4
+torch==2.1.1
+torchcrepe==0.0.21
+torchvision==0.16.1
+einops
+
+# General dependencies
+ffmpeg-python>=0.2.0
+numpy==1.23.5
+requests==2.31.0
+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
+
+# Visualization
+matplotlib==3.7.2
+tensorboard
+gradio==4.14.0
+
+# Miscellaneous
+ffmpy==0.3.1
+tensorboardX
+edge-tts==6.1.9
+pypresence
+beautifulsoup4
+flask
+local-attention

rvc/lib/tools/model_download.py

@@ -0,0 +1,342 @@
+import os
+import sys
+import wget
+import zipfile
+from bs4 import BeautifulSoup
+import requests
+from urllib.parse import unquote, urlencode, parse_qs, urlparse
+import re
+import shutil
+
+
+def find_folder_parent(search_dir, folder_name):
+    for dirpath, dirnames, _ in os.walk(search_dir):
+        if folder_name in dirnames:
+            return os.path.abspath(dirpath)
+    return None
+
+
+now_dir = os.getcwd()
+sys.path.append(now_dir)
+
+from rvc.lib.utils import format_title
+
+import rvc.lib.tools.gdown as gdown
+
+file_path = find_folder_parent(now_dir, "logs")
+
+zips_path = os.getcwd() + "/logs/zips"
+
+
+def search_pth_index(folder):
+    pth_paths = [
+        os.path.join(folder, file)
+        for file in os.listdir(folder)
+        if os.path.isfile(os.path.join(folder, file)) and file.endswith(".pth")
+    ]
+    index_paths = [
+        os.path.join(folder, file)
+        for file in os.listdir(folder)
+        if os.path.isfile(os.path.join(folder, file)) and file.endswith(".index")
+    ]
+
+    return pth_paths, index_paths
+
+
+def get_mediafire_download_link(url):
+    response = requests.get(url)
+    response.raise_for_status()
+    soup = BeautifulSoup(response.text, "html.parser")
+    download_button = soup.find(
+        "a", {"class": "input popsok", "aria-label": "Download file"}
+    )
+    if download_button:
+        download_link = download_button.get("href")
+        return download_link
+    else:
+        return None
+
+
+def download_from_url(url):
+    os.makedirs(zips_path, exist_ok=True)
+    if url != "":
+        if "drive.google.com" in url:
+            if "file/d/" in url:
+                file_id = url.split("file/d/")[1].split("/")[0]
+            elif "id=" in url:
+                file_id = url.split("id=")[1].split("&")[0]
+            else:
+                return None
+
+            if file_id:
+                os.chdir(zips_path)
+                try:
+                    gdown.download(
+                        f"https://drive.google.com/uc?id={file_id}",
+                        quiet=False,
+                        fuzzy=True,
+                    )
+                except Exception as error:
+                    error_message = str(error)
+                    if (
+                        "Too many users have viewed or downloaded this file recently"
+                        in error_message
+                    ):
+                        os.chdir(now_dir)
+                        return "too much use"
+                    elif (
+                        "Cannot retrieve the public link of the file." in error_message
+                    ):
+                        os.chdir(now_dir)
+                        return "private link"
+                    else:
+                        print(error_message)
+                        os.chdir(now_dir)
+                        return None
+
+        elif "disk.yandex.ru" in url:
+           base_url = 'https://cloud-api.yandex.net/v1/disk/public/resources/download?'
+           public_key = url  
+           final_url = base_url + urlencode(dict(public_key=public_key))
+           response = requests.get(final_url)
+           download_url = response.json()['href']
+           download_response = requests.get(download_url)
+
+           if download_response.status_code == 200:
+               filename = parse_qs(urlparse(unquote(download_url)).query).get('filename', [''])[0]
+               if filename: 
+                   os.chdir(zips_path)
+                   with open(filename, 'wb') as f:   
+                       f.write(download_response.content)
+           else:
+                print("Failed to get filename from URL.")
+                return None
+
+        elif "pixeldrain.com" in url:
+            try:
+                file_id = url.split("pixeldrain.com/u/")[1]
+                os.chdir(zips_path)
+                print(file_id)
+                response = requests.get(f"https://pixeldrain.com/api/file/{file_id}")
+                if response.status_code == 200:
+                    file_name = (
+                        response.headers.get("Content-Disposition")
+                        .split("filename=")[-1]
+                        .strip('";')
+                    )
+                    os.makedirs(zips_path, exist_ok=True)
+                    with open(os.path.join(zips_path, file_name), "wb") as newfile:
+                        newfile.write(response.content)
+                        os.chdir(file_path)
+                        return "downloaded"
+                else:
+                    os.chdir(file_path)
+                    return None
+            except Exception as e:
+                print(e)
+                os.chdir(file_path)
+                return None
+
+        elif "cdn.discordapp.com" in url:
+            file = requests.get(url)
+            os.chdir(zips_path)
+            if file.status_code == 200:
+                name = url.split("/")
+                with open(os.path.join(name[-1]), "wb") as newfile:
+                    newfile.write(file.content)
+            else:
+                return None
+
+        elif "/blob/" in url or "/resolve/" in url:
+            os.chdir(zips_path)
+            if "/blob/" in url:
+                url = url.replace("/blob/", "/resolve/")
+
+            response = requests.get(url, stream=True)
+            if response.status_code == 200:
+                file_name = url.split("/")[-1]
+                file_name = unquote(file_name)
+
+                file_name = re.sub(r"[^a-zA-Z0-9_.-]", "_", file_name)
+
+                total_size_in_bytes = int(response.headers.get("content-length", 0))
+                block_size = 1024
+                progress_bar_length = 50
+                progress = 0
+
+                with open(os.path.join(zips_path, file_name), "wb") as file:
+                    for data in response.iter_content(block_size):
+                        file.write(data)
+                        progress += len(data)
+                        progress_percent = int((progress / total_size_in_bytes) * 100)
+                        num_dots = int(
+                            (progress / total_size_in_bytes) * progress_bar_length
+                        )
+                        progress_bar = (
+                            "["
+                            + "." * num_dots
+                            + " " * (progress_bar_length - num_dots)
+                            + "]"
+                        )
+                        print(
+                            f"{progress_percent}% {progress_bar} {progress}/{total_size_in_bytes}  ",
+                            end="\r",
+                        )
+                        if progress_percent == 100:
+                            print("\n")
+
+            else:
+                os.chdir(now_dir)
+                return None
+        elif "/tree/main" in url:
+            os.chdir(zips_path)
+            response = requests.get(url)
+            soup = BeautifulSoup(response.content, "html.parser")
+            temp_url = ""
+            for link in soup.find_all("a", href=True):
+                if link["href"].endswith(".zip"):
+                    temp_url = link["href"]
+                    break
+            if temp_url:
+                url = temp_url
+                url = url.replace("blob", "resolve")
+                if "huggingface.co" not in url:
+                    url = "https://huggingface.co" + url
+
+                    wget.download(url)
+            else:
+                os.chdir(now_dir)
+                return None
+        else:
+            try:
+                os.chdir(zips_path)
+                wget.download(url)
+            except Exception as error:
+                os.chdir(now_dir)
+                print(error)
+                return None
+
+        for currentPath, _, zipFiles in os.walk(zips_path):
+            for Files in zipFiles:
+                filePart = Files.split(".")
+                extensionFile = filePart[len(filePart) - 1]
+                filePart.pop()
+                nameFile = "_".join(filePart)
+                realPath = os.path.join(currentPath, Files)
+                os.rename(realPath, nameFile + "." + extensionFile)
+
+        os.chdir(now_dir)
+        return "downloaded"
+
+    os.chdir(now_dir)
+    return None
+
+
+def extract_and_show_progress(zipfile_path, unzips_path):
+    try:
+        with zipfile.ZipFile(zipfile_path, "r") as zip_ref:
+            for file_info in zip_ref.infolist():
+                zip_ref.extract(file_info, unzips_path)
+        os.remove(zipfile_path)
+        return True
+    except Exception as error:
+        print(error)
+        return False
+
+
+def unzip_file(zip_path, zip_file_name):
+    zip_file_path = os.path.join(zip_path, zip_file_name + ".zip")
+    extract_path = os.path.join(file_path, zip_file_name)
+    with zipfile.ZipFile(zip_file_path, "r") as zip_ref:
+        zip_ref.extractall(extract_path)
+    os.remove(zip_file_path)
+
+
+url = sys.argv[1]
+
+if "?download=true" in url:
+    url = url.replace("?download=true", "")
+
+verify = download_from_url(url)
+
+if verify == "downloaded":
+    extract_folder_path = ""
+    for filename in os.listdir(zips_path):
+        if filename.endswith(".zip"):
+            zipfile_path = os.path.join(zips_path, filename)
+            print("Proceeding with the extraction...")
+
+            model_zip = os.path.basename(zipfile_path)
+            model_name = format_title(model_zip.split(".zip")[0])
+            extract_folder_path = os.path.join(
+                "logs",
+                os.path.normpath(model_name),
+            )
+
+            success = extract_and_show_progress(zipfile_path, extract_folder_path)
+
+            subfolders = [
+                f
+                for f in os.listdir(extract_folder_path)
+                if os.path.isdir(os.path.join(extract_folder_path, f))
+            ]
+            if len(subfolders) == 1:
+                subfolder_path = os.path.join(extract_folder_path, subfolders[0])
+                for item in os.listdir(subfolder_path):
+                    s = os.path.join(subfolder_path, item)
+                    d = os.path.join(extract_folder_path, item)
+                    shutil.move(s, d)
+                os.rmdir(subfolder_path)
+
+            for item in os.listdir(extract_folder_path):
+                if ".pth" in item:
+                    file_name = item.split(".pth")[0]
+                    if file_name != model_name:
+                        os.rename(
+                            os.path.join(extract_folder_path, item),
+                            os.path.join(extract_folder_path, model_name + ".pth"),
+                        )
+                else:
+                    if "v2" not in item:
+                        file_name = item.split("_nprobe_1_")[1].split("_v1")[0]
+                        if file_name != model_name:
+                            new_file_name = (
+                                item.split("_nprobe_1_")[0]
+                                + "_nprobe_1_"
+                                + model_name
+                                + "_v1"
+                            )
+                            os.rename(
+                                os.path.join(extract_folder_path, item),
+                                os.path.join(
+                                    extract_folder_path, new_file_name + ".index"
+                                ),
+                            )
+                    else:
+                        file_name = item.split("_nprobe_1_")[1].split("_v2")[0]
+                        if file_name != model_name:
+                            new_file_name = (
+                                item.split("_nprobe_1_")[0]
+                                + "_nprobe_1_"
+                                + model_name
+                                + "_v2"
+                            )
+                            os.rename(
+                                os.path.join(extract_folder_path, item),
+                                os.path.join(
+                                    extract_folder_path, new_file_name + ".index"
+                                ),
+                            )
+
+            if success:
+                print(f"Model {model_name} downloaded!")
+            else:
+                print(f"Error downloading {model_name}")
+                sys.exit()
+    if extract_folder_path == "":
+        print("Zip file was not found.")
+        sys.exit()
+    result = search_pth_index(extract_folder_path)
+else:
+    message = "Error"
+    sys.exit()

rvc/lib/tools/prerequisites_download.py

@@ -0,0 +1,54 @@
+import os
+import wget
+import sys
+
+url_base = "https://huggingface.co/kanoyo/0v2Super/resolve/main"
+models_download = [
+    (
+        "pretrained_v2/",
+        [
+            "f0D40k.pth",
+            "f0G40k.pth",
+        ],
+    ),
+]
+
+models_file = [
+    "hubert_base.pt",
+    "rmvpe.pt",
+    "fcpe.pt",
+    # "rmvpe.onnx"
+]
+
+executables_file = []
+
+folder_mapping = {
+    "pretrained_v2/": "rvc/pretraineds/pretrained_v2/",
+}
+
+for file_name in models_file:
+    destination_path = os.path.join(file_name)
+    url = f"{url_base}/{file_name}"
+    if not os.path.exists(destination_path):
+        os.makedirs(os.path.dirname(destination_path) or ".", exist_ok=True)
+        print(f"\nDownloading {url} to {destination_path}...")
+        wget.download(url, out=destination_path)
+
+for file_name in executables_file:
+    if sys.platform == "win32":
+        destination_path = os.path.join(file_name)
+        url = f"{url_base}/{file_name}"
+        if not os.path.exists(destination_path):
+            os.makedirs(os.path.dirname(destination_path) or ".", exist_ok=True)
+            print(f"\nDownloading {url} to {destination_path}...")
+            wget.download(url, out=destination_path)
+
+for remote_folder, file_list in models_download:
+    local_folder = folder_mapping.get(remote_folder, "")
+    for file in file_list:
+        destination_path = os.path.join(local_folder, file)
+        url = f"{url_base}/{remote_folder}{file}"
+        if not os.path.exists(destination_path):
+            os.makedirs(os.path.dirname(destination_path) or ".", exist_ok=True)
+            print(f"\nDownloading {url} to {destination_path}...")
+            wget.download(url, out=destination_path)