Upload 8 files

analyzer.py

@@ -0,0 +1,76 @@
+import numpy as np
+import matplotlib.pyplot as plt
+import librosa.display
+import librosa
+
+
+def calculate_features(y, sr):
+    stft = np.abs(librosa.stft(y))
+    duration = librosa.get_duration(y=y, sr=sr)
+    cent = librosa.feature.spectral_centroid(S=stft, sr=sr)[0]
+    bw = librosa.feature.spectral_bandwidth(S=stft, sr=sr)[0]
+    rolloff = librosa.feature.spectral_rolloff(S=stft, sr=sr)[0]
+    return stft, duration, cent, bw, rolloff
+
+
+def plot_title(title):
+    plt.suptitle(title, fontsize=16, fontweight="bold")
+
+
+def plot_spectrogram(y, sr, stft, duration, cmap="inferno"):
+    plt.subplot(3, 1, 1)
+    plt.imshow(
+        librosa.amplitude_to_db(stft, ref=np.max),
+        origin="lower",
+        extent=[0, duration, 0, sr / 1000],
+        aspect="auto",
+        cmap=cmap,  # Change the colormap here
+    )
+    plt.colorbar(format="%+2.0f dB")
+    plt.xlabel("Time (s)")
+    plt.ylabel("Frequency (kHz)")
+    plt.title("Spectrogram")
+
+
+def plot_waveform(y, sr, duration):
+    plt.subplot(3, 1, 2)
+    librosa.display.waveshow(y, sr=sr)
+    plt.xlabel("Time (s)")
+    plt.ylabel("Amplitude")
+    plt.title("Waveform")
+
+
+def plot_features(times, cent, bw, rolloff, duration):
+    plt.subplot(3, 1, 3)
+    plt.plot(times, cent, label="Spectral Centroid (kHz)", color="b")
+    plt.plot(times, bw, label="Spectral Bandwidth (kHz)", color="g")
+    plt.plot(times, rolloff, label="Spectral Rolloff (kHz)", color="r")
+    plt.xlabel("Time (s)")
+    plt.title("Spectral Features")
+    plt.legend()
+
+
+def analyze_audio(audio_file, save_plot_path="logs/audio_analysis.png"):
+    y, sr = librosa.load(audio_file)
+    stft, duration, cent, bw, rolloff = calculate_features(y, sr)
+
+    plt.figure(figsize=(12, 10))
+
+    plot_title("Audio Analysis" + " - " + audio_file.split("/")[-1])
+    plot_spectrogram(y, sr, stft, duration)
+    plot_waveform(y, sr, duration)
+    plot_features(librosa.times_like(cent), cent, bw, rolloff, duration)
+
+    plt.tight_layout()
+
+    if save_plot_path:
+        plt.savefig(save_plot_path, bbox_inches="tight", dpi=300)
+    plt.close()
+
+    audio_info = f"""Sample Rate: {sr}\nDuration: {(
+            str(round(duration, 2)) + " seconds"
+            if duration < 60
+            else str(round(duration / 60, 2)) + " minutes"
+    )}\nNumber of Samples: {len(y)}\nBits per Sample: {librosa.get_samplerate(audio_file)}\nChannels: {"Mono (1)" if y.ndim == 1 else "Stereo (2)"}"""
+
+    return audio_info, save_plot_path

gdown.py

