Update app.py

app.py

@@ -2,125 +2,202 @@ import os
 import logging
 import gradio as gr
 from gradio_client import Client, handle_file
+import gradio.themes as gr_themes
 
+# Set up logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
+# It's recommended to set the HUGGINGFACE_TOKEN as an environment variable
 token = os.getenv("HUGGINGFACE_TOKEN")
 
 def create_dubsync_interface():
-    client = Client("Tamiloneto8/Test1", hf_token=token, verbose=True)
-    target_langs = ["Assamese", "Bengali", "Gujarati", "Hindi", "Kannada", "Malayalam", "Marathi", "Odia", "Punjabi", "Tamil", "Telugu"]
-
-    with gr.Blocks(title="DubSync Wizard", css=".step-header {font-size:1.5em; font-weight:bold; margin-bottom:10px;} .section {margin-top:20px;} .final-audio {margin-top:20px;}") as demo:
-        gr.HTML("<div class='step-header'>Step 1: Upload Audio</div>")
-        audio_input = gr.Audio(sources=["upload"], type="filepath", label="Upload your audio file")
-        lang_dropdown = gr.Dropdown(target_langs, label="Select Target Language")
-        start_btn = gr.Button("Start Processing", variant="primary")
-
-        gr.HTML("<div class='step-header section'>Step 2: Edit Transcript & Translation</div>")
-        transcription_audio = gr.Audio(type="filepath", label="Play Original Chunk", visible=False)
-        transcription_text = gr.Textbox(label="Edit Transcription", lines=3, visible=False)
-        translation_text = gr.Textbox(label="Edit Translation", lines=3, visible=False)
-        next_chunk_btn = gr.Button("Next Chunk", visible=False)
-
-        gr.HTML("<div class='step-header section'>Step 3: Dubbing & Review</div>")
-        dubbing_audio = gr.Audio(type="filepath", label="Play Dubbed Chunk", visible=False)
-        redub_btn = gr.Button("Redub Chunk", visible=False)
-        finalize_btn = gr.Button("Finalize Chunk", visible=False)
-
-        gr.HTML("<div class='step-header section'>Step 4: Merge & Download</div>")
-        merge_btn = gr.Button("Merge All Chunks", visible=False)
-        final_audio = gr.Audio(type="filepath", label="Final Merged Audio", visible=False)
-
-        state = gr.State({"chunks": [], "index": 0})
+    """
+    Creates and configures the Gradio interface for the DubSync application.
+    """
+    try:
+        # Connect to the Gradio client on Hugging Face Spaces
+        client = Client("Tamiloneto8/Test1", hf_token=token, verbose=True)
+        logger.info("Successfully connected to Gradio client.")
+
+    except Exception as e:
+        logger.error("Error connecting to the private space: %s", e, exc_info=True)
+        # Create a fallback interface to show the connection error
+        with gr.Blocks() as demo:
+            gr.Markdown("# 🎬 DubSync - Connection Error")
+            gr.Textbox(
+                value=f"Failed to connect to the Hugging Face Space. Please ensure the Space is running and the token is correct. Error: {e}",
+                label="Error",
+                interactive=False
+            )
+        return demo
 
-        def start_processing(audio_file, lang):
-            hf_audio = handle_file(audio_file)
-            out = client.predict(audio_file=hf_audio, target_lang=lang, api_name="/process_audio_pipeline_step1")
-            chunks = [{
-                'original': out[2][i], 'transcript': out[3][i], 'translate': out[4][i], 'dubbed': out[5][i]
-            } for i in range(len(out[2]))]
-            state.value = {"chunks": chunks, "index": 0}
-            first = chunks[0]
+    # Define wrapper functions to call the API endpoints
+    def start_processing(audio_file, target_language):
+        if not audio_file or not target_language:
             return (
-                gr.update(value=first['original'], visible=True),  # transcription_audio
-                gr.update(value=first['transcript'], visible=True),  # transcription_text
-                gr.update(value=first['translate'], visible=True),  # translation_text
-                gr.update(visible=True)                           # next_chunk_btn
+                "Please provide both an audio file and a target language.",
+                None, "", "", None, "",
+                gr.update(visible=False), gr.update(visible=False)
+            )
+        try:
+            logger.info("Calling /process_audio_pipeline_step1 with file: %s", audio_file)
+            result = client.predict(
+                audio_file=handle_file(audio_file),
+                target_lang=target_language,
+                api_name="/process_audio_pipeline_step1"
+            )
+            logger.info("Received result from step 1: %s", result)
+            
+            # API returns a 7-element tuple, we map it to our UI outputs
+            # [status, internal_val, orig_audio, trans, transl, dubbed_audio, progress]
+            return (
+                result[0], result[2], result[3], result[4], result[5], result[6],
+                gr.update(visible=True), gr.update(visible=True) # Make edit and merge sections visible
+            )
+        except Exception as e:
+            logger.error("Error in start_processing: %s", e, exc_info=True)
+            return (
+                f"Error starting the process: {e}",
+                None, "", "", None, "",
+                gr.update(visible=False), gr.update(visible=False)
             )
 
