bazarr/libs/deep_translator/microsoft.py

147 lines
5.6 KiB
Python
Raw Normal View History

# -*- coding: utf-8 -*-
import requests
import logging
import sys
from .constants import BASE_URLS, MICROSOFT_CODES_TO_LANGUAGES
from .exceptions import LanguageNotSupportedException, ServerException, MicrosoftAPIerror
class MicrosoftTranslator:
"""
the class that wraps functions, which use the Microsoft translator under the hood to translate word(s)
"""
_languages = MICROSOFT_CODES_TO_LANGUAGES
supported_languages = list(_languages.values())
def __init__(self, api_key=None, region=None, source=None, target=None, proxies=None, **kwargs):
"""
@params api_key and target are the required params
@param api_key: your Microsoft API key
@param region: your Microsoft Location
"""
if not api_key:
raise ServerException(401)
else:
self.api_key = api_key
self.proxies = proxies
self.headers = {
"Ocp-Apim-Subscription-Key": self.api_key,
"Content-type": "application/json",
}
# region is not required but very common and goes to headers if passed
if region:
self.region = region
self.headers["Ocp-Apim-Subscription-Region"] = self.region
if not target:
raise ServerException(401)
else:
if type(target) is str:
self.target = target.lower()
else:
self.target = [i.lower() for i in target]
if self.is_language_supported(self.target):
self.target = self._map_language_to_code(self.target)
self.url_params = {'to': self.target, **kwargs}
if source:
self.source = source.lower()
if self.is_language_supported(self.source):
self.source = self._map_language_to_code(self.source)
self.url_params['from'] = self.source
self.__base_url = BASE_URLS.get("MICROSOFT_TRANSLATE")
@staticmethod
def get_supported_languages(as_dict=False, **kwargs):
"""
return the languages supported by the microsoft translator
@param as_dict: if True, the languages will be returned as a dictionary mapping languages to their abbreviations
@return: list or dict
"""
return MicrosoftTranslator.supported_languages if not as_dict else MicrosoftTranslator._languages
def _map_language_to_code(self, language, **kwargs):
"""
map the language to its corresponding code (abbreviation) if the language was passed by its full name by the user
@param language: a string (if 1 lang) or a list (if multiple langs)
@return: mapped value of the language or raise an exception if the language is not supported
"""
if type(language) is str:
language = [language]
for lang in language:
if lang in self._languages.values():
yield lang
elif lang in self._languages.keys():
yield self._languages[lang]
else:
raise LanguageNotSupportedException(lang)
def is_language_supported(self, language, **kwargs):
"""
check if the language is supported by the translator
@param language: a string (if 1 lang) or a list (if multiple langs)
@return: bool or raise an Exception
"""
if type(language) is str:
language = [language]
for lang in language:
if lang not in self._languages.keys():
if lang not in self._languages.values():
raise LanguageNotSupportedException(lang)
return True
def translate(self, text, **kwargs):
"""
function that uses microsoft translate to translate a text
@param text: desired text to translate
@return: str: translated text
"""
# a body must be a list of dicts to process multiple texts;
# I have not added multiple text processing here since it is covered by the translate_batch method
valid_microsoft_json = [{'text': text}]
try:
requested = requests.post(self.__base_url,
params=self.url_params,
headers=self.headers,
json=valid_microsoft_json,
proxies=self.proxies)
except requests.exceptions.RequestException:
exc_type, value, traceback = sys.exc_info()
logging.warning(f"Returned error: {exc_type.__name__}")
# Where Microsoft API responds with an api error, it returns a dict in response.json()
if type(requested.json()) is dict:
error_message = requested.json()['error']
raise MicrosoftAPIerror(error_message)
# Where it responds with a translation, its response.json() is a list e.g. [{'translations': [{'text': 'Hello world!', 'to': 'en'}]}]
elif type(requested.json()) is list:
all_translations = [i['text'] for i in requested.json()[0]['translations']]
return "\n".join(all_translations)
def translate_file(self, path, **kwargs):
"""
translate from a file
@param path: path to file
@return: translated text
"""
try:
with open(path) as f:
text = f.read().strip()
return self.translate(text)
except Exception as e:
raise e
def translate_batch(self, batch, **kwargs):
"""
translate a batch of texts
@param batch: list of texts to translate
@return: list of translations
"""
return [self.translate(text, **kwargs) for text in batch]