@@ -0,0 +1,354 @@
+import os
+import re
+import six
+import sys
+import json
+import tqdm
+import time
+import shutil
+import warnings
+import tempfile
+import textwrap
+import requests
+from six.moves import urllib_parse
+
+
+def indent(text, prefix):
+    """Indent each non-empty line of text with the given prefix."""
+    return "".join(
+        (prefix + line if line.strip() else line) for line in text.splitlines(True)
+    )
+
+
+class FileURLRetrievalError(Exception):
+    pass
+
+
+class FolderContentsMaximumLimitError(Exception):
+    pass
+
+
+def parse_url(url, warning=True):
+    """Parse URLs especially for Google Drive links.
+
+    Args:
+        url: URL to parse.
+        warning: Whether to warn if the URL is not a download link.
+
+    Returns:
+        A tuple (file_id, is_download_link), where file_id is the ID of the
+        file on Google Drive, and is_download_link is a flag indicating
+        whether the URL is a download link.
+    """
+    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 None, is_download_link
+
+    file_id = query.get("id", [None])[0]
+    if file_id is None:
+        for pattern in (
+            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)$",
+        ):
+            match = re.match(pattern, parsed.path)
+            if match:
+                file_id = match.group(1)
+                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 "
+            f"or the following url: https://drive.google.com/uc?id={file_id}"
+        )
+
+    return file_id, is_download_link
+
+
+CHUNK_SIZE = 512 * 1024  # 512KB
+HOME = os.path.expanduser("~")
+
+
+def get_url_from_gdrive_confirmation(contents):
+    """Extract the download URL from a Google Drive confirmation page."""
+    for pattern in (
+        r'href="(\/uc\?export=download[^"]+)',
+        r'href="/open\?id=([^"]+)"',
+        r'"downloadUrl":"([^"]+)',
+    ):
+        match = re.search(pattern, contents)
+        if match:
+            url = match.group(1)
+            if pattern == r'href="/open\?id=([^"]+)"':
+                uuid = re.search(
+                    r'<input\s+type="hidden"\s+name="uuid"\s+value="([^"]+)"',
+                    contents,
+                ).group(1)
+                url = (
+                    "https://drive.usercontent.google.com/download?id="
+                    + url
+                    + "&confirm=t&uuid="
+                    + uuid
+                )
+            elif pattern == r'"downloadUrl":"([^"]+)':
+                url = url.replace("\\u003d", "=").replace("\\u0026", "&")
+            else:
+                url = "https://docs.google.com" + url.replace("&", "&")
+            return url
+
+    match = re.search(r'<p class="uc-error-subcaption">(.*)</p>', contents)
+    if match:
+        error = match.group(1)
+        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):
+    """Create a requests session with optional proxy and cookie handling."""
+    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)
+
+    cookies_file = os.path.join(HOME, ".cache/gdown/cookies.json")
+    if os.path.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
+
+    return (sess, cookies_file) if return_cookies_file else 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 = f"https://drive.google.com/uc?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 = f"https://drive.google.com/uc?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 = f"https://drive.google.com/open?id={gdrive_file_id}"
+            continue
+
+        if res.headers["Content-Type"].startswith("text/html"):
+            title = re.search("<title>(.+)</title>", res.text)
+            if title:
+                title = title.group(1)
+                if title.endswith(" - Google Docs"):
+                    url = f"https://docs.google.com/document/d/{gdrive_file_id}/export?format={'docx' if format is None else format}"
+                    continue
+                if title.endswith(" - Google Sheets"):
+                    url = f"https://docs.google.com/spreadsheets/d/{gdrive_file_id}/export?format={'xlsx' if format is None else format}"
+                    continue
+                if title.endswith(" - Google Slides"):
+                    url = f"https://docs.google.com/presentation/d/{gdrive_file_id}/export?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 = f"https://docs.google.com/presentation/d/{gdrive_file_id}/export?format={'pptx' if format is None else format}"
+            continue
+
+        if use_cookies:
+            os.makedirs(os.path.dirname(cookies_file), exist_ok=True)
+            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:"
+                f"\n\n\t{url_origin}\n\n"
+                "but Gdown can't. Please check connections and permissions."
+            ).format(indent("\n".join(textwrap.wrap(str(e))), prefix="\t"))
+            raise FileURLRetrievalError(message)
+
+    if gdrive_file_id and is_gdrive_download_link:
+        content_disposition = urllib_parse.unquote(res.headers["Content-Disposition"])
+        filename_from_url = (
+            re.search(r"filename\*=UTF-8''(.*)", content_disposition)
+            or re.search(r'filename=["\']?(.*?)["\']?$', content_disposition)
+        ).group(1)
+        filename_from_url = filename_from_url.replace(os.path.sep, "_")
+    else:
+        filename_from_url = os.path.basename(url)
+
+    output = output or filename_from_url
+
+    output_is_path = isinstance(output, six.string_types)
+    if output_is_path and output.endswith(os.path.sep):
+        os.makedirs(output, exist_ok=True)
+        output = os.path.join(output, filename_from_url)
+
+    if output_is_path:
+        temp_dir = os.path.dirname(output) or "."
+        prefix = os.path.basename(output)
+        existing_tmp_files = [
+            os.path.join(temp_dir, file)
+            for file in os.listdir(temp_dir)
+            if file.startswith(prefix)
+        ]
+        if resume and existing_tmp_files:
+            if len(existing_tmp_files) > 1:
+                print(
+                    "There are multiple temporary files to resume:",
+                    file=sys.stderr,
+                )
+                for file in existing_tmp_files:
+                    print(f"\t{file}", file=sys.stderr)
+                print(
+                    "Please remove them except one to resume downloading.",
+                    file=sys.stderr,
+                )
+                return
+            tmp_file = existing_tmp_files[0]
+        else:
+            resume = False
+            tmp_file = tempfile.mktemp(
+                suffix=tempfile.template, prefix=prefix, dir=temp_dir
+            )
+        f = open(tmp_file, "ab")
+    else:
+        tmp_file = None
+        f = output
+
+    if tmp_file is not None and f.tell() != 0:
+        headers = {"Range": f"bytes={f.tell()}-"}
+        res = sess.get(url, headers=headers, stream=True, verify=verify)
+
+    if not quiet:
+        if resume:
+            print("Resume:", tmp_file, file=sys.stderr)
+        print(
+            "To:",
+            os.path.abspath(output) if output_is_path else output,
+            file=sys.stderr,
+        )
+
+    try:
+        total = int(res.headers.get("Content-Length", 0))
+        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

