Add application file

app.py

@@ -0,0 +1,533 @@
+# -*- coding: utf-8 -*-
+"""Fuction_Audio_Processing_combine_files.ipynb
+
+Automatically generated by Colaboratory.
+
+Original file is located at
+    https://colab.research.google.com/drive/1TKJBO1bX2CGo6awtPhr6KE2bBMUGlYrs
+"""
+
+# Ru a Pytho Script in Google Colab
+# # python "/content/class_audio_processing_for_aglc_alphet_phonetic_langues_africaines_tonal_languages (2).py"
+
+# !python /content/class_audio_processing_for_aglc_alphet_phonetic_langues_africaines_tonal_languages.py
+
+"""# Install libraries"""
+
+# pip install natsort
+
+# pip install pydub
+
+"""The code defines a function named **get_audio** that takes in three parameters: **audio_path**, **ext** and **check_subfolders**. It imports the necessary modules such as os and glob. The function searches for audio files in a directory specified by the **audio_path** parameter and returns two lists; the first list containing the absolute path of the audio files and the second list containing the relative path of the audio files. The function has an optional parameter **ext** that takes a list of audio file extensions to be searched for, and **check_subfolders** is another optional parameter that specifies whether to search for audio files recursively in subfolders or not.
+
+# get_audio() Functions
+"""
+
+from posix import mkdir
+audio_path1 = "/content/drive/MyDrive/Resulam/Mbú'ŋwɑ̀'nì/test_audio/Language1/"
+audio_path2 = "/content/drive/MyDrive/Resulam/Mbú'ŋwɑ̀'nì/test_audio/Language2/"
+
+
+# mkdir result
+
+import os
+
+# Define the path where the "result" directory should be created
+result_path = audio_path2 + "result/"
+
+# Create the "result" directory if it doesn't exist
+if not os.path.exists(result_path):
+  mkdir(result_path)
+
+
+# G:\.shortcut-targets-by-id\1kt35DKTNYSvIP56JDRN5ukyvOBlyXEwi\Mbú'ŋwɑ̀'nì\test_audio\Laguage2
+
+import glob
+import os
+
+from natsort import natsorted
+
+directory_path1 = audio_path1 +"*mp3"  # Update with the actual directory path and file extension
+directory_path2 = audio_path2 +"*mp3"  # Update with the actual directory path and file extension
+
+# Use glob to get the file names in the directory
+file_names1 = glob.glob(directory_path1)
+file_names2 = glob.glob(directory_path2)
+
+# Sort the file names based on the Windows initial key
+sorted_file_names1 = natsorted(file_names1, key=lambda x: x.lower())
+sorted_file_names2 = natsorted(file_names2, key=lambda x: x.lower())
+
+# Print the sorted file names
+for file_name in sorted_file_names1:
+    print(file_name)
+
+class AGLC:
+
+  # global len_chuck
+
+  def __init__(self,audio_path):
+    self.vow_map = {'à': 'à', 'á': 'á', 'ā': 'ā', 'ǎ': 'ǎ', 'â': 'â', 'è': 'è', 'é': 'é', 'ē': 'ē', 'ě': 'ě', 'ê': 'ê', 'ì': 'ì', 'í': 'í', 'ī': 'ī', 'ǐ': 'ǐ', 'î': 'î', 'ò': 'ò', 'ó': 'ó', 'ō': 'ō', 'ǒ': 'ǒ', 'ô': 'ô', 'ù': 'ù', 'ú': 'ú', 'ū': 'ū', 'ǔ': 'ǔ', 'û': 'û'}
+    self.audio_path = audio_path
+    # self.speed = play_speed
+    # self.input = input
+  def vowel_mapping(self,s):
+    output = ""
+    for char in s:
+        if char in self.vow_map:
+            output += self.vow_map[char]
+        else:
+            output += char
+    return output
+
+
+  def get_audio_files_dictionary(self,list_of_audio_files_including_extension):
+
+    """
+    The function takes a list of audio files including extensions as input: ['a1.mp3','a2.mp3']
+    It creates:
+    - a dictionary where the keys are the audio file names without extensions, and the values are
+    the audio file names including extensions.
+    - a new dictionary where the keys are combinations of two audio file names separated by a space
+    and the values are lists of the corresponding audio file names including extensions.
+    'a1 a2': ['a1.mp3', 'a2.mp3']
+    The combinations are formed by iterating over the sorted list of audio file names and adding all pairs of
+    names that come after the current name in the sorted list.
+    Finally, the function returns the new dictionary.
+
+    """
+
+    import os
+    list_of_audio_files_including_extension_base = [ os.path.basename(i) for i in list_of_audio_files_including_extension]
+    audio_files_no_ext = [i.split(".")[0] for i in list_of_audio_files_including_extension_base]
+
+    audio_files_dict = dict(zip(audio_files_no_ext, list_of_audio_files_including_extension))
+
+    new_dict = {}
+
+    sorted_list = sorted(list(audio_files_dict))
+    for i, val in enumerate(sorted_list):
+      for j in range(i,len(sorted_list)):
+        val_j = sorted_list[j]
+        new_dict[f"{val} {val_j}"] = [audio_files_dict[val], audio_files_dict[val_j]]
+    return new_dict
+
+
+
+  # Define a function to normalize a chunk to a target amplitude.
+  def match_target_amplitude(self,aChunk, target_dBFS):
+      ''' Normalize given audio chunk
+      The code normalizes an audio chunk to a target amplitude level given as `target_dBFS`.
+      It calculates the change in decibels (dBFS) required to achieve the target amplitude level and applies it to the input audio chunk.'''
+      change_in_dBFS = target_dBFS - aChunk.dBFS
+      return aChunk.apply_gain(change_in_dBFS)
+
+
+  def get_audio(self,audio_path, ext = ["*.mp3", "*.wav", "*.ogg", "*.flac"],check_subfolders=False):
+
+    """
+    The code defines a function named get_audio that takes in three parameters:
+    audio_path, ext and check_subfolders. It imports the necessary modules such as os and glob.
+    The function searches for audio files in a directory specified by the audio_path parameter and returns two lists;
+    the first list containing the absolute path of the audio files and the second list containing the relative path of the audio files.
+    The function has an optional parameter ext that takes a list of audio file extensions   to be searched for, and check_subfolders
+    is another optional parameter that specifies whether to search for audio files recursively in subfolders or not.
+    """
+
+    import os
+    import glob
+
+    # List of audio file extensions to search for
+    # AUDIO_EXTENSIONS = ext
+
+    # Directory to search for audio files
+    directory = audio_path  # Replace with the path to your directory
+
+    if check_subfolders == False:
+      # Search for audio files using glob
+      audio_files = []
+      for extension in ext:
+          audio_files.extend(glob.glob(directory + "*" + extension, recursive=check_subfolders))
+    else:
+
+      # Search for audio files using glob
+      audio_files = []
+      for extension in ext:
+          audio_files.extend(glob.glob(directory + "/**/" + extension, recursive=check_subfolders))
+
+    audio_base_names = [os.path.basename(i) for i in audio_files]
+
+    return audio_files, audio_base_names
+
+
+
+
+
+  # define function to play audio given input string and list of audio files
+  def play_audio(self,input_string_space_separated, list_of_audio_files_including_extension):
+      # import required module
+      from pydub import AudioSegment
+
+      # create dictionary of audio files and their corresponding inputs
+      files = self.get_audio_files_dictionary(list_of_audio_files_including_extension)
+
+
+      # if the input is not in the dictionary, try reversing the input and checking again
+      if input_string_space_separated not in files:
+
+
+          input_string_space_separated = " ".join(input_string_space_separated.split()[::-1])
+          # print("...........",files[input_string_space_separated])
+          invert_dict = {}
+          invert_dict[input_string_space_separated] = files[input_string_space_separated][::-1]
+          files.update(invert_dict)
+
+      # create a silent audio segment for a 2 second pause between audio files
+      silence = AudioSegment.silent(duration=2000)
+
+      # get the list of audio files corresponding to the input string
+      audio_files = files.get(input_string_space_separated)
+      # print(audio_files)
+
+      # raise an error if the input string is invalid
+      if audio_files is None:
+          raise ValueError("Invalid input string value")
+
+      # create an empty audio segment to add the audio files to
+      combined_audio = AudioSegment.empty()
+
+      # loop through the list of audio files and add each one to the combined audio segment
+      for filename in audio_files:
+          audio_segment = AudioSegment.from_file(f"{filename}")
+          combined_audio += audio_segment + silence
+
+      # return the combined audio segment
+      return combined_audio
+
+
+  def play_audio_with_various_space_between_chunks(self,song, min_cut_silence_len = 1.5, silence_padding_duration = 2.5):
+
+    """
+    The function takes an audio file and an optional silence duration as input and plays the audio with various spaces between each chunk.
+    The pydub library is used to split the audio file into chunks where there is silence for a specified duration determined by min_cut_silence_len
+    and then each chunk is padded with silence of duration silence_padding_duration.
+    For example, if min_cut_silence_len = 1.5, silence_padding_duration = 2.5
+    The function then normalizes each chunk and exports them as separate audio files in the mp3 format.
+    Finally, the function returns the entire audio file with the various spaces between each chunk as an AudioSegment object.
+
+    """
+
+
+    # Import the AudioSegment class for processing audio and the
+    # split_on_silence function for separating out silent chunks.
+    from pydub import AudioSegment
+    from pydub.silence import split_on_silence
+    import os
+
+
+    # Load your audio.
+    # song = AudioSegment.from_mp3(audio_file_path)
+
+    # Split track where the silence is 2 seconds or more and get chunks using
+    # the imported function.
+    chunks = split_on_silence (
+        # Use the loaded audio.
+        song,
+        # Specify that a silent chunk must be at least 2 seconds or 2000 ms long.
+        # min_silence_len = 2000,
+        min_silence_len = int(min_cut_silence_len*1000),
+        # Consider a chunk silent if it's quieter than -16 dBFS.
+        # (You may want to adjust this parameter.)
+        silence_thresh = -50
+    )
+    silence_duration = int(silence_padding_duration*1000)
+
+    audio_chunk = AudioSegment.silent(duration=1000)
+    silence_chunk = AudioSegment.silent(duration=silence_duration)
+    # Process each chunk with your parameters
+    for i, chunk in enumerate(chunks):
+        # Create a silence chunk that's 0.5 seconds (or 500 ms) long for padding.
+
+        # print(i, len(chunks))
+        # Add the padding chunk to beginning and end of the entire chunk.
+
+        if i < len(chunks)-1:
+          audio_chunk += chunk + silence_chunk
+        if i == len(chunks)-1:
+          audio_chunk += chunk
+
+        # Normalize the entire chunk.
+        normalized_chunk = self.match_target_amplitude(audio_chunk, -20.0)
+
+        # Export the audio chunk with new bitrate.
+        # print(i)
+        # print(f"Exporting chunk{i}.mp3.")
+
+        # normalized_chunk.export(
+        #     # ".//chunk{0}.mp3".format(i),
+        #     f"_part{i}.mp3",
+        #     bitrate = "192k",
+        #     format = "mp3"
+        # )
+    return audio_chunk, len(chunks)
+
+
+  def play_audio_combine(self,input, speed = 2):
+
+    audio_files = self.get_audio(self.audio_path, ext = ["*.mp3", "*.wav", "*.ogg", "*.flac"])
+
+    list_of_audio_files_including_extension = audio_files[0]
+    # get_audio_files_dictionary(list_of_audio_files_including_extension)
+
+    in_ = self.vowel_mapping(input)
+    audio_result = self.play_audio(in_,list_of_audio_files_including_extension)
+    audio_result_modified = self.play_audio_with_various_space_between_chunks(audio_result, silence_padding_duration = float(speed))
+
+    return audio_result_modified
+
+  def main_func(self,audio_path1, audio_path2,result_path):
+    import os
+    from pydub import AudioSegment
+    from natsort import natsorted
+    from os.path import basename
+
+    silent_end = AudioSegment.silent(duration=1000)
+    silent_begin = AudioSegment.silent(duration=3000)
+
+    audio_files_plus_ext1, audio_files1 = self.get_audio(audio_path1, ext = ["*.mp3", "*.wav", "*.ogg", "*.flac"],check_subfolders=False)
+    audio_files_plus_ext2, audio_files2 = self.get_audio(audio_path2, ext = ["*.mp3", "*.wav", "*.ogg", "*.flac"],check_subfolders=False)
+
+
+    # Sort the file names alphabtically
+    sorted_audio_file_names1 = natsorted(audio_files1, key=lambda x: x.lower())
+    sorted_audio_file_names2 = natsorted(audio_files2, key=lambda x: x.lower())
+
+    sorted_audio_file_names_ext1 = natsorted(audio_files_plus_ext1, key=lambda x: x.lower())
+    sorted_audio_file_names_ext2 = natsorted(audio_files_plus_ext2, key=lambda x: x.lower())
+
+    # Using a dictionary to map indices to filenames for faster lookup
+
+
+    file_dict2 = { ''.join(filter(str.isdigit, basename(path))): basename(path) for path in sorted_audio_file_names_ext1 }
+
+    # Create the mapping in a more efficient way
+    mapping_fast = { basename(path1): file_dict2.get(''.join(filter(str.isdigit, basename(path1))), None)
+                    for path1 in sorted_audio_file_names_ext2 if ''.join(filter(str.isdigit, basename(path1))) in file_dict2 }
+
+
+
+    audio_path1_ = [audio_path1 + i for i in mapping_fast.values()]
+
+    audio_path2_ = [audio_path2+i for i in mapping_fast.keys()]
+
+    silent_2s = AudioSegment.silent(duration=2000)
+
+    song = silent_2s
+
+    padding_duration = 3
+
+    for i in range (0,len(audio_path2_)):
+      # i = 1
+      song_name = os.path.basename(audio_path1_[i]).split("_")[0] + "_" + os.path.basename(audio_path2_[i])
+      print(song_name)
+
+      song_1 = AudioSegment.from_mp3(audio_path1_[i])
+      song_2 = AudioSegment.from_mp3(audio_path2_[i])
+
+      song_out, number_of_chunks = self.play_audio_with_various_space_between_chunks(song_2, min_cut_silence_len = 1.2, silence_padding_duration = padding_duration)
+
+      print("number_of_chunks:",number_of_chunks)
+
+
+      if number_of_chunks == 1:
+
+        songi = song_1 + silent_begin + song_2  + silent_begin + song_2
+
+      else:
+
+        songi = song_1 + silent_begin + song_2
+
+      songi.export(
+              # ".//chunk{0}.mp3".format(i),
+              result_path+"/"+song_name,
+              bitrate = "192k",
+              format = "mp3"
+          );
+      songi
+
+
+    audio_files_plus_ext, audio_files = self.get_audio(result_path, ext = ["*.mp3", "*.wav", "*.ogg", "*.flac"],check_subfolders=False)
+
+    # Sort the file names alphabtically
+    audio_files = natsorted(audio_files, key=lambda x: x.lower())
+
+    audio_files_plus_ext = natsorted(audio_files_plus_ext, key=lambda x: x.lower())
+
+
+    song = silent_begin
+
+
+
+    for i in range (0,len(audio_files_plus_ext)):
+      # i = 1
+      song_name = os.path.basename(audio_files_plus_ext[i])
+      print(song_name)
+      # song_name = f"{audio_path}reworked/pp_"+song_name
+
+      song_i = AudioSegment.from_mp3(audio_files_plus_ext[i])
+
+      # song += song_i+silent_end+flip_page_sound+silent_begin
+
+      song += song_i
+
+    song_name = f"{result_path}1_CombineAudio.mp3"
+
+    song.export(
+              # ".//chunk{0}.mp3".format(i),
+              song_name,
+              bitrate = "192k",
+              format = "mp3"
+          );
+
+audio_path1 = "/content/drive/MyDrive/Resulam/Mbú'ŋwɑ̀'nì/test_audio/Language1/"
+audio_path2 = "/content/drive/MyDrive/Resulam/Mbú'ŋwɑ̀'nì/test_audio/Language2/"
+
+result_path = "/content/drive/MyDrive/Resulam/Mbú'ŋwɑ̀'nì/test_audio/res/"
+
+
+player = AGLC(audio_path1)
+# player_yoruba = AGLC(audio_path_yoruba)
+
+player.main_func(audio_path1, audio_path2,result_path)
+
+def main(audio_path1, audio_path2,result_path):
+  player.main_func(audio_path1, audio_path2,result_path)
+
+def normalize_audio_for_ACX_Amazon(song):
+
+  desired_sample_rate = 44100  # Replace this with your desired sample rate
+  song = song.set_frame_rate(desired_sample_rate)
+
+
+  desired_dBFS = -20   # Target volume level in dBFS
+  current_dBFS = song.dBFS
+  gain_needed = desired_dBFS - current_dBFS
+
+  song_with_desired_volume = song.apply_gain(gain_needed)
+  # song_with_desired_volume.export("/content/output.mp3", format="mp3", bitrate="192000")
+
+
+  return song_with_desired_volume
+
+
+
+"""# Build Interface With Gradio"""
+
+pip install gradio
+
+
+
+import gradio as gr
+
+
+
+iface = gr.Interface(fn=main,
+                     inputs=[gr.Textbox(label="Laguage1 Path: "),
+                             gr.Textbox(value=1, label="Laguage2 Path: "),
+                             gr.Textbox(label="Results Path: ")],
+                     outputs="audio",
+                     title="Combine Audios")
+
+iface.launch(share=True,debug=True)
+
+
+
+
+
+# pip install transformers
+
+demo = gr.Blocks()
+
+with demo:
+    input_func1 = gr.Audio(type="filepath")
+    output_func1 = gr.Textbox()
+    output_func2 = gr.Label()
+
+    b1 = gr.Button("Recognize Speech")
+    b2 = gr.Button("Classify Sentiment")
+
+    b1.click(Func1, inputs=input_func1, outputs=output_func1)
+    b2.click(Func2, inputs=output_func1, outputs=output_func2)
+
+demo.launch(share=True)
+
+# get_audio(audio_path, ext = ["*.mp3", "*.wav", "*.ogg", "*.flac"],check_subfolders=False):
+# return audio_files, audio_base_names
+
+# def get_audio_files_dictionary(list_of_audio_files_including_extension):
+# return new_dict
+
+# play_audio(input_string_space_separated, list_of_audio_files_including_extension):
+# return combined_audio
+
+# play_audio_with_various_space_between_chunks(song, silence_duration = .5):
+#     return audio_chunk
+
+#  list_of_audio_files_including_extension =  get_audio()[0]
+
+
+# audio_result = play_audio("bǎ bá",list_of_audio_files_including_extension)
+# audio_result_modified = play_audio_with_various_space_between_chunks(audio_result, silence_duration = .2)
+
+# gr.Textbox(value=1, label="Duration in seconds"),
+
+#  inputs=[gr.Textbox(label="words: Example: ǎ bà"),
+#                              gr.Textbox(value=1, label="Duration in seconds"),
+#                              gr.Textbox(label="Path")],
+
+def func1(x):
+  x = float(x)
+  return x**2
+
+def func2(y):
+  y = float(y)
+  return y**2
+
+def func3(a):
+  a = float(a)
+  # b = float(b)
+  return 2*a
+
+
+
+demo = gr.Blocks()
+
+with demo:
+    input_func1 = gr.Textbox(label = "val1")
+    input_func2 = gr.Textbox(label = "val2")
+    # input_func3 = [gr.Textbox(label = "val3")
+
+    output_func1 = gr.Label(label = "result1")
+    output_func2 = gr.Label(label = "result2")
+    output_func3 = gr.Label(label = "result3")
+
+    b1 = gr.Button("x^2")
+    b2 = gr.Button("y^2")
+    b3 = gr.Button("x^2+y^2")
+
+
+    b1.click(func1, inputs=input_func1, outputs=output_func1)
+    b2.click(func2, inputs=input_func2, outputs=output_func2)
+    b3.click(func3, inputs=output_func1, outputs=output_func3)
+
+    # b2.click(play_audio, inputs=output_func1, outputs=output_func2)
+
+demo.launch(share=True, debug=True)
+
+def main_func(input_string, speed = 1):
+  audio_result = play_audio(input_string)
+
+  audio_result_modified = play_audio_with_various_space_between_chunks(audio_result, silence_duration = float(speed))
+  return audio_result_modified
+
+main_func("ǎ bà",".1")