| import gradio as gr, glob, os, auditok, zipfile, wave, pytube.exceptions, librosa, time, librosa, librosa.display, matplotlib.pyplot as plt, numpy as np | |
| from pytube import YouTube | |
| from moviepy.editor import VideoFileClip | |
| def download_video(url, download_as): | |
| try: | |
| yt = YouTube(url) | |
| except pytube.exceptions.RegexMatchError: | |
| raise gr.Error("URL not valid or is empty! Please fix the link or enter one!") | |
| video = yt.streams.get_highest_resolution() | |
| video.download() | |
| video_path = f"{video.default_filename}" | |
| video_clip = VideoFileClip(video_path) | |
| audio_clip = video_clip.audio | |
| if download_as == "wav": | |
| audio_clip.write_audiofile("output.wav") | |
| elif download_as == "mp3": | |
| audio_clip.write_audiofile("output.mp3") | |
| audio_clip.close() | |
| video_clip.close() | |
| for removalmp4 in glob.glob("*.mp4"): | |
| os.remove(removalmp4) | |
| return "Finished downloading! Please proceed to next tab." | |
| def split_audio_from_yt_video(mindur, maxdur, name_for_split_files, show_amount_of_files_and_file_dur): | |
| if show_amount_of_files_and_file_dur == True: | |
| gr.Warning(f"show_amount_of_files_and_file_dur set to True. This will take longer if your audio file is long.") | |
| if not os.path.exists("output.mp3") and not os.path.exists("output.wav"): | |
| raise gr.Error("Neither output.mp3 or output.wav exist! Did the video download correctly?") | |
| if mindur == maxdur: | |
| raise gr.Error(f"Cannot split mindur={mindur} and maxdur={maxdur}, min and max are the same number.") | |
| elif mindur > maxdur: | |
| raise gr.Error(f"Cannot split mindur={mindur} and maxdur={maxdur}, mindur is higher than maxdur.") | |
| elif name_for_split_files == None: | |
| raise gr.Error("Split files name cannot be empty!") | |
| else: | |
| audio_path = "output.wav" if not os.path.exists("output.mp3") else "output.mp3" | |
| audio_regions = auditok.split( | |
| audio_path, | |
| min_dur=mindur, | |
| max_dur=maxdur, | |
| max_silence=0.3, | |
| energy_threshold=45 | |
| ) | |
| os.remove(audio_path) | |
| for i, r in enumerate(audio_regions): | |
| filename = r.save(f"{name_for_split_files}-{i+1}.wav") | |
| for f in sorted(glob.glob("*.wav")): | |
| audio_files = glob.glob("*.wav") | |
| zip_file_name = "audio_files.zip" | |
| with zipfile.ZipFile(zip_file_name, "w") as zip_file: | |
| for audio_file in audio_files: | |
| zip_file.write(audio_file, os.path.basename(audio_file)) | |
| if show_amount_of_files_and_file_dur == False: | |
| for file2 in glob.glob("*.wav"): | |
| os.remove(file2) | |
| return "Files split successfully!\nCheck below for zipped files.", zip_file_name | |
| elif show_amount_of_files_and_file_dur == True: | |
| largest_file = ("", 0) | |
| total_files = 0 | |
| total_length = 0.0 | |
| for file_name in glob.glob("*.wav"): | |
| file_path = os.path.join(os.getcwd(), file_name) | |
| if file_path.lower().endswith(".wav"): | |
| try: | |
| with wave.open(file_path, 'r') as audio_file: | |
| frames = audio_file.getnframes() | |
| rate = audio_file.getframerate() | |
| duration = frames / float(rate) | |
| file_size = os.path.getsize(file_path) | |
| if file_size > largest_file[1]: | |
| largest_file = (file_name, file_size) | |
| total_length += duration | |
| total_files += 1 | |
| except wave.Error as e: | |
| raise gr.Error(f"Error reading file: {e}") | |
| length_mins = total_length / 60 | |
| for file2 in glob.glob("*.wav"): | |
| os.remove(file2) | |
| return f"Files split successfully!\nCheck below for zipped files.\n\n{total_files} files created, {length_mins:.2f} minutes total.", zip_file_name | |
| def analyze_audio(zip_file_path): | |
| with zipfile.ZipFile(zip_file_path, 'r') as zip_ref: | |
| zip_ref.extractall('unzipped_files') | |
| total_sample_rate = 0 | |
| total_files = 0 | |
| for file_name in os.listdir('unzipped_files'): | |
| if file_name.lower().endswith('.wav'): | |
| file_path = os.path.join('unzipped_files', file_name) | |
| try: | |
| with wave.open(file_path, 'r') as audio_file: | |
| sample_rate = audio_file.getframerate() | |
| total_sample_rate += sample_rate | |
| total_files += 1 | |
| except wave.Error as e: | |
| print(f"Error reading file: {e}") | |
| if total_files > 0: | |
| average_sample_rate = total_sample_rate / total_files | |
| return f"Average sample rate: {average_sample_rate}" | |
| else: | |
| return "No average sample rate could be found." | |
| def split_wav_or_mp3_file(audiofileuploader, mindur2, maxdur2, name_for_split_files2): | |
| if audiofileuploader == None: | |
| raise gr.Error("Audio file cannot be empty!") | |
| if mindur2 == maxdur2: | |
| raise gr.Error(f"Cannot split mindur={mindur} and maxdur={maxdur}, min and max are the same number.") | |
| elif mindur2 > maxdur2: | |
| raise gr.Error(f"Cannot split mindur={mindur} and maxdur={maxdur}, mindur is higher than maxdur.") | |
| elif name_for_split_files2 == None: | |
| raise gr.Error("Split files name cannot be empty!") | |
| else: | |
| audio_path = audiofileuploader | |
| audio_regions = auditok.split( | |
| audio_path, | |
| min_dur=mindur2, | |
| max_dur=maxdur2, | |
| max_silence=0.3, | |
| energy_threshold=45 | |
| ) | |
| os.remove(audio_path) | |
| for i, r in enumerate(audio_regions): | |
| filename = r.save(f"{name_for_split_files2}-{i+1}.wav") | |
| for f in sorted(glob.glob("*.wav")): | |
| audio_files = glob.glob("*.wav") | |
| zip_file_name2 = "audio_files.zip" | |
| with zipfile.ZipFile(zip_file_name2, "w") as zip_file: | |
| for audio_file in audio_files: | |
| zip_file.write(audio_file, os.path.basename(audio_file)) | |
| for file2 in glob.glob("*.wav"): | |
| os.remove(file2) | |
| return f"File split successfully!\nCheck below for zipped files.\nAmount created: {len(audio_files)}", zip_file_name2 | |
| def all_in_one_inator(ytvideo, download_yt_video_as, min_duration, max_duration, name_for_outputted_split_files, progress=gr.Progress()): | |
| if download_as == "mp3": | |
| gr.Warning("MP3 is experimental, especially with this, so caution is advised.") | |
| if min_duration == max_duration: | |
| raise gr.Error(f"Cannot split mindur={min_duration} and maxdur={max_duration}, min and max are the same number.") | |
| elif min_duration > max_duration: | |
| raise gr.Error(f"Cannot split mindur={min_duration} and maxdur={max_duration}, mindur is higher than maxdur.") | |
| elif name_for_outputted_split_files == None: | |
| raise gr.Error("Split files name cannot be empty!") | |
| else: | |
| try: | |
| progress(0, "Downloading video...") | |
| yt = YouTube(ytvideo) | |
| except pytube.exceptions.RegexMatchError: | |
| raise gr.Error("URL not valid or was left empty! Please fix the link or enter one.") | |
| video = yt.streams.get_highest_resolution() | |
| video.download() | |
| video_path = f"{video.default_filename}" | |
| video_clip = VideoFileClip(video_path) | |
| audio_clip = video_clip.audio | |
| if download_yt_video_as == "wav": | |
| audio_clip.write_audiofile("output.wav") | |
| elif download_yt_video_as == "mp3": | |
| audio_clip.write_audiofile("output.mp3") | |
| audio_clip.close() | |
| video_clip.close() | |
| for removemp4 in glob.glob("*.mp4"): | |
| os.remove(removemp4) | |
| progress(0.5, "Video downloaded! Starting split process...") | |
| audio_path = "output.wav" if not os.path.exists("output.mp3") else "output.mp3" | |
| audio_regions = auditok.split( | |
| audio_path, | |
| min_dur=min_duration, | |
| max_dur=max_duration, | |
| max_silence=0.3, | |
| energy_threshold=45 | |
| ) | |
| os.remove(audio_path) | |
| for i, r in enumerate(audio_regions): | |
| filename = r.save(f"{name_for_outputted_split_files}-{i+1}.wav") | |
| for f in sorted(glob.glob("*.wav")): | |
| audio_files = glob.glob("*.wav") | |
| zip_file_name = "audio_files.zip" | |
| with zipfile.ZipFile(zip_file_name, 'w') as zip_file: | |
| for audio_file in audio_files: | |
| zip_file.write(audio_file, os.path.basename(audio_file)) | |
| for file2 in glob.glob("*.wav"): | |
| os.remove(file2) | |
| progress(1, "Done! Cleaning up...") | |
| time.sleep(2) | |
| return "Process done successfully! Check below for zipped files!", zip_file_name | |
| def download_video_as_audio_only(yt_video, audio_output_format): | |
| try: | |
| yt = YouTube(yt_video) | |
| except pytube.exceptions.RegexMatchError: | |
| raise gr.Error("URL not valid or is empty! Please fix the link or enter one!") | |
| video = yt.streams.get_highest_resolution() | |
| video.download() | |
| video_path = f"{video.default_filename}" | |
| video_clip = VideoFileClip(video_path) | |
| audio_clip = video_clip.audio | |
| if audio_output_format == "wav": | |
| audio_clip.write_audiofile("output.wav") | |
| elif audio_output_format == "mp3": | |
| audio_clip.write_audiofile("output.mp3") | |
| audio_clip.close() | |
| video_clip.close() | |
| for mp4remove in glob.glob("*.mp4"): | |
| os.remove(mp4remove) | |
| single_zip_name = "only_audio.zip" | |
| audio_files = glob.glob("*.wav") if audio_output_format == "wav" else glob.glob("*.mp3") | |
| with zipfile.ZipFile(single_zip_name, 'w') as zip_file: | |
| for audio_file in audio_files: | |
| zip_file.write(audio_file, os.path.basename(audio_file)) | |
| for outputwavremoval in glob.glob("*.wav"): | |
| if os.path.exists(outputwavremoval): | |
| os.remove(outputwavremoval) | |
| for outputmp3removal in glob.glob("*.mp3"): | |
| if os.path.exists(outputmp3removal): | |
| os.remove(outputmp3removal) | |
| return "Done! Download the zip file below! This only contains the audio file.", single_zip_name | |
| def check_for_remaining_wav_or_mp3_files(which_filetype): | |
| audio_files = glob.glob(f"*.{which_filetype}") | |
| return f"There are {len(audio_files)} leftover files." | |
| def display_audio_spectrogram(audio_file): | |
| y, sr = librosa.load(audio_file) | |
| d = librosa.amplitude_to_db(np.abs(librosa.stft(y)), ref=np.max) | |
| plt.figure(figsize=(12, 8)) | |
| librosa.display.specshow(d, sr=sr, x_axis="time", y_axis="log") | |
| plt.colorbar(format="%+2.0f db") | |
| plt.title("Spectrogram") | |
| output = "spectrogram.png" | |
| plt.savefig(output) | |
| plt.close() | |
| return output | |
| with gr.Blocks(theme='sudeepshouche/minimalist', title="Global Dataset Maker") as app: | |
| gr.HTML( | |
| "<h1> Welcome to the GDMGS! (GlobalDatasetMaker Gradio Space) </h1>" | |
| ) | |
| gr.Markdown("## Duplicate this space if you want to make your own changes!") | |
| gr.HTML( | |
| """<p style="margin:5px auto;display: flex;justify-content: left;"> | |
| <a href="https://huggingface.co/spaces/Kryptone/GDMGS?duplicate=true"><img src="https://huggingface.co/datasets/huggingface/badges/resolve/main/duplicate-this-space-md-dark.svg" alt="Duplicate this Space"></a> | |
| </p>""" | |
| ) | |
| gr.Markdown( | |
| "This Space will create a dataset for you, all automatically. **Please be warned that due to not having a GPU on this Space, some steps might take longer to complete.**" | |
| ) | |
| with gr.Tabs(): | |
| with gr.TabItem("Download Video"): | |
| with gr.Row(): | |
| with gr.Column(): | |
| with gr.Row(): | |
| url = gr.Textbox(label="URL") | |
| download_as = gr.Radio(["wav", "mp3"], label="Audio format output", value="wav", info="What should the audio format be output as?") | |
| convertion = gr.Button("Download", variant='primary') | |
| convertion.click( | |
| fn=download_video, | |
| inputs=[url, download_as], | |
| outputs=gr.Text(label="Output") | |
| ) | |
| with gr.TabItem("Split audio files"): | |
| with gr.Row(): | |
| with gr.Column(): | |
| with gr.Row(): | |
| mindur = gr.Number(label="Min duration", minimum=1, maximum=10, value=1) | |
| maxdur = gr.Number(label="Max duration", minimum=1, maximum=10, value=5) | |
| name_for_split_files = gr.Textbox(label="Name for split files") | |
| show_amount_of_files_and_file_dur = gr.Checkbox(False, label="Show total amount of files and duration?") | |
| splitbtn = gr.Button("Split", variant='primary') | |
| splitbtn.click( | |
| split_audio_from_yt_video, | |
| inputs=[mindur, maxdur, name_for_split_files, show_amount_of_files_and_file_dur], | |
| outputs=[gr.Text(label="Output"), gr.File(label="Zipped files")] | |
| ) | |
| with gr.TabItem("Misc tools"): | |
| with gr.Tab("SR analyzer"): | |
| gr.Markdown("Upload a zip file of your wavs here and this will determine the average sample rate.") | |
| with gr.Row(): | |
| with gr.Column(): | |
| with gr.Row(): | |
| zipuploader = gr.File(file_count='single', file_types=[".zip"], label="ZIP file") | |
| uploadbtn = gr.Button("Analyze", variant='primary') | |
| uploadbtn.click( | |
| analyze_audio, | |
| [zipuploader], | |
| [gr.Text(label="Result")] | |
| ) | |
| with gr.Tab("File splitter"): | |
| gr.Markdown("If you would rather split a single WAV or mp3 audio file, use this method instead.") | |
| with gr.Row(): | |
| with gr.Column(): | |
| with gr.Row(): | |
| audiofileuploader = gr.File(file_count='single', file_types=[".wav", ".mp3"], label="WAV or mp3 file") | |
| mindur2 = gr.Number(label="Min duration", minimum=1, maximum=10, value=1) | |
| maxdur2 = gr.Number(label="Max duration", minimum=1, maximum=10, value=5) | |
| name_for_split_files2 = gr.Textbox(label="Name for split files") | |
| audiofileuploadbtn = gr.Button("Split", variant='primary') | |
| audiofileuploadbtn.click( | |
| split_wav_or_mp3_file, | |
| [audiofileuploader, mindur2, maxdur2, name_for_split_files2], | |
| [gr.Text(label="Output"), gr.File(label="Zipped files")] | |
| ) | |
| with gr.Tab("All-in-one downloader and splitter"): | |
| gr.Markdown("This is very experimental and may break or change in the future. This essentially combines both the first 2 tabs into an all-in-one script.") | |
| with gr.Row(): | |
| with gr.Column(): | |
| with gr.Row(): | |
| ytvideo = gr.Textbox(label="URL") | |
| download_yt_video_as = gr.Radio(["wav", "mp3"], value="wav", label="Audio output format") | |
| min_duration = gr.Number(label="Min duration", minimum=1, maximum=10, value=1) | |
| max_duration = gr.Number(label="Max duration", minimum=1, maximum=10, value=5) | |
| name_for_outputted_split_files = gr.Textbox(label="Name for split files") | |
| download_and_split_btn = gr.Button("Download and split", variant='primary') | |
| download_and_split_btn.click( | |
| all_in_one_inator, | |
| [ytvideo, download_yt_video_as, min_duration, max_duration, name_for_outputted_split_files], | |
| [gr.Text(label="Result"), gr.File(label="Zipped files")] | |
| ) | |
| with gr.Tab("Audio only download"): | |
| gr.Markdown("If you want to download only the audio (to isolate bgm using UVR, etc), use this method, which will only extract audio and not split the audio.") | |
| with gr.Row(): | |
| with gr.Column(): | |
| with gr.Row(): | |
| yt_video = gr.Textbox(label="URL") | |
| audio_output_format = gr.Radio(["wav", "mp3"], value="wav", label="Download audio as:") | |
| commence_download = gr.Button("Download", variant='primary') | |
| commence_download.click( | |
| download_video_as_audio_only, | |
| [yt_video, audio_output_format], | |
| [gr.Text(label="Output"), gr.File(label="Zipped audio file")] | |
| ) | |
| with gr.Tab("Check for leftover mp3 or wav files"): | |
| gr.Markdown("There might be instances where sometimes a few wav or mp3 files are left over after a conversion. This section tells how many of those files are left, if any.") | |
| with gr.Row(): | |
| with gr.Column(): | |
| with gr.Row(): | |
| which_filetype = gr.Radio(["wav", "mp3"], value="wav", label="Search for what filetype?") | |
| checkbtn = gr.Button("Check for files", variant='primary') | |
| checkbtn.click( | |
| check_for_remaining_wav_or_mp3_files, | |
| which_filetype, | |
| gr.Text(label="Result") | |
| ) | |
| with gr.Tab("Audio spectrogram"): | |
| gr.Markdown("Insert a wav file here and this will show the spectrogram for it.") | |
| with gr.Row(): | |
| with gr.Column(): | |
| filetoanalyze = gr.File(file_count='single', file_types=[".wav"], label="WAV file") | |
| analyzebtn = gr.Button("Display", variant='primary') | |
| analyzebtn.click( | |
| display_audio_spectrogram, | |
| filetoanalyze, | |
| gr.Image(label="Spectrogram result", show_download_button=False, scale=2) | |
| ) | |
| with gr.TabItem("Changelog"): | |
| gr.Markdown("v0.97 - Added new spectrogram tool in Misc Tools and removed pitch analyzer as it did not fit with the purpose of this Space.") | |
| gr.Markdown("v0.96 - Added new remaining files tool in Misc Tools.") | |
| gr.Markdown("v0.95 - Fixed issue with mp3 files not downloading audio properly.") | |
| gr.Markdown("v0.94a - Fixed issue with existing output.wav or output.mp3 files clashing with the split audio files with addition of the new tool.") | |
| gr.Markdown("v0.94 - Added new tool: YouTube-to-audio.") | |
| gr.Markdown("v0.93 - Removed obsolete warnings and fixed issue with all-in-one if output.mp3 or output.wav doesnt exist.") | |
| gr.Markdown("v0.92 - Added all-in-one tab under Misc Tools.") | |
| gr.Markdown("v0.91 - Added mp3 file support for single file splitting, and also fixed bug if neither output.wav or output.mp3 exists.") | |
| gr.Markdown("v0.90a - Fixed bug that if 'show_amount_of_files_and_file_dur' was False, split wav files would not be deleted.") | |
| gr.Markdown("v0.90 - Added mp3 support for downloading a Youtube video.") | |
| gr.Markdown("v0.85 - Fixed bug in pitch analyzer if no audio file was given.") | |
| gr.Markdown("v0.80 - Added new tool: Pitch Analyzer.") | |
| gr.Markdown("v0.75 - Fixed bug that would cause split wav files to be packaged with the previously split wav files.") | |
| gr.Markdown("v0.74 - Added new tool: WAV file splitter.") | |
| gr.Markdown("v0.73 - Added Misc Tools tab and new Sample Rate analyzer tool.") | |
| gr.Markdown("v0.70 - Fixed bug if no URL was passed or if the URL was invalid.") | |
| gr.Markdown("v0.65 - Fixed bug if user tried to split an audio file when 'output.wav' didnt exist.") | |
| gr.Markdown("v0.60 - Initial push to Huggingface Space.") | |
| app.launch() |