download_audio.py

import json
import os
import tarfile
import zipfile
import gzip
import subprocess
from os.path import join as p_join
from math import ceil, floor
from tqdm import tqdm
from multiprocessing import Pool
from typing import Optional, Dict
from glob import glob
# import librosa

import pandas as pd
import soundfile as sf
from datasets import Dataset, Audio, DatasetDict

audio_loader = Audio()
# dataset config
url_metadata_dict = {
    "enA-jaA": "https://dl.fbaipublicfiles.com/seamless/data/seamless_align_nov2023_extension/seamless.dataset.metadata.public.enA-jaA.tsv.gz",
    "enA-jpn": "https://dl.fbaipublicfiles.com/seamless/data/seamless.dataset.metadata.public.enA-jpn.withduration.tsv.gz"
}
direction = os.getenv("DIRECTION", "enA-jaA")
sides = set(direction.split("-"))
cache_dir_audio = p_join("download", "audio", direction)
cache_dir_feature = p_join("download", "feature", direction)
os.makedirs(cache_dir_feature, exist_ok=True)
for s in sides:
    os.makedirs(p_join(cache_dir_audio, s), exist_ok=True)
# processor config
n_pool = int(os.getenv("N_POOL", 1))
wget_max_retry = os.getenv("MAX_RETRY", "2")
wget_timeout = os.getenv("TIMEOUT", "20")
line_no_start = int(os.getenv("LINE_NO_START", 0))
line_no_end = int(os.getenv("LINE_NO_END", 10000))
dataset_id = os.getenv("DATASET_ID", 0)
hf_org = os.getenv("HF_ORG", "asahi417")
hf_dataset = f"seamless-align-{direction}"
skip_download = bool(int(os.getenv("SKIP_DOWNLOAD", 0)))
sampling_rate = 16000  # seamless-align aligns audio in 16kHz


def wget(url: str, output_file: Optional[str] = None):
    os.makedirs(os.path.dirname(output_file), exist_ok=True)
    subprocess.run(["wget", url, "-O", output_file, "--tries", wget_max_retry, "--timeout", wget_timeout])
    if not os.path.exists(output_file):
        return False
    if output_file.endswith('.tar.gz') or output_file.endswith('.tgz') or output_file.endswith('.tar'):
        if output_file.endswith('.tar'):
            tar = tarfile.open(output_file)
        else:
            tar = tarfile.open(output_file, "r:gz")
        tar.extractall(os.path.dirname(output_file))
        tar.close()
        os.remove(output_file)
    elif output_file.endswith('.gz'):
        with gzip.open(output_file, 'rb') as f:
            with open(output_file.replace('.gz', ''), 'wb') as f_write:
                f_write.write(f.read())
        os.remove(output_file)
    elif output_file.endswith('.zip'):
        with zipfile.ZipFile(output_file, 'r') as zip_ref:
            zip_ref.extractall()
        os.remove(output_file)
    return True


def get_metadata():
    url_metadata = url_metadata_dict[direction]
    meta_data_filename = os.path.basename(url_metadata)
    meta_data_path = p_join("download", "meta", meta_data_filename)
    if not os.path.exists(meta_data_path.replace(".gz", "")):
        assert wget(url_metadata, output_file=meta_data_path)
    df = pd.read_csv(meta_data_path.replace(".gz", ""), sep=r'[\t\s]', header=None)
    df = df[[0, 2, 3, 4, 9, 10, 11, 12]]
    df.columns = ["id", "url", "duration_start", "duration_end", "laser_score", "direction", "side", "line_no"]
    if direction == "enA-jpn":
        df = df[df["side"] == "enA"]
    assert len(df["direction"].unique()) == 1
    df.pop("direction")
    return df.sort_values(by=["line_no", "side"])


def to_json_serializable(val):
    if "float" in str(type(val)):
        return float(val)
    if "int" in str(type(val)):
        return int(val)
    return str(val)


def cleanup(features, feature_file):
    if os.path.exists(feature_file):
        os.remove(feature_file)
    for _side in sides:
        for _unrelated_audio_file in glob(p_join(cache_dir_audio, _side, f"{features['line_no']}.*")):
            os.remove(_unrelated_audio_file)
    # create a dummy so that we can skip from next run
    with open(feature_file, "w") as f:
        json.dump({"dummy": "dummy"}, f)


