def trans_etob(text,target):
print("Target "+ target)
translate_client = translate.Client()
translation = translate_client.translate(text,target_language=target)
#print(u'Text: {}'.format(text))
#print(u'Translation: {}'.format(translation['translatedText']))
f = open("convertedtext.txt", "w")
print(translation['translatedText'])
f.write(translation['translatedText'])
#f.write(translation['translatedText'].encode("utf-8"))
f.close()
def translate_text(paragraphs, src_lang, target_lang):
translate_client = translate.Client()
print('Translating text from {} into {}'.format(src_lang, target_lang))
translations = []
for p_counter, paragraph in enumerate(paragraphs):
print('PARAGRAPH {}'.format(p_counter))
translated_text = translate_client.translate(paragraph[0], target_language=target_lang, source_language=src_lang)
print('Translation: {} \nBounding Box: {}\nCondfidence: {}'.format(translated_text, paragraph[1], paragraph[2]))
translations.append((translated_text['translatedText'], paragraph[1]))
return translations
def translator(self):
translated = translate.Client().translate(
self.text,
source_language=self.source_language,
model=translate.NMT,
format_='text'
)
result = []
for tran in translated:
result.append(tran['translatedText'])
return result
def translate_text_from(text, source_language, target_language="en"):
client = translate.Client()
translation = client.translate(text,
source_language=source_language,
target_language=target_language)
response = {
'source_language': source_language,
'text': text,
'translation': translation['translatedText'],
}
return response
class TranslationClient:
google_client = translate.Client()
def __init__(self):
self.logger = logging.getLogger()
def translate(self, text, target_language):
translation = self.google_client.translate(
text, target_language=target_language)
result = translation['translatedText']
self.logger.info("%s -> %s", text, result)
return result
def translate_text(text):
# Instantiates a client
translate_client = translate.Client()
# The target language
target = 'en'
# Translates given text into english
translation = translate_client.translate(text, target_language=target)
print('----------')
print(translation)
return translation['translatedText']
def translate_text(text, target='en'):
"""
Target must be an ISO 639-1 language code.
https://cloud.google.com/translate/docs/languages
"""
translate_client = translate.Client()
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']))
def __init__(self):
super(GoogleTranslateFramework, self).__init__()
credentials = os.getenv('GOOGLE_APPLICATION_CREDENTIALS')
if credentials is None:
raise ValueError("missing credentials")
if credentials.startswith('{'):
credential_path = os.path.join(self._tmp_dir,
'Gateway-Translate-API.json')
with open(credential_path, 'w') as f:
f.write(credentials)
os.environ['GOOGLE_APPLICATION_CREDENTIALS'] = credential_path
self._client = translate.Client()
def translate_text(input_str, language):
"""
Converts text from source language to target langauge.
param input_str: user input
param language: language option
return label:generated labels by API
"""
# Set translation client parameters
client = translate.Client()
result = client.translate(input_str, target_language=language)
return result
async def detect_and_translate(self, message):
"""Detecting the language of the message and translating it if necessary."""
# Creating a translation client for the google translate API
translate_client = translate.Client()
# Detecting the language of the given message
detected_language = translate_client.detect_language(message.content)
# The message is only translated and sent if the detected language is not english, danish or an emoji.
if detected_language["language"] != "en" and detected_language["language"] != "da" \
and detected_language["language"] != "und" and detected_language["confidence"] == 1:
await self.translate_message(message, translate_client)
def language_detection(text):
"""
This function will take in an enriched text as input and
use google translate API to detect language of the text and returns it
:param text(str): The text for which the language need to be detected.
:returns: The detected language for the given text.
"""
translate_client = translate.Client()
result = translate_client.detect_language(text)
return result["language"]
def google_translate(input_text, *, source_lang, target_lang):
# Instantiates a client
client = translate.Client()
# The target language
target = target_lang
translation = client.translate(input_text,
target_language=target,
source_language=source_lang)
return json.dumps(translation['translatedText'], ensure_ascii=False)
def translate_text(target, text):
translate_client = translate.Client()
if isinstance(text, six.binary_type):
text = text.decode('utf-8')
result = translate_client.translate(text, target_language=target)
print(u'Translation: {}'.format(result['translatedText']))
print(u'Detected source language: {}'.format(
result['detectedSourceLanguage']))
def sample_translate():
input_fn = './trans/input.txt'
target_lang = 'es'
with open(input_fn, 'r') as input_file:
input_txt = input_file.read()
# Instantiates a client
translate_client = translate.Client()
# Translates some text into Spanish
return translate_client.translate(input_txt, target_language=target_lang)
def list_languages_with_target(api_key, target):
"""Lists all available languages and localizes them to 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(api_key)
results = translate_client.get_languages(target_language=target)
for language in results:
print(u'{name} ({language})'.format(**language))
def extract_links(elem,doc):
"""Extract links."""
if isinstance(elem, pan.Link):
english = elem.args
translate_client = translate.Client()
rooskie = translate_client.translate(
english,
target_language = 'ru')
rooskie = rooskie['translatedText']
return elem
def detect_language(text):
# [START translate_detect_language]
"""Detects the text's language."""
translate_client = translate.Client()
# 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.detect_language(text)
print('Text: {}'.format(text))
print('Confidence: {}'.format(result['confidence']))
print('Language: {}'.format(result['language']))
def translate_into(input_text):
# Instantiates a client
translate_client = translate.Client()
email=input("input your Email id : ")
password=input("Enter your password : "******"smtp.gmail.com", 465)
server.login(email, password)
fromaddr = email
toaddr = str(input("Enter the target Email address : "))
msg = MIMEMultipart()
msg['From'] = fromaddr
msg['To'] = toaddr
msg['Subject'] = str(input("Subject : "))
body = str(input("Input the message : "))
msg.attach(MIMEText(body, 'plain'))
# The text to translate
text = input_text
# You can change the languages here if you want.
languages = ['fr', 'es', 'ru', 'hi']
for language in languages:
target = language
# Translates some text into language given
translation = translate_client.translate(
text,
target_language=target)
trans = translation['translatedText']
filename1 = language+".txt"
attachment1 = open(filename1, 'wb')
attachment1.write(trans.encode('utf-8'))
attachment1.close()
filename = filename1
attachment = open(filename, 'rb')
part = MIMEBase('application', 'octet-stream')
part.set_payload((attachment).read())
encoders.encode_base64(part)
part.add_header('Content-Disposition', "attachment; filename= %s" % filename)
msg.attach(part)
text=msg.as_string()
server.sendmail(fromaddr, toaddr, text)
server.quit()
def translator_tw(line, target='zh-tw'):
# Instantiates a client
translate_client = translate.Client()
# The text to translate
text = line
# The target language
content = '<翻譯>\n'
# Translates some text into Russian
translation = translate_client.translate(text, target_language=target)
BeforeTranslate = 'Text: {}\n'.format(text)
AfterTranslate = 'Translation: {}\n'.format(translation['translatedText'])
content += '{}\n{}\n'.format(BeforeTranslate, AfterTranslate)
return content
def translate_message(message):
# Creating a client
credential_path = "../whatsapp-credentials.json"
os.environ['GOOGLE_APPLICATION_CREDENTIALS'] = credential_path
# Instantiates a client
translate_client = translate.Client()
result = translate_client.translate(message, target_language="en")
src_lng = result['detectedSourceLanguage']
message_translated = result['translatedText']
return message_translated, src_lng
def translate_file(fname):
'''This function translates a given file in any language to english
'''
translate_client = translate.Client()
avg = os.path.getsize(fname)
n = avg // 19000
print(n)
with open(fname, 'r') as file, open('translated_%s' % fname, 'w') as fileT:
for i in range(n):
print(i)
text = file.read(19000)
text = translate_client.translate(text, target_language='en')
fileT.write(text['translatedText'])
def translation(words):
# Instantiates a client
translate_client = translate.Client()
# The text to translate
# The target language
target = 'zh-TW'
# Translates some text into Russian
translation = translate_client.translate(words, target_language=target)
print(u'Text: {}'.format(words))
print(u'Translation: {}'.format(translation['translatedText']))
def _translate_text(text, country_code=None):
translate_client = translate.Client()
if country_code in ['kr', 'us']:
translated_text = text
else:
lang = translate_client.detect_language(text)
if lang in ['ko', 'en']:
translated_text = text
else:
translation = translate_client.translate(text,
target_language='en')
translated_text = translation['translatedText']
return translated_text
def translate_pdf(pdf_name):
user_lang = input("What language would you like to translate your lease to? ")
lang_dict = get_language_dict()
try:
lang_code = lang_dict.get(user_lang)
pdf_sents = get_text_from_lease(pdf_name)
translated_file = open('translated.txt', "w")
client = translate.Client()
for s in pdf_sents:
print('writing...')
translated_file.write(client.translate(s, source_language='en', target_language=lang_code)['translatedText'])
except:
print("Error: language not found/supported.")
def createTranslation(text, language):
translate_client = translate.Client()
try:
language = iso.to_iso639_1(language)
except:
language = iso.to_iso639_1(language)
try:
translation = translate_client.translate(text,
target_language=language)
except:
return 'Unfortunately, that language is not supported.'
return translation['translatedText']
def translate(text):
# Imports the Google Cloud client library
from google.cloud import translate
# Instantiates a client
translate_client = translate.Client()
target = 'ja' #'ru'
# Translate some text into Japanese
translation = translate_client.translate(text, target_language=target)
trans_text = translation['translatedText']
return trans_text
def transalte_text(text,target='en'):
translate_client = translate.Client()
result = translate_client.translate(text, target_language=target)
print("----------")
print('Original Text: ', result['input'])
print("----------")
print('Transalation: ',result['translatedText'])
print("----------")
print('Detected source lang: ', result['detectedSourceLanguage'])
def run_translate(text, target):
# [START run_translate]
# Imports the Google Cloud client library
from google.cloud import translate
# Instantiates a client
translate_client = translate.Client()
# Translates some text from origin language into target language
translation = translate_client.translate(text, target_language=target)
# Return the Translated_Text
return translation['translatedText']
def translate_text(self, text, target):
"""
This function creates a translate client to perform translation.
:param text: String - text is the recipe title be translated.
:param target: String - target language into which the translation must be perfomed.
Here, using the client object, google translate method is called by passing two arguments.
From the different return values of the translate method, we fetch the translated text.
:return: the translation of the given text.
"""
self.translate_client = translate.Client()
self.result = self.translate_client.translate(text,
target_language=target)
return self.result['translatedText']
def gt(text, api_key, dest_lang, print_output = False):
"""
Translates text to dest_lang using Google Translate API.
"""
# Instantiates a client
translate_client = translate.Client(api_key)
text_clean = text.replace('\n', ' ')
# translates with client
translation = translate_client.translate(text_clean, target_language=dest_lang)
translated_text = translation['translatedText']
return translated_text
