scripts/create_data_manifest.py

"""Script to create Nemo compatible data manifests for jeli-asr"""

## Imports
import glob
import os
import csv
import random
import json
import shutil
import sys
from pydub import AudioSegment

# Key callable to sort wav files paths
def key_sort_paths(path: str) -> int:
    """Serve as key function to sort the wav files paths

    Args:
        path (str): An individual path

    Returns:
        int: The number of the split (between 1 and 6)
    """
    return int(path[-5])

# Function to read and combine the audios
def read_audios(glob_paths: list[str]) -> AudioSegment:
    """Read the six 10 mns audio as AudioSegments and returns the combined 1 hr audio

    Args:
        glob_paths (list[str]): list of the paths of the 6 .wav files

    Returns:
        AudioSegment: The combined audio
    """
    audios = []
    for wav_file in sorted(glob_paths, key=key_sort_paths):
        audios.append(AudioSegment.from_file(file=wav_file, format="wav"))
    final_audio = sum(audios[1:], start=audios[0])
    return final_audio

# A function that reads and return the utterances from .tsv files
def read_tsv(tsv_file_path: str) -> list[list[int | str]]:
    """Read a .tsv file and return the utterances in it

    Args:
        tsv_file_path (str): The path to the tsv file

    Returns:
        list[list[int | str]]: The returned utterances with the timestamps coverted to int
    """
    with open(tsv_file_path,"r", encoding='utf-8') as recording_transcript:
        tsv_file_rows = csv.reader(recording_transcript, delimiter="\t")
        utterances = [[int(start), int(end), bam, french] for start, end, bam, french in tsv_file_rows]
    return utterances
            
# Function to subdivide the audio (transcript) into multiple variable length slices
def create_var_length_samples(utterances: list[list[int | str]], min_duration: int = 1000,
                max_duration: int = 120000) -> list[list[list[int | str]]]:
    """Create variable length combination of utterances to make samples which duration vary between 1s and 2mns

    Args:
        utterances (list[list[int  |  str]]): The read tsv file containing the transcriptions of the audio
        min_duration (int, optional): min duration of a sample in milliseconds. Defaults to 1000.
        max_duration (int, optional): max duration of a sample in milliseconds. Defaults to 120000.

    Returns:
        list[list[list[int | str]]]: The list of created samples
    """
    samples = []
    current_slice = []
    current_duration = 0

    i = 0
    while i < len(utterances):
        utterance_start, utterance_end = utterances[i][:2]
        utterance_duration = utterance_end - utterance_start
        
        # If current slice duration is less than max duration, add the utterance to this sample
        if current_duration + utterance_duration <= max_duration:
            current_slice.append(utterances[i])
            current_duration += utterance_duration
            i += 1
        else:
            # Save the current sample and reset for a new one
            samples.append(current_slice)
            current_slice = []
            current_duration = 0
        
        # Randomly decide whether to end the current sample based on time or number of utterances
        if current_duration >= min_duration:
            if random.choice([True, False, False]) or len(current_slice) >= random.randint(1, 20):
                samples.append(current_slice)
                current_slice = []
                current_duration = 0

    # Add the final slice if it exists
    if current_slice: # equivalent to if current_slice is empty
        samples.append(current_slice)

    return samples

# Function to create and save the audio samples for a specific list of samples
def slice_and_save_audios(samples: list[list[list[int | str]]], griot_id: str,
                          data_dir: str, audio_dir_path: str) -> list[list[float | str]]:
    """Slice and save the audio samples created for a specific 1hr recording

    Args:
        samples (list[list[list[int  |  str]]]): The samples created with function "create_var_length_samples"
        griot_id (str): The ID of the griot in the recording (eg: griots_r17)
        data_dir (str): The directory containing all the data.
        audio_dir_path (str): The diretory the save the sliced audios in.

    Returns:
        list[list[int | str]]: A list version of manifests (eg: [[audiofile_path, duration, bambara, translation], ...])
    """
    wav_files_paths = glob.glob(f'{data_dir}/{griot_id}/*.wav')
    griot_recording = read_audios(glob_paths=wav_files_paths)
    # A list to store only the data needed to create 
    list_manifests = []

    for sample in samples:
        start = sample[0][0]
        end = sample[-1][1]
        duration = (end - start) / 1000 # in seconds
        # Flag audios with more than 100 seconds 
        more_than_100s = " ###" if duration >= 100 else ""

        # get trancriptions and translations of utterances composing the samples
        transcriptions, translations = [utt[2] for utt in sample], [utt[3] for utt in sample]
        transcription = " ".join(transcriptions)
        translation = " ".join(translations)

        # create the sample wav file and save it
        audio_file_path = f"{audio_dir_path}/{griot_id}-{start}-{end}.wav"
        griot_recording[start:end].export(out_f=audio_file_path, format="wav")
        print(f"Sample {griot_id}-{start}-{end} saved in {audio_file_path}{more_than_100s}")

        # Create the manifest list and save it
        list_manifests.append([audio_file_path, duration, transcription, translation])
    return list_manifests

