cloudlanguagetools 11.2.1__tar.gz → 11.2.2__tar.gz

{cloudlanguagetools-11.2.1 → cloudlanguagetools-11.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cloudlanguagetools
-Version: 11.2.1
+Version: 11.2.2
 Summary: Interface with various cloud APIs for language processing such as translation, text to speech
 Home-page: https://github.com/Language-Tools/cloud-language-tools-core
 Author: Luc

{cloudlanguagetools-11.2.1 → cloudlanguagetools-11.2.2}/cloudlanguagetools/azure.py

@@ -6,6 +6,7 @@ import operator
 import pydub
 import logging
 import pprint
+from typing import List
 
 import cloudlanguagetools.service
 import cloudlanguagetools.constants
@@ -33,6 +34,29 @@ GENDER_MAP = {
     'Neutral': cloudlanguagetools.constants.Gender.Any,
 }
 
+VOICE_OPTIONS = {
+            'rate' : {
+                'type': cloudlanguagetools.options.ParameterType.number.name,
+                'min': 0.5,
+                'max': 3.0,
+                'default': 1.0
+            },
+            'pitch': {
+                'type': cloudlanguagetools.options.ParameterType.number.name,
+                'min': -100,
+                'max': 100,
+                'default': 0
+            },
+            cloudlanguagetools.options.AUDIO_FORMAT_PARAMETER: {
+                'type': cloudlanguagetools.options.ParameterType.list.name,
+                'values': [
+                    cloudlanguagetools.options.AudioFormat.mp3.name,
+                    cloudlanguagetools.options.AudioFormat.ogg_opus.name,
+                ],
+                'default': cloudlanguagetools.options.AudioFormat.mp3.name
+            }
+}
+
 class AzureVoice(cloudlanguagetools.ttsvoice.TtsVoice):
     def __init__(self, voice_data):
         # print(voice_data)
@@ -64,28 +88,52 @@ class AzureVoice(cloudlanguagetools.ttsvoice.TtsVoice):
             return f'{self.display_name} ({self.voice_type})'
 
     def get_options(self):
-        return {
-            'rate' : {
-                'type': cloudlanguagetools.options.ParameterType.number.name,
-                'min': 0.5,
-                'max': 3.0,
-                'default': 1.0
-            },
-            'pitch': {
-                'type': cloudlanguagetools.options.ParameterType.number.name,
-                'min': -100,
-                'max': 100,
-                'default': 0
-            },
-            cloudlanguagetools.options.AUDIO_FORMAT_PARAMETER: {
-                'type': cloudlanguagetools.options.ParameterType.list.name,
-                'values': [
-                    cloudlanguagetools.options.AudioFormat.mp3.name,
-                    cloudlanguagetools.options.AudioFormat.ogg_opus.name,
-                ],
-                'default': cloudlanguagetools.options.AudioFormat.mp3.name
-            }
-        }
+        return VOICE_OPTIONS
+
+def locale_to_audio_language(locale: str) -> cloudlanguagetools.languages.AudioLanguage:
+    locale = AUDIO_LOCALE_OVERRIDE_MAP.get(locale, locale)
+    language_enum_name = locale.replace('-', '_')
+    audio_language = cloudlanguagetools.languages.AudioLanguage[language_enum_name]    
+    return audio_language
+
+def build_tts_voice_v3(voice_data) -> cloudlanguagetools.ttsvoice.TtsVoice_v3:
+    local_name = voice_data['LocalName']
+    display_name = voice_data['DisplayName']
+    voice_type = voice_data['VoiceType']
+
+    # build all attributes required for TtsVoice_v3
+    # name
+    if local_name != display_name:
+        voice_name = f"{display_name} {local_name} ({voice_type})"
+    else:
+        voice_name = f'{display_name} ({voice_type})'    
+    voice_key = {
+        'name': voice_data['Name']
+    }
+    options = VOICE_OPTIONS
+    service = cloudlanguagetools.constants.Service.Azure
+    gender = GENDER_MAP[voice_data['Gender']]
+    service_fee = cloudlanguagetools.constants.ServiceFee.paid
+
+    azure_locale_list = [voice_data['Locale']]
+    if 'SecondaryLocaleList' in voice_data:
+        azure_locale_list = voice_data['SecondaryLocaleList']
+        # ensure the main locale is present
+        azure_locale_list.append(voice_data['Locale'])
+        # unique array
+        azure_locale_list = list(set(azure_locale_list))
+
+    audio_languages = [locale_to_audio_language(locale) for locale in azure_locale_list]
+
+    return cloudlanguagetools.ttsvoice.TtsVoice_v3(
+        name=voice_name,
+        voice_key=voice_key,
+        options=options,
+        service=service,
+        gender=gender,
+        audio_languages=audio_languages,
+        service_fee=service_fee)
+
 
 def get_translation_language_enum(language_id):
     # print(f'language_id: {language_id}')
@@ -250,7 +298,11 @@ class AzureService(cloudlanguagetools.service.Service):
 
         result = synthesizer.speak_ssml(ssml_str)
         if result.reason != azure.cognitiveservices.speech.ResultReason.SynthesizingAudioCompleted:
-            error_message = f'Could not generate audio: {result.cancellation_details.reason} {result.cancellation_details.error_details}'
+            # special case errors:
+            if 'standard voices will no longer be supported' in result.cancellation_details.error_details:
+                error_message = 'Azure Standard voices are not supported anymore, please switch to Neural voices.'
+            else:
+                error_message = f'Could not generate audio: {result.cancellation_details.reason} {result.cancellation_details.error_details}'
             raise cloudlanguagetools.errors.RequestError(error_message)
 
         stream = azure.cognitiveservices.speech.AudioDataStream(result)
@@ -281,6 +333,29 @@ class AzureService(cloudlanguagetools.service.Service):
                     logging.error(f'could not process voice for {voice_data}', exc_info=True)
             return result
 
+    def get_tts_voice_list_v3(self) -> List[cloudlanguagetools.ttsvoice.TtsVoice_v3]:
+        # returns list of TtsVoice_v3
+
+        token = self.get_token()
+
+        base_url = f'https://{self.region}.tts.speech.microsoft.com/'
+        path = 'cognitiveservices/voices/list'
+        constructed_url = base_url + path
+        headers = {
+            'Authorization': 'Bearer ' + token,
+        }        
+        response = requests.get(constructed_url, headers=headers)
+        if response.status_code == 200:
+            voice_list = json.loads(response.content)
+            result = []
+            for voice_data in voice_list:
+                # print(voice_data['Status'])
+                try:
+                    result.append(build_tts_voice_v3(voice_data))
+                except:
+                    logger.exception(f'could not process voice for {voice_data}')
+            return result            
+
     def get_translation(self, text, from_language_key, to_language_key):
         base_url = f'{self.url_translator_base}/translate?api-version=3.0'
         params = f'&to={to_language_key}&from={from_language_key}'

{cloudlanguagetools-11.2.1 → cloudlanguagetools-11.2.2}/cloudlanguagetools/constants.py

@@ -46,6 +46,11 @@ class RequestMode(enum.Enum):
     dynamic = enum.auto()
     edit = enum.auto()
 
+class APIVersion(enum.Enum):
+    v1 = enum.auto()
+    v2 = enum.auto()
+    v3 = enum.auto()
+
 # service and language related constants
 # ======================================
 

{cloudlanguagetools-11.2.1 → cloudlanguagetools-11.2.2}/cloudlanguagetools/elevenlabs.py

@@ -27,6 +27,21 @@ GENDER_MAP = {
     'female': cloudlanguagetools.constants.Gender.Female,
 }
 
+VOICE_OPTIONS = {
+            'stability' : {
+                'type': cloudlanguagetools.options.ParameterType.number.name,
+                'min': 0.0,
+                'max': 1.0,
+                'default': DEFAULT_STABILITY
+            },
+            'similarity_boost' : {
+                'type': cloudlanguagetools.options.ParameterType.number.name,
+                'min': 0.0,
+                'max': 1.0,
+                'default': DEFAULT_SIMILARITY_BOOST
+            },                        
+}
+
 class ElevenLabsVoice(cloudlanguagetools.ttsvoice.TtsVoice):
     def __init__(self, voice_data, language: cloudlanguagetools.languages.AudioLanguage, model_id, model_short_name):
         # pprint.pprint(voice_data)
@@ -50,20 +65,7 @@ class ElevenLabsVoice(cloudlanguagetools.ttsvoice.TtsVoice):
         return f'{self.name} ({self.model_short_name})'
 
     def get_options(self):
-        return {
-            'stability' : {
-                'type': cloudlanguagetools.options.ParameterType.number.name,
-                'min': 0.0,
-                'max': 1.0,
-                'default': DEFAULT_STABILITY
-            },
-            'similarity_boost' : {
-                'type': cloudlanguagetools.options.ParameterType.number.name,
-                'min': 0.0,
-                'max': 1.0,
-                'default': DEFAULT_SIMILARITY_BOOST
-            },                        
-        }
+        return VOICE_OPTIONS
 
 class ElevenLabsService(cloudlanguagetools.service.Service):
     def __init__(self):
@@ -187,3 +189,83 @@ class ElevenLabsService(cloudlanguagetools.service.Service):
 
         return result
 
+
+    def get_tts_voice_list_v3(self) -> List[cloudlanguagetools.ttsvoice.TtsVoice_v3]:
+        result = []
+
+        # first, get all models to get list of languages
+        url = "https://api.elevenlabs.io/v1/models"
+        response = requests.get(url, headers=self.get_headers(), timeout=cloudlanguagetools.constants.RequestTimeout)
+        response.raise_for_status()
+        model_data = response.json()
+
+        # restrict to models that can do text to speech (elevenlabs introduced voice conversion)
+        model_data = [model for model in model_data if model['can_do_text_to_speech']]
+
+        #pprint.pprint(model_data)
+        # model_data: 
+        # [{'can_be_finetuned': True,
+        # 'can_do_text_to_speech': True,
+        # 'can_do_voice_conversion': False,
+        # 'description': 'Use our standard English language model to generate speech '
+        #                 'in a variety of voices, styles and moods.',
+        # 'languages': [{'language_id': 'en', 'name': 'English'}],
+        # 'model_id': 'eleven_monolingual_v1',
+        # 'name': 'Eleven Monolingual v1',
+        # 'token_cost_factor': 1.0},
+        # {'can_be_finetuned': True,
+        # 'can_do_text_to_speech': True,
+        # 'can_do_voice_conversion': True,
+        # 'description': 'Generate lifelike speech in multiple languages and create '
+        #                 'content that resonates with a broader audience. ',
+        # 'languages': [{'language_id': 'en', 'name': 'English'},
+        #                 {'language_id': 'de', 'name': 'German'},
+        #                 {'language_id': 'pl', 'name': 'Polish'},
+        #                 {'language_id': 'es', 'name': 'Spanish'},
+        #                 {'language_id': 'it', 'name': 'Italian'},
+        #                 {'language_id': 'fr', 'name': 'French'},
+        #                 {'language_id': 'pt', 'name': 'Portuguese'},
+        #                 {'language_id': 'hi', 'name': 'Hindi'}],
+        # 'model_id': 'eleven_multilingual_v1',
+        # 'name': 'Eleven Multilingual v1',
+        # 'token_cost_factor': 1.0}]
+        #         
+
+
+        # now, retrieve voice list
+        # call elevenlabs API to list TTS voices
+        url = "https://api.elevenlabs.io/v1/voices"
+
+        response = requests.get(url, headers=self.get_headers(), timeout=cloudlanguagetools.constants.RequestTimeout)
+        response.raise_for_status()
+
+        data = response.json()
+
+        for model in model_data:
+            model_id = model['model_id']
+            model_name = model['name']
+            model_short_name = model_name.replace('Eleven ', '').strip()
+            # for language_record in model['languages']:
+            for voice_data in data['voices']:
+                try:
+                    languages = model['languages']
+                    language_id_list = [language_record['language_id'] for language_record in languages]
+                    audio_language_enum_list = [self.get_audio_language(language_id) for language_id in language_id_list]
+                    voice = cloudlanguagetools.ttsvoice.TtsVoice_v3(
+                        name=voice_data['name'],
+                        voice_key={
+                            'voice_id': voice_data['voice_id'],
+                            'model_id': model_id,
+                        },
+                        options=VOICE_OPTIONS,
+                        service=cloudlanguagetools.constants.Service.ElevenLabs,
+                        gender=GENDER_MAP.get(voice_data['labels']['gender'], cloudlanguagetools.constants.Gender.Male),
+                        audio_languages=audio_language_enum_list,
+                        service_fee=cloudlanguagetools.constants.ServiceFee.paid
+                    )
+                    result.append(voice)
+                except Exception as e:
+                    logger.exception(f'ElevenLabs: error processing voice_data: {voice_data}')
+
+        return result
+

{cloudlanguagetools-11.2.1 → cloudlanguagetools-11.2.2}/cloudlanguagetools/forvo.py

@@ -46,7 +46,7 @@ class ForvoVoice(cloudlanguagetools.ttsvoice.TtsVoice):
         return f'{self.get_audio_language_name()}, {self.get_gender().name}, {self.service.name}'
 
     def get_voice_shortname(self):
-        return None
+        return f'{self.language_code}-{self.country_code}'
 
     def get_options(self):
         return {}
@@ -57,6 +57,10 @@ class ForvoService(cloudlanguagetools.service.Service):
     def __init__(self):
         self.url_base = 'https://apicommercial.forvo.com'
         self.build_audio_language_map()
+        
+        # on 2024/07, forvo started throwing some errors with SSL verification, suspect an incorrect
+        # setup on their side but they are taking too long to fix it.
+        self.verify_ssl = False
 
     def configure(self, config):
         self.key = config['key']
@@ -87,7 +91,8 @@ class ForvoService(cloudlanguagetools.service.Service):
         url = f'{self.url_base}/key/{self.key}/format/json/action/word-pronunciations/word/{encoded_text}/language/{language}{sex_param}{username_param}/order/rate-desc/limit/1{country_code}'
 
         try:
-            response = requests.get(url, headers=self.get_headers(), timeout=cloudlanguagetools.constants.RequestTimeout)
+            response = requests.get(url, headers=self.get_headers(), timeout=cloudlanguagetools.constants.RequestTimeout,
+                                    verify=self.verify_ssl)
             response.raise_for_status()
 
             data = response.json()
@@ -98,7 +103,8 @@ class ForvoService(cloudlanguagetools.service.Service):
             audio_url = items[0]['pathmp3']
             output_temp_file = tempfile.NamedTemporaryFile()
             output_temp_filename = output_temp_file.name
-            audio_request = requests.get(audio_url, headers=self.get_headers(), timeout=cloudlanguagetools.constants.RequestTimeout)
+            audio_request = requests.get(audio_url, headers=self.get_headers(), timeout=cloudlanguagetools.constants.RequestTimeout,
+                                         verify=self.verify_ssl)
             open(output_temp_filename, 'wb').write(audio_request.content)
             return output_temp_file
         except requests.exceptions.ReadTimeout as exception:
@@ -275,7 +281,8 @@ class ForvoService(cloudlanguagetools.service.Service):
 
         # https://api.forvo.com/documentation/word-pronunciations/
         url = f'{self.url_base}/key/{self.key}/format/json/action/language-list/min-pronunciations/5000'
-        response = requests.get(url, headers=self.get_headers(), timeout=cloudlanguagetools.constants.RequestTimeout)
+        response = requests.get(url, headers=self.get_headers(), timeout=cloudlanguagetools.constants.RequestTimeout,
+                                    verify=self.verify_ssl)
         if response.status_code == 200:
             data = response.json()
             languages = data['items']

{cloudlanguagetools-11.2.1 → cloudlanguagetools-11.2.2}/cloudlanguagetools/languages.py

@@ -354,6 +354,7 @@ class AudioLanguage(enum.Enum):
     ne_NP = (Language.ne, "Nepali (Nepal)")
     nl_BE = (Language.nl, "Dutch (Belgium)")
     nl_NL = (Language.nl, "Dutch (Netherlands)")
+    or_IN = (Language.or_, "Oriya (India)")
     pa_IN = (Language.pa, "Punjabi (India)")
     pl_PL = (Language.pl, "Polish")
     ps_AF = (Language.ps, "Pashto (Afghanistan)")

{cloudlanguagetools-11.2.1 → cloudlanguagetools-11.2.2}/cloudlanguagetools/openai.py

@@ -17,27 +17,7 @@ logger = logging.getLogger(__name__)
 
 DEFAULT_TTS_SPEED = 1.0
 
-class OpenAIVoice(cloudlanguagetools.ttsvoice.TtsVoice):
-    def __init__(self, name: str, 
-                audio_language: cloudlanguagetools.languages.AudioLanguage,
-                gender: cloudlanguagetools.constants.Gender):
-        self.name = name
-        self.gender = gender
-        self.audio_language = audio_language
-        self.service = cloudlanguagetools.constants.Service.OpenAI
-        self.service_fee = cloudlanguagetools.constants.ServiceFee.paid
-
-    def get_voice_key(self):
-        return {
-            'name': self.name,
-            'language': self.audio_language.name            
-        }
-
-    def get_voice_shortname(self):
-        return self.name
-
-    def get_options(self):
-        return {
+VOICE_OPTIONS = {
             'speed' : {
                 'type': cloudlanguagetools.options.ParameterType.number.name,
                 'min': 0.25,
@@ -52,63 +32,9 @@ class OpenAIVoice(cloudlanguagetools.ttsvoice.TtsVoice):
                 ],
                 'default': cloudlanguagetools.options.AudioFormat.mp3.name
             }
-        }
-
-class OpenAIService(cloudlanguagetools.service.Service):
-    def __init__(self):
-        self.chatbot_model = "gpt-3.5-turbo"
-
-    def configure(self, config):
-        self.api_key = config['api_key']
-        self.client = OpenAI(api_key=self.api_key)
-
-    def single_prompt(self, prompt, max_tokens):
-        messages = [
-            {'role': 'user', 'content': prompt}
-        ]        
-
-        if max_tokens != None:
-            response = self.client.chat.completions.create(model=self.chatbot_model,
-            messages=messages,
-            max_tokens=max_tokens)    
-        else:
-            response = self.client.chat.completions.create(model=self.chatbot_model,
-            messages=messages)    
-        logger.debug(pprint.pformat(response))
-        tokens_used = response.usage.total_tokens
-        response_text = response.choices[0].message.content
-        return response_text, tokens_used
-
-    def full_query(self, messages, max_tokens):
-        if max_tokens != None:
-            response = self.client.chat.completions.create(model=self.chatbot_model,
-            messages=messages,
-            max_tokens=max_tokens)    
-        else:
-            response = self.client.chat.completions.create(model=self.chatbot_model,
-            messages=messages)    
-        logger.debug(pprint.pformat(response))
-        return response
-
-    def speech_to_text(self, filepath, audio_format: cloudlanguagetools.options.AudioFormat):
+}
 
