ui change (pandas)

app.py

@@ -6,6 +6,7 @@ import shutil
 import zipfile
 import random
 import json
+import pandas as pd # Import pandas
 from openai import AsyncOpenAI
 
 from utils.script_parser import parse_dialogue_script, calculate_cost, MAX_SCRIPT_LENGTH
@@ -44,57 +45,133 @@ SPEAKER_CONFIG_METHODS = [
     "Single Voice (Global)", 
     "Random per Speaker", 
     "A/B Round Robin", 
-    "Detailed Configuration (JSON)"
+    "Detailed Configuration (Table)" # Changed from JSON
 ]
-DEFAULT_SPEAKER_CONFIG_METHOD = "Random per Speaker"
+DEFAULT_SPEAKER_CONFIG_METHOD = "Random per Speaker" # Or "Detailed Configuration (Table)" if preferred
 APP_AVAILABLE_VOICES = ALL_TTS_VOICES.copy()
-_speaker_config_cache = {}
-
-def parse_detailed_speaker_config(json_text, parsed_script_lines):
-    config_map = {}
-    default_voice = APP_AVAILABLE_VOICES[0]
+_speaker_config_cache = {} # For Random/AB
+
+# --- Speaker Configuration Table Logic ---
+DATAFRAME_HEADERS = ["Speaker Name", "Voice", "Speed (0.25-4.0)", "Instructions (Text)"]
+DATAFRAME_COL_SPEAKER = 0
+DATAFRAME_COL_VOICE = 1
+DATAFRAME_COL_SPEED = 2
+DATAFRAME_COL_INSTRUCTIONS = 3
+
+def get_speakers_from_script(script_text):
+    if not script_text.strip():
+        return []
     try:
-        if not json_text.strip():
-            return {}
+        # Use a simplified parsing just for speaker names if full parsing is too heavy here
+        # For now, leverage existing robust parser.
+        parsed_lines, _ = parse_dialogue_script(script_text)
+        unique_speakers = sorted(list(set(p["speaker"] for p in parsed_lines)))
+        return unique_speakers
+    except ValueError: # Catch parsing errors like script too long
+        return [] # Or raise/notify
+
+def convert_df_to_config_map(df_data):
+    """Converts DataFrame data (list of lists) to the internal config map."""
+    config_map = {}
+    if not df_data or not df_data['data']: # df_data can be {'data': [], 'headers': []}
+        return config_map
+
+    for row in df_data['data']:
+        speaker_name = row[DATAFRAME_COL_SPEAKER]
+        voice = row[DATAFRAME_COL_VOICE]
+        speed_str = str(row[DATAFRAME_COL_SPEED]).strip()
+        instructions = str(row[DATAFRAME_COL_INSTRUCTIONS]).strip()
+
+        # Validate voice
+        if voice not in APP_AVAILABLE_VOICES:
+            print(f"Warning: Invalid voice '{voice}' for speaker '{speaker_name}' in table. Using default '{APP_AVAILABLE_VOICES[0]}'.")
+            voice = APP_AVAILABLE_VOICES[0]
+        
+        cfg = {"voice": voice}
+        
+        if speed_str:
+            try:
+                speed_val = float(speed_str)
+                if 0.25 <= speed_val <= 4.0:
+                    cfg["speed"] = speed_val
+                else:
+                    print(f"Warning: Speed '{speed_val}' for '{speaker_name}' out of range (0.25-4.0). Ignoring.")
+            except ValueError:
+                print(f"Warning: Invalid speed value '{speed_str}' for '{speaker_name}'. Ignoring.")
         
-        config_list = json.loads(json_text)
-        if not isinstance(config_list, list):
-            raise ValueError("JSON config must be a list of speaker objects.")
+        if instructions:
+            cfg["instructions"] = instructions
             
