scripts/prepare_data.py

"""
prepare_data.py  —  Step 3: pull Igbo-English clips from AfriSwitch.

Runs in Google Colab. Streams the AfriSwitch dataset (does NOT download all
54h), saves N clips as .wav into audio/<language>/, and writes/append rows to
audio/ground_truth.csv with the true transcript for each clip.

Defensive by design: AfriSwitch's exact field names were not assumed. The
script prints the dataset's real schema first, then auto-detects the
transcript column from a list of likely names. If none match, it stops and
shows you the available columns so we fix ONE line instead of guessing.

Usage (in a Colab cell):
    !python prepare_data.py --language igbo --n 30

Config name / split handling is also auto-detected: AfriSwitch may expose
each language as a separate config, or as a column inside one dataset. Both
paths are tried.
"""

import argparse
import csv
import os
import re

import soundfile as sf
from datasets import (
    load_dataset,
    get_dataset_config_names,
    get_dataset_split_names,
)

DATASET_ID = "intronhealth/AfriSwitch"

# Likely names for the ground-truth transcript column, in priority order.
# The first one present in the dataset's features wins.
TRANSCRIPT_FIELD_CANDIDATES = [
    "transcript",
    "transcription",
    "text",
    "sentence",
    "target",
    "normalized_text",
]

# Likely names for the audio column.
AUDIO_FIELD_CANDIDATES = ["audio", "audio_file", "path", "file"]

# Map our simple --language values to whatever AfriSwitch might call them.
# We try each candidate as a config name; the first that loads wins.
LANGUAGE_ALIASES = {
    "igbo": ["igbo", "ig", "Igbo", "ibo"],
    "yoruba": ["yoruba", "yo", "Yoruba"],
    "hausa": ["hausa", "ha", "Hausa"],
    "pidgin": ["pidgin", "pcm", "Pidgin", "naija"],
}

REPO_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
AUDIO_DIR = os.path.join(REPO_ROOT, "audio")
GROUND_TRUTH_CSV = os.path.join(AUDIO_DIR, "ground_truth.csv")


def pick_split(config_name):
    """
    AfriSwitch has no 'train' split. Ask the dataset what splits it actually
    has and prefer test/validation/eval, else fall back to the first one.
    """
    try:
        splits = get_dataset_split_names(DATASET_ID, config_name)
    except Exception as e:  # noqa: BLE001
        print(f"[info] Could not list splits ({e}); defaulting to 'test'.")
        return "test"
    print(f"[info] Available splits for '{config_name}': {splits}")
    for preferred in ("test", "validation", "eval", "dev", "train"):
        if preferred in splits:
            return preferred
    return splits[0]


def detect_field(features, candidates, kind):
    """Return the first candidate present in the dataset features."""
    for name in candidates:
        if name in features:
            return name
    raise SystemExit(
        f"\n[STOP] Could not find the {kind} column.\n"
        f"Tried: {candidates}\n"
        f"Actual columns in this dataset: {list(features)}\n"
        f"Fix: add the correct name to the *_FIELD_CANDIDATES list at the top "
        f"of prepare_data.py and re-run."
    )


def load_language_stream(language):
    """
    Try to open a streaming split for the requested language.

    Strategy 1: language is its own config name (load_dataset(id, config)).
    Strategy 2: single dataset with a 'language' column we filter on.
    Returns (streaming_dataset, needs_language_filter, language_value_used).
    """
    aliases = LANGUAGE_ALIASES.get(language, [language])

    # What configs does this dataset actually expose?
    try:
        configs = get_dataset_config_names(DATASET_ID)
        print(f"[info] Available configs: {configs}")
    except Exception as e:  # noqa: BLE001
        configs = []
        print(f"[info] Could not list configs ({e}); will try default load.")

    # Strategy 1 — language as a config.
    for alias in aliases:
        if alias in configs:
            split = pick_split(alias)
            print(f"[info] Loading config '{alias}' split '{split}' (streaming)…")
            ds = load_dataset(DATASET_ID, alias, split=split, streaming=True)
            return ds, False, alias

    # Strategy 2 — default dataset, filter by a language column later.
    split = pick_split(None)
    print(f"[info] No per-language config matched; loading default split "
          f"'{split}' (streaming) and will filter by language column.")
    ds = load_dataset(DATASET_ID, split=split, streaming=True)
    return ds, True, aliases[0]