-        if audio_format in [cloudlanguagetools.options.AudioFormat.ogg_opus, cloudlanguagetools.options.AudioFormat.ogg_vorbis]:
-            # need to convert to wav first
-            sound = pydub.AudioSegment.from_ogg(filepath)
-            wav_tempfile = tempfile.NamedTemporaryFile(prefix='cloudlanguagetools_OpenAI_speech_to_text', suffix='.wav')
-            sound.export(wav_tempfile.name, format="wav")
-            filepath = wav_tempfile.name
-
-        logger.debug(f'opening file {filepath}')
-        audio_file= open(filepath, "rb")
-        transcript = self.client.audio.transcriptions.create(model="whisper-1", file=audio_file)
-        return transcript.text
-    
-    
-    def get_tts_voice_list(self) -> List[OpenAIVoice]:
-        result = []
-
-        supported_languages = [
+TTS_SUPPORTED_LANGUAGES = [
             AudioLanguage.af_ZA,
             AudioLanguage.ar_XA,
             AudioLanguage.hy_AM,
@@ -169,9 +95,85 @@ class OpenAIService(cloudlanguagetools.service.Service):
             AudioLanguage.ur_IN,
             AudioLanguage.vi_VN,
             AudioLanguage.cy_GB            
-        ]
+]
 