-        for item in config_list:
-            if not isinstance(item, dict) or "speaker" not in item or "voice" not in item:
-                print(f"Skipping malformed item in JSON config: {item}")
-                continue
-            if item["voice"] not in APP_AVAILABLE_VOICES:
-                print(f"Warning: Voice '{item['voice']}' for speaker '{item['speaker']}' not recognized. Falling back to '{default_voice}'.")
-                item["voice"] = default_voice
-
-            if "speed" in item:
-                try:
-                    item["speed"] = float(item["speed"])
-                    if not (0.25 <= item["speed"] <= 4.0):
-                        print(f"Warning: Speed for speaker '{item['speaker']}' out of range (0.25-4.0). Clamping.")
-                        item["speed"] = max(0.25, min(item["speed"], 4.0))
-                except ValueError:
-                    print(f"Warning: Invalid speed value for speaker '{item['speaker']}'. Using default.")
-                    item.pop("speed", None)
-
-            config_map[item["speaker"]] = {
-                "voice": item["voice"],
-                "speed": item.get("speed"),
-                "instructions": item.get("instructions")
-            }
-        return config_map
-    except json.JSONDecodeError as e:
-        raise ValueError(f"Invalid JSON in Detailed Speaker Configuration: {e}")
-    except ValueError as e:
-        raise e
-    except Exception as e:
-        raise ValueError(f"Error parsing Detailed Speaker Configuration: {e}")
+        config_map[speaker_name] = cfg
+    return config_map
+
+def load_speakers_for_table(script_text, current_df_data_obj, selected_tts_model):
+    """
+    Populates a DataFrame structure based on speakers in the script.
+    Tries to preserve existing settings from current_df_data_obj.
+    current_df_data_obj is the raw object from gr.DataFrame, like {'data': [...], 'headers': ...}
+    """
+    current_config_map = {}
+    if current_df_data_obj and current_df_data_obj.get('data'):
+        # Convert existing DataFrame to a temporary map to easily fetch settings
+        for row in current_df_data_obj['data']:
+            # Ensure row has enough elements to prevent IndexError
+            if len(row) >= len(DATAFRAME_HEADERS):
+                speaker = row[DATAFRAME_COL_SPEAKER]
+                current_config_map[speaker] = {
+                    "voice": row[DATAFRAME_COL_VOICE],
+                    "speed": str(row[DATAFRAME_COL_SPEED]),
+                    "instructions": str(row[DATAFRAME_COL_INSTRUCTIONS])
+                }
+            else:
+                print(f"Skipping malformed row in current DataFrame data: {row}")
+
+
+    unique_speakers = get_speakers_from_script(script_text)
+    new_df_rows = []
+
+    default_voice = APP_AVAILABLE_VOICES[0]
+    default_speed_str = "1.0"
+    default_instructions_str = ""
+
+    for speaker in unique_speakers:
+        existing_settings = current_config_map.get(speaker, {})
+        new_df_rows.append([
+            speaker,
+            existing_settings.get("voice", default_voice),
+            existing_settings.get("speed", default_speed_str),
+            existing_settings.get("instructions", default_instructions_str)
+        ])
+    
+    # Provide info about which columns are relevant
+    speed_info = " (for tts-1/tts-1-hd)" if selected_tts_model in ["tts-1", "tts-1-hd"] else " (N/A for this model)"
+    instr_info = " (for gpt-4o-mini-tts)" if selected_tts_model == "gpt-4o-mini-tts" else " (N/A for this model)"
+    
+    headers_with_model_info = [
+        DATAFRAME_HEADERS[0],
+        DATAFRAME_HEADERS[1],
+        f"{DATAFRAME_HEADERS[2]}{speed_info}",
+        f"{DATAFRAME_HEADERS[3]}{instr_info}",
+    ]
+
+    # If no speakers, provide a dummy row to keep the DataFrame component from erroring/disappearing if it needs data
+    if not new_df_rows:
+        new_df_rows.append(["(No speakers detected)", default_voice, default_speed_str, default_instructions_str])
+
+    # Return a new DataFrame object compatible with gr.DataFrame.update
+    # This structure for gr.DataFrame update might be df_obj or pd.DataFrame(new_df_rows, columns=...)
+    # Let's try returning a pandas DataFrame
+    return gr.update(value=pd.DataFrame(new_df_rows, columns=DATAFRAME_HEADERS), headers=headers_with_model_info)
+
+
+# --- Existing parsing and config logic (slightly adapted if needed) ---
+def parse_detailed_speaker_config(json_text, parsed_script_lines): # Kept for reference or other uses, but not for Table UI
+    # ... (implementation from previous version for JSON parsing)
+    pass # For now, this function is not directly used by the Table UI.
 
 def get_config_for_speaker(speaker_name, speaker_config_method, unique_script_speakers, 
-                           global_selected_voice, detailed_config_map):
-    global _speaker_config_cache
+                           global_selected_voice, detailed_config_map_from_table_or_json):
+    global _speaker_config_cache 
     if _speaker_config_cache.get("__method") != speaker_config_method or \
        _speaker_config_cache.get("__speakers_set") != frozenset(unique_script_speakers):
         _speaker_config_cache = {"__method": speaker_config_method, "__speakers_set": frozenset(unique_script_speakers)}
