Upload 9 files

rvc/lib/tools/gdown.py

@@ -0,0 +1,402 @@
+from __future__ import print_function
+
+import json
+import os
+import os.path as osp
+import re
+import warnings
+from six.moves import urllib_parse
+import shutil
+import sys
+import tempfile
+import textwrap
+import time
+
+import requests
+import six
+import tqdm
+
+def indent(text, prefix):
+    def prefixed_lines():
+        for line in text.splitlines(True):
+            yield (prefix + line if line.strip() else line)
+
+    return "".join(prefixed_lines())
+
+class FileURLRetrievalError(Exception):
+    pass
+
+
+class FolderContentsMaximumLimitError(Exception):
+    pass
+
+def parse_url(url, warning=True):
+    """Parse URLs especially for Google Drive links.
+
+    file_id: ID of file on Google Drive.
+    is_download_link: Flag if it is download link of Google Drive.
+    """
+    parsed = urllib_parse.urlparse(url)
+    query = urllib_parse.parse_qs(parsed.query)
+    is_gdrive = parsed.hostname in ["drive.google.com", "docs.google.com"]
+    is_download_link = parsed.path.endswith("/uc")
+
+    if not is_gdrive:
+        return is_gdrive, is_download_link
+
+    file_id = None
+    if "id" in query:
+        file_ids = query["id"]
+        if len(file_ids) == 1:
+            file_id = file_ids[0]
+    else:
+        patterns = [
+            r"^/file/d/(.*?)/(edit|view)$",
+            r"^/file/u/[0-9]+/d/(.*?)/(edit|view)$",
+            r"^/document/d/(.*?)/(edit|htmlview|view)$",
+            r"^/document/u/[0-9]+/d/(.*?)/(edit|htmlview|view)$",
+            r"^/presentation/d/(.*?)/(edit|htmlview|view)$",
+            r"^/presentation/u/[0-9]+/d/(.*?)/(edit|htmlview|view)$",
+            r"^/spreadsheets/d/(.*?)/(edit|htmlview|view)$",
+            r"^/spreadsheets/u/[0-9]+/d/(.*?)/(edit|htmlview|view)$",
+        ]
+        for pattern in patterns:
+            match = re.match(pattern, parsed.path)
+            if match:
+                file_id = match.groups()[0]
+                break
+
+    if warning and not is_download_link:
+        warnings.warn(
+            "You specified a Google Drive link that is not the correct link "
+            "to download a file. You might want to try `--fuzzy` option "
+            "or the following url: {url}".format(
+                url="https://drive.google.com/uc?id={}".format(file_id)
+            )
+        )
+
+    return file_id, is_download_link
+
+
+CHUNK_SIZE = 512 * 1024  # 512KB
+home = osp.expanduser("~")
+
+
+def get_url_from_gdrive_confirmation(contents):
+    url = ""
+    m = re.search(r'href="(\/uc\?export=download[^"]+)', contents)
+    if m:
+        url = "https://docs.google.com" + m.groups()[0]
+        url = url.replace("&", "&")
+        return url
+
+    m = re.search(r'href="/open\?id=([^"]+)"', contents)
+    if m:
+        url = m.groups()[0]
+        uuid = re.search(r'<input\s+type="hidden"\s+name="uuid"\s+value="([^"]+)"', contents)
+        uuid = uuid.groups()[0]
+        url = "https://drive.usercontent.google.com/download?id=" + url + "&confirm=t&uuid=" + uuid
+        return url
+        
+
+    m = re.search(r'"downloadUrl":"([^"]+)', contents)
+    if m:
+        url = m.groups()[0]
+        url = url.replace("\\u003d", "=")
+        url = url.replace("\\u0026", "&")
+        return url
+
+    m = re.search(r'<p class="uc-error-subcaption">(.*)</p>', contents)
+    if m:
+        error = m.groups()[0]
+        raise FileURLRetrievalError(error)
+
+    raise FileURLRetrievalError(
+        "Cannot retrieve the public link of the file. "
+        "You may need to change the permission to "
+        "'Anyone with the link', or have had many accesses."
+    )
+def _get_session(proxy, use_cookies, return_cookies_file=False):
+    sess = requests.session()
+
+    sess.headers.update(
+        {"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6)"}
+    )
+
+    if proxy is not None:
+        sess.proxies = {"http": proxy, "https": proxy}
+        print("Using proxy:", proxy, file=sys.stderr)
+
+    # Load cookies if exists
+    cookies_file = osp.join(home, ".cache/gdown/cookies.json")
+    if osp.exists(cookies_file) and use_cookies:
+        with open(cookies_file) as f:
+            cookies = json.load(f)
+        for k, v in cookies:
+            sess.cookies[k] = v
+
+    if return_cookies_file:
+        return sess, cookies_file
+    else:
+        return sess
+
+
+def download(
+    url=None,
+    output=None,
+    quiet=False,
+    proxy=None,
+    speed=None,
+    use_cookies=True,
+    verify=True,
+    id=None,
+    fuzzy=True,
+    resume=False,
+    format=None,
+):
+    """Download file from URL.
+
+    Parameters
+    ----------
+    url: str
+        URL. Google Drive URL is also supported.
+    output: str
+        Output filename. Default is basename of URL.
+    quiet: bool
+        Suppress terminal output. Default is False.
+    proxy: str
+        Proxy.
+    speed: float
+        Download byte size per second (e.g., 256KB/s = 256 * 1024).
+    use_cookies: bool
+        Flag to use cookies. Default is True.
+    verify: bool or string
+        Either a bool, in which case it controls whether the server's TLS
+        certificate is verified, or a string, in which case it must be a path
+        to a CA bundle to use. Default is True.
+    id: str
+        Google Drive's file ID.
+    fuzzy: bool
+        Fuzzy extraction of Google Drive's file Id. Default is False.
+    resume: bool
+        Resume the download from existing tmp file if possible.
+        Default is False.
+    format: str, optional
+        Format of Google Docs, Spreadsheets and Slides. Default is:
+            - Google Docs: 'docx'
+            - Google Spreadsheet: 'xlsx'
+            - Google Slides: 'pptx'
+
+    Returns
+    -------
+    output: str
+        Output filename.
+    """
+    if not (id is None) ^ (url is None):
+        raise ValueError("Either url or id has to be specified")
+    if id is not None:
+        url = "https://drive.google.com/uc?id={id}".format(id=id)
+
+    url_origin = url
+
+    sess, cookies_file = _get_session(
+        proxy=proxy, use_cookies=use_cookies, return_cookies_file=True
+    )
+
+    gdrive_file_id, is_gdrive_download_link = parse_url(url, warning=not fuzzy)
+
+    if fuzzy and gdrive_file_id:
+        # overwrite the url with fuzzy match of a file id
+        url = "https://drive.google.com/uc?id={id}".format(id=gdrive_file_id)
+        url_origin = url
+        is_gdrive_download_link = True
+
+
+
+    while True:
+        res = sess.get(url, stream=True, verify=verify)
+
+        if url == url_origin and res.status_code == 500:
+            # The file could be Google Docs or Spreadsheets.
+            url = "https://drive.google.com/open?id={id}".format(
+                id=gdrive_file_id
+            )
+            continue
+
+        if res.headers["Content-Type"].startswith("text/html"):
+            m = re.search("<title>(.+)</title>", res.text)
+            if m and m.groups()[0].endswith(" - Google Docs"):
+                url = (
+                    "https://docs.google.com/document/d/{id}/export"
+                    "?format={format}".format(
+                        id=gdrive_file_id,
+                        format="docx" if format is None else format,
+                    )
+                )
+                continue
+            elif m and m.groups()[0].endswith(" - Google Sheets"):
+                url = (
+                    "https://docs.google.com/spreadsheets/d/{id}/export"
+                    "?format={format}".format(
+                        id=gdrive_file_id,
+                        format="xlsx" if format is None else format,
+                    )
+                )
+                continue
+            elif m and m.groups()[0].endswith(" - Google Slides"):
+                url = (
+                    "https://docs.google.com/presentation/d/{id}/export"
+                    "?format={format}".format(
+                        id=gdrive_file_id,
+                        format="pptx" if format is None else format,
+                    )
+                )
+                continue
+        elif (
+            "Content-Disposition" in res.headers
+            and res.headers["Content-Disposition"].endswith("pptx")
+            and format not in {None, "pptx"}
+        ):
+            url = (
+                "https://docs.google.com/presentation/d/{id}/export"
+                "?format={format}".format(
+                    id=gdrive_file_id,
+                    format="pptx" if format is None else format,
+                )
+            )
+            continue
+
+        if use_cookies:
+            if not osp.exists(osp.dirname(cookies_file)):
+                os.makedirs(osp.dirname(cookies_file))
+            # Save cookies
+            with open(cookies_file, "w") as f:
+                cookies = [
+                    (k, v)
+                    for k, v in sess.cookies.items()
+                    if not k.startswith("download_warning_")
+                ]
+                json.dump(cookies, f, indent=2)
+
+        if "Content-Disposition" in res.headers:
+            # This is the file
+            break
+        if not (gdrive_file_id and is_gdrive_download_link):
+            break
+
+        # Need to redirect with confirmation
+        try:
+            url = get_url_from_gdrive_confirmation(res.text)
+        except FileURLRetrievalError as e:
+            message = (
+                "Failed to retrieve file url:\n\n{}\n\n"
+                "You may still be able to access the file from the browser:"
+                "\n\n\t{}\n\n"
+                "but Gdown can't. Please check connections and permissions."
+            ).format(
+                indent("\n".join(textwrap.wrap(str(e))), prefix="\t"),
+                url_origin,
+            )
+            raise FileURLRetrievalError(message)
+
+    if gdrive_file_id and is_gdrive_download_link:
+        content_disposition = six.moves.urllib_parse.unquote(
+            res.headers["Content-Disposition"]
+        )
+
+        m = re.search(r"filename\*=UTF-8''(.*)", content_disposition)
+        if not m:
+            m = re.search(r'filename=["\']?(.*?)["\']?$', content_disposition)
+        filename_from_url = m.groups()[0]
+        filename_from_url = filename_from_url.replace(osp.sep, "_")
+    else:
+        filename_from_url = osp.basename(url)
+
+    if output is None:
+        output = filename_from_url
+
+    output_is_path = isinstance(output, six.string_types)
+    if output_is_path and output.endswith(osp.sep):
+        if not osp.exists(output):
+            os.makedirs(output)
+        output = osp.join(output, filename_from_url)
+
+    if output_is_path:
+        existing_tmp_files = []
+        for file in os.listdir(osp.dirname(output) or "."):
+            if file.startswith(osp.basename(output)):
+                existing_tmp_files.append(osp.join(osp.dirname(output), file))
+        if resume and existing_tmp_files:
+            if len(existing_tmp_files) != 1:
+                print(
+                    "There are multiple temporary files to resume:",
+                    file=sys.stderr,
+                )
+                print("\n")
+                for file in existing_tmp_files:
+                    print("\t", file, file=sys.stderr)
+                print("\n")
+                print(
+                    "Please remove them except one to resume downloading.",
+                    file=sys.stderr,
+                )
+                return
+            tmp_file = existing_tmp_files[0]
+        else:
+            resume = False
+            # mkstemp is preferred, but does not work on Windows
+            # https://github.com/wkentaro/gdown/issues/153
+            tmp_file = tempfile.mktemp(
+                suffix=tempfile.template,
+                prefix=osp.basename(output),
+                dir=osp.dirname(output),
+            )
+        f = open(tmp_file, "ab")
+    else:
+        tmp_file = None
+        f = output
+
+    if tmp_file is not None and f.tell() != 0:
+        headers = {"Range": "bytes={}-".format(f.tell())}
+        res = sess.get(url, headers=headers, stream=True, verify=verify)
+
+    if not quiet:
+        # print("Downloading...", file=sys.stderr)
+        if resume:
+            print("Resume:", tmp_file, file=sys.stderr)
+        # if url_origin != url:
+        #     print("From (original):", url_origin, file=sys.stderr)
+        #     print("From (redirected):", url, file=sys.stderr)
+        # else:
+        #     print("From:", url, file=sys.stderr)
+        print(
+            "To:",
+            osp.abspath(output) if output_is_path else output,
+            file=sys.stderr,
+        )
+
+    try:
+        total = res.headers.get("Content-Length")
+        if total is not None:
+            total = int(total)
+        if not quiet:
+            pbar = tqdm.tqdm(total=total, unit="B", unit_scale=True)
+        t_start = time.time()
+        for chunk in res.iter_content(chunk_size=CHUNK_SIZE):
+            f.write(chunk)
+            if not quiet:
+                pbar.update(len(chunk))
+            if speed is not None:
+                elapsed_time_expected = 1.0 * pbar.n / speed
+                elapsed_time = time.time() - t_start
+                if elapsed_time < elapsed_time_expected:
+                    time.sleep(elapsed_time_expected - elapsed_time)
+        if not quiet:
+            pbar.close()
+        if tmp_file:
+            f.close()
+            shutil.move(tmp_file, output)
+    finally:
+        sess.close()
+
+    return output

