Update app.py

app.py

@@ -4,7 +4,9 @@ import os
 import requests
 import gradio as gr
 import random
+import time
 from openai import OpenAI
+from requests.exceptions import RequestException, Timeout, ConnectionError
 
 # Available voices for audio generation
 VOICES = ["alloy", "ash", "ballad", "coral", "echo", "fable", "onyx", "nova", "sage", "shimmer", "verse"]
@@ -35,11 +37,23 @@ SUPPORTED_LANGUAGES = [
     "Vietnamese", "Welsh"
 ]
 
+# Max retries for API calls
+MAX_RETRIES = 3
+RETRY_DELAY = 2  # seconds
+
+def create_openai_client(api_key):
+    """Create an OpenAI client with proper timeout settings"""
+    return OpenAI(
+        api_key=api_key,
+        timeout=60.0,  # 60 second timeout
+        max_retries=3  # Allow 3 retries
+    )
+
 def process_text_input(api_key, text_prompt, selected_voice):
     """Generate audio response from text input"""
     try:
         # Initialize OpenAI client with the provided API key
-        client = OpenAI(api_key=api_key)
+        client = create_openai_client(api_key)
         
         completion = client.chat.completions.create(
             model="gpt-4o-audio-preview",
@@ -63,6 +77,10 @@ def process_text_input(api_key, text_prompt, selected_voice):
         text_response = completion.choices[0].message.content
         
         return text_response, temp_path
+    except ConnectionError as e:
+        return f"Connection error: {str(e)}. Please check your internet connection and try again.", None
+    except Timeout as e:
+        return f"Timeout error: {str(e)}. The request took too long to complete. Please try again.", None
     except Exception as e:
         return f"Error: {str(e)}", None
 
@@ -73,7 +91,7 @@ def process_audio_input(api_key, audio_path, text_prompt, selected_voice):
             return "Please upload or record audio first.", None
         
         # Initialize OpenAI client with the provided API key
-        client = OpenAI(api_key=api_key)
+        client = create_openai_client(api_key)
         
         # Read audio file and encode to base64
         with open(audio_path, "rb") as audio_file:
@@ -120,6 +138,10 @@ def process_audio_input(api_key, audio_path, text_prompt, selected_voice):
         text_response = completion.choices[0].message.content
         
         return text_response, temp_path
+    except ConnectionError as e:
+        return f"Connection error: {str(e)}. Please check your internet connection and try again.", None
+    except Timeout as e:
+        return f"Timeout error: {str(e)}. The request took too long to complete. Please try again.", None
     except Exception as e:
         return f"Error: {str(e)}", None
 
@@ -129,38 +151,86 @@ def transcribe_audio(api_key, audio_path):
         if not audio_path:
             return "No audio file provided for transcription."
         
-        client = OpenAI(api_key=api_key)
+        client = create_openai_client(api_key)
         
+        # Make sure the file exists and is readable
+        if not os.path.exists(audio_path):
+            return "Audio file not found or inaccessible."
+            
+        # Check file size
+        file_size = os.path.getsize(audio_path)
+        if file_size == 0:
+            return "Audio file is empty."
+            
         with open(audio_path, "rb") as audio_file:
-            transcription = client.audio.transcriptions.create(
-                model="gpt-4o-transcribe", 
-                file=audio_file
-            )
+            for attempt in range(MAX_RETRIES):
+                try:
+                    transcription = client.audio.transcriptions.create(
+                        model="gpt-4o-transcribe", 
+                        file=audio_file
+                    )
+                    return transcription.text
+                except (ConnectionError, Timeout) as e:
+                    if attempt < MAX_RETRIES - 1:
+                        time.sleep(RETRY_DELAY)
+                        # Reset file pointer
+                        audio_file.seek(0)
+                        continue
+                    else:
+                        return f"Transcription failed after {MAX_RETRIES} attempts: {str(e)}"
+                except Exception as e:
+                    return f"Transcription error: {str(e)}"
         
-        return transcription.text
     except Exception as e:
         return f"Transcription error: {str(e)}"
 
 def translate_audio(api_key, audio_path):
-    """Translate audio to English using OpenAI's Whisper model"""
+    """Translate audio to English using OpenAI's Whisper model with improved error handling"""
     try:
         if not audio_path:
             return "No audio file provided for translation."
+            
+        # Verify file exists and is accessible
+        if not os.path.exists(audio_path):
+            return "Audio file not found or inaccessible."
+            
+        # Check file size
+        file_size = os.path.getsize(audio_path)
+        if file_size == 0:
+            return "Audio file is empty."
         
-        client = OpenAI(api_key=api_key)
+        client = create_openai_client(api_key)
         
-        with open(audio_path, "rb") as audio_file:
-            translation = client.audio.translations.create(
-                model="whisper-1", 
-                file=audio_file
-            )
+        # Implement retry mechanism
+        for attempt in range(MAX_RETRIES):
+            try:
+                with open(audio_path, "rb") as audio_file:
+                    translation = client.audio.translations.create(
+                        model="whisper-1", 
+                        file=audio_file,
+                        timeout=90.0  # Extended timeout for translation
+                    )
+                return translation.text
+            except (ConnectionError, Timeout) as e:
+                if attempt < MAX_RETRIES - 1:
+                    # Wait before retrying
+                    time.sleep(RETRY_DELAY * (attempt + 1))  # Exponential backoff
+                    continue
+                else:
+                    return f"Translation failed after {MAX_RETRIES} attempts: Connection error. Please check your internet connection and try again."
+            except Exception as e:
+                # Handle other exceptions
+                error_message = str(e)
+                if "connection" in error_message.lower():
+                    return f"Connection error: {error_message}. Please check your internet connection and try again."
+                else:
+                    return f"Translation error: {error_message}"
         
-        return translation.text
     except Exception as e:
         return f"Translation error: {str(e)}"
 
 def download_example_audio():
-    """Download a random example audio file for testing"""
+    """Download a random example audio file for testing with improved error handling"""
     try:
         # Randomly select one of the example audio URLs
         url = random.choice(EXAMPLE_AUDIO_URLS)
@@ -168,15 +238,27 @@ def download_example_audio():
         # Get the voice name from the URL for feedback
         voice_name = url.split('/')[-1].split('.')[0]
         
-        response = requests.get(url)
-        response.raise_for_status()
-        
-        # Save to a temporary file
-        temp_path = tempfile.mktemp(suffix=".wav")
-        with open(temp_path, "wb") as f:
-            f.write(response.content)
-        
-        return temp_path, f"Loaded example voice: {voice_name}"
+        # Implement retry mechanism
+        for attempt in range(MAX_RETRIES):
+            try:
+                response = requests.get(url, timeout=30)
+                response.raise_for_status()
+                
+                # Save to a temporary file
+                temp_path = tempfile.mktemp(suffix=".wav")
+                with open(temp_path, "wb") as f:
+                    f.write(response.content)
+                
+                return temp_path, f"Loaded example voice: {voice_name}"
+            except (ConnectionError, Timeout) as e:
+                if attempt < MAX_RETRIES - 1:
+                    time.sleep(RETRY_DELAY)
+                    continue
+                else:
+                    return None, f"Failed to download example after {MAX_RETRIES} attempts: {str(e)}"
+            except Exception as e:
+                return None, f"Error loading example: {str(e)}"
+                
     except Exception as e:
         return None, f"Error loading example: {str(e)}"
 
@@ -185,6 +267,12 @@ def use_example_audio():
     audio_path, message = download_example_audio()
     return audio_path, message
 
+def check_api_key(api_key):
+    """Validate if the API key is provided"""
+    if not api_key or api_key.strip() == "":
+        return False
+    return True
+
 # Create Gradio Interface
 with gr.Blocks(title="OpenAI Audio Chat App") as app:
     gr.Markdown("# OpenAI Audio Chat App")
@@ -219,6 +307,9 @@ with gr.Blocks(title="OpenAI Audio Chat App") as app:
         
         # Function to process text input and then transcribe the resulting audio
         def text_input_with_transcription(api_key, text_prompt, voice):
+            if not check_api_key(api_key):
+                return "Please enter your OpenAI API key first.", None, "No API key provided."
+                
             text_response, audio_path = process_text_input(api_key, text_prompt, voice)
             
             # Get transcription of the generated audio
@@ -266,10 +357,15 @@ with gr.Blocks(title="OpenAI Audio Chat App") as app:
         
         # Function to process audio input, generate response, and provide transcriptions
         def audio_input_with_transcription(api_key, audio_path, text_prompt, voice):
+            if not check_api_key(api_key):
+                return "Please enter your OpenAI API key first.", None, "No API key provided.", "No API key provided."
+                
             # First transcribe the input audio
             input_transcription = "N/A"
             if audio_path:
                 input_transcription = transcribe_audio(api_key, audio_path)
+            else:
+                return "Please upload or record audio first.", None, "No audio to transcribe.", "No audio provided."
             
             # Process the audio input and get response
             text_response, response_audio_path = process_audio_input(api_key, audio_path, text_prompt, voice)
@@ -297,33 +393,43 @@ with gr.Blocks(title="OpenAI Audio Chat App") as app:
         gr.Markdown("## Listen to samples of each voice")
         
         def generate_voice_sample(api_key, voice_type):
-            try:
-                if not api_key:
-                    return "Please enter your OpenAI API key first.", None, "No transcription available."
-                
-                client = OpenAI(api_key=api_key)
-                completion = client.chat.completions.create(
-                    model="gpt-4o-audio-preview",
-                    modalities=["text", "audio"],
-                    audio={"voice": voice_type, "format": "wav"},
-                    messages=[
-                        {
-                            "role": "user",
-                            "content": f"This is a sample of the {voice_type} voice. It has its own unique tone and character."
-                        }
-                    ]
-                )
+            if not check_api_key(api_key):
+                return "Please enter your OpenAI API key first.", None, "No API key provided."
                 
-                # Save the audio to a temporary file
-                wav_bytes = base64.b64decode(completion.choices[0].message.audio.data)
-                temp_path = tempfile.mktemp(suffix=".wav")
-                with open(temp_path, "wb") as f:
-                    f.write(wav_bytes)
-                
-                # Get transcription
-                transcription = transcribe_audio(api_key, temp_path)
+            try:
+                client = create_openai_client(api_key)
                 
-                return f"Sample generated with voice: {voice_type}", temp_path, transcription
+                # Use retry mechanism
+                for attempt in range(MAX_RETRIES):
+                    try:
+                        completion = client.chat.completions.create(
+                            model="gpt-4o-audio-preview",
+                            modalities=["text", "audio"],
+                            audio={"voice": voice_type, "format": "wav"},
+                            messages=[
+                                {
+                                    "role": "user",
+                                    "content": f"This is a sample of the {voice_type} voice. It has its own unique tone and character."
+                                }
+                            ]
+                        )
+                        
+                        # Save the audio to a temporary file
+                        wav_bytes = base64.b64decode(completion.choices[0].message.audio.data)
+                        temp_path = tempfile.mktemp(suffix=".wav")
+                        with open(temp_path, "wb") as f:
+                            f.write(wav_bytes)
+                        
+                        # Get transcription
+                        transcription = transcribe_audio(api_key, temp_path)
+                        
+                        return f"Sample generated with voice: {voice_type}", temp_path, transcription
+                    except (ConnectionError, Timeout) as e:
+                        if attempt < MAX_RETRIES - 1:
+                            time.sleep(RETRY_DELAY)
+                            continue
+                        else:
+                            return f"Connection error after {MAX_RETRIES} attempts: {str(e)}. Please check your internet connection.", None, "No sample generated."
             except Exception as e:
                 return f"Error: {str(e)}", None, "No transcription available."
         
@@ -346,7 +452,7 @@ with gr.Blocks(title="OpenAI Audio Chat App") as app:
             outputs=[sample_text, sample_audio, sample_transcription]
         )
     