def extract_audio(audio):
    """
    Return (samples_ndarray, sampling_rate) from whatever the datasets library
    hands us. Handles two formats:
      - classic HF Audio feature: {"array": np.ndarray, "sampling_rate": int}
      - newer torchcodec AudioDecoder object (datasets >= 3.x with torchcodec)
    """
    import numpy as np

    # Classic dict format.
    if isinstance(audio, dict) and "array" in audio:
        return np.asarray(audio["array"]), int(audio["sampling_rate"])

    # torchcodec AudioDecoder — decode all samples to a tensor.
    if hasattr(audio, "get_all_samples"):
        samples = audio.get_all_samples()
        data = samples.data  # torch tensor, shape [channels, num_samples]
        arr = data.numpy() if hasattr(data, "numpy") else np.asarray(data)
        if arr.ndim == 2:
            arr = arr.T  # soundfile wants [num_samples, channels]
        return arr, int(samples.sample_rate)

    raise SystemExit(
        f"[STOP] Don't know how to read audio object of type {type(audio)}. "
        f"Attributes: {dir(audio)[:20]}"
    )


def slugify(value, fallback):
    value = re.sub(r"[^a-zA-Z0-9._-]", "_", str(value)).strip("_")
    return value or fallback


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--language", default="igbo",
                        choices=list(LANGUAGE_ALIASES))
    parser.add_argument("--n", type=int, default=30,
                        help="number of clips to pull")
    args = parser.parse_args()

    out_dir = os.path.join(AUDIO_DIR, args.language)
    os.makedirs(out_dir, exist_ok=True)

    ds, needs_filter, lang_value = load_language_stream(args.language)

    # Peek the first example to learn the schema before committing.
    first = next(iter(ds))
    print(f"\n[schema] Columns: {list(first.keys())}")
    audio_field = detect_field(first, AUDIO_FIELD_CANDIDATES, "audio")
    text_field = detect_field(first, TRANSCRIPT_FIELD_CANDIDATES, "transcript")
    lang_field = None
    if needs_filter:
        for cand in ("language", "lang", "locale"):
            if cand in first:
                lang_field = cand
                break
        if lang_field is None:
            raise SystemExit(
                f"[STOP] Need to filter by language but found no language "
                f"column. Columns: {list(first.keys())}"
            )
        print(f"[info] Filtering on '{lang_field}' == '{lang_value}'")

    print(f"[info] audio column  = '{audio_field}'")
    print(f"[info] text column   = '{text_field}'")

    # Re-open the stream so we start from the top (we consumed one above).
    ds, _, _ = load_language_stream(args.language)

    rows = []
    saved = 0
    scanned = 0
    for ex in ds:
        scanned += 1
        if needs_filter and str(ex.get(lang_field, "")).lower() != lang_value.lower():
            continue

        array, sr = extract_audio(ex[audio_field])

        clip_id = f"{args.language}_{saved:03d}"
        wav_path = os.path.join(out_dir, f"{clip_id}.wav")
        sf.write(wav_path, array, sr)

        transcript = str(ex[text_field]).strip()
        rows.append((clip_id, args.language, transcript))
        saved += 1
        print(f"  [{saved}/{args.n}] {clip_id}.wav  ← \"{transcript[:50]}…\"")

        if saved >= args.n:
            break

    # Write/refresh ground_truth.csv (header + all rows for this language).
    # Preserve any existing rows for OTHER languages.
    existing = []
    if os.path.exists(GROUND_TRUTH_CSV):
        with open(GROUND_TRUTH_CSV, newline="", encoding="utf-8") as f:
            reader = csv.reader(f)
            header = next(reader, None)
            for r in reader:
                if len(r) >= 3 and r[1] != args.language:
                    existing.append(tuple(r[:3]))

    with open(GROUND_TRUTH_CSV, "w", newline="", encoding="utf-8") as f:
        writer = csv.writer(f)
        writer.writerow(["clip_id", "language", "transcript"])
        writer.writerows(existing)
        writer.writerows(rows)

    print(f"\n[done] Saved {saved} clips to {out_dir}")
    print(f"[done] Wrote {len(rows)} rows for '{args.language}' to {GROUND_TRUTH_CSV}")
    print(f"[note] Scanned {scanned} dataset examples to collect them.")


if __name__ == "__main__":
    main()