rvc/lib/tools/launch_tensorboard.py

@@ -0,0 +1,15 @@
+import time
+from tensorboard import program
+
+log_path = "logs"
+
+if __name__ == "__main__":
+    tb = program.TensorBoard()
+    tb.configure(argv=[None, "--logdir", log_path])
+    url = tb.launch()
+    print(
+        f"Access the tensorboard using the following link:\n{url}?pinnedCards=%5B%7B%22plugin%22%3A%22scalars%22%2C%22tag%22%3A%22loss%2Fg%2Ftotal%22%7D%2C%7B%22plugin%22%3A%22scalars%22%2C%22tag%22%3A%22loss%2Fd%2Ftotal%22%7D%2C%7B%22plugin%22%3A%22scalars%22%2C%22tag%22%3A%22loss%2Fg%2Fkl%22%7D%2C%7B%22plugin%22%3A%22scalars%22%2C%22tag%22%3A%22loss%2Fg%2Fmel%22%7D%5D"
+    )
+
+    while True:
+        time.sleep(600)

rvc/lib/tools/model_download.py

@@ -0,0 +1,225 @@
+import os
+import sys
+import wget
+import zipfile
+from bs4 import BeautifulSoup
+import requests
+from urllib.parse import unquote
+import re
+
+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)
+
+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 "/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]
+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_name = os.path.basename(zipfile_path)
+            extract_folder_path = os.path.join(
+                "logs",
+                os.path.normpath(str(model_name).replace(".zip", "")),
+            )
+
+            success = extract_and_show_progress(zipfile_path, extract_folder_path)
+            if success:
+                print(f"Model {model_name} downloaded!")
+            else:
+                print(f"Error downloading {model_name}")
+                sys.exit()
+    if extract_folder_path == "":
+        print("No zip founded...")
+        sys.exit()
+    result = search_pth_index(extract_folder_path)
+else:
+    message = "Error"
+    sys.exit()