# A function to shuffle and split samples
def shuffle_and_split(dataset: list[list[float | str]],
                      test: int | float = 0.15) -> tuple[list[list[float | str]]]:
    """Shuffle and split the whole dataset

    Args:
        dataset (list[list[int  |  str]]): The combined list of all list manifest returned by "slice_and_save_audios"
        test (int | float, optional): The number of sample to include that make the test set or and percentage of the whole dataset to use as the test set. Defaults to 0.15.

    Returns:
        tuple[list[list[list[int | str]]]]: The train and test sets samples returned separately
    """
    random.shuffle(dataset)
    if isinstance(test, float):
        test = int(test * len(dataset))
    test_set_samples = dataset[0:test]
    train_set_samples = dataset[test:]
    return train_set_samples, test_set_samples

# A function to create audio sample files and manifests
def create_manifest(dataset_split: list[list[float | str]], split_name: str,
                    dir_path: str) -> None:
    """Create manifest files 

    Args:
        dataset_split (list[list[float  |  str]]): Split of the dataset to create manifest for
        split_name (str): Name of the split
        dir_path (str): The directory to save the new data manifest in
    """
    # Ensure directories for manifests and audios
    os.makedirs(f'{dir_path}/manifests', exist_ok=True)
    os.makedirs(f'{dir_path}/french-manifests', exist_ok=True)
    os.makedirs(f'{dir_path}/audios/{split_name}', exist_ok=True)

    # Define manifest file paths
    manifest_path = f'{dir_path}/manifests/{split_name}_manifest.json'
    french_manifest_path = f'{dir_path}/french-manifests/{split_name}_french_manifest.json'
    audio_dir_path = f'{dir_path}/audios/{split_name}'

    with open(manifest_path, 'w', encoding="utf-8") as manifest_file, open(french_manifest_path, 'w', encoding="utf-8") as french_file:
        for sample in dataset_split:
            # move the audio sample file in the corresponding split directory
            new_audio_path = f'{audio_dir_path}/{sample[0].split("/")[-1]}'
            shutil.move(src=sample[0], dst=new_audio_path)

            # Prepare the manifest line
            manifest_line = {
                "audio_filepath": os.path.relpath(new_audio_path),
                "duration": sample[1],
                "text": sample[2]  # Bambara transcription goes to the text field
            }

            french_manifest_line = {
                "audio_filepath": os.path.relpath(new_audio_path),
                "duration": sample[1],
                "text": sample[3]
            }

            # Write manifest files
            manifest_file.write(json.dumps(manifest_line) + '\n')
            french_file.write(json.dumps(french_manifest_line) + '\n')
    print(f"{split_name} manifests files have been created successfully!\nCorresponding audios files have been moved to {audio_dir_path}")

if __name__ == "__main__":
    data_path = sys.argv[1]
    manifest_dir = sys.argv[2]
    tsv_dir = f'{data_path}/aligned-transcriptions'

    # Get all the revised transcription files in .tsv format
    tsv_paths = glob.glob(f'{tsv_dir}/*.tsv')
    # list to store the list manifests per griots
    final_list_manifest = []
    for tsv_file in tsv_paths:
        id_griot = tsv_file.split("/")[-1][:-4]
        griot_utterances = read_tsv(tsv_file_path=tsv_file)
        # Get samples (can be made of one or more utterances)
        griot_samples = create_var_length_samples(utterances=griot_utterances)
        list_manifest = slice_and_save_audios(samples=griot_samples, griot_id=id_griot,
                                    data_dir=data_path, audio_dir_path=f'{manifest_dir}/audios')
        final_list_manifest.append(list_manifest)
    # Get a single list manifest for all the samples
    final_list_manifest = sum(final_list_manifest, start=[])
    # Shuffle and split the final list of all sample,manifests
    train_set, test_set = shuffle_and_split(dataset=final_list_manifest, test=0.15) # Use 15% of the dataset for test
    print(f'len(train_set) == {len(train_set)} and len(test_set) == {len(test_set)}')

    create_manifest(dataset_split=train_set, split_name="train", dir_path=manifest_dir)
    create_manifest(dataset_split=test_set, split_name="test", dir_path=manifest_dir)