-        for audio_language in supported_languages:
+class OpenAIVoice(cloudlanguagetools.ttsvoice.TtsVoice):
+    def __init__(self, name: str, 
+                audio_language: cloudlanguagetools.languages.AudioLanguage,
+                gender: cloudlanguagetools.constants.Gender):
+        self.name = name
+        self.gender = gender
+        self.audio_language = audio_language
+        self.service = cloudlanguagetools.constants.Service.OpenAI
+        self.service_fee = cloudlanguagetools.constants.ServiceFee.paid
+
+    def get_voice_key(self):
+        return {
+            'name': self.name,
+            'language': self.audio_language.name            
+        }
+
+    def get_voice_shortname(self):
+        return self.name
+
+    def get_options(self):
+        return VOICE_OPTIONS
+
+class OpenAIService(cloudlanguagetools.service.Service):
+    def __init__(self):
+        self.chatbot_model = "gpt-3.5-turbo"
+
+    def configure(self, config):
+        self.api_key = config['api_key']
+        self.client = OpenAI(api_key=self.api_key)
+
+    def single_prompt(self, prompt, max_tokens):
+        messages = [
+            {'role': 'user', 'content': prompt}
+        ]        
+
+        if max_tokens != None:
+            response = self.client.chat.completions.create(model=self.chatbot_model,
+            messages=messages,
+            max_tokens=max_tokens)    
+        else:
+            response = self.client.chat.completions.create(model=self.chatbot_model,
+            messages=messages)    
+        logger.debug(pprint.pformat(response))
+        tokens_used = response.usage.total_tokens
+        response_text = response.choices[0].message.content
+        return response_text, tokens_used
+
+    def full_query(self, messages, max_tokens):
+        if max_tokens != None:
+            response = self.client.chat.completions.create(model=self.chatbot_model,
+            messages=messages,
+            max_tokens=max_tokens)    
+        else:
+            response = self.client.chat.completions.create(model=self.chatbot_model,
+            messages=messages)    
+        logger.debug(pprint.pformat(response))
+        return response
+
+    def speech_to_text(self, filepath, audio_format: cloudlanguagetools.options.AudioFormat):
+
+        if audio_format in [cloudlanguagetools.options.AudioFormat.ogg_opus, cloudlanguagetools.options.AudioFormat.ogg_vorbis]:
+            # need to convert to wav first
+            sound = pydub.AudioSegment.from_ogg(filepath)
+            wav_tempfile = tempfile.NamedTemporaryFile(prefix='cloudlanguagetools_OpenAI_speech_to_text', suffix='.wav')
+            sound.export(wav_tempfile.name, format="wav")
+            filepath = wav_tempfile.name
+
+        logger.debug(f'opening file {filepath}')
+        audio_file= open(filepath, "rb")
+        transcript = self.client.audio.transcriptions.create(model="whisper-1", file=audio_file)
+        return transcript.text
+    
+    
+    def get_tts_voice_list(self) -> List[OpenAIVoice]:
+        result = []
+
+        for audio_language in TTS_SUPPORTED_LANGUAGES:
             result.extend([
                 OpenAIVoice('alloy', audio_language, cloudlanguagetools.constants.Gender.Female),
                 OpenAIVoice('echo', audio_language, cloudlanguagetools.constants.Gender.Male),
@@ -182,6 +184,32 @@ class OpenAIService(cloudlanguagetools.service.Service):
             ])
         return result
 
