debug new 2

app.py

@@ -1,3 +1,4 @@
+# FILE: app.py
 import gradio as gr
 import os
 import asyncio
@@ -13,8 +14,7 @@ from ui_layout import (
 from event_handlers import (
     handle_script_processing, handle_calculate_cost,
     update_model_controls_visibility, update_speaker_config_method_visibility,
-    handle_load_refresh_button_click # Import the new wrapper
-    # load_refresh_per_speaker_ui_core is now internal to event_handlers.py
+    handle_load_refresh_button_click 
 )
 
 OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
@@ -22,7 +22,7 @@ NSFW_API_URL_TEMPLATE = os.getenv("NSFW_API_URL_TEMPLATE")
 MODEL_DEFAULT_FROM_ENV = os.getenv("MODEL_DEFAULT", MODEL_DEFAULT_ENV)
 EFFECTIVE_MODEL_DEFAULT = MODEL_DEFAULT_FROM_ENV if MODEL_DEFAULT_FROM_ENV in TTS_MODELS_AVAILABLE else MODEL_DEFAULT_ENV
 async_openai_client = None
-# ... (Secrets loading logic remains the same) ...
+
 if not OPENAI_API_KEY:
     try:
         from huggingface_hub import HfApi
@@ -54,22 +54,19 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
     (script_input, tts_model_dropdown, pause_input,
      global_speed_input, global_instructions_input) = create_main_input_components(EFFECTIVE_MODEL_DEFAULT)
 
-    # Destructure the returned components from create_speaker_config_components
     (speaker_config_method_dropdown, single_voice_group, global_voice_dropdown,
      detailed_per_speaker_ui_group, load_per_speaker_ui_button,
-     dynamic_speaker_ui_wrapper) = create_speaker_config_components() # MODIFIED: use dynamic_speaker_ui_wrapper
+     dynamic_speaker_ui_area) = create_speaker_config_components() # dynamic_speaker_ui_area is now a gr.Group
 
     (calculate_cost_button, generate_button, cost_output,
      individual_lines_zip_output, merged_dialogue_mp3_output,
      status_output) = create_action_and_output_components()
 
-    # Event handler for TTS Model Dropdown
     tts_model_dropdown.change(
         fn=update_model_controls_visibility,
-        # CLEANUP: Removed duplicate speaker_configs_state
-        inputs=[tts_model_dropdown, script_input, speaker_configs_state], 
-        # MODIFIED: Output to the wrapper
-        outputs=[global_speed_input, global_instructions_input, dynamic_speaker_ui_wrapper, speaker_configs_state] 
+        # MODIFIED: Removed duplicate speaker_configs_state
+        inputs=[tts_model_dropdown, script_input, speaker_configs_state],
+        outputs=[global_speed_input, global_instructions_input, dynamic_speaker_ui_area, speaker_configs_state]
     )
 
     speaker_config_method_dropdown.change(
@@ -78,13 +75,11 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
         outputs=[single_voice_group, detailed_per_speaker_ui_group]
     )
     
