app.py

import base64
import tempfile
import os
import requests
import gradio as gr
import random
from openai import OpenAI

# Available voices for audio generation
VOICES = ["alloy", "ash", "ballad", "coral", "echo", "fable", "onyx", "nova", "sage", "shimmer", "verse"]

# Example audio URLs
EXAMPLE_AUDIO_URLS = [
    "https://cdn.openai.com/API/docs/audio/alloy.wav",
    "https://cdn.openai.com/API/docs/audio/ash.wav",
    "https://cdn.openai.com/API/docs/audio/coral.wav",
    "https://cdn.openai.com/API/docs/audio/echo.wav",
    "https://cdn.openai.com/API/docs/audio/fable.wav",
    "https://cdn.openai.com/API/docs/audio/onyx.wav",
    "https://cdn.openai.com/API/docs/audio/nova.wav",
    "https://cdn.openai.com/API/docs/audio/sage.wav",
    "https://cdn.openai.com/API/docs/audio/shimmer.wav"
]

# Supported languages for translation
SUPPORTED_LANGUAGES = [
    "Afrikaans", "Arabic", "Armenian", "Azerbaijani", "Belarusian", "Bosnian", 
    "Bulgarian", "Catalan", "Chinese", "Croatian", "Czech", "Danish", "Dutch", 
    "English", "Estonian", "Finnish", "French", "Galician", "German", "Greek", 
    "Hebrew", "Hindi", "Hungarian", "Icelandic", "Indonesian", "Italian", "Japanese", 
    "Kannada", "Kazakh", "Korean", "Latvian", "Lithuanian", "Macedonian", "Malay", 
    "Marathi", "Maori", "Nepali", "Norwegian", "Persian", "Polish", "Portuguese", 
    "Romanian", "Russian", "Serbian", "Slovak", "Slovenian", "Spanish", "Swahili", 
    "Swedish", "Tagalog", "Tamil", "Thai", "Turkish", "Ukrainian", "Urdu", 
    "Vietnamese", "Welsh"
]

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)
        
        completion = client.chat.completions.create(
            model="gpt-4o-audio-preview",
            modalities=["text", "audio"],
            audio={"voice": selected_voice, "format": "wav"},
            messages=[
                {
                    "role": "user",
                    "content": text_prompt
                }
            ]
        )
        
        # 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 the text response directly from the API
        text_response = completion.choices[0].message.content
        
        return text_response, temp_path
    except Exception as e:
        return f"Error: {str(e)}", None

def process_audio_input(api_key, audio_path, text_prompt, selected_voice):
    """Process audio input and generate a response"""
    try:
        if not audio_path:
            return "Please upload or record audio first.", None
        
        # Initialize OpenAI client with the provided API key
        client = OpenAI(api_key=api_key)
        
        # Read audio file and encode to base64
        with open(audio_path, "rb") as audio_file:
            audio_data = audio_file.read()
        encoded_audio = base64.b64encode(audio_data).decode('utf-8')
        
        # Create message content with both text and audio
        message_content = []
        
        if text_prompt:
            message_content.append({
                "type": "text",
                "text": text_prompt
            })
        
        message_content.append({
            "type": "input_audio",
            "input_audio": {
                "data": encoded_audio,
                "format": "wav"
            }
        })
        
        # Call OpenAI API
        completion = client.chat.completions.create(
            model="gpt-4o-audio-preview",
            modalities=["text", "audio"],
            audio={"voice": selected_voice, "format": "wav"},
            messages=[
                {
                    "role": "user",
                    "content": message_content
                }
            ]
        )
        
        # Save the audio response
        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 the text response
        text_response = completion.choices[0].message.content
        
        return text_response, temp_path
    except Exception as e:
        return f"Error: {str(e)}", None

def transcribe_audio(api_key, audio_path):
    """Transcribe an audio file using OpenAI's API"""
    try:
        if not audio_path:
            return "No audio file provided for transcription."
        
        client = OpenAI(api_key=api_key)
        
        with open(audio_path, "rb") as audio_file:
            transcription = client.audio.transcriptions.create(
                model="gpt-4o-transcribe", 
                file=audio_file
            )
        
        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"""
    try:
        if not audio_path:
            return "No audio file provided for translation."
        
        client = OpenAI(api_key=api_key)
        
        with open(audio_path, "rb") as audio_file:
            translation = client.audio.translations.create(
                model="whisper-1", 
                file=audio_file
            )
        
        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"""
    try:
        # Randomly select one of the example audio URLs
        url = random.choice(EXAMPLE_AUDIO_URLS)
        
        # 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}"
    except Exception as e:
        return None, f"Error loading example: {str(e)}"

def use_example_audio():
    """Load random example audio for the interface"""
    audio_path, message = download_example_audio()
    return audio_path, message