+    def build_tts_voice_v3(self, voice_name, gender):
+        return cloudlanguagetools.ttsvoice.TtsVoice_v3(
+            name=voice_name,
+            voice_key={
+                'name': voice_name
+            },
+            options=VOICE_OPTIONS,
+            service=cloudlanguagetools.constants.Service.OpenAI,
+            gender=gender,
+            audio_languages=TTS_SUPPORTED_LANGUAGES,
+            service_fee=cloudlanguagetools.constants.ServiceFee.paid
+        )
+
+    def get_tts_voice_list_v3(self) -> List[cloudlanguagetools.ttsvoice.TtsVoice_v3]:
+        # returns list of TtsVoice_v3
+
+        result = [
+            self.build_tts_voice_v3('alloy', cloudlanguagetools.constants.Gender.Female),
+            self.build_tts_voice_v3('echo', cloudlanguagetools.constants.Gender.Male),
+            self.build_tts_voice_v3('fable', cloudlanguagetools.constants.Gender.Female),
+            self.build_tts_voice_v3('onyx', cloudlanguagetools.constants.Gender.Male),
+            self.build_tts_voice_v3('nova', cloudlanguagetools.constants.Gender.Female),
+            self.build_tts_voice_v3('shimmer', cloudlanguagetools.constants.Gender.Female)
+        ]
+        return result
+
     def get_tts_audio(self, text, voice_key, options):
         # https://platform.openai.com/docs/guides/text-to-speech
         # https://platform.openai.com/docs/api-reference/audio/createSpeech?lang=python