-    # New tab for audio translation
+    # New tab for audio translation with improved error handling
     with gr.Tab("Audio Translation"):
         gr.Markdown("## Translate audio from other languages to English")
         gr.Markdown("Supports 50+ languages including: Arabic, Chinese, French, German, Japanese, Spanish, and many more.")
@@ -360,39 +466,72 @@ with gr.Blocks(title="OpenAI Audio Chat App") as app:
                 )
                 
                 translate_btn = gr.Button("Translate to English")
+                connection_status = gr.Textbox(label="Connection Status", value="Ready", interactive=False)
             
             with gr.Column():
                 translation_output = gr.Textbox(label="English Translation", lines=5)
                 original_transcription = gr.Textbox(label="Original Transcription (if available)", lines=5)
         
         def translate_audio_input(api_key, audio_path):
-            """Handle the translation of uploaded audio"""
+            """Handle the translation of uploaded audio with better connection handling"""
+            if not check_api_key(api_key):
+                return "Please enter your OpenAI API key first.", "No API key provided.", "No API key provided."
+                
             try:
                 if not audio_path:
-                    return "Please upload or record audio first.", "No audio to transcribe."
+                    return "Please upload or record audio first.", "No audio to translate.", "Connection ready"
+                
+                # Update connection status
+                yield "Processing...", "Preparing audio for translation...", "Connecting to OpenAI API..."
                 
                 # Get the translation
                 translation = translate_audio(api_key, audio_path)
                 
