Upload 4 files

Code Rebase, clean up - no changes functionality, just under-hood stuff

dataset-creation.py

@@ -0,0 +1,52 @@
+import os
+import subprocess
+from rich.console import Console
+from rich.prompt import Prompt
+from rich.table import Table
+
+# Initialize Rich Console
+console = Console()
+
+# Prompt user for input and output directories
+INPUT_DIR = Prompt.ask("[bold cyan]Enter the input directory for video files[/bold cyan]", default="PATH-TO-VIDEOS")
+OUTPUT_DIR = Prompt.ask("[bold cyan]Enter the output directory for extracted audio[/bold cyan]", default="SAVE-PATH-OF-WAVS")
+
+# Ensure directories exist
+if not os.path.isdir(INPUT_DIR):
+    console.print(f"[bold red]Error:[/bold red] Input directory does not exist: {INPUT_DIR}", style="red")
+    exit(1)
+os.makedirs(OUTPUT_DIR, exist_ok=True)
+
+# Process video files
+video_files = [f for f in sorted(os.listdir(INPUT_DIR)) if f.endswith((".mkv", ".mp4"))]
+if not video_files:
+    console.print(f"[bold red]Error:[/bold red] No video files found in: {INPUT_DIR}", style="red")
+    exit(1)
+
+console.print(f"[bold green]Found {len(video_files)} video file(s). Starting processing...[/bold green]")
+for index, file_name in enumerate(video_files, start=1):
+    input_path = os.path.join(INPUT_DIR, file_name)
+    output_file = os.path.join(OUTPUT_DIR, f"{index:04d}_eng.wav")
+
+    # Construct ffmpeg command
+    ffmpeg_command = [
+        "ffmpeg",
+        "-i", input_path,
+        "-map", "0:m:language:eng",
+        "-vn",
+        "-acodec", "pcm_s16le",
+        "-ar", "16000",
+        "-ac", "1",
+        output_file
+    ]
+
+    console.print(f"Processing: {file_name} ({index}/{len(video_files)})")
+
+    # Execute the ffmpeg command
+    try:
+        subprocess.run(ffmpeg_command, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        console.print(f"[bold green]Success:[/bold green] Extracted audio to: {output_file}", style="green")
+    except subprocess.CalledProcessError as e:
+        console.print(f"[bold red]Error processing {file_name}:[/bold red] {e}", style="red")
+
+console.print("[bold green]All files processed successfully.[/bold green]")

diarize-dataset.py

@@ -0,0 +1,66 @@
+import os
+import json
+from rich.console import Console
+from rich.prompt import Prompt
+from pyannote.audio import Pipeline
+
+# Initialize Rich Console
+console = Console()
+
+# Prompt user for configuration
+HF_TOKEN = Prompt.ask("[bold cyan]Enter your Hugging Face token[/bold cyan]", default="HF-TOKEN-HERE")
+INPUT_DIR = Prompt.ask("[bold cyan]Enter the input directory for WAV files[/bold cyan]", default="WAVS-PATH")
+OUTPUT_DIR = Prompt.ask("[bold cyan]Enter the output directory for diarization JSON files[/bold cyan]", default="JSONS-PATH")
+
+# Validate configuration
+if not HF_TOKEN or not HF_TOKEN.startswith("hf_"):
+    console.print("[bold red]Error:[/bold red] Invalid Hugging Face token.", style="red")
+    exit(1)
+if not os.path.isdir(INPUT_DIR):
+    console.print(f"[bold red]Error:[/bold red] Input directory does not exist: {INPUT_DIR}", style="red")
+    exit(1)
+os.makedirs(OUTPUT_DIR, exist_ok=True)
+
+# Load the speaker diarization pipeline
+console.print("[bold cyan]Loading speaker diarization pipeline...[/bold cyan]")
+try:
+    pipeline = Pipeline.from_pretrained("pyannote/speaker-diarization", use_auth_token=HF_TOKEN)
+    console.print("[bold green]Pipeline loaded successfully.[/bold green]")
+except Exception as e:
+    console.print(f"[bold red]Error loading pipeline:[/bold red] {e}", style="red")
+    exit(1)
+
+# Process WAV files
+wav_files = [f for f in os.listdir(INPUT_DIR) if f.endswith(".wav")]
+if not wav_files:
+    console.print(f"[bold red]Error:[/bold red] No WAV files found in: {INPUT_DIR}", style="red")
+    exit(1)
+
+console.print(f"[bold green]Found {len(wav_files)} WAV file(s). Starting processing...[/bold green]")
+for i, file_name in enumerate(wav_files, start=1):
+    console.print(f"[bold blue][{i}/{len(wav_files)}] Processing {file_name}...[/bold blue]")
+    file_path = os.path.join(INPUT_DIR, file_name)
+
+    try:
+        diarization = pipeline(file_path)
+    except Exception as e:
+        console.print(f"[bold red]Error processing {file_name}:[/bold red] {e}", style="red")
+        continue
+
+    # Extract and save speaker segments
+    data = [
+        {
+            "speaker": speaker,
+            "start": turn.start,
+            "end": turn.end
+        }
+        for turn, _, speaker in diarization.itertracks(yield_label=True)
+    ]
+
+    output_path = os.path.join(OUTPUT_DIR, f"{os.path.splitext(file_name)[0]}.json")
+    with open(output_path, "w") as f:
+        json.dump(data, f, indent=2)
+
+    console.print(f"[bold green]Finished processing {file_name}. Results saved to {output_path}.[/bold green]")
+
+console.print("[bold green]All files processed successfully.[/bold green]")

identify-speaker.py

@@ -0,0 +1,122 @@
+import os
+import json
+import pandas as pd
+import tempfile
+import subprocess
+from datetime import datetime
+from playsound import playsound
+from rich.console import Console
+from rich.prompt import Prompt
+
+# Initialize Rich Console
+console = Console()
+
+# Paths
+JSON_DIR = "JSON-PATH"  # JSON files with all speakers
+AUDIO_DIR = "WAVS-PATH"  # Original WAV files
+MAPPING_FILE = "PATH-TO-speaker_mapping.csv"  # Speaker mapping CSV
+
+# Validate paths
+if not os.path.isdir(JSON_DIR):
+    console.print(f"[bold red]Error:[/bold red] JSON directory does not exist: {JSON_DIR}", style="red")
+    exit(1)
+if not os.path.isdir(AUDIO_DIR):
+    console.print(f"[bold red]Error:[/bold red] Audio directory does not exist: {AUDIO_DIR}", style="red")
+    exit(1)
+if not os.path.isfile(MAPPING_FILE):
+    console.print(f"[bold yellow]Warning:[/bold yellow] Mapping file does not exist. A new file will be created: {MAPPING_FILE}", style="yellow")
+    df = pd.DataFrame(columns=['json_file', 'target_speaker_label'])
+else:
+    df = pd.read_csv(MAPPING_FILE)
+
+# Pre-validate files
+json_files = [f for f in os.listdir(JSON_DIR) if f.endswith(".json")]
+valid_files = []
+for json_file in json_files:
+    json_path = os.path.join(JSON_DIR, json_file)
+    wav_file = os.path.join(AUDIO_DIR, os.path.splitext(json_file)[0] + ".wav")
+    if not os.path.exists(json_path) or not os.path.exists(wav_file):
+        console.print(f"[bold yellow]Skipping {json_file}:[/bold yellow] Missing JSON or WAV file.", style="yellow")
+    else:
+        valid_files.append((json_file, json_path, wav_file))
+
+console.print(f"[bold green]Found {len(valid_files)} valid file(s) to process.[/bold green]")
+
+# Process files
+for json_file, json_path, wav_file in valid_files:
+    if json_file in df['json_file'].values and pd.notna(df.loc[df['json_file'] == json_file, 'target_speaker_label'].values[0]):
+        console.print(f"[bold blue]Skipping {json_file}:[/bold blue] Already mapped.", style="blue")
+        continue
+
+    with open(json_path, "r") as f:
+        try:
+            segments = json.load(f)
+        except json.JSONDecodeError:
+            console.print(f"[bold red]Error:[/bold red] JSON file {json_file} is not properly formatted. Skipping.", style="red")
+            continue
+
+    if not segments:
+        console.print(f"[bold yellow]No segments found in {json_file}. Skipping.[/bold yellow]", style="yellow")
+        continue
+
+    console.rule(f"Processing Episode: [bold green]{json_file}[/bold green]", style="bold blue")
+
+    unique_speakers = list(set(seg["speaker"] for seg in segments))
+    target_speaker_label = None
+
+    for speaker_label in unique_speakers:
+        speaker_segments = [seg for seg in segments if seg["speaker"] == speaker_label]
+
+        for segment in speaker_segments:
+            start_time, end_time = segment["start"], segment["end"]
+
+            if end_time - start_time < 1.0:
+                console.print(f"[bold yellow]Skipping short segment {start_time}-{end_time} for speaker {speaker_label}.[/bold yellow]", style="yellow")
+                continue
+
+            with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as temp_segment:
+                segment_path = temp_segment.name
+                cmd = [
+                    "ffmpeg", "-hide_banner", "-loglevel", "error", "-y",
+                    "-i", wav_file, "-ss", str(start_time), "-to", str(end_time), "-c", "copy",
+                    segment_path
+                ]
+                subprocess_run = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+                if subprocess_run.returncode != 0:
+                    console.print(f"[bold red]Error extracting segment {start_time}-{end_time} for speaker {speaker_label}.[/bold red]", style="red")
+                    continue
+
+            try:
+                playsound(segment_path)
+            except Exception as e:
+                console.print(f"[bold red]Error playing segment for speaker {speaker_label}:[/bold red] {e}", style="red")
+                os.remove(segment_path)
+                continue
+
+            os.remove(segment_path)
+            user_input = Prompt.ask(
+                f"Speaker: [bold yellow]{speaker_label}[/bold yellow]. Is this the target speaker? [Y]es/[N]o/[S]kip remaining",
+                choices=["y", "n", "s"]
+            )
+
+            if user_input == "y":
+                target_speaker_label = speaker_label
+                break
+            elif user_input == "s":
+                break
+
+        if target_speaker_label or user_input == "s":
+            break
+
+    if target_speaker_label:
+        df = pd.concat([df, pd.DataFrame({"json_file": [json_file], "target_speaker_label": [target_speaker_label]})], ignore_index=True)
+        console.print(f"[bold green]Mapped {json_file} to speaker {target_speaker_label}.[/bold green]", style="green")
+    else:
+        df = pd.concat([df, pd.DataFrame({"json_file": [json_file], "target_speaker_label": ["not-target-speaker"]})], ignore_index=True)
+        console.print(f"[bold yellow]No target speaker identified for {json_file}.[/bold yellow]", style="yellow")
+
+    df.to_csv(MAPPING_FILE, index=False)
+    console.print(f"[bold cyan]Mapping saved to {MAPPING_FILE}.[/bold cyan]", style="cyan")
+
+console.print("[bold green]Processing complete.[/bold green]")
+

isolate-trim.py

@@ -0,0 +1,130 @@
+import os
+import json
+import subprocess
+import pandas as pd
+from rich.console import Console
+
+# Initialize Rich Console
+console = Console()
+
+# Paths
+JSON_DIR = "JSON-PATH"  # JSON files with speaker data
+AUDIO_DIR = "WAVS-PATH"  # Original WAV files
+MAPPING_FILE = "PATH-TO-speaker_mapping.csv"  # Mapping CSV
+OUTPUT_DIR = "SAVE-PATH-TARGETED-SPEAKER-WAVS"  # Directory for extracted speaker WAVs
+
+# Ensure output directory exists
+os.makedirs(OUTPUT_DIR, exist_ok=True)
+
+# Load the speaker mapping file
+if not os.path.exists(MAPPING_FILE):
+    console.print(f"[bold red]Mapping file not found:[/bold red] {MAPPING_FILE}")
+    exit(1)
+
+df = pd.read_csv(MAPPING_FILE)
+
+# Maximum length for trimmed clips (in seconds)
+MAX_CLIP_LENGTH = 30
+
+def crop_and_trim_silence(input_file, output_prefix, max_length):
+    """
+    Crops the audio to chunks of max_length seconds, then trims silence.
+    """
+    # Step 1: Get the duration of the input audio
+    probe_cmd = [
+        "ffprobe", "-i", input_file, "-show_entries", "format=duration", 
+        "-v", "error", "-of", "csv=p=0"
+    ]
+    result = subprocess.run(probe_cmd, stdout=subprocess.PIPE, text=True)
+    duration = float(result.stdout.strip())
+
+    # Step 2: Split into chunks of max_length seconds
+    start_time = 0
+    chunk_index = 1
+    while start_time < duration:
+        end_time = min(start_time + max_length, duration)
+        chunk_output = f"{output_prefix}_chunk{chunk_index:02d}_raw.wav"
+
+        # Crop the audio to the current chunk
+        crop_cmd = [
+            "ffmpeg", "-hide_banner", "-loglevel", "error", "-y",
+            "-i", input_file, "-ss", str(start_time), "-to", str(end_time),
+            "-c", "copy", chunk_output
+        ]
+        subprocess.run(crop_cmd)
+
+        # Step 3: Trim silence from the cropped chunk
+        trimmed_output = f"{output_prefix}_chunk{chunk_index:02d}.wav"
+        trim_cmd = [
+            "ffmpeg", "-hide_banner", "-loglevel", "error", "-y",
+            "-i", chunk_output,
+            "-af", "silenceremove=start_periods=1:start_duration=0.5:start_threshold=-30dB:"
+                   "stop_periods=1:stop_duration=0.5:stop_threshold=-30dB",
+            trimmed_output
+        ]
+        subprocess.run(trim_cmd)
+
+        console.print(f"[green]Processed chunk:[/green] {trimmed_output}")
+
+        # Cleanup the raw chunk
+        os.remove(chunk_output)
+        start_time += max_length
+        chunk_index += 1
+
+# Process each file in the mapping
+for _, row in df.iterrows():
+    json_file = row['json_file']
+    target_speaker_label = row['target_speaker_label']
+
+    # Skip files without a valid target speaker
+    if target_speaker_label == "not-target-speaker" or pd.isna(target_speaker_label):
+        console.print(f"[yellow]Skipping {json_file}:[/yellow] No target speaker identified.")
+        continue
+
+    # Paths
+    json_path = os.path.join(JSON_DIR, json_file)
+    wav_file = os.path.join(AUDIO_DIR, os.path.splitext(json_file)[0] + ".wav")
+
+    if not os.path.exists(json_path) or not os.path.exists(wav_file):
+        console.print(f"[red]Missing JSON or WAV file for {json_file}, skipping.[/red]")
+        continue
+
+    # Load JSON segments
+    with open(json_path, "r") as f:
+        segments = json.load(f)
+
+    # Process only segments for the target speaker
+    for segment in segments:
+        if segment["speaker"] != target_speaker_label:
+            continue
+
+        start_time = segment["start"]
+        end_time = segment["end"]
+
+        # Skip short segments
+        if end_time - start_time < 1.0:
+            console.print(f"[yellow]Skipping short segment {start_time}-{end_time} for {target_speaker_label}.[/yellow]")
+            continue
+
+        # Output file prefix
+        output_prefix = os.path.join(
+            OUTPUT_DIR,
+            f"{os.path.splitext(json_file)[0]}_{start_time:.2f}-{end_time:.2f}"
+        )
+
+        # Extract the segment
+        temp_segment = f"{output_prefix}_raw.wav"
+        extract_cmd = [
+            "ffmpeg", "-hide_banner", "-loglevel", "error", "-y",
+            "-i", wav_file, "-ss", str(start_time), "-to", str(end_time),
+            "-c", "copy", temp_segment
+        ]
+        subprocess.run(extract_cmd)
+
+        # Crop and trim silence
+        crop_and_trim_silence(temp_segment, output_prefix, MAX_CLIP_LENGTH)
+
+        # Cleanup the raw segment
+        os.remove(temp_segment)
+
+console.print("[bold green]All files processed. Check the output directory for results.[/bold green]")