# Create Gradio Interface
with gr.Blocks(title="OpenAI Audio Chat App") as app:
    gr.Markdown("# OpenAI Audio Chat App")
    gr.Markdown("Interact with GPT-4o audio model through text and audio inputs")
    
    # API Key input (used across all tabs)
    api_key = gr.Textbox(
        label="OpenAI API Key", 
        placeholder="Enter your OpenAI API key here",
        type="password"
    )
    
    with gr.Tab("Text to Audio"):
        with gr.Row():
            with gr.Column():
                text_input = gr.Textbox(
                    label="Text Prompt", 
                    placeholder="Enter your question or prompt here...",
                    lines=3
                )
                text_voice = gr.Dropdown(
                    choices=VOICES,
                    value="alloy",
                    label="Voice"
                )
                text_submit = gr.Button("Generate Response")
            
            with gr.Column():
                text_output = gr.Textbox(label="AI Response (Checks Error)", lines=5)
                audio_output = gr.Audio(label="AI Response (Audio)")
                transcribed_output = gr.Textbox(label="Transcription of Audio Response", lines=3)
        
        # Function to process text input and then transcribe the resulting audio
        def text_input_with_transcription(api_key, text_prompt, voice):
            text_response, audio_path = process_text_input(api_key, text_prompt, voice)
            
            # Get transcription of the generated audio
            if audio_path:
                transcription = transcribe_audio(api_key, audio_path)
            else:
                transcription = "No audio generated to transcribe."
                
            return text_response, audio_path, transcription
        
        text_submit.click(
            fn=text_input_with_transcription,
            inputs=[api_key, text_input, text_voice],
            outputs=[text_output, audio_output, transcribed_output]
        )
    
    with gr.Tab("Audio Input to Audio Response"):
        with gr.Row():
            with gr.Column():
                audio_input = gr.Audio(
                    label="Audio Input", 
                    type="filepath",
                    sources=["microphone", "upload"]
                )
                example_btn = gr.Button("Use Random Example Audio")
                example_message = gr.Textbox(label="Example Status", interactive=False)
                
                accompanying_text = gr.Textbox(
                    label="Accompanying Text (Optional)", 
                    placeholder="Add any text context or question about the audio...",
                    lines=2
                )
                audio_voice = gr.Dropdown(
                    choices=VOICES,
                    value="alloy",
                    label="Response Voice"
                )
                audio_submit = gr.Button("Process Audio & Generate Response")
            
            with gr.Column():
                audio_text_output = gr.Textbox(label="AI Response (Checks Error)", lines=5)
                audio_audio_output = gr.Audio(label="AI Response (Audio)")
                audio_transcribed_output = gr.Textbox(label="Transcription of Audio Response", lines=3)
                input_transcription = gr.Textbox(label="Transcription of Input Audio", lines=3)
        
        # Function to process audio input, generate response, and provide transcriptions
        def audio_input_with_transcription(api_key, audio_path, text_prompt, voice):
            # First transcribe the input audio
            input_transcription = "N/A"
            if audio_path:
                input_transcription = transcribe_audio(api_key, audio_path)
            
            # Process the audio input and get response
            text_response, response_audio_path = process_audio_input(api_key, audio_path, text_prompt, voice)
            
            # Transcribe the response audio
            response_transcription = "No audio generated to transcribe."
            if response_audio_path:
                response_transcription = transcribe_audio(api_key, response_audio_path)
                
            return text_response, response_audio_path, response_transcription, input_transcription
        
        audio_submit.click(
            fn=audio_input_with_transcription,
            inputs=[api_key, audio_input, accompanying_text, audio_voice],
            outputs=[audio_text_output, audio_audio_output, audio_transcribed_output, input_transcription]
        )
        
        example_btn.click(
            fn=use_example_audio,
            inputs=[],
            outputs=[audio_input, example_message]
        )
    
    with gr.Tab("Voice Samples"):
        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."
                        }
                    ]
                )
                
                # 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 Exception as e:
                return f"Error: {str(e)}", None, "No transcription available."
        
        with gr.Row():
            sample_voice = gr.Dropdown(
                choices=VOICES,
                value="alloy",
                label="Select Voice Sample"
            )
            sample_btn = gr.Button("Generate Sample")
        
        with gr.Row():
            sample_text = gr.Textbox(label="Status")
            sample_audio = gr.Audio(label="Voice Sample")
            sample_transcription = gr.Textbox(label="Transcription", lines=3)
        
        sample_btn.click(
            fn=generate_voice_sample,
            inputs=[api_key, sample_voice],
            outputs=[sample_text, sample_audio, sample_transcription]
        )
    
    # New tab for audio translation
    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.")
        
        with gr.Row():
            with gr.Column():
                translation_audio_input = gr.Audio(
                    label="Audio to Translate", 
                    type="filepath",
                    sources=["microphone", "upload"]
                )
                
                translate_btn = gr.Button("Translate to English")
            
            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"""
            try:
                if not audio_path:
                    return "Please upload or record audio first.", "No audio to transcribe."
                
                # Get the translation
                translation = translate_audio(api_key, audio_path)
                
                # Try to get original transcription (this might be in the original language)
                try:
                    original = transcribe_audio(api_key, audio_path)
                except:
                    original = "Could not transcribe original audio."
                
                return translation, original
            except Exception as e:
                return f"Translation error: {str(e)}", "Error occurred during processing."
        
        translate_btn.click(
            fn=translate_audio_input,
            inputs=[api_key, translation_audio_input],
            outputs=[translation_output, original_transcription]
        )
        
        # Show supported languages
        with gr.Accordion("Supported Languages", open=False):
            gr.Markdown(", ".join(SUPPORTED_LANGUAGES))
    
    gr.Markdown("""
    ## Notes:
    - You must provide your OpenAI API key in the field above
    - The model used is `gpt-4o-audio-preview` for conversation, `gpt-4o-transcribe` for transcriptions, and `whisper-1` for translations
    - Audio inputs should be in WAV format for chat and any supported format for translation
    - Available voices: alloy, ash, ballad, coral, echo, fable, onyx, nova, sage, shimmer, and verse
    - 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 __name__ == "__main__":
    app.launch()