""" Gradio Audio Dataset Collector -------------------------------- Features: - Upload a CSV of English sentences. Optional column: pidgin_text. - For each row: view English (read-only), edit/add Pidgin translation, record audio from mic. - Listen before saving; overwrite allowed. No timestamps in filenames — saved as `.wav`. - Navigate Previous/Next or jump via dropdown. Review table updates live. - Export metadata CSV and a ZIP (audio + metadata) for sharing. CSV requirements: - If your CSV has columns named `english_text` (required) and optionally `pidgin_text` and `row_id`. - If `row_id` is missing, it will be created as 0..N-1. Run: pip install gradio pandas numpy soundfile scipy python app.py Then open the local URL Gradio prints. """ import os import io import shutil from typing import Tuple, Optional, List import numpy as np import pandas as pd import gradio as gr # Optional audio writers try: import soundfile as sf HAVE_SF = True except Exception: HAVE_SF = False from scipy.io import wavfile AUDIO_DIR = "recordings" META_CSV_PATH = "combined_sentences.csv" EXPORT_ZIP_PATH = "dataset_export.zip" DEFAULT_CSV_PATH = "combined_sentences.csv" STATE_FILE = "app_state.txt" os.makedirs(AUDIO_DIR, exist_ok=True) # ----------------------------- # Helpers # ----------------------------- def save_state(idx: int): with open(STATE_FILE, 'w') as f: f.write(str(idx)) def load_state() -> int: if os.path.exists(STATE_FILE): try: with open(STATE_FILE, 'r') as f: return int(f.read().strip()) except: pass return 0 def load_csv(fileobj) -> Tuple[pd.DataFrame, int, List[int]]: df = pd.read_csv(fileobj) # Normalize columns # Expect english_text; allow variations if "english_text" not in df.columns: # Try to infer a reasonable column candidates = [c for c in df.columns if str(c).lower() in ["english", "text", "sentence", "prompt"]] if candidates: df = df.rename(columns={candidates[0]: "english_text"}) else: raise ValueError("CSV must include an 'english_text' column (or a similar one like 'sentence').") if "pidgin_text" not in df.columns: df["pidgin_text"] = "" if "row_id" not in df.columns: df["row_id"] = range(len(df)) if "audio_file_path" not in df.columns: df["audio_file_path"] = "" # Ensure types df["english_text"] = df["english_text"].astype(str) df["pidgin_text"] = df["pidgin_text"].astype(str) df["row_id"] = df["row_id"].astype(int) df["audio_file_path"] = df["audio_file_path"].astype(str) # Sort by row_id to keep ordering stable df = df.sort_values("row_id").reset_index(drop=True) idx = load_state() idx = max(0, min(idx, len(df) - 1)) options = df["row_id"].tolist() return df, idx, options def get_row_view(df: pd.DataFrame, idx: int): row = df.iloc[idx] english = row["english_text"] pidgin = row["pidgin_text"] row_id = int(row["row_id"]) audio_path = row.get("audio_file_path", "") or "" audio_display = audio_path if (audio_path and os.path.exists(audio_path)) else None return row_id, english, pidgin, audio_display def get_progress(df: pd.DataFrame) -> str: if df.empty: return "No data loaded" has_text = df["pidgin_text"].str.strip() != "" has_audio = df["audio_file_path"].str.strip() != "" audio_exists = df["audio_file_path"].apply(lambda x: os.path.exists(x) if x else False) completed = len(df[has_text & has_audio & audio_exists]) total = len(df) return f"Progress: {completed}/{total} completed ({completed/total*100:.1f}%)" def find_next_incomplete(df: pd.DataFrame, current_idx: int) -> int: if df.empty: return current_idx incomplete = df[(df["pidgin_text"].str.strip() == "") | (df["audio_file_path"].str.strip() == "")] if incomplete.empty: return current_idx next_incomplete = incomplete[incomplete.index > current_idx] if not next_incomplete.empty: return next_incomplete.index[0] return incomplete.index[0] def write_wav(filepath: str, audio_tuple) -> None: """Write (sr, np.ndarray) to filepath as 16-bit PCM WAV.""" if audio_tuple is None: return sr, data = audio_tuple # Ensure data is numpy array data = np.array(data, dtype=np.float32) # Ensure mono if data.ndim > 1: data = np.mean(data, axis=1) # Normalize to [-1, 1] range if np.max(np.abs(data)) > 0: data = data / np.max(np.abs(data)) if HAVE_SF: sf.write(filepath, data, samplerate=sr, subtype="PCM_16") else: # Convert to int16 for scipy writer data_i16 = np.int16(data * 32767) wavfile.write(filepath, sr, data_i16) def save_current(df: pd.DataFrame, idx: int, pidgin_text: str, audio_np) -> Tuple[pd.DataFrame, str, Optional[str]]: row = df.iloc[idx] row_id = int(row["row_id"]) # Update text first df.at[idx, "pidgin_text"] = pidgin_text or "" saved_audio_path = None # Save audio if provided; otherwise leave existing file as-is if audio_np is not None: # No timestamps — fixed name per row saved_audio_path = os.path.join(AUDIO_DIR, f"{row_id}.wav") write_wav(saved_audio_path, audio_np) df.at[idx, "audio_file_path"] = saved_audio_path else: # Keep existing path saved_audio_path = df.at[idx, "audio_file_path"] or None # Persist metadata CSV and state df.to_csv(META_CSV_PATH, index=False) save_state(idx) status = "Saved (text and audio)." if audio_np is not None else "Saved text (no new audio)." return df, status, saved_audio_path def goto_index(df: pd.DataFrame, idx: int): idx = max(0, min(idx, len(df) - 1)) return get_row_view(df, idx), idx def export_dataset(df: pd.DataFrame) -> Tuple[str, str]: # Always refresh metadata before export df.to_csv(META_CSV_PATH, index=False) # Create ZIP containing recordings/ + metadata.csv if os.path.exists(EXPORT_ZIP_PATH): os.remove(EXPORT_ZIP_PATH) # Make an archive in a temp folder structure tmp_root = "_export_tmp" if os.path.exists(tmp_root): shutil.rmtree(tmp_root) os.makedirs(tmp_root, exist_ok=True) # Copy metadata shutil.copy2(META_CSV_PATH, os.path.join(tmp_root, os.path.basename(META_CSV_PATH))) # Copy audio dir out_audio = os.path.join(tmp_root, os.path.basename(AUDIO_DIR)) shutil.copytree(AUDIO_DIR, out_audio, dirs_exist_ok=True) shutil.make_archive("dataset_export", "zip", tmp_root) shutil.rmtree(tmp_root) return META_CSV_PATH, EXPORT_ZIP_PATH # ----------------------------- # UI # ----------------------------- with gr.Blocks(title="English→Pidgin Audio Collector", theme=gr.themes.Soft()) as demo: gr.Markdown(""" # English → Pidgin Audio Collector Upload your CSV of English sentences, or use the default provided below. """) state_df = gr.State(pd.DataFrame()) state_idx = gr.State(0) with gr.Row(): csv_in = gr.File(label="Upload CSV", file_types=[".csv"], file_count="single") load_btn = gr.Button("Load CSV", variant="primary") default_btn = gr.Button("Use Default CSV", variant="secondary") # NEW BUTTON with gr.Row(): row_picker = gr.Dropdown(label="Jump to Row ID", choices=[], interactive=True, allow_custom_value=True) with gr.Row(): row_id_out = gr.Number(label="Row ID", interactive=False) progress_out = gr.Markdown("No data loaded") english_box = gr.Textbox(label="English (read-only)", interactive=False, lines=3) pidgin_box = gr.Textbox(label="Pidgin (editable)", interactive=True, lines=3, placeholder="Type Pidgin translation here…") def auto_save_text(df, idx, text): try: if df.empty: return df df.at[idx, "pidgin_text"] = text or "" df.to_csv(META_CSV_PATH, index=False) return df except Exception: return df pidgin_box.change(auto_save_text, [state_df, state_idx, pidgin_box], [state_df]) gr.Markdown("### Record / Review") with gr.Row(): mic = gr.Audio(sources=["microphone"], type="numpy", label="Record Pidgin (mic)") saved_audio_player = gr.Audio(label="Current Saved Audio", interactive=False) with gr.Row(): save_btn = gr.Button("💾 Save / Overwrite", variant="primary") rerecord_btn = gr.Button("↺ Clear Recording (Re-record)") with gr.Row(): prev_btn = gr.Button("◀ Previous") next_btn = gr.Button("Next ▶") skip_btn = gr.Button("⏭ Skip to Incomplete", variant="secondary") status_out = gr.Markdown(visible=True) gr.Markdown("### Review Table (live)") table = gr.Dataframe( headers=["row_id", "english_text", "pidgin_text", "audio_file_path"], interactive=False, column_widths=["10%", "35%", "35%", "20%"] ) with gr.Row(): export_meta_btn = gr.Button("Export Metadata CSV") export_zip_btn = gr.Button("Export ZIP (Audio + Metadata)") meta_file = gr.File(label="Download metadata.csv", interactive=False) zip_file = gr.File(label="Download dataset_export.zip", interactive=False) # ----------------------------- # Callbacks # ----------------------------- def on_load(file): try: if file is None: raise gr.Error("Please upload a CSV file.") df, idx, options = load_csv(file.name) (row_id, eng, pid, audio), idx = goto_index(df, idx) table_df = df[["row_id", "english_text", "pidgin_text", "audio_file_path"]].copy() table_df["english_text"] = table_df["english_text"].str[:50] + "..." table_df["pidgin_text"] = table_df["pidgin_text"].str[:50] + "..." progress = get_progress(df) return ( df, idx, options, gr.update(value=row_id, interactive=False), eng, pid, audio, table_df, gr.update(choices=options, value=row_id), "Loaded CSV.", progress ) except Exception as e: return pd.DataFrame(), 0, [], None, "", "", None, pd.DataFrame(), gr.update(choices=[]), f"Error: {str(e)}", "No data loaded" load_btn.click( fn=on_load, inputs=[csv_in], outputs=[state_df, state_idx, row_picker, row_id_out, english_box, pidgin_box, saved_audio_player, table, row_picker, status_out, progress_out] ) # NEW: Load default CSV callback def on_load_default(): try: if not os.path.exists(DEFAULT_CSV_PATH): return pd.DataFrame(), 0, [], None, "", "", None, pd.DataFrame(), gr.update(choices=[]), f"Default CSV not found at {DEFAULT_CSV_PATH}", "No data loaded" df, idx, options = load_csv(DEFAULT_CSV_PATH) (row_id, eng, pid, audio), idx = goto_index(df, idx) table_df = df[["row_id", "english_text", "pidgin_text", "audio_file_path"]].copy() table_df["english_text"] = table_df["english_text"].str[:50] + "..." table_df["pidgin_text"] = table_df["pidgin_text"].str[:50] + "..." progress = get_progress(df) return ( df, idx, gr.update(choices=options, value=row_id), gr.update(value=row_id, interactive=False), eng, pid, audio, table_df, gr.update(choices=options, value=row_id), "Loaded default CSV.", progress ) except Exception as e: return pd.DataFrame(), 0, gr.update(choices=[]), None, "", "", None, pd.DataFrame(), gr.update(choices=[]), f"Error: {str(e)}", "No data loaded" default_btn.click( fn=on_load_default, inputs=None, outputs=[state_df, state_idx, row_picker, row_id_out, english_box, pidgin_box, saved_audio_player, table, row_picker, status_out, progress_out] ) def on_pick(df, current_idx, pick_id): try: if df is None or len(df) == 0: return current_idx, None, "", "", None idx = int(df.index[df["row_id"] == int(pick_id)][0]) (row_id, eng, pid, audio), idx = goto_index(df, idx) return idx, row_id, eng, pid, audio except Exception: return current_idx, None, "", "", None row_picker.change( fn=on_pick, inputs=[state_df, state_idx, row_picker], outputs=[state_idx, row_id_out, english_box, pidgin_box, saved_audio_player] ) def nav(df, idx, step): try: if df is None or len(df) == 0: return idx, None, "", "", None, gr.update(), "No data loaded" idx = max(0, min(idx + step, len(df) - 1)) (row_id, eng, pid, audio), idx = goto_index(df, idx) progress = get_progress(df) return idx, row_id, eng, pid, audio, gr.update(value=row_id), progress except Exception: return idx, None, "", "", None, gr.update(), "Error navigating" def skip_to_incomplete(df, idx): try: if df is None or len(df) == 0: return idx, None, "", "", None, gr.update(), "No data loaded" idx = find_next_incomplete(df, idx) (row_id, eng, pid, audio), idx = goto_index(df, idx) progress = get_progress(df) return idx, row_id, eng, pid, audio, gr.update(value=row_id), progress except Exception: return idx, None, "", "", None, gr.update(), "Error finding incomplete" prev_btn.click(lambda df, idx: nav(df, idx, -1), [state_df, state_idx], [state_idx, row_id_out, english_box, pidgin_box, saved_audio_player, row_picker, progress_out]) next_btn.click(lambda df, idx: nav(df, idx, 1), [state_df, state_idx], [state_idx, row_id_out, english_box, pidgin_box, saved_audio_player, row_picker, progress_out]) skip_btn.click(skip_to_incomplete, [state_df, state_idx], [state_idx, row_id_out, english_box, pidgin_box, saved_audio_player, row_picker, progress_out]) def on_save(df, idx, pidgin_text, audio_np): try: if df is None or len(df) == 0: return df, None, pd.DataFrame(), "No data to save", None, "No data loaded", "" df, status, saved_path = save_current(df, idx, pidgin_text, audio_np) table_df = df[["row_id", "english_text", "pidgin_text", "audio_file_path"]].copy() table_df["english_text"] = table_df["english_text"].str[:50] + "..." table_df["pidgin_text"] = table_df["pidgin_text"].str[:50] + "..." (row_id, eng, pid, audio), idx = goto_index(df, idx) progress = get_progress(df) return df, saved_path if saved_path else None, table_df, status, None, progress, pid except Exception as e: return df, None, pd.DataFrame(), f"Save error: {str(e)}", None, "Error", "" save_btn.click( fn=on_save, inputs=[state_df, state_idx, pidgin_box, mic], outputs=[state_df, saved_audio_player, table, status_out, mic, progress_out, pidgin_box] ) def on_rerecord(): return gr.update(value=None), "Recording cleared. You can re-record now." rerecord_btn.click(on_rerecord, outputs=[mic, status_out]) def do_export_meta(df): if df is None or len(df) == 0: raise gr.Error("Load a CSV first.") meta_path, _ = export_dataset(df) return gr.update(value=meta_path) export_meta_btn.click(do_export_meta, inputs=[state_df], outputs=[meta_file]) def do_export_zip(df): if df is None or len(df) == 0: raise gr.Error("Load a CSV first.") _, zip_path = export_dataset(df) return gr.update(value=zip_path) export_zip_btn.click(do_export_zip, inputs=[state_df], outputs=[zip_file]) # Auto-load default CSV on startup def auto_load(): try: if os.path.exists(DEFAULT_CSV_PATH): df, idx, options = load_csv(DEFAULT_CSV_PATH) (row_id, eng, pid, audio), idx = goto_index(df, idx) table_df = df[["row_id", "english_text", "pidgin_text", "audio_file_path"]].copy() table_df["english_text"] = table_df["english_text"].str[:50] + "..." table_df["pidgin_text"] = table_df["pidgin_text"].str[:50] + "..." progress = get_progress(df) return ( df, idx, gr.update(choices=options, value=row_id), row_id, eng, pid, audio, table_df, "Auto-loaded default CSV.", progress ) except Exception: pass return pd.DataFrame(), 0, gr.update(choices=[]), None, "", "", None, pd.DataFrame(), "No default CSV found.", "No data loaded" demo.load( fn=auto_load, outputs=[state_df, state_idx, row_picker, row_id_out, english_box, pidgin_box, saved_audio_player, table, status_out, progress_out] ) if __name__ == "__main__": demo.launch(share=True)