{cloudlanguagetools-11.2.1 → cloudlanguagetools-11.2.2}/cloudlanguagetools/service.py

@@ -1,8 +1,10 @@
 import requests
 import tempfile
 import logging
+from typing import List
 
 import cloudlanguagetools.constants
+import cloudlanguagetools.ttsvoice
 
 logger = logging.getLogger(__name__)
 
@@ -40,6 +42,20 @@ class Service():
     def get_tts_voice_list(self):
         return []
 
+    def get_tts_voice_list_v3(self) -> List[cloudlanguagetools.ttsvoice.TtsVoice_v3]:
+        # the default implementation will convert list of voices to list of TtsVoice_v3
+        voices = self.get_tts_voice_list()
+        voices_v3 = [cloudlanguagetools.ttsvoice.TtsVoice_v3(
+            name=voice.get_voice_shortname(),
+            voice_key=voice.get_voice_key(),
+            options=voice.get_options(),
+            service=voice.service,
+            gender=voice.get_gender(),
+            audio_languages=[voice.audio_language],
+            service_fee=voice.service_fee
+        ) for voice in voices]
+        return voices_v3
+
     def get_translation_language_list(self):
         return []
 

{cloudlanguagetools-11.2.1 → cloudlanguagetools-11.2.2}/cloudlanguagetools/servicemanager.py