def get_audio(dataframe: pd.DataFrame):
    resampler = {}
    features = {"line_no": int(dataframe.pop('line_no').values[0])}
    feature_file = p_join(cache_dir_feature, f'{features["line_no"]}.json')
    for side, df in dataframe.groupby("side"):
        df.pop("side")
        features.update({f"{side}.{k}": to_json_serializable(v) for k, v in df.iloc[0].to_dict().items()})
        identifier = os.path.basename(features[f"{side}.url"]).split(".")[-1]
        features[f"{side}.path"] = str(p_join(cache_dir_audio, side, f"{features['line_no']}.{identifier}"))
        start, end = features[f"{side}.duration_start"], features[f"{side}.duration_end"]
        if not os.path.exists(features[f"{side}.path"]):
            print(f"WGET {features[f'{side}.url']}")
            flag = wget(features[f"{side}.url"], output_file=features[f"{side}.path"])
            if not flag:
                print("\n#### ERROR: wget failure ####\n")
                cleanup(features, feature_file)
                return None
            else:
                try:
                    print(f"LOAD AUDIO FROM {features[f'{side}.path']}")
                    wav, sr = sf.read(features[f"{side}.path"])
                    print(f"wav shape:{wav.shape}")
                    if wav.ndim > 1:
                        wav = wav[:, 0]
                    wav = wav[floor(start / sampling_rate * sr):ceil(end / sampling_rate * sr)]
                    print(f"wav shape (after truncate):{wav.shape}")
                    wav = wav[:int(end/sampling_rate * sr) + sr]
                    print(f"SAVING: {features[f'{side}.path']}")
                    sf.write(features[f"{side}.path"], wav, sr)
                    # if sr != sampling_rate:
                    #     print(f"RESAMPLING: {wav.shape} length audio")
                    #     wav = librosa.resample(wav, orig_sr=sr, target_sr=sampling_rate)
                    # sf.write(features[f"{side}.path"], wav[start:end], sampling_rate)

                except Exception as e:
                    print(f"\n#### ERROR ####\n {e}")
                    cleanup(features, feature_file)
                    return None
    print(f"\n### SUCCESS! ###\n:{features['line_no']}")
    with open(feature_file, "w") as f:
        json.dump(features, f)
    return features["line_no"]


if __name__ == '__main__':
    if not skip_download:
        df_metadata = get_metadata()
        print(f"metadata: {len(df_metadata)}, {line_no_start} --> {line_no_end}")
        inputs = [
            g for line_no, g in df_metadata.groupby("line_no")
            if line_no_start <= line_no < line_no_end and not os.path.exists(
                p_join(cache_dir_feature, f'{int(line_no)}.json')
            )
        ]
        print(f"filtered unique lines: {len(inputs)}")
        if direction == "enA-jaA":
            inputs = [g for g in inputs if len(g["side"].unique()) == 2 and set(g["side"].unique()) == sides]
            print(f"removed side != 2: {len(inputs)}")

        if n_pool == 1:
            for g in tqdm(inputs, total=len(inputs)):
                line_no = get_audio(g)
        else:
            with Pool(n_pool) as pool:
                for line_no in pool.imap_unordered(get_audio, inputs):
                    if line_no:
                        print(line_no)

    def loader(feature: str) -> Dict:
        with open(feature) as f_reader:
            return json.load(f_reader)


    print("UPLOADING TO HF!!!")
    features = [p_join(cache_dir_feature, f'{i}.json') for i in range(line_no_start, line_no_end)]
    print(f"- raw feature: {len(features)}")
    features = [i for i in features if os.path.exists(i)]
    print(f"- path exists: {len(features)}")
    features = [loader(i) for i in features]
    features = [i for i in features if "dummy" not in i]
    print(f"- dummy removed: {len(features)}")
    print(f"push {len(features)} records to hub")
    data_dict = {}
    for side in sides:
        data_dict.update({f"{side}.audio": [i.pop(f"{side}.path") for i in features]})
    data_dict.update({k: [i[k] for i in features] for k in features[0].keys()})
    audio_dataset = Dataset.from_dict(data_dict)
    for side in sides:
        audio_dataset = audio_dataset.cast_column(f"{side}.audio", Audio())
    DatasetDict({"train": audio_dataset}).push_to_hub(
        f"{hf_org}/{hf_dataset}",
        config_name=f"subset_{dataset_id}"
    )


    # DatasetDict({"train": audio_dataset.select(list(range(1000)))}).push_to_hub(
    #     f"{hf_org}/{hf_dataset}",
    #     config_name=f"subset_{dataset_id}"
    # )

    # # 2 panel
    # dataset_id = 75
    # DatasetDict({"train": audio_dataset.select(list(range(3000, len(audio_dataset))))}).push_to_hub(
    #     f"{hf_org}/{hf_dataset}",
    #     config_name=f"subset_{dataset_id}"
    # )
    #
    #


    # audio_dataset = audio_dataset.select(list(range(2500)))
    # dataset_to_push = DatasetDict({"train": audio_dataset})
    # repo_name = f"{hf_org}/{hf_dataset}"
    # dataset_to_push.push_to_hub(repo_name, config_name=f"subset_{dataset_id}")
    # dataset_to_push.push_to_hub(repo_name, config_name=f"subset_{dataset_id}", max_shard_size="2GiB")
    # dataset_to_push.push_to_hub(repo_name, config_name=f"subset_{dataset_id}", num_shards={"train": 1})

    # while True:
    #     try:
    #         dataset_to_push.push_to_hub(repo_name, config_name=f"subset_{dataset_id}")
    #         break
    #     except Exception:
    #         print(f"FAILED: push_to_hub on {repo_name} failed. wait 60 sec and retry soon...")
    #         time.sleep(60)