This repository has been archived by the owner on Nov 29, 2023. It is now read-only.
/
cloud_tts.py
265 lines (223 loc) · 10.4 KB
/
cloud_tts.py
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
# -*- coding: utf-8 -*-
# Copyright 2020 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
import proto # type: ignore
__protobuf__ = proto.module(
package="google.cloud.texttospeech.v1",
manifest={
"SsmlVoiceGender",
"AudioEncoding",
"ListVoicesRequest",
"ListVoicesResponse",
"Voice",
"SynthesizeSpeechRequest",
"SynthesisInput",
"VoiceSelectionParams",
"AudioConfig",
"SynthesizeSpeechResponse",
},
)
class SsmlVoiceGender(proto.Enum):
r"""Gender of the voice as described in `SSML voice
element <https://www.w3.org/TR/speech-synthesis11/#edef_voice>`__.
"""
SSML_VOICE_GENDER_UNSPECIFIED = 0
MALE = 1
FEMALE = 2
NEUTRAL = 3
class AudioEncoding(proto.Enum):
r"""Configuration to set up audio encoder. The encoding
determines the output audio format that we'd like.
"""
AUDIO_ENCODING_UNSPECIFIED = 0
LINEAR16 = 1
MP3 = 2
OGG_OPUS = 3
class ListVoicesRequest(proto.Message):
r"""The top-level message sent by the client for the ``ListVoices``
method.
Attributes:
language_code (str):
Optional. Recommended.
`BCP-47 <https://www.rfc-editor.org/rfc/bcp/bcp47.txt>`__
language tag. If specified, the ListVoices call will only
return voices that can be used to synthesize this
language_code. E.g. when specifying "en-NZ", you will get
supported "en-\*" voices; when specifying "no", you will get
supported "no-\*" (Norwegian) and "nb-*" (Norwegian Bokmal)
voices; specifying "zh" will also get supported "cmn-*"
voices; specifying "zh-hk" will also get supported "yue-\*"
voices.
"""
language_code = proto.Field(proto.STRING, number=1)
class ListVoicesResponse(proto.Message):
r"""The message returned to the client by the ``ListVoices`` method.
Attributes:
voices (Sequence[~.cloud_tts.Voice]):
The list of voices.
"""
voices = proto.RepeatedField(proto.MESSAGE, number=1, message="Voice")
class Voice(proto.Message):
r"""Description of a voice supported by the TTS service.
Attributes:
language_codes (Sequence[str]):
The languages that this voice supports, expressed as
`BCP-47 <https://www.rfc-editor.org/rfc/bcp/bcp47.txt>`__
language tags (e.g. "en-US", "es-419", "cmn-tw").
name (str):
The name of this voice. Each distinct voice
has a unique name.
ssml_gender (~.cloud_tts.SsmlVoiceGender):
The gender of this voice.
natural_sample_rate_hertz (int):
The natural sample rate (in hertz) for this
voice.
"""
language_codes = proto.RepeatedField(proto.STRING, number=1)
name = proto.Field(proto.STRING, number=2)
ssml_gender = proto.Field(proto.ENUM, number=3, enum="SsmlVoiceGender")
natural_sample_rate_hertz = proto.Field(proto.INT32, number=4)
class SynthesizeSpeechRequest(proto.Message):
r"""The top-level message sent by the client for the
``SynthesizeSpeech`` method.
Attributes:
input (~.cloud_tts.SynthesisInput):
Required. The Synthesizer requires either
plain text or SSML as input.
voice (~.cloud_tts.VoiceSelectionParams):
Required. The desired voice of the
synthesized audio.
audio_config (~.cloud_tts.AudioConfig):
Required. The configuration of the
synthesized audio.
"""
input = proto.Field(proto.MESSAGE, number=1, message="SynthesisInput")
voice = proto.Field(proto.MESSAGE, number=2, message="VoiceSelectionParams")
audio_config = proto.Field(proto.MESSAGE, number=3, message="AudioConfig")
class SynthesisInput(proto.Message):
r"""Contains text input to be synthesized. Either ``text`` or ``ssml``
must be supplied. Supplying both or neither returns
[google.rpc.Code.INVALID_ARGUMENT][]. The input size is limited to
5000 characters.
Attributes:
text (str):
The raw text to be synthesized.
ssml (str):
The SSML document to be synthesized. The SSML document must
be valid and well-formed. Otherwise the RPC will fail and
return [google.rpc.Code.INVALID_ARGUMENT][]. For more
information, see
`SSML <https://cloud.google.com/text-to-speech/docs/ssml>`__.
"""
text = proto.Field(proto.STRING, number=1)
ssml = proto.Field(proto.STRING, number=2)
class VoiceSelectionParams(proto.Message):
r"""Description of which voice to use for a synthesis request.
Attributes:
language_code (str):
Required. The language (and potentially also the region) of
the voice expressed as a
`BCP-47 <https://www.rfc-editor.org/rfc/bcp/bcp47.txt>`__
language tag, e.g. "en-US". This should not include a script
tag (e.g. use "cmn-cn" rather than "cmn-Hant-cn"), because
the script will be inferred from the input provided in the
SynthesisInput. The TTS service will use this parameter to
help choose an appropriate voice. Note that the TTS service
may choose a voice with a slightly different language code
than the one selected; it may substitute a different region
(e.g. using en-US rather than en-CA if there isn't a
Canadian voice available), or even a different language,
e.g. using "nb" (Norwegian Bokmal) instead of "no"
(Norwegian)".
name (str):
The name of the voice. If not set, the service will choose a
voice based on the other parameters such as language_code
and gender.
ssml_gender (~.cloud_tts.SsmlVoiceGender):
The preferred gender of the voice. If not set, the service
will choose a voice based on the other parameters such as
language_code and name. Note that this is only a preference,
not requirement; if a voice of the appropriate gender is not
available, the synthesizer should substitute a voice with a
different gender rather than failing the request.
"""
language_code = proto.Field(proto.STRING, number=1)
name = proto.Field(proto.STRING, number=2)
ssml_gender = proto.Field(proto.ENUM, number=3, enum="SsmlVoiceGender")
class AudioConfig(proto.Message):
r"""Description of audio data to be synthesized.
Attributes:
audio_encoding (~.cloud_tts.AudioEncoding):
Required. The format of the audio byte
stream.
speaking_rate (float):
Optional. Input only. Speaking rate/speed, in the range
[0.25, 4.0]. 1.0 is the normal native speed supported by the
specific voice. 2.0 is twice as fast, and 0.5 is half as
fast. If unset(0.0), defaults to the native 1.0 speed. Any
other values < 0.25 or > 4.0 will return an error.
pitch (float):
Optional. Input only. Speaking pitch, in the range [-20.0,
20.0]. 20 means increase 20 semitones from the original
pitch. -20 means decrease 20 semitones from the original
pitch.
volume_gain_db (float):
Optional. Input only. Volume gain (in dB) of the normal
native volume supported by the specific voice, in the range
[-96.0, 16.0]. If unset, or set to a value of 0.0 (dB), will
play at normal native signal amplitude. A value of -6.0 (dB)
will play at approximately half the amplitude of the normal
native signal amplitude. A value of +6.0 (dB) will play at
approximately twice the amplitude of the normal native
signal amplitude. Strongly recommend not to exceed +10 (dB)
as there's usually no effective increase in loudness for any
value greater than that.
sample_rate_hertz (int):
Optional. The synthesis sample rate (in hertz) for this
audio. When this is specified in SynthesizeSpeechRequest, if
this is different from the voice's natural sample rate, then
the synthesizer will honor this request by converting to the
desired sample rate (which might result in worse audio
quality), unless the specified sample rate is not supported
for the encoding chosen, in which case it will fail the
request and return [google.rpc.Code.INVALID_ARGUMENT][].
effects_profile_id (Sequence[str]):
Optional. Input only. An identifier which selects 'audio
effects' profiles that are applied on (post synthesized)
text to speech. Effects are applied on top of each other in
the order they are given. See `audio
profiles <https://cloud.google.com/text-to-speech/docs/audio-profiles>`__
for current supported profile ids.
"""
audio_encoding = proto.Field(proto.ENUM, number=1, enum="AudioEncoding")
speaking_rate = proto.Field(proto.DOUBLE, number=2)
pitch = proto.Field(proto.DOUBLE, number=3)
volume_gain_db = proto.Field(proto.DOUBLE, number=4)
sample_rate_hertz = proto.Field(proto.INT32, number=5)
effects_profile_id = proto.RepeatedField(proto.STRING, number=6)
class SynthesizeSpeechResponse(proto.Message):
r"""The message returned to the client by the ``SynthesizeSpeech``
method.
Attributes:
audio_content (bytes):
The audio data bytes encoded as specified in the request,
including the header for encodings that are wrapped in
containers (e.g. MP3, OGG_OPUS). For LINEAR16 audio, we
include the WAV header. Note: as with all bytes fields,
protobuffers use a pure binary representation, whereas JSON
representations use base64.
"""
audio_content = proto.Field(proto.BYTES, number=1)
__all__ = tuple(sorted(__protobuf__.manifest))