initial upload attempt
initial upload attempt
This commit is contained in:
erew123 committed
1 parent
84c19ed5a9
commit
9fd928f6e7
527 files changed
+37359
No files matched your search
@@ -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
|
||||
@@ -0,0 +1,409 @@
|
||||
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
|
||||
@@ -0,0 +1,16 @@
|
||||
import time
|
||||
from tensorboard import program
|
||||
|
||||
log_path = "logs"
|
||||
|
||||
|
||||
def launch_tensorboard_pipeline():
|
||||
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)
|
||||
@@ -0,0 +1,353 @@
|
||||
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
|
||||
import six
|
||||
|
||||
|
||||
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
|
||||
|
||||
from rvc.lib.tools import 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=True,
|
||||
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:
|
||||
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
|
||||
|
||||
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(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)
|
||||
|
||||
|
||||
def model_download_pipeline(url):
|
||||
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"
|
||||
@@ -0,0 +1,96 @@
|
||||
import os
|
||||
import wget
|
||||
|
||||
url_base = "https://huggingface.co/nolinkhere"
|
||||
pretraineds_v1_list = [
|
||||
(
|
||||
"pretrained_v1/",
|
||||
[
|
||||
"D32k.pth",
|
||||
"D40k.pth",
|
||||
"D48k.pth",
|
||||
"G32k.pth",
|
||||
"G40k.pth",
|
||||
"G48k.pth",
|
||||
"f0D32k.pth",
|
||||
"f0D40k.pth",
|
||||
"f0D48k.pth",
|
||||
"f0G32k.pth",
|
||||
"f0G40k.pth",
|
||||
"f0G48k.pth",
|
||||
],
|
||||
),
|
||||
]
|
||||
pretraineds_v2_list = [
|
||||
(
|
||||
"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_list = [
|
||||
"hubert_base.pt",
|
||||
"contentvec_base.pt",
|
||||
"rmvpe.pt",
|
||||
"fcpe.pt",
|
||||
# "rmvpe.onnx"
|
||||
]
|
||||
|
||||
executables_list = ["ffmpeg.exe", "ffprobe.exe"]
|
||||
|
||||
folder_mapping_list = {
|
||||
"pretrained_v1/": "rvc/pretraineds/pretrained_v1/",
|
||||
"pretrained_v2/": "rvc/pretraineds/pretrained_v2/",
|
||||
}
|
||||
|
||||
|
||||
def prequisites_download_pipeline(pretraineds_v1, pretraineds_v2, models, exe):
|
||||
def download_files(file_list):
|
||||
for file_name in file_list:
|
||||
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)
|
||||
|
||||
if models == "True":
|
||||
download_files(models_list)
|
||||
|
||||
if exe == "True" and os.name == "nt":
|
||||
download_files(executables_list)
|
||||
|
||||
if pretraineds_v1 == "True":
|
||||
for remote_folder, file_list in pretraineds_v1_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}"
|
||||
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)
|
||||
|
||||
if pretraineds_v2 == "True":
|
||||
for remote_folder, file_list in pretraineds_v2_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}"
|
||||
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)
|
||||
@@ -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",
|
||||
),
|
||||
},
|
||||
}
|
||||
@@ -0,0 +1,107 @@
|
||||
from pydub.silence import detect_nonsilent
|
||||
from pydub import AudioSegment
|
||||
import numpy as np
|
||||
import re
|
||||
import os
|
||||
|
||||
from ...lib.utils import format_title
|
||||
|
||||
|
||||
def process_audio(file_path):
|
||||
try:
|
||||
# load audio file
|
||||
song = AudioSegment.from_file(file_path)
|
||||
|
||||
# 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}")
|
||||
@@ -0,0 +1,19 @@
|
||||
import sys
|
||||
import asyncio
|
||||
import edge_tts
|
||||
|
||||
|
||||
async def main():
|
||||
text = sys.argv[1]
|
||||
voice = sys.argv[2]
|
||||
rate = int(sys.argv[3])
|
||||
output_file = sys.argv[4]
|
||||
|
||||
rates = f"+{rate}%" if rate >= 0 else f"{rate}%"
|
||||
|
||||
await edge_tts.Communicate(text, voice, rate=rates).save(output_file)
|
||||
print(f"TTS with {voice} completed. Output TTS file: '{output_file}'")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
asyncio.run(main())
|
||||
File diff suppressed because it is too large.
Load diff
Reference in new issue
Block a user