def __init__(self):
"""
Initialize the translator object. Load in the accepted languages. Make sure key is valid.
:param key: the Google Project API Key
"""
os.environ[
"GOOGLE_APPLICATION_CREDENTIALS"] = 'botlate-b3e46cfde885.json'
self.detected_lang = "" #stores the detected language
self.translate_client = translate.Client()
self.speech_client = texttospeech.TextToSpeechClient()
#Different genders for voice
self.male = texttospeech.SsmlVoiceGender.MALE
self.female = texttospeech.SsmlVoiceGender.FEMALE
self.neutral = texttospeech.SsmlVoiceGender.NEUTRAL
#Create a dictionary of language_code -> name
self.lang_dict = {} #code -> name
self.lang_dict_rev = {} #name -> code
translate_client = translate.Client()
all_langs = translate_client.get_languages()
for pair in all_langs:
self.lang_dict[pair["language"]] = pair["name"]
self.lang_dict_rev[pair["name"]] = pair["language"]
self.speech_langs = supported_speech_langs()
def translated(text):
from google.cloud import translate_v2 as translate
translate_client = translate.Client()
client = translate.Client()
result = client.translate(text, target_language='ko')
# print(result['translatedText'])
return result['translatedText']
def translate_text_list(text_list, option):
translate_client = translate.Client()
translated_text_list_raw = []
if option == 1:
translated_text_list_raw = translate_client.translate(
text_list, source_language='en', target_language='es')
elif option == 2:
translated_text_list_raw = translate_client.translate(
text_list, source_language='en', target_language='pt')
elif option == 3:
translated_text_list_raw = translate_client.translate(
text_list, source_language='es', target_language='en')
elif option == 4:
translated_text_list_raw = translate_client.translate(
text_list, source_language='es', target_language='pt')
elif option == 5:
translated_text_list_raw = translate_client.translate(
text_list, source_language='pt', target_language='en')
elif option == 6:
translated_text_list_raw = translate_client.translate(
text_list, source_language='pt', target_language='es')
translated_text_list = []
for line in translated_text_list_raw:
translated_text_list.append(line['translatedText'])
return translated_text_list
def __init__(self, language_code='definitions'):
self.local_dictionary = dict()
self.language_code = language_code
self.def_dictionary = PyDictionary() # Dictionary for definitions
self.api_dictionary = translate.Client() # Dictionary for translations
# To avoid inadvertent api usage in development, uncomment next line
# self.api_dictionary = PyDictionary()
# pos codes used by PyDictionary
self.pydictionary_codes = {
'n': 'Noun',
'v': 'Verb',
'j': 'Adjective',
'i': 'Adjective',
'r': 'Adverb'
}
if not os.path.exists(f'Local_Dictionaries/{language_code}'):
# Directory for local dictionary does not exist, create it now
os.mkdir(f'Local_Dictionaries/{language_code}')
with open(
f'Local_Dictionaries/{language_code}/en_dictionary_01'
f'.json',
mode='w') as f:
f.write('{}')
self._load_local_dictionary() # Contains previously translated data
def translate_text(target, text):
"""Translates text into the target language.
Target must be an ISO 639-1 language code.
See https://g.co/cloud/translate/v2/translate-reference#supported_languages
"""
import six
from google.cloud import translate_v2 as translate
translate_client = translate.Client()
if isinstance(text, six.binary_type):
text = text.decode("utf-8")
if target == 'ar-EG':
target = 'ar'
elif target == 'nb-NO':
target = 'nb'
# Text can also be a sequence of strings, in which case this method
# will return a sequence of results for each text.
result = translate_client.translate(text, target_language=target)
print("Google Translate: {} -> {}".format(
result["input"], result["translatedText"].replace(''', '\'')))
return result['translatedText'].replace(''', '\'')
def get_client(gcp_service_account_key=None):
"""
Get a translate API client from the service account key.
"""
if gcp_service_account_key is None or gcp_service_account_key == "":
return translate.Client()
try:
credentials = json.loads(gcp_service_account_key)
except (ValueError, TypeError) as e:
logging.error(e)
raise ValueError("GCP service account key is not valid JSON")
credentials = service_account.Credentials.from_service_account_info(
credentials)
logging.info("Credentials loaded")
client = translate.Client(credentials=credentials)
return client
def translate2dict(sentences, dictpath):
environ['GOOGLE_APPLICATION_CREDENTIALS'] = './key.json'
translate_client = translate.Client()
def translation(text):
if isinstance(text, six.binary_type):
text = text.decode('utf-8')
result = translate_client.translate(text, 'en')
return result['translatedText']
if not isfile(dictpath):
with open(dictpath, 'w') as f:
json.dump({}, f)
for item in sentences:
with open(dictpath) as f:
translations = json.load(f)
try:
translations[item]
except KeyError:
translations[item] = translation(item)
with open(dictpath, 'w+') as f:
json.dump(translations, f)
def translate_text(text_dict, target="en"):
"""Translates text into the target language. Target must be an ISO 639-1 language code.
See https://g.co/cloud/translate/v2/translate-reference#supported_languages
Args:
text_dict: Dictionary format input.
"""
import six
from google.cloud import translate_v2 as translate
text = text_dict[text_column_in]
translate_client = translate.Client()
if isinstance(text, six.binary_type):
text = text.decode("utf-8")
# Text can also be a sequence of strings, in which case this method
# will return a sequence of results for each text.
result = translate_client.translate(text, target_language=target)
result_str = result['translatedText']
# Construct dict matching output table schema table_schema_out.
return {text_column_out: result_str, text_column_in: text}
def is_gtrans_pro_valid(request):
try:
start_time = time.time()
tar_lang = "vi"
sentence = "Hello World"
gtran_file = Config.objects.get(user__id=request.user.id)
if gtran_file.gtran_file is not None:
os.environ[
'GOOGLE_APPLICATION_CREDENTIALS'] = gtran_file.gtran_file.path
translate_client = translate.Client()
result = translate_client.translate(sentence,
target_language=tar_lang)
j = {
"is_success": True,
"err_msg": None,
"time": time.time() - start_time
}
j.update({"result": result})
else:
j = {"is_success": False, "err_msg": "Invalid APIkey or not exist"}
return HttpResponse(json.dumps(j, ensure_ascii=False),
content_type="application/json",
status=status.HTTP_200_OK)
except ValueError as e:
j = {"is_success": False, "err_msg": +str(e)}
return HttpResponse(json.dumps(j, ensure_ascii=False),
content_type="application/json",
status=status.HTTP_200_OK)
def predict(self, data):
from google.cloud import translate_v2 as translate
translate_client = translate.Client()
result = translate_client.translate(data,
source_language='en',
target_language='es')
return result['translatedText']
def predict2(self, text):
spa_vocab = self.spa_vectorization.get_vocabulary()
spa_index_lookup = dict(zip(range(len(spa_vocab)), spa_vocab))
max_decoded_sentence_length = 20
def decode_sequence(input_sentence):
tokenized_input_sentence = self.eng_vectorization([input_sentence])
decoded_sentence = "[start]"
result = []
for i in range(max_decoded_sentence_length):
tokenized_target_sentence = self.spa_vectorization(
[decoded_sentence])[:, :-1]
predictions = self.base_model(
[tokenized_input_sentence, tokenized_target_sentence])
sampled_token_index = np.argmax(predictions[0, i, :])
sampled_token = spa_index_lookup[sampled_token_index]
decoded_sentence += " " + sampled_token
result.append(sampled_token)
if sampled_token == "[end]":
break
return ' '.join(result[:-1])
# return decode_sequence(text)
import six
if isinstance(text, six.binary_type):
text = text.decode("utf-8")
from google.cloud import translate_v2 as translate
result = translate.Client().translate(text, target_language='spa')
return result['translatedText']
def translate_text(target, Listoftext):
"""Translates text into the target language.
Target must be an ISO 639-1 language code.
See https://g.co/cloud/translate/v2/translate-reference#supported_languages
"""
# print("target",target)
# print("List",Listoftext)
import six
from google.cloud import translate_v2 as translate
result_list = []
translate_client = translate.Client()
for text in Listoftext:
# print("insideloop",text)
if isinstance(text, six.binary_type):
text = text.decode("utf-8")
# print("afterif",text)
# Text can also be a sequence of strings, in which case this method
# will return a sequence of results for each text.
result = translate_client.translate(text, target_language=target)
temp = format(result["translatedText"])
result_list.append(temp)
final_list = list(map(lambda x, y: (x, y), Listoftext, result_list))
return final_list, result_list
def __init__(self, dst_lang=None):
super().__init__()
self.src_lang = "en"
self.dst_lang = dst_lang
self.accepted_langs = ["fr", "de", "zh-TW", "es", "ru"]
self.translator = translate.Client()
def translate(input_text, target_lang, engine, source_lang='auto'):
assert engine in ['Amazon', 'Google', 'Google_free']
if engine == 'Amazon':
translate_client = connect_amazon_translate()
try:
response = translate_client.translate_text(
Text=input_text,
SourceLanguageCode=source_lang,
TargetLanguageCode=target_lang)
return response.get('SourceLanguageCode'), response.get(
'TranslatedText')
except:
return 'failed_to_translate', input_text
if engine == 'Google':
translate_client = translate_v2.Client()
response = translate_client.translate(input_text,
target_language=target_lang)
return response['detectedSourceLanguage'], response[
'translatedText']
if engine == 'Google_free':
response = translate_google_free(input_text,
target_lang,
source_lang=source_lang)
return 'no_detection', response
def translate_text(text, target='en'):
translate_client = translate.Client()
result = translate_client.translate(text, target_language=target)
print('Text: ', result['input'])
print('Translation: ', result['translatedText'])
print('Detected source language: ', result['detectedSourceLanguage'])
def translate(text):
try:
client = translate_v2.Client()
result = client.translate(text, 'ko')
return (result['translatedText'])
except Exception:
return 'Fatal: 자막 번역에 실패하였습니다.'
def get_lastest_reading():
global phrase
while get_lastest_reading_thread.is_alive():
global lastest_reading
label = lastest_reading
if label != "":
if label == "dot":
if phrase != "":
spell = Speller()
phrase = spell(phrase)
if lang != "en":
translate_client = translate.Client()
translated_test = translate_client.translate(phrase, target_language=lang)["translatedText"]
voice = gTTS( text=translated_test, lang=lang, tld=top_domain[output_language], slow=False)
else:
voice = gTTS( text=phrase, lang=lang, tld=top_domain[output_language], slow=False)
voice_file = "voice-{}.mp3".format(str(randint(1, 9999999)))
voice.save(voice_file)
play_audio_thread = threading.Thread(target=play_audio, args=[voice_file])
play_audio_thread.daemon = True
play_audio_thread.start()
print (TGREEN + "audio:" + phrase, ENDC)
phrase = ""
elif label == "space":
phrase += " "
spell = Speller()
phrase = spell(phrase)
print (TGREEN + phrase, ENDC)
else:
phrase += label
print (TGREEN + label, ENDC)
time.sleep(detection_speed)
lastest_reading = ""
def check_for_non_english(new_content):
"""this function Counts the number of non-english and english texts in a line"""
max_pos = 800 # this is the max starting position that an english word does exceed
translate_client = translate.Client()
target = 'en'
detected_words = []
for i, j in enumerate(new_content):
temp_words = []
for u, t in enumerate(new_content[i]):
counts = {'en': 0, 'af': 0}
left_bbox = contents[i][u][0][0][0]
for s, r in enumerate(new_content[i][u]):
try:
text = new_content[i][u][s][1]
output = translate_client.translate(
text, target_language=target)
if output[
'detectedSourceLanguage'] == 'en' or left_bbox < max_pos:
counts['en'] += 1
else:
counts['af'] += 1
except:
...
temp_words.append(counts)
detected_words.append(temp_words)
return detected_words
def translate():
# speech-to-text portion
def transcribe_gcs(gcs_uri):
from google.cloud import speech
client = speech.SpeechClient()
audio = speech.RecognitionAudio(uri=gcs_uri)
config = speech.RecognitionConfig(
encoding=speech.RecognitionConfig.AudioEncoding.FLAC,
sample_rate_hertz=48000,
language_code="en-US",
)
operation = client.long_running_recognize(config=config, audio=audio)
response = operation.result(timeout=90)
text = []
for result in response.results:
text.append(result.alternatives[0].transcript)
return "".join(text)
f = "gs://audiofiles-underthemoon/New Recording 2.flac" #replace this with the user's audio file
text = transcribe_gcs(f)
# translation portion
from google.cloud import translate_v2 as translate
translate_client = translate.Client()
target = "zh"
output = translate_client.translate(text, target_language=target)
i = 0
last = ""
for key, value in output.items():
if i == 0:
last = value
i += 1
return last
def __init__(self, with_translation_support=False):
self.sp_classifier = SentimentClassifier()
self.af_classifier = Afinn(language='es')
self.vader_classifier = SentimentIntensityAnalyzer()
self._download_polyglot_languages()
if with_translation_support:
self.translator = translate.Client()
def __init__(self, bot):
self.bot = bot
credentials = Credentials.from_service_account_file(
f"{HOME_DIR}/authentication/{cloud_creds}")
self.translator = translate.Client(credentials=credentials)
self.lang_cache = dict()
self.session = aiohttp.ClientSession()
def translate_text(target, source, text):
translate_client = translate.Client()
result = translate_client.translate(text,
target_language=target,
source_language=source,
mime_type='text/html')
return result['translatedText']
def translate_text_with_model(target, text, model='nmt'):
# [START translate_text_with_model]
"""Translates text into the target language.
Make sure your project is allowlisted.
Target must be an ISO 639-1 language code.
See https://g.co/cloud/translate/v2/translate-reference#supported_languages
"""
from google.cloud import translate_v2 as translate
translate_client = translate.Client()
if isinstance(text, six.binary_type):
text = text.decode('utf-8')
# Text can also be a sequence of strings, in which case this method
# will return a sequence of results for each text.
result = translate_client.translate(text,
target_language=target,
model=model)
print(u'Text: {}'.format(result['input']))
print(u'Translation: {}'.format(result['translatedText']))
print(u'Detected source language: {}'.format(
result['detectedSourceLanguage']))
def translate_all_text(target, text):
"""Translates text into the target language.
Target must be an ISO 639-1 language code.
See https://g.co/cloud/translate/v2/translate-reference#supported_languages
"""
translate_client = translate.Client()
result_text = []
# Text can also be a sequence of strings, in which case this method
# will return a sequence of results for each text.
n_text = len(text)
# print(n_text)
num_executions = math.ceil(n_text / 120)
# print(num_executions)
for i in range(0, num_executions):
# print(i)
pos = i * 120
# print(pos)
end_pos = pos + 120
if (pos + 120) > n_text:
end_pos = n_text
else:
end_pos = pos + 120
# print(end_pos)
text_to_translate = text[(pos):(end_pos)]
result = translate_client.translate(text_to_translate,
target_language=target)
# print(result)
for t in result:
result_text.append(t["translatedText"])
return result_text
def translate_lang(msg, lang):
translate_client = translate.Client()
rply = translate_client.translate(msg, target_language=lang)
return rply['translatedText']
def translate_text(target, text):
# [START translate_translate_text]
"""Translates text into the target language.
Target must be an ISO 639-1 language code.
See https://g.co/cloud/translate/v2/translate-reference#supported_languages
"""
from google.cloud import translate_v2 as translate
if not setEnv():
return ''
translate_client = translate.Client()
if isinstance(text, six.binary_type):
text = text.decode('utf-8')
# Text can also be a sequence of strings, in which case this method
# will return a sequence of results for each text.
result = translate_client.translate(text, target_language=target)
print(u'Text: {}'.format(result['input']))
print(u'Translation: {}'.format(result['translatedText']))
print(u'Detected source language: {}'.format(
result['detectedSourceLanguage']))
# [END translate_translate_text]
return result
def translate_text(target, text):
"""Translates text into the target language.
Target must be an ISO 639-1 language code.
See https://g.co/cloud/translate/v2/translate-reference#supported_languages
(pip install --upgrade google-api-python-client)
pip install google-cloud-translate
"""
import six
from google.cloud import translate_v2 as translate
translate_client = translate.Client()
if isinstance(text, six.binary_type):
text = text.decode("utf-8")
# Text can also be a sequence of strings, in which case this method
# will return a sequence of results for each text.
result = translate_client.translate(text, target_language=target)
print(u"Text: {}".format(result["input"]))
print(u"Translation: {}".format(result["translatedText"]))
print(u"Detected source language: {}".format(
result["detectedSourceLanguage"]))
return result["translatedText"]
def getfacts():
# Set variables used in other functions
global text
# Assess which language the text is written in, so the sentiment analysis works
gtranslate_functions = translate_v2.Client()
output_gtranslate = gtranslate_functions.detect_language(text.get(0.0, END))
language_code_output_gtranslate = (output_gtranslate['language'])
glanguage_functions = language.LanguageServiceClient()
# document = text which is going to be analyzed
document = language.types.Document(
content=text.get(0.0, END),
language=language_code_output_gtranslate,
type='PLAIN_TEXT')
# Analyze text with google sentiment analysis
response_glanguage = glanguage_functions.analyze_sentiment(document=document, encoding_type='UTF32')
sentiment_output_glanguage = response_glanguage.document_sentiment
# Store relevant numbers in variables
s_score = str(sentiment_output_glanguage.score)
s_mag = str(sentiment_output_glanguage.magnitude)
# Store text in more practical variable
s = text.get(0.0, END)
# Count the number of characters, words and phrases of text and convert the number to string
characters = str(len(s))
words = str(len(re.findall(r'\w+', s)))
phrases = str(len(re.split(r'[.!?]+', s)))
# Insert infos at the beginning of the text
text.insert(1.0, 'Textfacts \n\nCharacters: ' + characters + '\nWords: ' + words + '\nSentences: ' + phrases + '\n\nScore: ' + s_score + '\nThe score tells us the overall emotional sentiment in the text. 1 = very positive, -1 = very negative.\n\nMagnitude: ' + s_mag + '\nThe magnitude illustrates the amount of emotional (positive and negative) content in a text. The longer a text the higher its magnitude.\n\n')
def translate(text, src, dest,formatT=None):
# translator = Translator()
# return translator.translate(text, src=src, dest=dest).text
translate_client = translate_v2.Client()
result = translate_client.translate(
text, target_language=dest, model='nmt',format_=formatT)
return result['translatedText'].replace(""", '"').replace("'", '"').replace(';', '"')
def translate_sentences(text_list, output):
"""Translates text into the target language.
Target must be an ISO 639-1 language code.
See https://g.co/cloud/translate/v2/translate-reference#supported_languages
"""
from google.cloud import translate_v2 as translate
# RODAR export GOOGLE_APPLICATION_CREDENTIALS="/home/arthurtelles/gtranslate-api-290022-4899f0c9d3f7.json"
translate_client = translate.Client()
# text = 'ola eu gosto de framboesa'
result_list = []
# Text can also be a sequence of strings, in which case this method
# will return a sequence of results for each text.
for line in tqdm(text_list):
if isinstance(line, six.binary_type):
line = line.decode("utf-8")
result = translate_client.translate(line, target_language='en')
result_list.append(result)
# print(u"Text: {}".format(result["input"]))
# print(u"Translation: {}".format(result["translatedText"]))
# print(u"Detected source language: {}".format(result["detectedSourceLanguage"]))
text_file2 = open("eng_gtranslate.txt", "a")
for line in result_list:
text_file2.write(f"{line['translatedText']}\n")
text_file2.close()
return result_list
