import gradio as gr import tempfile import openai import requests import os from functools import partial def tts( input_text: str, model: str, voice: str, api_key: str, response_format: str = "mp3", speed: float = 1.0, ) -> str: """ Convert input text to speech using OpenAI's Text-to-Speech API. Parameters: input_text (str): The text to be converted to speech. model (str): The model to use for synthesis (e.g., 'tts-1', 'tts-1-hd'). voice (str): The voice to use when generating the audio. api_key (str): OpenAI API key. response_format (str): Format of the output audio. Defaults to 'mp3'. speed (float): Speed of the generated audio. Defaults to 1.0. Returns: str: File path to the generated audio file. Raises: gr.Error: If input parameters are invalid or API call fails. """ if not api_key.strip(): raise gr.Error( "API key is required. Get an API key at: https://platform.openai.com/account/api-keys" ) if not input_text.strip(): raise gr.Error("Input text cannot be empty.") if len(input_text) > 4096: raise gr.Error("Input text exceeds the maximum length of 4096 characters.") if speed < 0.25 or speed > 4.0: raise gr.Error("Speed must be between 0.25 and 4.0.") headers = { "Authorization": f"Bearer {api_key}", "Content-Type": "application/json", } data = { "model": model, "input": input_text, "voice": voice, "response_format": response_format, "speed": speed, } try: response = requests.post( "https://api.openai.com/v1/audio/speech", headers=headers, json=data, ) response.raise_for_status() except requests.exceptions.HTTPError as http_err: raise gr.Error(f"HTTP error occurred: {http_err} - {response.text}") except Exception as err: raise gr.Error(f"An error occurred: {err}") # The content will be the audio file content audio_content = response.content file_extension = response_format.lower() # PCM is raw data, so it does not have a standard file extension if file_extension == "pcm": file_extension = "raw" with tempfile.NamedTemporaryFile( suffix=f".{file_extension}", delete=False ) as temp_file: temp_file.write(audio_content) temp_file_path = temp_file.name return temp_file_path def main(): """ Main function to create and launch the Gradio interface. """ MODEL_OPTIONS = ["tts-1", "tts-1-hd"] VOICE_OPTIONS = ["alloy", "echo", "fable", "onyx", "nova", "shimmer"] RESPONSE_FORMAT_OPTIONS = ["mp3", "opus", "aac", "flac", "wav", "pcm"] # Predefine voice previews URLs VOICE_PREVIEW_URLS = { voice: f"https://cdn.openai.com/API/docs/audio/{voice}.wav" for voice in VOICE_OPTIONS } # Download audio previews to disk before initiating the interface PREVIEW_DIR = "voice_previews" os.makedirs(PREVIEW_DIR, exist_ok=True) VOICE_PREVIEW_FILES = {} for voice, url in VOICE_PREVIEW_URLS.items(): local_file_path = os.path.join(PREVIEW_DIR, f"{voice}.wav") if not os.path.exists(local_file_path): try: response = requests.get(url) response.raise_for_status() with open(local_file_path, "wb") as f: f.write(response.content) except requests.exceptions.RequestException as e: print(f"Failed to download {voice} preview: {e}") VOICE_PREVIEW_FILES[voice] = local_file_path # Set static paths for Gradio to serve gr.static(PREVIEW_DIR) with gr.Blocks(title="OpenAI - Text to Speech") as demo: gr.Markdown("# OpenAI Text-to-Speech Demo") with gr.Row(): with gr.Column(scale=1): with gr.Group(): preview_audio = gr.Audio( interactive=False, label="Preview Audio", value=None, visible=True, ) # Function to play the selected voice sample def play_voice_sample(voice): return gr.update(value=VOICE_PREVIEW_FILES[voice]) # Create buttons for each voice for voice in VOICE_OPTIONS: voice_button = gr.Button( value=f"{voice.capitalize()}", variant="secondary", size="sm", ) voice_button.click( fn=partial(play_voice_sample, voice=voice), outputs=preview_audio, ) with gr.Column(scale=1): api_key_input = gr.Textbox( label="OpenAI API Key", info="https://platform.openai.com/account/api-keys", type="password", placeholder="Enter your OpenAI API Key", ) model_dropdown = gr.Dropdown( choices=MODEL_OPTIONS, label="Model", value="tts-1", info="Select tts-1 for speed or tts-1-hd for quality.", ) voice_dropdown = gr.Dropdown( choices=VOICE_OPTIONS, label="Voice Options", value="echo", info="The voice to use when generating the audio.", ) response_format_dropdown = gr.Dropdown( choices=RESPONSE_FORMAT_OPTIONS, label="Response Format", value="mp3", ) speed_slider = gr.Slider( minimum=0.25, maximum=4.0, step=0.05, label="Voice Speed", value=1.0, ) with gr.Column(scale=2): input_textbox = gr.Textbox( label="Input Text", lines=10, placeholder="Type your text here...", ) # Add a character counter below the input textbox char_count_text = gr.Markdown("0 / 4096") # Function to update the character count def update_char_count(input_text): char_count = len(input_text) return f"**{char_count} / 4096**" # Update character count when the user stops typing input_textbox.change( fn=update_char_count, inputs=input_textbox, outputs=char_count_text, ) submit_button = gr.Button( "Convert Text to Speech", variant="primary", ) with gr.Column(scale=1): output_audio = gr.Audio(label="Output Audio") # Define the event handler for the submit button with error handling def on_submit( input_text, model, voice, api_key, response_format, speed ): audio_file = tts( input_text, model, voice, api_key, response_format, speed ) return audio_file # Trigger the conversion when the submit button is clicked submit_button.click( fn=on_submit, inputs=[ input_textbox, model_dropdown, voice_dropdown, api_key_input, response_format_dropdown, speed_slider, ], outputs=output_audio, ) # Launch the Gradio app with error display enabled demo.launch(show_error=True) if __name__ == "__main__": main()