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