File size: 10,164 Bytes
42966de
 
 
98b32f1
 
 
 
 
 
 
 
 
 
a9471a7
5c3b1e4
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
a9471a7
5c3b1e4
 
 
 
 
 
 
 
 
 
 
8c90b52
 
539d552
 
8c90b52
 
 
 
2c9d387
 
 
 
 
 
8c90b52
772e8a8
4bac96b
5c3b1e4
 
 
 
 
 
 
 
42966de
a9471a7
 
 
42966de
539d552
bd43650
0d286b6
6385f1b
e847c01
42966de
0dbb78f
b990bac
3a80faa
 
 
 
 
 
 
 
 
15934ba
 
73490cc
15934ba
b990bac
96ee146
0d286b6
a284cb9
96ee146
 
0d286b6
 
96ee146
c8ad460
96ee146
 
 
73490cc
512ecf5
 
 
 
 
 
 
 
 
 
 
055f404
7b9da97
 
 
 
 
 
3020c69
7b9da97
 
 
 
3d1c56c
98b32f1
7b9da97
 
6e60917
46e322b
1777fa6
7b9da97
 
 
 
 
 
 
 
 
 
 
 
 
055f404
 
5814747
055f404
 
 
 
3a80faa
 
 
 
 
 
 
 
 
055f404
5814747
 
055f404
e0954fa
055f404
5814747
055f404
5814747
b990bac
055f404
7b9da97
09aa99e
055f404
09aa99e
055f404
09aa99e
055f404
09aa99e
 
 
 
 
 
 
 
 
 
 
 
 
b990bac
 
 
09aa99e
 
b990bac
 
 
09aa99e
 
 
 
 
 
 
 
055f404
b990bac
 
c8ad460
b990bac
 
42966de
98b32f1
b990bac
 
 
 
 
 
3a80faa
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
0d286b6
539d552
0d286b6
97e46d3
42966de
dac7224
 
3020c69
98b32f1
 
 
 
 
 
 
 
9813b68
dfb71ed
 
614dae3
 
42966de
 
7a15797
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
import gradio as gr
import tempfile
import openai
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.

    :param input_text: The text to be converted to speech.
    :type input_text: str
    :param model: The model to use for synthesis (e.g., 'tts-1', 'tts-1-hd').
    :type model: str
    :param voice: The voice profile to use (e.g., 'alloy', 'echo', 'fable', etc.).
    :type voice: str
    :param api_key: OpenAI API key.
    :type api_key: str
    :param response_format: The audio format of the output file, defaults to 'mp3'.
    :type response_format: str, optional
    :param speed: The speed of the synthesized speech (0.25 to 4.0), defaults to 1.0.
    :type speed: float, optional
    :return: File path to the generated audio file.
    :rtype: str
    :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.")

    openai.api_key = api_key

    try:
        # Create the audio speech object
        speech_file = openai.audio.speech.create(
            model=model.lower(),
            voice=voice.lower(),
            input=input_text,
            response_format=response_format,
            speed=speed,
        )
        # Save the audio content to a temporary file
        file_extension = f".{response_format}"
        with tempfile.NamedTemporaryFile(
            suffix=file_extension, delete=False, mode="wb"
        ) as temp_file:
            temp_file_path = temp_file.name
            temp_file.write(speech_file.content)

    except openai.OpenAIError as e:
        # Catch OpenAI exceptions
        raise gr.Error(f"An OpenAI error occurred: {e}")
    except Exception as e:
        # Catch any other exceptions
        raise gr.Error(f"An unexpected error occurred: {e}")

    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"]
    VOICE_PREVIEW_FILES = {voice: f"{voice}.wav" for voice in VOICE_OPTIONS}

    with gr.Blocks(title="OpenAI - Text to Speech") as demo:
        with gr.Row():
            with gr.Column(scale=1):

                def play_voice_sample(voice: str):
                    """
                    Play the preview audio sample for the selected voice.

                    :param voice: The name of the voice to preview.
                    :type voice: str
                    :return: Updated Gradio Audio component with the selected voice sample.
                    :rtype: gr.Audio
                    """
                    return gr.update(
                        value=VOICE_PREVIEW_FILES[voice],
                        label=f"Preview Voice: {voice.capitalize()}",
                    )

                with gr.Group():
                    # Set the default preview audio to one of the voices
                    default_voice = "Echo"
                    preview_audio = gr.Audio(
                        interactive=False,
                        label=f"Preview Voice: {default_voice.capitalize()}",
                        value=VOICE_PREVIEW_FILES[default_voice],
                        visible=True,
                        show_download_button=False,
                        show_share_button=False,
                        autoplay=False,
                    )

                    # 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",
                    value="Echo",
                )
                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 (0000 / 4096 chars)",
                    lines=10,
                    placeholder="Type your text here...",
                )

                def update_label(input_text: str):
                    """
                    Update the label of the input textbox with the current character count.

                    :param input_text: The current text in the input textbox.
                    :type input_text: str
                    :return: Updated Gradio component with new label.
                    :rtype: gr.update
                    """
                    char_count = len(input_text)
                    new_label = f"Input Text ({char_count:04d} / 4096 chars)"
                    return gr.update(label=new_label)

                # Update the label when the text changes, with progress hidden
                input_textbox.change(
                    fn=update_label,
                    inputs=input_textbox,
                    outputs=input_textbox,
                    show_progress="hidden",  # Hide the progress indicator
                )

                # Initialize the submit button as non-interactive
                submit_button = gr.Button(
                    "Enter OpenAI API Key",
                    variant="primary",
                    interactive=False,
                )

                # Function to update the submit button based on API Key input
                def update_button(api_key):
                    """
                    Update the submit button's label and interactivity based on the API key input.

                    :param api_key: The current text in the API key input.
                    :type api_key: str
                    :return: Updated Gradio component for the submit button.
                    :rtype: gr.update
                    """
                    if api_key.strip():
                        # There is an API key, enable the submit button
                        return gr.update(
                            value="Convert Text to Speech", interactive=True
                        )
                    else:
                        # No API key, disable the submit button
                        return gr.update(
                            value="Enter OpenAI API Key", interactive=False
                        )

                # Update the submit button whenever the API Key input changes
                api_key_input.input(
                    fn=update_button,
                    inputs=api_key_input,
                    outputs=submit_button,
                )

            with gr.Column(scale=1):
                output_audio = gr.Audio(
                    label="Output Audio",
                    show_download_button=True,
                    show_share_button=False,
                )

        def on_submit(
            input_text: str,
            model: str,
            voice: str,
            api_key: str,
            response_format: str,
            speed: float,
        ) -> str:
            """
            Event handler for the submit button; converts text to speech using the tts function.

            :param input_text: The text to convert to speech.
            :type input_text: str
            :param model: The TTS model to use (e.g., 'tts-1', 'tts-1-hd').
            :type model: str
            :param voice: The voice profile to use (e.g., 'alloy', 'echo', etc.).
            :type voice: str
            :param api_key: OpenAI API key.
            :type api_key: str
            :param response_format: The audio format of the output file.
            :type response_format: str
            :param speed: The speed of the synthesized speech.
            :type speed: float
            :return: File path to the generated audio file.
            :rtype: str
            """
            audio_file = tts(
                input_text, model.lower(), voice.lower(), 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()