@@ -152,6 +152,14 @@ class ServiceManager():
         tts_voice_list = self.get_tts_voice_list()
         return [voice.json_obj() for voice in tts_voice_list]
 
+    @cachetools.cached(cache=cachetools.TTLCache(maxsize=1024, ttl=cloudlanguagetools.constants.TTLCacheTimeout))
+    def get_tts_voice_list_v3(self):
+        result = []
+        for key, service in self.services.items():
+            logging.info(f'retrieving voice list from {key}')
+            result.extend(service.get_tts_voice_list_v3())
+        return result
+
     @cachetools.cached(cache=cachetools.TTLCache(maxsize=1024, ttl=cloudlanguagetools.constants.TTLCacheTimeout))
     def get_translation_language_list(self) -> List[cloudlanguagetools.translationlanguage.TranslationLanguage]:
         result = []

{cloudlanguagetools-11.2.1 → cloudlanguagetools-11.2.2}/cloudlanguagetools/ttsvoice.py

@@ -1,4 +1,8 @@
 import json
+import dataclasses
+from typing import List, Dict, Any
+import cloudlanguagetools.constants
+import cloudlanguagetools.languages
 
 class TtsVoice():
     def __init__(self):
@@ -34,4 +38,16 @@ class TtsVoice():
         }
    
     def __repr__(self):