rvc/lib/tools/prerequisites_download.py

@@ -0,0 +1,84 @@
+import os
+import wget
+import sys
+
+url_base = "https://huggingface.co/lj1995/VoiceConversionWebUI/resolve/main"
+models_download = [
+    (
+        "pretrained/",
+        [
+            "D32k.pth",
+            "D40k.pth",
+            "D48k.pth",
+            "G32k.pth",
+            "G40k.pth",
+            "G48k.pth",
+            "f0D32k.pth",
+            "f0D40k.pth",
+            "f0D48k.pth",
+            "f0G32k.pth",
+            "f0G40k.pth",
+            "f0G48k.pth",
+        ],
+    ),
+    (
+        "pretrained_v2/",
+        [
+            "D32k.pth",
+            "D40k.pth",
+            "D48k.pth",
+            "G32k.pth",
+            "G40k.pth",
+            "G48k.pth",
+            "f0D32k.pth",
+            "f0D40k.pth",
+            "f0D48k.pth",
+            "f0G32k.pth",
+            "f0G40k.pth",
+            "f0G48k.pth",
+        ],
+    ),
+]
+
+models_file = [
+    "hubert_base.pt",
+    "rmvpe.pt",
+    # "rmvpe.onnx",
+]
+
+executables_file = [
+    "ffmpeg.exe",
+    "ffprobe.exe",
+]
+
+folder_mapping = {
+    "pretrained/": "rvc/pretraineds/pretrained_v1/",
+    "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)

rvc/lib/tools/pretrained_selector.py

@@ -0,0 +1,63 @@
+def pretrained_selector(pitch_guidance):
+    if pitch_guidance:
+        return {
+            "v1": {
+                "32000": (
+                    "rvc/pretraineds/pretrained_v1/f0G32k.pth",
+                    "rvc/pretraineds/pretrained_v1/f0D32k.pth",
+                ),
+                "40000": (
+                    "rvc/pretraineds/pretrained_v1/f0G40k.pth",
+                    "rvc/pretraineds/pretrained_v1/f0D40k.pth",
+                ),
+                "48000": (
+                    "rvc/pretraineds/pretrained_v1/f0G48k.pth",
+                    "rvc/pretraineds/pretrained_v1/f0D48k.pth",
+                ),
+            },
+            "v2": {
+                "32000": (
+                    "rvc/pretraineds/pretrained_v2/f0G32k.pth",
+                    "rvc/pretraineds/pretrained_v2/f0D32k.pth",
+                ),
+                "40000": (
+                    "rvc/pretraineds/pretrained_v2/f0G40k.pth",
+                    "rvc/pretraineds/pretrained_v2/f0D40k.pth",
+                ),
+                "48000": (
+                    "rvc/pretraineds/pretrained_v2/f0G48k.pth",
+                    "rvc/pretraineds/pretrained_v2/f0D48k.pth",
+                ),
+            },
+        }
+    else:
+        return {
+            "v1": {
+                "32000": (
+                    "rvc/pretraineds/pretrained_v1/G32k.pth",
+                    "rvc/pretraineds/pretrained_v1/D32k.pth",
+                ),
+                "40000": (
+                    "rvc/pretraineds/pretrained_v1/G40k.pth",
+                    "rvc/pretraineds/pretrained_v1/D40k.pth",
+                ),
+                "48000": (
+                    "rvc/pretraineds/pretrained_v1/G48k.pth",
+                    "rvc/pretraineds/pretrained_v1/D48k.pth",
+                ),
+            },
+            "v2": {
+                "32000": (
+                    "rvc/pretraineds/pretrained_v2/G32k.pth",
+                    "rvc/pretraineds/pretrained_v2/D32k.pth",
+                ),
+                "40000": (
+                    "rvc/pretraineds/pretrained_v2/G40k.pth",
+                    "rvc/pretraineds/pretrained_v2/D40k.pth",
+                ),
+                "48000": (
+                    "rvc/pretraineds/pretrained_v2/G48k.pth",
+                    "rvc/pretraineds/pretrained_v2/D48k.pth",
+                ),
+            },
+        }

rvc/lib/tools/split_audio.py

@@ -0,0 +1,113 @@
+from pydub.silence import detect_nonsilent
+from pydub import AudioSegment
+import numpy as np
+import re
+import os
+import unicodedata
+
+def format_title(title):
+    formatted_title = unicodedata.normalize('NFKD', title).encode('ascii', 'ignore').decode('utf-8')
+    formatted_title = re.sub(r'[\u2500-\u257F]+', '', title)
+    formatted_title = re.sub(r'[^\w\s-]', '', title)
+    formatted_title = re.sub(r'\s+', '_', formatted_title)
+    return formatted_title
+
+
+def process_audio(file_path):
+    try:
+        # load audio file
+        song = AudioSegment.from_file(file_path)
+
+        print(f"Ignore the warning if you saw any...")
+
+        # set silence threshold and duration
+        silence_thresh = -70  # dB
+        min_silence_len = 750  # ms, adjust as needed
+
+        # detect nonsilent parts
+        nonsilent_parts = detect_nonsilent(song, min_silence_len=min_silence_len, silence_thresh=silence_thresh)
+
+        # Create a new directory to store chunks
+        file_dir = os.path.dirname(file_path)
+        file_name = os.path.basename(file_path).split('.')[0]
+        file_name = format_title(file_name)
+        new_dir_path = os.path.join(file_dir, file_name)
+        os.makedirs(new_dir_path, exist_ok=True)
+
+        # Check if timestamps file exists, if so delete it
+        timestamps_file = os.path.join(file_dir, f"{file_name}_timestamps.txt")
+        if os.path.isfile(timestamps_file):
+            os.remove(timestamps_file)
+
+        # export chunks and save start times
+        segment_count = 0
+        for i, (start_i, end_i) in enumerate(nonsilent_parts):
+            chunk = song[start_i:end_i]
+            chunk_file_path = os.path.join(new_dir_path, f"chunk{i}.wav")
+            chunk.export(chunk_file_path, format="wav")
+
+            print(f"Segment {i} created!")
+            segment_count += 1
+
+            # write start times to file
+            with open(timestamps_file, "a", encoding="utf-8") as f:
+                f.write(f"{chunk_file_path} starts at {start_i} ms\n")
+
+        print(f"Total segments created: {segment_count}")
+        print(f"Split all chunks for {file_path} successfully!")
+
+        return "Finish", new_dir_path
+
+    except Exception as e:
+        print(f"An error occurred: {e}")
+        return "Error", None
+
+
+def merge_audio(timestamps_file):
+    try:
+        # Extract prefix from the timestamps filename
+        prefix = os.path.basename(timestamps_file).replace('_timestamps.txt', '')
+        timestamps_dir = os.path.dirname(timestamps_file)
+
+        # Open the timestamps file
+        with open(timestamps_file, "r", encoding="utf-8") as f:
+            lines = f.readlines()
+
+        # Initialize empty list to hold audio segments
+        audio_segments = []
+        last_end_time = 0
+
+        print(f"Processing file: {timestamps_file}")
+
+        for line in lines:
+            # Extract filename and start time from line
+            match = re.search(r"(chunk\d+.wav) starts at (\d+) ms", line)
+            if match:
+                filename, start_time = match.groups()
+                start_time = int(start_time)
+
+                # Construct the complete path to the chunk file
+                chunk_file = os.path.join(timestamps_dir, prefix, filename)
+
+                # Add silence from last_end_time to start_time
+                silence_duration = max(start_time - last_end_time, 0)
+                silence = AudioSegment.silent(duration=silence_duration)
+                audio_segments.append(silence)
+
+                # Load audio file and append to list
+                audio = AudioSegment.from_wav(chunk_file)
+                audio_segments.append(audio)
+
+                # Update last_end_time
+                last_end_time = start_time + len(audio)
+
+                print(f"Processed chunk: {chunk_file}")
+
+        # Concatenate all audio_segments and export
+        merged_audio = sum(audio_segments)
+        merged_audio_np = np.array(merged_audio.get_array_of_samples())
+        #print(f"Exported merged file: {merged_filename}\n")
+        return merged_audio.frame_rate, merged_audio_np
+
+    except Exception as e:
+        print(f"An error occurred: {e}")

rvc/lib/tools/tts.py

@@ -0,0 +1,16 @@
+import sys
+import asyncio
+import edge_tts
+
+
+async def main():
+    text = sys.argv[1]
+    voice = sys.argv[2]
+    output_file = sys.argv[3]
+
+    await edge_tts.Communicate(text, voice).save(output_file)
+    print(f"TTS with {voice} completed. Output TTS file: '{output_file}'")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

rvc/lib/tools/validators.py

@@ -0,0 +1,67 @@
+import argparse
+import os 
+import json
+
+
+def validate_sampling_rate(value):
+    valid_sampling = [
+        "32000",
+        "40000",
+        "48000",
+    ]
+    if value in valid_sampling:
+        return value
+    else:
+        raise argparse.ArgumentTypeError(
+            f"Invalid sampling_rate. Please choose from {valid_sampling} not {value}"
+        )
+
+
+def validate_f0up_key(value):
+    f0up_key = int(value)
+    if -12 <= f0up_key <= 12:
+        return f0up_key
+    else:
+        raise argparse.ArgumentTypeError(f"f0up_key must be in the range of -12 to +12")
+
+def validate_true_false(value):
+    valid_tf = [
+        "True",
+        "False",
+    ]
+    if value in valid_tf:
+        return value
+    else:
+        raise argparse.ArgumentTypeError(
+            f"Invalid true_false. Please choose from {valid_tf} not {value}"
+        )
+
+def validate_f0method(value):
+    valid_f0methods = [
+        "pm",
+        "dio",
+        "crepe",
+        "crepe-tiny",
+        "harvest",
+        "rmvpe",
+    ]
+    if value in valid_f0methods:
+        return value
+    else:
+        raise argparse.ArgumentTypeError(
+            f"Invalid f0method. Please choose from {valid_f0methods} not {value}"
+        )
+
+def validate_tts_voices(value):
+    json_path = os.path.join("rvc", "lib", "tools", "tts_voices.json")
+    with open(json_path, 'r') as file:
+        tts_voices_data = json.load(file)
+
+    # Extrae los valores de "ShortName" del JSON
+    short_names = [voice.get("ShortName", "") for voice in tts_voices_data]
+    if value in short_names:
+        return value
+    else:
+        raise argparse.ArgumentTypeError(
+            f"Invalid voice. Please choose from {short_names} not {value}"
+        )