-    # Event handler for the "Load/Refresh" Button
     load_per_speaker_ui_button.click(
         fn=handle_load_refresh_button_click,
-        # CLEANUP: Removed duplicate speaker_configs_state
+        # MODIFIED: Removed duplicate speaker_configs_state
         inputs=[script_input, speaker_configs_state, tts_model_dropdown], 
-        # MODIFIED: Output to the wrapper
-        outputs=[dynamic_speaker_ui_wrapper, speaker_configs_state] 
+        outputs=[dynamic_speaker_ui_area, speaker_configs_state]
     )
     
     calculate_cost_button.click(

event_handlers.py

@@ -1,5 +1,5 @@
+# FILE: event_handlers.py
 import gradio as gr
-# ... (other imports remain the same) ...
 import os
 import asyncio
 import tempfile
@@ -18,7 +18,6 @@ DEFAULT_FALLBACK_VOICE = APP_AVAILABLE_VOICES[0] if APP_AVAILABLE_VOICES else "a
 
 
 def get_speakers_from_script(script_text: str):
-    # ... (no change) ...
     if not script_text.strip():
         return []
     try:
@@ -34,7 +33,6 @@ def get_speakers_from_script(script_text: str):
         return []
 
 def handle_dynamic_input_change(new_value, current_configs_state_dict: dict, speaker_name: str, config_key: str, tts_model: str):
-    # ... (no change) ...
     if current_configs_state_dict is None: 
         current_configs_state_dict = {}
     if speaker_name not in current_configs_state_dict:
@@ -44,29 +42,37 @@ def handle_dynamic_input_change(new_value, current_configs_state_dict: dict, spe
     return current_configs_state_dict
 
 
-# CLEANUP: Modify function signatures to remove the redundant speaker_configs_state_comp argument
+# MODIFIED: Removed speaker_configs_state_component from signature
 def load_refresh_per_speaker_ui_core(script_text: str, current_configs_state_dict: dict, tts_model: str):
     """
     Core logic for generating per-speaker UI components.
-    Returns: (list_of_components_for_inner_column, updated_state_dict)
+    Returns: (list_of_components_for_group, updated_state_dict)
     """
-    print(f"DEBUG: load_refresh_per_speaker_ui_core CALLED (for wrapper). TTS Model: {tts_model}")
-    # This list of components will be the children of the *new inner column*
-    debug_markdown = gr.Markdown("## !! Test Content for Inner Column (via Wrapper) !!")
-    return [debug_markdown], {} # Returns: (list_of_components, state_dictionary)
-
+    # --- START OF PHASE 1 DEBUGGING (returns list of components directly) ---
+    print(f"DEBUG: load_refresh_per_speaker_ui_core CALLED. TTS Model: {tts_model}. Script: '{script_text[:50]}...'")
+    # For now, we just return a list containing a single Markdown component.
+    # This list will become the children of the dynamic_speaker_ui_area (which is a gr.Group).
+    debug_markdown = gr.Markdown(f"## !! Dynamic Area Test Content !!\nModel: {tts_model}\nTimestamp: {gr.utils.now()}", ) # Added timestamp for visual refresh confirmation
+    
+    # When implementing the full logic, this function should:
+    # 1. Parse script_text to get unique_speakers.
+    # 2. For each speaker, create a gr.Accordion with relevant controls (voice dropdown, speed slider OR vibe/instructions).
+    # 3. Populate these controls based on current_configs_state_dict or defaults.
+    # 4. Ensure these controls are set up to call handle_dynamic_input_change, updating speaker_configs_state.
+    # 5. Return the list of gr.Accordion components and the (potentially modified) current_configs_state_dict.
+    
+    # For PHASE 1, we return a simple list and an empty (or unchanged) state.
+    return [debug_markdown], current_configs_state_dict # Return current_configs_state_dict as it might be used/updated later
 
 async def handle_script_processing(
     openai_api_key: str, async_openai_client, nsfw_api_url_template: str, 
     dialogue_script: str, tts_model: str, pause_ms: int,
-    # ... (rest of function signature and body unchanged) ...
     speaker_config_method: str, global_voice_selection: str,
     speaker_configs_state_dict: dict,
     global_speed: float,
     global_instructions: str,
     progress=gr.Progress(track_tqdm=True)
 ):
-    # ... (content of this function remains unchanged) ...
     if not openai_api_key or not async_openai_client:
         return None, None, "Error: OpenAI API Key or client is not configured."
     if not dialogue_script.strip():
@@ -123,15 +129,15 @@ async def handle_script_processing(
                     line_instructions = custom_instr
                 elif vibe != "None" and vibe != "Custom...":
                     line_instructions = PREDEFINED_VIBES.get(vibe, "")
-                if not line_instructions and global_instructions and global_instructions.strip():
+                if not line_instructions and global_instructions and global_instructions.strip(): # Fallback to global if specific instructions are empty
                     line_instructions = global_instructions
-                elif not line_instructions:
+                elif not line_instructions: # Ensure it's None if truly empty
                     line_instructions = None
         elif speaker_config_method in ["Random per Speaker", "A/B Round Robin"]:
             line_voice = speaker_voice_map.get(speaker_name, safe_default_global_voice)
         
-        if tts_model not in ["tts-1", "tts-1-hd"]:
-            line_speed = 1.0
+        if tts_model not in ["tts-1", "tts-1-hd"]: # Ensure speed is only applied to tts-1 models
+            line_speed = 1.0 # Default speed for other models
 
         out_fn = os.path.join(job_audio_path_prefix, f"line_{line_data['id']}_{speaker_name.replace(' ','_')}.mp3")
         progress(i / len(parsed_lines), desc=f"Synthesizing: Line {i+1}/{len(parsed_lines)} ({speaker_name})")
@@ -176,13 +182,13 @@ async def handle_script_processing(
             zf.write(f_path, os.path.basename(f_path))
     
     merged_fn = os.path.join(job_audio_path_prefix, "merged_dialogue.mp3")
-    files_to_actually_merge = [f for f in ordered_files_for_merge_and_zip if f]
+    files_to_actually_merge = [f for f in ordered_files_for_merge_and_zip if f] # Only non-None paths
     merged_path = merge_mp3_files(files_to_actually_merge, merged_fn, pause_ms)
 
     status = f"Successfully processed {len(valid_files_for_zip)} out of {len(parsed_lines)} lines. "
     if len(valid_files_for_zip) < len(parsed_lines): status += "Some lines may have failed. "
     if not merged_path and len(valid_files_for_zip) > 0: status += "Merging audio failed. "
-    elif not merged_path: status = "No audio to merge."
+    elif not merged_path: status = "No audio to merge." # Or all failed
     else: status += "Merged audio generated."
         
     return (zip_fn if os.path.exists(zip_fn) else None,
@@ -190,7 +196,6 @@ async def handle_script_processing(
            status)
 
 def handle_calculate_cost(dialogue_script: str, tts_model: str):
-    # ... (no change) ...
     if not dialogue_script.strip(): return "Cost: $0.00 (Script is empty)"
     try:
         parsed, chars = parse_dialogue_script(dialogue_script)
@@ -199,46 +204,37 @@ def handle_calculate_cost(dialogue_script: str, tts_model: str):
         return f"Estimated Cost for {len(parsed)} lines ({chars} chars): ${cost:.6f}"
     except ValueError as e:
         return f"Cost calculation error: {str(e)}"
-    except Exception as e:
+    except Exception as e: # Generic fallback
         return f"An unexpected error occurred during cost calculation: {str(e)}"
 
-# Wrapper for the "Load/Refresh Per-Speaker UI Button" click
-# CLEANUP: Signature changed
+# MODIFIED: Removed speaker_configs_state_comp from signature
 def handle_load_refresh_button_click(script_text: str, current_configs_state_dict: dict, tts_model: str):
-    components_list_for_inner_column, new_state_dict = load_refresh_per_speaker_ui_core(
-        script_text, current_configs_state_dict, tts_model # CLEANUP: Removed speaker_configs_state_comp
+    components_list_for_group, new_state_dict = load_refresh_per_speaker_ui_core(
+        script_text, current_configs_state_dict, tts_model # MODIFIED: Call without speaker_configs_state_comp
     )
-    
-    # Create a new instance of the inner gr.Column with the dynamic children
-    new_inner_column = gr.Column(children=components_list_for_inner_column, elem_id="dynamic_ui_area_for_speakers")
-    
-    # Return gr.update for the wrapper group (to replace its children with the new_inner_column), 
+    # Return gr.update for the dynamic_speaker_ui_area (which is a gr.Group), 
     # and the raw state dict for the gr.State component.
-    return gr.update(children=[new_inner_column]), new_state_dict
+    return gr.update(children=components_list_for_group), new_state_dict
 
-# Handler for TTS model dropdown change
-# CLEANUP: Signature changed
+# MODIFIED: Removed speaker_configs_state_comp from signature
 def update_model_controls_visibility(selected_model: str, script_text_for_refresh: str, current_configs_state_dict: dict):
     """Updates visibility of global controls and refreshes per-speaker UI when TTS model changes."""
-    print(f"Model changed to: {selected_model}. Refreshing dynamic UI (via wrapper) and controls.") 
+    print(f"Model changed to: {selected_model}. Refreshing dynamic UI and controls.") 
+    dynamic_ui_update_for_group = None
+    updated_state_dict_for_return = current_configs_state_dict
+
     try:
-        dynamic_ui_children_list, updated_state_dict = load_refresh_per_speaker_ui_core(
-            script_text_for_refresh, current_configs_state_dict, selected_model # CLEANUP: Removed speaker_configs_state_comp
+        dynamic_ui_components_list, updated_state_dict = load_refresh_per_speaker_ui_core(
+            script_text_for_refresh, current_configs_state_dict, selected_model # MODIFIED: Call without speaker_configs_state_comp
         )
-        
-        # Create a new instance of the inner gr.Column
-        new_inner_column_for_model_change = gr.Column(children=dynamic_ui_children_list, elem_id="dynamic_ui_area_for_speakers")
-        
-        # This will be the update for the dynamic_speaker_ui_wrapper
-        dynamic_ui_update_for_wrapper = gr.update(children=[new_inner_column_for_model_change])
+        dynamic_ui_update_for_group = gr.update(children=dynamic_ui_components_list)
+        updated_state_dict_for_return = updated_state_dict
 
     except Exception as e:
         print(f"Error in load_refresh_per_speaker_ui_core called from model_controls_visibility: {e}")
         error_markdown = gr.Markdown(f"Error refreshing per-speaker UI: {e}")
-        # Update the wrapper to show an error message inside a new inner column
-        error_inner_column = gr.Column(children=[error_markdown], elem_id="dynamic_ui_area_for_speakers")
-        dynamic_ui_update_for_wrapper = gr.update(children=[error_inner_column])
-        updated_state_dict = current_configs_state_dict 
+        dynamic_ui_update_for_group = gr.update(children=[error_markdown])
+        # Keep current_configs_state_dict as is on error
 
     is_tts1_family = selected_model in ["tts-1", "tts-1-hd"]
     is_gpt_mini_tts = selected_model == "gpt-4o-mini-tts"
@@ -246,12 +242,11 @@ def update_model_controls_visibility(selected_model: str, script_text_for_refres
     return (
         gr.update(visible=is_tts1_family, interactive=is_tts1_family), 
         gr.update(visible=is_gpt_mini_tts, interactive=is_gpt_mini_tts), 
-        dynamic_ui_update_for_wrapper, # MODIFIED: This now updates the wrapper
-        updated_state_dict      
+        dynamic_ui_update_for_group, 
+        updated_state_dict_for_return      
     )
 
 def update_speaker_config_method_visibility(method: str):
-    # ... (no change) ...
     is_single = (method == "Single Voice (Global)")
     is_detailed_per_speaker = (method == "Detailed Configuration (Per Speaker UI)")
     

ui_layout.py

@@ -1,7 +1,7 @@
 import gradio as gr
 from utils.openai_tts import OPENAI_VOICES as ALL_TTS_VOICES # Import directly for APP_AVAILABLE_VOICES
 
-# --- UI Constants and Configuration ---
+# --- UI Constants and Configuration ---\
 TTS_MODELS_AVAILABLE = ["tts-1", "tts-1-hd", "gpt-4o-mini-tts"]
 MODEL_DEFAULT_ENV = "tts-1-hd" # Default if env var not set or invalid
 
@@ -42,7 +42,7 @@ def create_main_input_components(model_default_value):
     """Creates the main input components for script, model, pause, and global settings."""
     with gr.Row():
         with gr.Column(scale=2):
-            script_input = gr.TextArea(label="Dialogue Script", placeholder="[Speaker1] Hello world!\n[Speaker2] How are you today?", lines=10)
+            script_input = gr.TextArea(label="Dialogue Script", placeholder="[Speaker1] Hello world!\\n[Speaker2] How are you today?", lines=10)
         with gr.Column(scale=1):
             tts_model_dropdown = gr.Dropdown(TTS_MODELS_AVAILABLE, label="TTS Model", value=model_default_value)
             pause_input = gr.Number(label="Pause Between Lines (ms)", value=500, minimum=0, maximum=5000, step=50)
@@ -80,23 +80,17 @@ def create_speaker_config_components():
     with gr.Column(visible=(DEFAULT_SPEAKER_CONFIG_METHOD == "Detailed Configuration (Per Speaker UI)")) as detailed_per_speaker_ui_group:
         load_per_speaker_ui_button = gr.Button("Load/Refresh Per-Speaker Settings UI (from Script Above)")
         gr.Markdown("<small>Click button above to populate settings for each speaker found in the script. Settings are applied per-speaker. If script changes, click again to refresh.</small>")
-        
-        # NEW: Wrapper for the dynamic area
-        # This group will now be the target for updates.
-        dynamic_speaker_ui_wrapper = gr.Group(elem_id="dynamic_ui_wrapper_for_speakers")
-        with dynamic_speaker_ui_wrapper:
-             # The actual column is now a child of the wrapper.
-             # It can be initially empty or have a placeholder if desired.
-             dynamic_speaker_ui_area = gr.Column(elem_id="dynamic_ui_area_for_speakers") 
+        # MODIFIED: dynamic_speaker_ui_area is now a gr.Group.
+        # Children will be added/updated dynamically to this group.
+        dynamic_speaker_ui_area = gr.Group(elem_id="dynamic_ui_area_for_speakers") 
     
-    # Ensure the new wrapper is returned correctly
     return (
         speaker_config_method_dropdown, 
         single_voice_group, 
         global_voice_dropdown, 
         detailed_per_speaker_ui_group, 
         load_per_speaker_ui_button, 
-        dynamic_speaker_ui_wrapper # MODIFIED: Return the wrapper
+        dynamic_speaker_ui_area # This is now a gr.Group
     )
 
 def create_action_and_output_components():
@@ -112,11 +106,11 @@ def create_action_and_output_components():
     status_output = gr.Textbox(label="Status", interactive=False, lines=2, max_lines=5)
     return calculate_cost_button, generate_button, cost_output, individual_lines_zip_output, merged_dialogue_mp3_output, status_output
 
-def create_examples_ui(inputs_for_examples, process_fn, outputs_for_examples=None): # Added outputs_for_examples
+def create_examples_ui(inputs_for_examples, process_fn, outputs_for_examples=None):
     """Creates the examples section."""
     gr.Markdown("## Example Scripts")
-    example_script_1 = "[Alice] Hello Bob, this is a test using the detailed configuration method.\n[Bob] Hi Alice! I'm Bob, and I'll have my own voice settings.\n[Alice] Let's see how this sounds."
-    example_script_2 = "[Narrator] This is a short story.\n[CharacterA] Once upon a time...\n[Narrator] ...there was a Gradio app.\n[CharacterB] And it could talk!"
+    example_script_1 = "[Alice] Hello Bob, this is a test using the detailed configuration method.\\n[Bob] Hi Alice! I'm Bob, and I'll have my own voice settings.\\n[Alice] Let's see how this sounds."
+    example_script_2 = "[Narrator] This is a short story.\\n[CharacterA] Once upon a time...\\n[Narrator] ...there was a Gradio app.\\n[CharacterB] And it could talk!"
     
     examples_data = [
         [example_script_1, "tts-1-hd", 300, "Detailed Configuration (Per Speaker UI)", DEFAULT_GLOBAL_VOICE, {}, 1.0, ""],
@@ -136,23 +130,21 @@ def create_examples_ui(inputs_for_examples, process_fn, outputs_for_examples=Non
         gr.Markdown("<p style='color: orange;'>No valid examples could be loaded due to configuration mismatch.</p>")
         return None
 
-    # If process_fn and outputs_for_examples are provided, make examples runnable
     if process_fn and outputs_for_examples:
         return gr.Examples(
             examples=valid_examples_data,
             inputs=inputs_for_examples,
             outputs=outputs_for_examples,
             fn=process_fn,
-            cache_examples=False, # Caching can be complex with external API calls
-            examples_per_page=5, # Corrected parameter name
+            cache_examples=False,
+            examples_per_page=5,
             label="Example Scripts (Click to Load & Run)",
-            run_on_click=True # Make examples run when clicked
+            run_on_click=True
         )
-    else: # Otherwise, just load inputs
+    else: 
         return gr.Examples(
             examples=valid_examples_data,
             inputs=inputs_for_examples,
-            examples_per_page=5, # Corrected parameter name
+            examples_per_page=5,
             label="Example Scripts (Click to Load Inputs)",
-            # No fn, outputs, or run_on_click if process_fn is None
         )