-        return json.dumps(self.json_obj(), indent=4, sort_keys=True, ensure_ascii=False)
+        return json.dumps(self.json_obj(), indent=4, sort_keys=True, ensure_ascii=False)
+
+# this class is used with API version 3
+# support for multilingual voices
+@dataclasses.dataclass
+class TtsVoice_v3:
+    name: str
+    voice_key: Dict[str, Any]
+    options: Dict[str, Dict[str, Any]]
+    service: cloudlanguagetools.constants.Service
+    gender: cloudlanguagetools.constants.Gender
+    audio_languages: List[cloudlanguagetools.languages.AudioLanguage]
+    service_fee: cloudlanguagetools.constants.ServiceFee

{cloudlanguagetools-11.2.1 → cloudlanguagetools-11.2.2}/cloudlanguagetools.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cloudlanguagetools
-Version: 11.2.1
+Version: 11.2.2
 Summary: Interface with various cloud APIs for language processing such as translation, text to speech
 Home-page: https://github.com/Language-Tools/cloud-language-tools-core
 Author: Luc

{cloudlanguagetools-11.2.1 → cloudlanguagetools-11.2.2}/setup.py

@@ -6,7 +6,7 @@ from setuptools.command.install import install
 # twine upload dist/*
 
 setup(name='cloudlanguagetools',
-      version='11.2.1',
+      version='11.2.2',
       description='Interface with various cloud APIs for language processing such as translation, text to speech',
       long_description=open('README.rst', encoding='utf-8').read(),
       url='https://github.com/Language-Tools/cloud-language-tools-core',