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