-        def go_next(state_dict):
-            idx = state_dict['index'] + 1
-            if idx < len(state_dict['chunks']):
-                state_dict['index'] = idx
-                chunk = state_dict['chunks'][idx]
-                return (
-                    state_dict,                              # state
-                    gr.update(value=chunk['original'], visible=True),  # transcription_audio
-                    gr.update(value=chunk['transcript'], visible=True),  # transcription_text
-                    gr.update(value=chunk['translate'], visible=True),  # translation_text
-                    gr.update(visible=True),                # next_chunk_btn
-                    gr.update(visible=False),               # dubbing_audio
-                    gr.update(visible=False),               # redub_btn
-                    gr.update(visible=False)                # finalize_btn
-                )
-            else:
-                return (
-                    state_dict,                              # state
-                    gr.update(visible=False),               # transcription_audio
-                    gr.update(visible=False),               # transcription_text
-                    gr.update(visible=False),               # translation_text
-                    gr.update(visible=False),               # next_chunk_btn
-                    gr.update(value=state_dict['chunks'][state_dict['index']]['dubbed'], visible=True),  # dubbing_audio
-                    gr.update(visible=True),                # redub_btn
-                    gr.update(visible=True)                 # finalize_btn
+    def navigate_chunk(transcription, translation, direction):
+        # The API uses different endpoints for next/previous navigation
+        # We assume /lambda is for previous and /lambda_1 is for next
+        api_to_call = "/lambda" if direction == "prev" else "/lambda_1"
+        try:
+            logger.info("Calling %s to navigate.", api_to_call)
+            result = client.predict(
+                t=transcription,
+                tr=translation,
+                api_name=api_to_call
+            )
+            logger.info("Received result from navigation: %s", result)
+            # API returns a 6-element tuple
+            # [internal_val, orig_audio, trans, transl, dubbed_audio, progress]
+            return result[1], result[2], result[3], result[4], result[5]
+        except Exception as e:
+            logger.error("Error navigating chunks: %s", e, exc_info=True)
+            return None, f"Error navigating chunks: {e}", "", None, ""
+
+    def generate_dubbed_chunk(transcription, translation):
+        if not transcription and not translation:
+            return None
+        try:
+            logger.info("Calling /generate_dubbed_chunk.")
+            dubbed_path = client.predict(
+                transcription=transcription,
+                translation=translation,
+                api_name="/generate_dubbed_chunk"
+            )
+            logger.info("Received dubbed chunk: %s", dubbed_path)
+            return dubbed_path
+        except Exception as e:
+            logger.error("Error generating dubbed chunk: %s", e, exc_info=True)
+            return None
+
+    def finalize_current_chunk():
+        try:
+            logger.info("Calling /finalize_current_chunk.")
+            progress = client.predict(api_name="/finalize_current_chunk")
+            logger.info("Received finalization progress: %s", progress)
+            return progress
+        except Exception as e:
+            logger.error("Error finalizing chunk: %s", e, exc_info=True)
+            return f"Error finalizing chunk: {e}"
+
+    def merge_all_chunks():
+        try:
+            logger.info("Calling /merge_audio_files.")
+            final_status, final_audio = client.predict(api_name="/merge_audio_files")
+            logger.info("Received final merged audio.")
+            return final_status, final_audio
+        except Exception as e:
+            logger.error("Error merging audio files: %s", e, exc_info=True)
+            return f"Error merging audio: {e}", None
+
+    # Define the Gradio Interface using Blocks for a custom layout
+    with gr.Blocks(theme=gr_themes.Soft(), title="DubSync - AI Audio Dubbing") as demo:
+        gr.Markdown("# 🎬 DubSync - AI Audio Dubbing Pipeline")
+        gr.Markdown("Transform your audio into another Indian language with full editing control.")
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                gr.Markdown("### 📤 Step 1: Upload & Configure")
+                audio_input = gr.Audio(sources=["upload"], type="filepath", label="🎵 Upload Audio File")
+                lang_dropdown = gr.Dropdown(
+                    choices=["Assamese", "Bengali", "Gujarati", "Hindi", "Kannada", "Malayalam", "Marathi", "Odia", "Punjabi", "Tamil", "Telugu"],
+                    label="🌐 Target Language"
                 )
-
-        def redub(state_dict):
-            chunk = state_dict['chunks'][state_dict['index']]
-            dubbed = client.predict(transcription=chunk['transcript'], translation=chunk['translate'], api_name="/generate_dubbed_chunk")
-            state_dict['chunks'][state_dict['index']]['dubbed'] = dubbed
-            return gr.update(value=dubbed, visible=True)  # dubbing_audio
-
-        def finalize(state_dict):
-            state_dict['chunks'][state_dict['index']]['finalized'] = True
-            if all(c.get('finalized', False) for c in state_dict['chunks']):
-                return gr.update(visible=True)  # merge_btn
-            return gr.update(visible=False)  # merge_btn
-
-        def merge_all(state_dict):
-            out = client.predict(api_name="/merge_audio_files")
-            return gr.update(value=out[1], visible=True)  # final_audio
-
-        start_btn.click(
-            start_processing,
+                process_btn = gr.Button("🎯 Start Processing", variant="primary")
+        
+        step1_output = gr.Textbox(label="📊 Processing Status", interactive=False)
+        
+        with gr.Column(visible=False) as edit_section:
+            gr.Markdown("### ✏️ Step 2: Edit, Generate & Finalize Chunks")
+            with gr.Row():
+                prev_btn = gr.Button("◀️ Previous")
+                next_btn = gr.Button("Next ▶️")
+            original_audio = gr.Audio(label="Original Chunk Audio", type="filepath", interactive=False)
+            transcription_text = gr.Textbox(label="Transcription (edit if needed)", lines=2, interactive=True)
+            translation_text = gr.Textbox(label="Translation (edit if needed)", lines=2, interactive=True)
+            with gr.Row():
+                generate_btn = gr.Button("🔊 Generate Dubbed Chunk")
+                finalize_btn = gr.Button("✔️ Finalize Chunk", variant="secondary")
+            dubbed_audio = gr.Audio(label="Dubbed Chunk Audio", type="filepath", interactive=False)
+            progress_text = gr.Textbox(label="Progress", interactive=False)
+        
+        with gr.Row(visible=False) as merge_section:
+            gr.Markdown("### 🏁 Step 3: Merge Final Audio")
+            merge_btn = gr.Button("🚀 Merge All Finalized Chunks", variant="primary")
+        
+        final_output = gr.Textbox(label="🎉 Final Results", interactive=False)
+        output_audio = gr.Audio(label="🔊 Final Dubbed Audio", type="filepath", interactive=False)
+
+        # Connect functions to UI components
+        process_btn.click(
+            fn=start_processing,
             inputs=[audio_input, lang_dropdown],
-            outputs=[transcription_audio, transcription_text, translation_text, next_chunk_btn]
+            outputs=[step1_output, original_audio, transcription_text, translation_text, dubbed_audio, progress_text, edit_section, merge_section]
         )
-        next_chunk_btn.click(
-            go_next,
-            inputs=[state],
-            outputs=[state, transcription_audio, transcription_text, translation_text, next_chunk_btn, dubbing_audio, redub_btn, finalize_btn]
+        
+        prev_btn.click(
+            fn=lambda t, tr: navigate_chunk(t, tr, "prev"),
+            inputs=[transcription_text, translation_text],
+            outputs=[original_audio, transcription_text, translation_text, dubbed_audio, progress_text]
         )
-        redub_btn.click(
-            redub,
-            inputs=[state],
-            outputs=[dubbing_audio]
+        
+        next_btn.click(
+            fn=lambda t, tr: navigate_chunk(t, tr, "next"),
+            inputs=[transcription_text, translation_text],
+            outputs=[original_audio, transcription_text, translation_text, dubbed_audio, progress_text]
         )
+
+        generate_btn.click(
+            fn=generate_dubbed_chunk,
+            inputs=[transcription_text, translation_text],
+            outputs=[dubbed_audio]
+        )
+
         finalize_btn.click(
-            finalize,
-            inputs=[state],
-            outputs=[merge_btn]
+            fn=finalize_current_chunk,
+            inputs=[],
+            outputs=[progress_text]
         )
+
         merge_btn.click(
-            merge_all,
-            inputs=[state],
-            outputs=[final_audio]
+            fn=merge_all_chunks,
+            inputs=[],
+            outputs=[final_output, output_audio]
         )
-
+        
     return demo
 
 if __name__ == "__main__":
-    ui = create_dubsync_interface()
-    ui.launch(show_error=True, share=False, server_name="0.0.0.0", server_port=7860)
+    dubsync_interface = create_dubsync_interface()
+    if dubsync_interface:
+        dubsync_interface.launch(show_error=True, share=False, server_name="0.0.0.0", server_port=7860)
+    else:
+        logger.error("Failed to create the Gradio interface.")