+                # If there's a connection error message in the translation
+                if "connection error" in translation.lower():
+                    yield translation, "Translation failed due to connection issues.", "Connection failed"
+                    return
+                
                 # Try to get original transcription (this might be in the original language)
                 try:
                     original = transcribe_audio(api_key, audio_path)
-                except:
+                    if "error" in original.lower():
+                        original = "Could not transcribe original audio due to connection issues."
+                except Exception:
                     original = "Could not transcribe original audio."
                 
-                return translation, original
+                yield translation, original, "Connection successful"
+            except ConnectionError as e:
+                yield f"Connection error: {str(e)}. Please check your internet connection and try again.", "Translation failed.", "Connection failed"
+            except Timeout as e:
+                yield f"Timeout error: {str(e)}. The request took too long to complete. Please try again.", "Translation timed out.", "Connection timed out"
             except Exception as e:
-                return f"Translation error: {str(e)}", "Error occurred during processing."
+                yield f"Translation error: {str(e)}", "Error occurred during processing.", "Error occurred"
         
         translate_btn.click(
             fn=translate_audio_input,
             inputs=[api_key, translation_audio_input],
-            outputs=[translation_output, original_transcription]
+            outputs=[translation_output, original_transcription, connection_status]
         )
         
         # Show supported languages
         with gr.Accordion("Supported Languages", open=False):
             gr.Markdown(", ".join(SUPPORTED_LANGUAGES))
+        
+        # Connection troubleshooting tips
+        with gr.Accordion("Connection Troubleshooting", open=False):
+            gr.Markdown("""
+            ### If you experience connection errors:
+            
+            1. **Check your internet connection** - Ensure you have a stable internet connection
+            2. **Verify your API key** - Make sure your OpenAI API key is valid and has sufficient credits
+            3. **Try a smaller audio file** - Large audio files may time out during upload
+            4. **Wait and retry** - OpenAI servers might be experiencing high traffic
+            5. **Check file format** - Make sure your audio file is in a supported format (MP3, WAV, etc.)
+            6. **Try on a different network** - Some networks might block API calls to OpenAI
+            
+            The app will automatically retry failed connections up to 3 times.
+            """)
     
     gr.Markdown("""
     ## Notes:
@@ -403,6 +542,7 @@ with gr.Blocks(title="OpenAI Audio Chat App") as app:
     - Each audio response is automatically transcribed for verification
     - The "Use Random Example Audio" button will load a random sample from OpenAI's demo voices
     - The translation feature supports 50+ languages, translating them to English
+    - If you experience connection errors, the app will automatically retry up to 3 times
     """)
 
 if __name__ == "__main__":