@@ -105,20 +182,23 @@ def get_config_for_speaker(speaker_name, speaker_config_method, unique_script_sp
         base_config["voice"] = global_selected_voice if global_selected_voice in APP_AVAILABLE_VOICES else APP_AVAILABLE_VOICES[0]
         return base_config
     
-    if speaker_config_method == "Detailed Configuration (JSON)":
-        if speaker_name in detailed_config_map:
-            speaker_specific = detailed_config_map[speaker_name]
-            return {
+    # This part now uses the map derived from either JSON (if we kept that option) or Table
+    if speaker_config_method == "Detailed Configuration (Table)": # or "Detailed Configuration (JSON)"
+        if speaker_name in detailed_config_map_from_table_or_json:
+            speaker_specific = detailed_config_map_from_table_or_json[speaker_name]
+            return { # Ensure all keys exist, falling back to None if not in map
                 "voice": speaker_specific.get("voice", base_config["voice"]),
-                "speed": speaker_specific.get("speed"),
-                "instructions": speaker_specific.get("instructions")
+                "speed": speaker_specific.get("speed"), 
+                "instructions": speaker_specific.get("instructions") 
             }
-        else:
-            print(f"Warning: Speaker '{speaker_name}' not found in Detailed JSON. Using default voice '{base_config['voice']}'.")
+        else: 
+            print(f"Warning: Speaker '{speaker_name}' not found in Detailed Config. Using default voice '{base_config['voice']}'.")
             return base_config
 
+    # For "Random" and "A/B"
     if speaker_name not in _speaker_config_cache:
         if speaker_config_method == "Random per Speaker":
+            # ... (same logic as before) ...
             available_voices_shuffled = random.sample(APP_AVAILABLE_VOICES, len(APP_AVAILABLE_VOICES))
             if not _speaker_config_cache.get("__all_assigned_random"):
                  for i, spk_unique in enumerate(unique_script_speakers):
@@ -127,7 +207,9 @@ def get_config_for_speaker(speaker_name, speaker_config_method, unique_script_sp
                  _speaker_config_cache["__all_assigned_random"] = True
             if speaker_name not in _speaker_config_cache:
                  _speaker_config_cache[speaker_name] = {"voice": random.choice(APP_AVAILABLE_VOICES)}
+
         elif speaker_config_method == "A/B Round Robin":
+            # ... (same logic as before) ...
             if not _speaker_config_cache.get("__all_assigned_ab"):
                 for i, spk_unique in enumerate(unique_script_speakers):
                      if spk_unique not in _speaker_config_cache:
@@ -138,14 +220,16 @@ def get_config_for_speaker(speaker_name, speaker_config_method, unique_script_sp
                 _speaker_config_cache[speaker_name] = {"voice": APP_AVAILABLE_VOICES[speaker_idx % len(APP_AVAILABLE_VOICES)]}
         else:
              _speaker_config_cache[speaker_name] = {"voice": APP_AVAILABLE_VOICES[0]}
-
+    
     cached_entry = _speaker_config_cache.get(speaker_name, base_config.copy())
     return {"voice": cached_entry.get("voice", base_config["voice"]), "speed": None, "instructions": None}
 
+
 async def handle_script_processing(
     dialogue_script: str, tts_model: str, pause_ms: int, 
     speaker_config_method: str, global_voice_selection: str, 
-    detailed_speaker_json: str, global_speed: float, 
+    speaker_details_df_value: dict, # This will be the dict from gr.DataFrame value
+    global_speed: float, 
     global_instructions: str, progress=gr.Progress(track_tqdm=True)):
     global _speaker_config_cache
     _speaker_config_cache = {}
@@ -156,36 +240,36 @@ async def handle_script_processing(
         return None, None, "Error: Script is empty."
 
     job_audio_path_prefix = os.path.join(tempfile.gettempdir(), "current_job_audio")
-    if os.path.exists(job_audio_path_prefix):
-        shutil.rmtree(job_audio_path_prefix)
+    if os.path.exists(job_audio_path_prefix): shutil.rmtree(job_audio_path_prefix)
     os.makedirs(job_audio_path_prefix, exist_ok=True)
 
     try:
         parsed_lines, total_chars = parse_dialogue_script(dialogue_script)
-        if not parsed_lines:
-            return None, None, "Error: No valid dialogue lines found."
-    except ValueError as e:
-        return None, None, f"Script parsing error: {str(e)}"
+        if not parsed_lines: return None, None, "Error: No valid dialogue lines found."
+    except ValueError as e: return None, None, f"Script parsing error: {str(e)}"
 
     unique_speakers = sorted(list(set(p["speaker"] for p in parsed_lines)))
+    
+    # This is where we get the detailed config map
     parsed_detailed_config_map = {}
-    if speaker_config_method == "Detailed Configuration (JSON)":
+    if speaker_config_method == "Detailed Configuration (Table)":
         try:
-            parsed_detailed_config_map = parse_detailed_speaker_config(detailed_speaker_json, parsed_lines)
-        except ValueError as e:
-            return None, None, f"Configuration Error: {str(e)}"
+            parsed_detailed_config_map = convert_df_to_config_map(speaker_details_df_value)
+        except Exception as e: # Catch any error during DataFrame conversion
+            return None, None, f"Error processing Speaker Table: {str(e)}"
+    # (If you had a JSON option, you'd parse JSON here too)
 
     tasks, line_audio_files = [], [None] * len(parsed_lines)
     for i, line_data in enumerate(parsed_lines):
         speaker_name = line_data["speaker"]
         speaker_base_cfg = get_config_for_speaker(
             speaker_name, speaker_config_method, unique_speakers, 
-            global_voice_selection, parsed_detailed_config_map)
+            global_voice_selection, parsed_detailed_config_map # Pass the map
+        )
         line_voice = speaker_base_cfg["voice"]
         
         effective_speed = global_speed
-        if speaker_base_cfg.get("speed") is not None:
-            effective_speed = speaker_base_cfg["speed"]
+        if speaker_base_cfg.get("speed") is not None: effective_speed = speaker_base_cfg["speed"]
         
         effective_instructions = global_instructions if global_instructions and global_instructions.strip() else None
         if speaker_base_cfg.get("instructions") is not None and speaker_base_cfg["instructions"].strip():
@@ -228,6 +312,7 @@ async def handle_script_processing(
            status)
 
 def handle_calculate_cost(dialogue_script: str, tts_model: str):
+    # ... (same as before) ...
     if not dialogue_script.strip(): return "Cost: $0.000000 (Empty script)"
     try:
         parsed, chars = parse_dialogue_script(dialogue_script)
@@ -238,8 +323,8 @@ def handle_calculate_cost(dialogue_script: str, tts_model: str):
     except Exception as e: return f"Cost calc error: {str(e)}"
 
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# Dialogue Script to Speech Converter (Enhanced)")
-    gr.Markdown("Convert scripts with control over voices, speed, and instructions.")
+    gr.Markdown("# Dialogue Script to Speech Converter (Enhanced Table Config)")
+    # ... (intro markdown same) ...
     if not OPENAI_API_KEY or not async_openai_client:
         gr.Markdown("<h3 style='color:red;'>Warning: OPENAI_API_KEY not set. Synthesis will fail.</h3>")
 
@@ -249,33 +334,34 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
         with gr.Column(scale=1):
             tts_model_dropdown = gr.Dropdown(TTS_MODELS_AVAILABLE, label="TTS Model", value=MODEL_DEFAULT, info="Affects controls below.")
             pause_input = gr.Number(label="Pause (ms)", value=500, minimum=0, maximum=5000, step=50, info="Between merged lines.")
-            global_speed_input = gr.Slider(minimum=0.25, maximum=4.0, value=1.0, step=0.05, label="Global Speed (tts-1/tts-1-hd)", visible=(MODEL_DEFAULT in ["tts-1", "tts-1-hd"]), interactive=True)
-            global_instructions_input = gr.Textbox(label="Global Instructions (gpt-4o-mini-tts)", placeholder="e.g., Speak calmly.", visible=(MODEL_DEFAULT == "gpt-4o-mini-tts"), interactive=True, lines=2)
+            global_speed_input = gr.Slider(minimum=0.25, maximum=4.0, value=1.0, step=0.05, label="Global Speed (tts-1/hd)", visible=(MODEL_DEFAULT in ["tts-1", "tts-1-hd"]), interactive=True)
+            global_instructions_input = gr.Textbox(label="Global Instructions (gpt-4o-mini)", placeholder="e.g., Speak calmly.", visible=(MODEL_DEFAULT == "gpt-4o-mini-tts"), interactive=True, lines=2)
 
     gr.Markdown("### Speaker Configuration")
     with gr.Row():
         speaker_config_method_dropdown = gr.Dropdown(SPEAKER_CONFIG_METHODS, label="Speaker Config Method", value=DEFAULT_SPEAKER_CONFIG_METHOD)
-        global_voice_dropdown = gr.Dropdown(APP_AVAILABLE_VOICES, label="Global Voice ('Single Voice' method)", value=APP_AVAILABLE_VOICES[0], visible=(DEFAULT_SPEAKER_CONFIG_METHOD == "Single Voice (Global)"), interactive=True)
+        global_voice_dropdown = gr.Dropdown(APP_AVAILABLE_VOICES, label="Global Voice ('Single Voice')", value=APP_AVAILABLE_VOICES[0], visible=(DEFAULT_SPEAKER_CONFIG_METHOD == "Single Voice (Global)"), interactive=True)
     
-    initial_json_config_example = """[
-  {"speaker": "Alice", "voice": "nova", "speed": 1.1, "instructions": "sound excited"},
-  {"speaker": "Bob", "voice": "echo"},
-  {"speaker": "Narrator", "voice": "shimmer", "instructions": "be very serious"}
-]""".strip()
-
-    detailed_speaker_config_input = gr.Code(
-        label="Detailed Speaker Configuration (JSON)",
-        language="json",
-        lines=7,
-        value=initial_json_config_example,
-        visible=(DEFAULT_SPEAKER_CONFIG_METHOD == "Detailed Configuration (JSON)")
-    )
-    # New Markdown for info text, visibility tied to dropdown
-    detailed_config_info_md = gr.Markdown(
-        "<small>Define voice per speaker. Optionally, `speed` (0.25-4.0) for `tts-1`/`tts-1-hd` models, "
-        "and `instructions` (text) for `gpt-4o-mini-tts`.</small>",
-        visible=(DEFAULT_SPEAKER_CONFIG_METHOD == "Detailed Configuration (JSON)")
-    )
+    # --- New UI for Detailed Table Configuration ---
+    current_visibility_detailed_table = (DEFAULT_SPEAKER_CONFIG_METHOD == "Detailed Configuration (Table)")
+    
+    with gr.Column(visible=current_visibility_detailed_table) as detailed_table_config_group:
+        load_speakers_button = gr.Button("Load/Refresh Speakers for Table from Script Above")
+        gr.Markdown(f"<small>Available voices: {', '.join(APP_AVAILABLE_VOICES)}. Type a voice name into the 'Voice' column. "
+                    "Speed and Instructions applicability depends on the globally selected TTS model.</small>")
+        speaker_details_df = gr.DataFrame(
+            label="Per-Speaker Settings (Editable Table)",
+            headers=DATAFRAME_HEADERS,
+            # Initialize with a placeholder row or empty data
+            value=pd.DataFrame([["(Load speakers first)", APP_AVAILABLE_VOICES[0], "1.0", ""]], columns=DATAFRAME_HEADERS),
+            interactive=True,
+            # `max_rows=20` or some sensible limit might be good for UI
+            # `datatype` can be used to specify types per column, e.g., ["str", "str", "number", "str"]
+            # For now, all will be string input in table, conversion happens in backend.
+            # Consider making "Speaker Name" column read-only if possible with Gradio versions
+        )
+
+    # --- End New UI ---
     
     with gr.Row():
         calculate_cost_button = gr.Button("Calculate Cost")
@@ -287,47 +373,66 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
         merged_dialogue_mp3_output = gr.Audio(label="Merged MP3", type="filepath")
     status_output = gr.Textbox(label="Status", interactive=False, lines=2)
 
+    # --- Event Handlers ---
     def update_model_controls(selected_model):
+        # ... (same as before) ...
         is_tts1 = selected_model in ["tts-1", "tts-1-hd"]
         is_gpt_mini = selected_model == "gpt-4o-mini-tts"
+        # Also update headers for DataFrame when model changes
+        speed_info = " (for tts-1/tts-1-hd)" if is_tts1 else " (N/A for this model)"
+        instr_info = " (for gpt-4o-mini-tts)" if is_gpt_mini else " (N/A for this model)"
+        new_headers = [DATAFRAME_HEADERS[0], DATAFRAME_HEADERS[1], f"{DATAFRAME_HEADERS[2]}{speed_info}", f"{DATAFRAME_HEADERS[3]}{instr_info}"]
+
         return {
             global_speed_input: gr.update(visible=is_tts1, interactive=is_tts1),
-            global_instructions_input: gr.update(visible=is_gpt_mini, interactive=is_gpt_mini)
+            global_instructions_input: gr.update(visible=is_gpt_mini, interactive=is_gpt_mini),
+            speaker_details_df: gr.update(headers=new_headers) # Update headers dynamically
         }
-    tts_model_dropdown.change(fn=update_model_controls, inputs=[tts_model_dropdown], outputs=[global_speed_input, global_instructions_input])
+    tts_model_dropdown.change(fn=update_model_controls, inputs=[tts_model_dropdown], outputs=[global_speed_input, global_instructions_input, speaker_details_df])
 
     def update_speaker_controls(method):
         is_single = (method == "Single Voice (Global)")
-        is_detailed = (method == "Detailed Configuration (JSON)")
+        is_detailed_table = (method == "Detailed Configuration (Table)")
         return {
             global_voice_dropdown: gr.update(visible=is_single, interactive=is_single),
-            detailed_speaker_config_input: gr.update(visible=is_detailed, interactive=is_detailed),
-            detailed_config_info_md: gr.update(visible=is_detailed) # Control visibility of new Markdown
+            detailed_table_config_group: gr.update(visible=is_detailed_table), # Show/hide the whole group
         }
-    speaker_config_method_dropdown.change(fn=update_speaker_controls, inputs=[speaker_config_method_dropdown], outputs=[global_voice_dropdown, detailed_speaker_config_input, detailed_config_info_md])
+    speaker_config_method_dropdown.change(fn=update_speaker_controls, inputs=[speaker_config_method_dropdown], outputs=[global_voice_dropdown, detailed_table_config_group])
+    
+    # Connect Load Speakers button
+    load_speakers_button.click(
+        fn=load_speakers_for_table,
+        inputs=[script_input, speaker_details_df, tts_model_dropdown], # Pass current DF to preserve, and model for header info
+        outputs=[speaker_details_df]
+    )
     
     calculate_cost_button.click(fn=handle_calculate_cost, inputs=[script_input, tts_model_dropdown], outputs=[cost_output])
     generate_button.click(
         fn=handle_script_processing,
         inputs=[script_input, tts_model_dropdown, pause_input, speaker_config_method_dropdown, 
-                global_voice_dropdown, detailed_speaker_config_input, global_speed_input, global_instructions_input],
+                global_voice_dropdown, 
+                speaker_details_df, # Changed from detailed_speaker_config_input (JSON)
+                global_speed_input, global_instructions_input],
         outputs=[individual_lines_zip_output, merged_dialogue_mp3_output, status_output])
 
     gr.Markdown("## Examples")
-    ex_script1 = "[A] Hi B.\n[B] Hey A.\n[A] What's up?"
-    ex_json1 = '[{"speaker": "A", "voice": "nova", "instr...": "curious"}, {"speaker": "B", "voice": "echo", "speed": 0.9}]'.replace("instr...", "instructions") # Hack for brevity
-    ex_script2 = "[Cpt] Status?\n[Comp] Nominal. Slow.\n[Cpt] Good."
-    ex_json2 = '[{"speaker": "Cpt", "voice": "alloy"}, {"speaker": "Comp", "voice": "onyx", "speed": 0.8, "instr...": "robotic"}]'.replace("instr...", "instructions")
+    # Examples will need to be adjusted if the "Detailed Configuration (Table)" is default and needs pre-filled table
+    # For simplicity, examples might focus on other config methods or a very simple table.
+    # For "Detailed Configuration (Table)", the flow is: type script -> click "Load Speakers" -> edit table -> generate.
+    # So, an example would just set the script and method. The table data itself isn't directly an input to an example click.
+    # We can, however, provide an example script.
     gr.Examples(
         examples=[
-            [ex_script1, "gpt-4o-mini-tts", 250, "Detailed Configuration (JSON)", APP_AVAILABLE_VOICES[0], ex_json1, 1.0, "Speak naturally."],
-            [ex_script2, "tts-1-hd", 300, "Detailed Configuration (JSON)", APP_AVAILABLE_VOICES[0], ex_json2, 1.1, ""],
-            ["[N] Single line.", "tts-1", 0, "Single Voice (Global)", "fable", "", 1.2, ""]],
+            ["[Alice] Hi Bob.\n[Bob] Hello Alice.\n[Alice] This table config is new!", "tts-1-hd", 300, "Detailed Configuration (Table)", APP_AVAILABLE_VOICES[0], None, 1.0, ""], # DF input is None for example
+            ["[Narrator] A single line, global voice.", "tts-1", 0, "Single Voice (Global)", "fable", None, 1.2, ""],
+            ["[Random1] Voice 1\n[Random2] Voice 2", "gpt-4o-mini-tts", 400, "Random per Speaker", APP_AVAILABLE_VOICES[0], None, 1.0, "Speak clearly."]
+        ],
         inputs=[script_input, tts_model_dropdown, pause_input, speaker_config_method_dropdown, global_voice_dropdown, 
-                detailed_speaker_config_input, global_speed_input, global_instructions_input],
+                speaker_details_df, # This will be None for example clicks unless we can construct a df
+                global_speed_input, global_instructions_input],
         outputs=[individual_lines_zip_output, merged_dialogue_mp3_output, status_output],
         fn=handle_script_processing, cache_examples=False)
 
 if __name__ == "__main__":
     if os.name == 'nt': asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
-    demo.launch()
+    demo.launch(debug=True) # Added debug=True for easier testing of UI changes

requirements.txt

@@ -3,4 +3,5 @@ pydub
 ffmpeg-python
 gradio>=4.27
 gradio_client
-httpx
+httpx
+pandas