launch_tensorboard.py

@@ -0,0 +1,21 @@
+import time
+import logging
+from tensorboard import program
+
+log_path = "logs"
+
+
+def launch_tensorboard_pipeline():
+    logging.getLogger("root").setLevel(logging.WARNING)
+    logging.getLogger("tensorboard").setLevel(logging.WARNING)
+
+    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)

model_download.py

@@ -0,0 +1,385 @@
+import os
+import re
+import six
+import sys
+import wget
+import shutil
+import zipfile
+import requests
+from bs4 import BeautifulSoup
+from urllib.parse import unquote, urlencode, parse_qs, urlparse
+
+now_dir = os.getcwd()
+sys.path.append(now_dir)
+
+from rvc_cli.rvc.lib.utils import format_title
+from rvc_cli.rvc.lib.tools import gdown
+
+
+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
+
+
+file_path = find_folder_parent(now_dir, "logs")
+zips_path = os.path.join(file_path, "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=True,
+                        fuzzy=True,
+                    )
+                except Exception as error:
+                    error_message = str(
+                        f"An error occurred downloading the file: {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 error:
+                print(f"An error occurred downloading the file: {error}")
+                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:
+                content_disposition = six.moves.urllib_parse.unquote(
+                    response.headers["Content-Disposition"]
+                )
+                m = re.search(r'filename="([^"]+)"', content_disposition)
+                file_name = m.groups()[0]
+                file_name = file_name.replace(os.path.sep, "_")
+                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
+        elif "applio.org" in url:
+            parts = url.split("/")
+            id_with_query = parts[-1]
+            id_parts = id_with_query.split("?")
+            id_number = id_parts[0]
+
+            url = "https://cjtfqzjfdimgpvpwhzlv.supabase.co/rest/v1/models"
+            headers = {
+                "apikey": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImNqdGZxempmZGltZ3B2cHdoemx2Iiwicm9sZSI6ImFub24iLCJpYXQiOjE2OTUxNjczODgsImV4cCI6MjAxMDc0MzM4OH0.7z5WMIbjR99c2Ooc0ma7B_FyGq10G8X-alkCYTkKR10"
+            }
+
+            params = {"id": f"eq.{id_number}"}
+            response = requests.get(url, headers=headers, params=params)
+            if response.status_code == 200:
+                json_response = response.json()
+                print(json_response)
+                if json_response:
+                    link = json_response[0]["link"]
+                    verify = download_from_url(link)
+                    if verify == "downloaded":
+                        return "downloaded"
+                    else:
+                        return None
+            else:
+                return None
+        else:
+            try:
+                os.chdir(zips_path)
+                wget.download(url)
+            except Exception as error:
+                os.chdir(now_dir)
+                print(f"An error occurred downloading the file: {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(f"An error occurred extracting the zip file: {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)
+
+
+def model_download_pipeline(url: str):
+    try:
+        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
+                    )
+
+                    macosx_path = os.path.join(extract_folder_path, "__MACOSX")
+                    if os.path.exists(macosx_path):
+                        shutil.rmtree(macosx_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:
+                                if "_nprobe_1_" in item and "_v1" 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:
+                                if "_nprobe_1_" in item and "_v2" in item:
+                                    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}")
+                        return "Error"
+            if extract_folder_path == "":
+                print("Zip file was not found.")
+                return "Error"
+            result = search_pth_index(extract_folder_path)
+            return result
+        else:
+            return "Error"
+    except Exception as error:
+        print(f"An unexpected error occurred: {error}")
+        return "Error"

prerequisites.py

@@ -0,0 +1,114 @@
+import os
+from concurrent.futures import ThreadPoolExecutor
+from tqdm import tqdm
+import requests
+import sys
+import pdb
+import traceback
+
+# Automatically invoke the debugger on an unhandled exception.
+def debug_excepthook(exc_type, exc_value, exc_traceback):
+    traceback.print_exception(exc_type, exc_value, exc_traceback)
+    pdb.post_mortem(exc_traceback)
+
+sys.excepthook = debug_excepthook
+
+url_base = "https://huggingface.co/IAHispano/Applio/resolve/main/Resources"
+
+# Define the file lists
+models_list = [("predictors/", ["rmvpe.pt", "fcpe.pt"])]
+embedders_list = [("embedders/contentvec/", ["pytorch_model.bin", "config.json"])]
+executables_list = [
+    ("", ["ffmpeg.exe", "ffprobe.exe"]),
+]
+
+folder_mapping_list = {
+    "embedders/contentvec/": ".rvc_cli/rvc/models/embedders/contentvec/",
+    "predictors/": ".rvc_cli/rvc/models/predictors/",
+    "formant/": ".rvc_cli/rvc/models/formant/",
+}
+
+
+def get_file_size_all(file_list):
+    """
+    Calculate the total size of files to be downloaded, regardless of local existence.
+    """
+    total_size = 0
+    for remote_folder, files in file_list:
+        # Use the mapping if available; otherwise, use an empty local folder
+        local_folder = folder_mapping_list.get(remote_folder, "")
+        for file in files:
+            url = f"{url_base}/{remote_folder}{file}"
+            response = requests.head(url)
+            total_size += int(response.headers.get("content-length", 0))
+    return total_size
+
+
+def download_file(url, destination_path, global_bar):
+    """
+    Download a file from the given URL to the specified destination path,
+    updating the global progress bar as data is downloaded.
+    """
+    dir_name = os.path.dirname(destination_path)
+    if dir_name:
+        os.makedirs(dir_name, exist_ok=True)
+    response = requests.get(url, stream=True)
+    block_size = 1024
+    with open(destination_path, "wb") as file:
+        for data in response.iter_content(block_size):
+            file.write(data)
+            global_bar.update(len(data))
+
+
+def download_mapping_files(file_mapping_list, global_bar):
+    """
+    Download all files in the provided file mapping list using a thread pool executor,
+    and update the global progress bar as downloads progress.
+    This version downloads all files regardless of whether they already exist.
+    """
+    with ThreadPoolExecutor() as executor:
+        futures = []
+        for remote_folder, file_list in file_mapping_list:
+            local_folder = folder_mapping_list.get(remote_folder, "")
+            for file in file_list:
+                destination_path = os.path.join(local_folder, file)
+                url = f"{url_base}/{remote_folder}{file}"
+                futures.append(
+                    executor.submit(download_file, url, destination_path, global_bar)
+                )
+        for future in futures:
+            future.result()
+
+
+def calculate_total_size(models, exe):
+    """
+    Calculate the total size of all files to be downloaded based on selected categories.
+    """
+    total_size = 0
+    if models:
+        total_size += get_file_size_all(models_list)
+        total_size += get_file_size_all(embedders_list)
+    if exe and os.name == "nt":
+        total_size += get_file_size_all(executables_list)
+    return total_size
+
+
+def prerequisites_download_pipeline(models, exe):
+    """
+    Manage the download pipeline for different categories of files.
+    """
+    total_size = calculate_total_size(models, exe)
+    if total_size > 0:
+        with tqdm(
+            total=total_size, unit="iB", unit_scale=True, desc="Downloading all files"
+        ) as global_bar:
+            if models:
+                download_mapping_files(models_list, global_bar)
+                download_mapping_files(embedders_list, global_bar)
+            if exe:
+                if os.name == "nt":
+                    download_mapping_files(executables_list, global_bar)
+                else:
+                    print("No executables needed for non-Windows systems.")
+    else:
+        print("No files to download.")

pretrained_selector.py

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

split_audio.py

@@ -0,0 +1,56 @@
+import numpy as np
+import librosa
+
+
+def process_audio(audio, sr=16000, silence_thresh=-60, min_silence_len=250):
+    """
+    Splits an audio signal into segments using a fixed frame size and hop size.
+
+    Parameters:
+    - audio (np.ndarray): The audio signal to split.
+    - sr (int): The sample rate of the input audio (default is 16000).
+    - silence_thresh (int): Silence threshold (default =-60dB)
+    - min_silence_len (int): Minimum silence duration (default 250ms).
+
+    Returns:
+    - list of np.ndarray: A list of audio segments.
+    - np.ndarray: The intervals where the audio was split.
+    """
+    frame_length = int(min_silence_len / 1000 * sr)
+    hop_length = frame_length // 2
+    intervals = librosa.effects.split(
+        audio, top_db=-silence_thresh, frame_length=frame_length, hop_length=hop_length
+    )
+    audio_segments = [audio[start:end] for start, end in intervals]
+
+    return audio_segments, intervals
+
+
+def merge_audio(audio_segments, intervals, sr_orig, sr_new):
+    """
+    Merges audio segments back into a single audio signal, filling gaps with silence.
+
+    Parameters:
+    - audio_segments (list of np.ndarray): The non-silent audio segments.
+    - intervals (np.ndarray): The intervals used for splitting the original audio.
+    - sr_orig (int): The sample rate of the original audio
+    - sr_new (int): The sample rate of the model
+
+    Returns:
+    - np.ndarray: The merged audio signal with silent gaps restored.
+    """
+    sr_ratio = sr_new / sr_orig if sr_new > sr_orig else 1.0
+
+    merged_audio = np.zeros(
+        int(intervals[0][0] * sr_ratio if intervals[0][0] > 0 else 0),
+        dtype=audio_segments[0].dtype,
+    )
+
+    merged_audio = np.concatenate((merged_audio, audio_segments[0]))
+
+    for i in range(1, len(intervals)):
+        silence_duration = int((intervals[i][0] - intervals[i - 1][1]) * sr_ratio)
+        silence = np.zeros(silence_duration, dtype=audio_segments[0].dtype)
+        merged_audio = np.concatenate((merged_audio, silence, audio_segments[i]))
+
+    return merged_audio