Quote:Bob: 
Hey there!

Ryan: 
What's up?

SFX: explosions

Quote::Bob: 
Hey there!

:Ryan: 
What's up?

:SFX: explosions

Quote:import os
import sys
import re
import glob
import argparse
from pydub import AudioSegment
from pydub.silence import split_on_silence

# Import document readers.
try:
    from docx import Document
except ImportError:
    print("Missing python-docx. Please install it via pip (pip install python-docx)")
    sys.exit(1)

try:
    import PyPDF2
except ImportError:
    print("Missing PyPDF2. Please install it via pip (pip install PyPDF2)")
    sys.exit(1)

# Base directory for audio and script files.
BASE_DIR = r"E:\$Galactic Punch Bowl\Podcast\Studio"


def read_script(file_path):
    """
    Reads a script from a PDF or DOCX file and returns a list of nonempty text lines.
    For PDFs, a heuristic is applied to remove the header and footer (first and last line of each page).
    """
    ext = os.path.splitext(file_path)[1].lower()
    lines = []
    if ext == ".pdf":
        try:
            with open(file_path, "rb") as f:
                reader = PyPDF2.PdfReader(f)
                for page in reader.pages:
                    page_text = page.extract_text()
                    if page_text:
                        page_lines = page_text.splitlines()
                        if len(page_lines) > 2:
                            page_lines = page_lines[1:-1]  # Remove header and footer.
                        lines.extend([line.strip() for line in page_lines if line.strip()])
        except Exception as e:
            print(f"Error reading PDF file: {e}")
            sys.exit(1)
    elif ext == ".docx":
        try:
            doc = Document(file_path)
            for para in doc.paragraphs:
                if para.text.strip():
                    lines.append(para.text.strip())
        except Exception as e:
            print(f"Error reading DOCX file: {e}")
            sys.exit(1)
    else:
        print("Unsupported file type. Please use a PDF or DOCX file.")
        sys.exit(1)
    return lines


def parse_script(lines):
    """
    Parses script lines into a list of tasks.

    Expected format for auto‑split mode:
      :IDENTIFIER: remaining text

    For example:
      :LIVIA: Hello!
      :MARCUS: Hi there!
      :SFX: explosions

    The IDENTIFIER "SFX" (case-insensitive) indicates a sound effect task;
    otherwise, the task is treated as dialogue.
    """
    tasks = []
    for line in lines:
        line = line.strip()
        if not line:
            continue
        if line.startswith(":"):
            parts = line.split(":")
            if len(parts) < 3:
                print(f"Warning: Not enough parts in line, skipping: {line}")
                continue
            identifier = parts[1].strip()
            if identifier.upper() == "SFX":
                sfx_name = parts[2].strip()
                if sfx_name:
                    tasks.append({
                        "type": "sfx",
                        "name": sfx_name
                    })
                else:
                    print(f"Warning: No SFX name provided, skipping: {line}")
            else:
                # For dialogue, we ignore any text after the identifier.
                tasks.append({
                    "type": "dialogue",
                    "name": identifier
                })
        else:
            print(f"Warning: Unrecognized line format, skipping: {line}")
    return tasks


def assemble_podcast(script_file, episode):
    print(f"Reading script: {script_file}")
    script_lines = read_script(script_file)
    tasks = parse_script(script_lines)

    if not tasks:
        print("Warning: No valid tasks found in the script.")

    final_audio = AudioSegment.empty()
    # Cache for loaded large audio files.
    audio_cache = {}
    # Cache for auto-split segments along with an index pointer.
    auto_split_cache = {}

    for idx, task in enumerate(tasks, start=1):
        print(f"Processing task {idx}: {task}")
        if task["type"] == "dialogue":
            # Instead of forcing an episode number, search for any file that starts with the character's name.
            pattern_mp3 = os.path.join(BASE_DIR, f"{task['name']}*.mp3")
            pattern_wav = os.path.join(BASE_DIR, f"{task['name']}*.wav")
            files = glob.glob(pattern_mp3)
            if not files:
                files = glob.glob(pattern_wav)
            if not files:
                print(f"Warning: Large audio file not found for dialogue '{task['name']}'. Skipping task.")
                continue
            files.sort()  # Sort to ensure consistent behavior.
            key = os.path.splitext(os.path.basename(files[0]))[0]
        elif task["type"] == "sfx":
            # For SFX, the file name must be exactly "SFX_<name>" (no episode number).
            key = f"SFX_{task['name']}"
        else:
            print(f"Warning: Unknown task type '{task['type']}', skipping.")
            continue

        # Load the large audio file if not already loaded.
        if key not in audio_cache:
            audio_file_path = None
            for ext in [".mp3", ".wav"]:
                candidate = os.path.join(BASE_DIR, key + ext)
                if os.path.exists(candidate):
                    audio_file_path = candidate
                    break
            if not audio_file_path:
                print(f"Warning: Large audio file not found for key '{key}'. Skipping task.")
                continue
            try:
                large_audio = AudioSegment.from_file(audio_file_path)
                audio_cache[key] = large_audio
                print(f"Loaded large audio file for key '{key}': {audio_file_path}")
            except Exception as e:
                print(f"Warning: Error loading audio file '{audio_file_path}': {e}. Skipping task.")
                continue
        else:
            large_audio = audio_cache[key]

        # Auto-split the large audio file using silence detection.
        if key not in auto_split_cache:
            silence_thresh = large_audio.dBFS - 16
            segments = split_on_silence(
                large_audio,
                min_silence_len=2000,  # Split when silence is >2 seconds.
                silence_thresh=silence_thresh,
                keep_silence=200  # Optionally retain a bit of silence.
            )
            if not segments:
                print(f"Warning: No segments detected in audio for key '{key}'. Skipping task.")
                continue
            auto_split_cache[key] = {"segments": segments, "index": 0}
            print(f"Auto-split {len(segments)} segments for key '{key}'.")
        cache_entry = auto_split_cache[key]
        segments_list = cache_entry["segments"]
        seg_index = cache_entry["index"]
        if seg_index >= len(segments_list):
            print(
                f"Warning: Not enough segments in audio for key '{key}' (requested segment {seg_index + 1}). Skipping task.")
            continue
        segment = segments_list[seg_index]
        cache_entry["index"] += 1
        final_audio += segment
        print(f"Appended auto-split segment from key '{key}' (segment {seg_index + 1}).")

    output_filename = f"episode_{episode}_final.mp3"
    output_path = os.path.join(BASE_DIR, output_filename)
    try:
        final_audio.export(output_path, format="mp3")
        print(f"Podcast assembled successfully. Output file: {output_path}")
    except Exception as e:
        print(f"Error exporting final audio: {e}")


def main():
    parser = argparse.ArgumentParser(
        description="Assemble a podcast episode by automatically splitting large audio files based on silence detection."
    )
    parser.add_argument(
        "--script",
        required=False,
        default=r"E:\$Galactic Punch Bowl\Podcast\Studio\episode_3_script.pdf",
        help="Path to the script file (.pdf or .docx)."
    )
    parser.add_argument(
        "--episode",
        required=False,
        default="1",
        help="Episode number (used in naming dialogue audio files if applicable). Defaults to '1' if not provided."
    )
    args = parser.parse_args()
    assemble_podcast(args.script, args.episode)


if __name__ == "__main__":
    main()