def test_delete_glossary(self): # Setup Expected Response name_2 = "name2-1052831874" expected_response = {"name": name_2} expected_response = translation_service_pb2.DeleteGlossaryResponse( **expected_response) operation = operations_pb2.Operation( name="operations/test_delete_glossary", done=True) operation.response.Pack(expected_response) # Mock the API response channel = ChannelStub(responses=[operation]) patch = mock.patch("google.api_core.grpc_helpers.create_channel") with patch as create_channel: create_channel.return_value = channel client = translate_v3.TranslationServiceClient() # Setup Request name = client.glossary_path("[PROJECT]", "[LOCATION]", "[GLOSSARY]") response = client.delete_glossary(name) result = response.result() assert expected_response == result assert len(channel.requests) == 1 expected_request = translation_service_pb2.DeleteGlossaryRequest( name=name) actual_request = channel.requests[0][1] assert expected_request == actual_request
def test_batch_translate_text_exception(self): # Setup Response error = status_pb2.Status() operation = operations_pb2.Operation( name="operations/test_batch_translate_text_exception", done=True) operation.error.CopyFrom(error) # Mock the API response channel = ChannelStub(responses=[operation]) patch = mock.patch("google.api_core.grpc_helpers.create_channel") with patch as create_channel: create_channel.return_value = channel client = translate_v3.TranslationServiceClient() # Setup Request parent = client.location_path("[PROJECT]", "[LOCATION]") source_language_code = "sourceLanguageCode1687263568" target_language_codes = [] input_configs = [] output_config = {} response = client.batch_translate_text( parent, source_language_code, target_language_codes, input_configs, output_config, ) exception = response.exception() assert exception.errors[0] == error
def test_get_glossary(self): # Setup Expected Response name_2 = "name2-1052831874" entry_count = 811131134 expected_response = {"name": name_2, "entry_count": entry_count} expected_response = translation_service_pb2.Glossary( **expected_response) # Mock the API response channel = ChannelStub(responses=[expected_response]) patch = mock.patch("google.api_core.grpc_helpers.create_channel") with patch as create_channel: create_channel.return_value = channel client = translate_v3.TranslationServiceClient() # Setup Request name = client.glossary_path("[PROJECT]", "[LOCATION]", "[GLOSSARY]") response = client.get_glossary(name) assert expected_response == response assert len(channel.requests) == 1 expected_request = translation_service_pb2.GetGlossaryRequest( name=name) actual_request = channel.requests[0][1] assert expected_request == actual_request
def test_list_glossaries(self): # Setup Expected Response next_page_token = "" glossaries_element = {} glossaries = [glossaries_element] expected_response = { "next_page_token": next_page_token, "glossaries": glossaries, } expected_response = translation_service_pb2.ListGlossariesResponse( **expected_response) # Mock the API response channel = ChannelStub(responses=[expected_response]) patch = mock.patch("google.api_core.grpc_helpers.create_channel") with patch as create_channel: create_channel.return_value = channel client = translate_v3.TranslationServiceClient() # Setup Request parent = client.location_path("[PROJECT]", "[LOCATION]") paged_list_response = client.list_glossaries(parent) resources = list(paged_list_response) assert len(resources) == 1 assert expected_response.glossaries[0] == resources[0] assert len(channel.requests) == 1 expected_request = translation_service_pb2.ListGlossariesRequest( parent=parent) actual_request = channel.requests[0][1] assert expected_request == actual_request
def translate_text_with_glossary(text="YOUR_TEXT_TO_TRANSLATE", project_id="YOUR_PROJECT_ID", glossary_id="YOUR_GLOSSARY_ID"): """Translates a given text using a glossary.""" client = translate_v3.TranslationServiceClient() contents = [text] parent = client.location_path(project_id, "us-central1") glossary = client.glossary_path( project_id, "us-central1", glossary_id # The location of the glossary ) glossary_config = translate_v3.types.TranslateTextGlossaryConfig( glossary=glossary) # Supported language codes: https://cloud.google.com/translate/docs/languages response = client.translate_text( contents, target_language_code="ja", source_language_code="en", parent=parent, glossary_config=glossary_config, ) print("Translated text: \n") for translation in response.glossary_translations: print(u"\t {}".format(translation.translated_text))
def google_translate(list_to_translate): list_to_translate.append('--------') try: os.environ['GOOGLE_APPLICATION_CREDENTIALS'] = os.path.realpath('Credentials/GoogleCredentials.json') client = translate_v3.TranslationServiceClient() location = 'global' project_id = 'translator-of-subtitlings' list_to_translate = list_to_translate parent = client.location_path(project_id, location) response = client.translate_text( parent=parent, contents=list_to_translate, mime_type='text/plain', source_language_code='en-US', target_language_code='ru-RU' ) list_of_translations = response.translations list_result = [] for translation in list_of_translations: list_result.append(translation.translated_text) return list_to_translate, list_result except google_exp.ServiceUnavailable: return ['No internet!']
def test_create_glossary(self): # Setup Expected Response name = "name3373707" entry_count = 811131134 expected_response = {"name": name, "entry_count": entry_count} expected_response = translation_service_pb2.Glossary( **expected_response) operation = operations_pb2.Operation( name="operations/test_create_glossary", done=True) operation.response.Pack(expected_response) # Mock the API response channel = ChannelStub(responses=[operation]) patch = mock.patch("google.api_core.grpc_helpers.create_channel") with patch as create_channel: create_channel.return_value = channel client = translate_v3.TranslationServiceClient() # Setup Request parent = client.location_path("[PROJECT]", "[LOCATION]") glossary = {} response = client.create_glossary(parent, glossary) result = response.result() assert expected_response == result assert len(channel.requests) == 1 expected_request = translation_service_pb2.CreateGlossaryRequest( parent=parent, glossary=glossary) actual_request = channel.requests[0][1] assert expected_request == actual_request
def test_translate_text(self): # Setup Expected Response expected_response = {} expected_response = translation_service_pb2.TranslateTextResponse( **expected_response) # Mock the API response channel = ChannelStub(responses=[expected_response]) patch = mock.patch("google.api_core.grpc_helpers.create_channel") with patch as create_channel: create_channel.return_value = channel client = translate_v3.TranslationServiceClient() # Setup Request contents = [] target_language_code = "targetLanguageCode1323228230" parent = client.location_path("[PROJECT]", "[LOCATION]") response = client.translate_text(contents, target_language_code, parent) assert expected_response == response assert len(channel.requests) == 1 expected_request = translation_service_pb2.TranslateTextRequest( contents=contents, target_language_code=target_language_code, parent=parent) actual_request = channel.requests[0][1] assert expected_request == actual_request
def translate_text_with_glossary(text, project_id="testtrans-1578532759135", glossary_id="test_glossary"): global translated_output import google.cloud.translate_v3 as gt import os location = 'us-central1' ## location of your gcp bucket credential_file = "C:/google_trans/testtrans-1578532759135-1303d7b01080.json" ## credential key file directory gcs_glossary_uri = 'gs://test_med_trans/test_glossary.csv' ## uri of storage and glossary os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = credential_file client = gt.TranslationServiceClient() parent = client.location_path(project_id, location) glossary = client.glossary_path( project_id, location, glossary_id # The location of the glossary ) glossary_config = gt.types.TranslateTextGlossaryConfig(glossary=glossary) # Supported language codes: https://cloud.google.com/translate/docs/languages response = client.translate_text( contents=[text], source_language_code="ko", target_language_code="en", parent=parent, glossary_config=glossary_config, ) for translation in response.glossary_translations: translated_output = translation.translated_text return translated_output
def translate_sentences(): # Enrich latest document in database with eng/rus translations datastore_client = datastore.Client() kind = "Sentences" query = datastore_client.query(kind=kind) text_entities = list(query.fetch()) key = datastore_client.key(kind, 'sample_task') entity = datastore.Entity(key) location = "global" parent = f"projects/reflected-flux-308118/locations/{location}" for text_entity in text_entities: entity["text"] = text_entity["text"] entity["timestamp"] = text_entity["timestamp"] entity["sentiment"] = text_entity["sentiment"] translate_client = translate.TranslationServiceClient() response = translate_client.translate_text( contents=[entity["text"]], target_language_code="en", parent=parent, ) entity["text_en"] = response.translations[0].translated_text sentiment = analyze_text_sentiment(entity["text_en"])[0].get('sentiment score') entity["sentiment_en"] = 'unknown' if sentiment > 0: entity["sentiment_en"] = 'positive' if sentiment < 0: entity["sentiment_en"] = 'negative' if sentiment == 0: entity["sentiment_en"] = 'neutral' translate_client = translate.TranslationServiceClient() response = translate_client.translate_text( contents=[entity["text"]], target_language_code="de", parent=parent, ) entity["text_de"] = response.translations[0].translated_text sentiment = analyze_text_sentiment(entity["text_de"])[0].get('sentiment score') entity["sentiment_de"] = 'unknown' if sentiment > 0: entity["sentiment_de"] = 'positive' if sentiment < 0: entity["sentiment_de"] = 'negative' if sentiment == 0: entity["sentiment_de"] = 'neutral' datastore_client.put(entity) return entity
def delete_glossary(project_id="YOUR_PROJECT_ID", glossary_id="YOUR_GLOSSARY_ID"): """Delete a specific glossary based on the glossary ID.""" client = translate.TranslationServiceClient() parent = client.glossary_path(project_id, "us-central1", glossary_id) operation = client.delete_glossary(parent) result = operation.result(timeout=90) print("Deleted: {}".format(result.name))
def get_glossary(project_id="YOUR_PROJECT_ID", glossary_id="YOUR_GLOSSARY_ID"): """Get a particular glossary based on the glossary ID.""" client = translate.TranslationServiceClient() name = client.glossary_path(project_id, "us-central1", glossary_id) response = client.get_glossary(name=name) print(u"Glossary name: {}".format(response.name)) print(u"Entry count: {}".format(response.entry_count)) print(u"Input URI: {}".format(response.input_config.gcs_source.input_uri))
def __init__(self, project, location): ''' Constructor. :param project: :param location: ''' self.project_id = project self.location = location self.client = translate.TranslationServiceClient() self.parent = self.client.location_path(project, location) logger.debug("GlossaryClient initialized")
def __get_client(): global __client if __client is None: if 'GOOGLE_SERVICE_ACCOUNT_CRED' in os.environ: service_account_info = json.loads(os.environ['GOOGLE_SERVICE_ACCOUNT_CRED']) else: with open(f"{os.getenv('HOME')}/google_service_account_cred.json", 'r') as f: service_account_info = json.load(f) credentials = service_account.Credentials.from_service_account_info( service_account_info) __client = translate.TranslationServiceClient(credentials=credentials) return __client
def test_detect_language_exception(self): # Mock the API response channel = ChannelStub(responses=[CustomException()]) patch = mock.patch("google.api_core.grpc_helpers.create_channel") with patch as create_channel: create_channel.return_value = channel client = translate_v3.TranslationServiceClient() # Setup request parent = client.location_path("[PROJECT]", "[LOCATION]") with pytest.raises(CustomException): client.detect_language(parent)
def test_list_glossaries_exception(self): channel = ChannelStub(responses=[CustomException()]) patch = mock.patch("google.api_core.grpc_helpers.create_channel") with patch as create_channel: create_channel.return_value = channel client = translate_v3.TranslationServiceClient() # Setup request parent = client.location_path("[PROJECT]", "[LOCATION]") paged_list_response = client.list_glossaries(parent) with pytest.raises(CustomException): list(paged_list_response)
def test_get_glossary_exception(self): # Mock the API response channel = ChannelStub(responses=[CustomException()]) patch = mock.patch("google.api_core.grpc_helpers.create_channel") with patch as create_channel: create_channel.return_value = channel client = translate_v3.TranslationServiceClient() # Setup request name = client.glossary_path("[PROJECT]", "[LOCATION]", "[GLOSSARY]") with pytest.raises(CustomException): client.get_glossary(name)
def test_batch_translate_text(self): # Setup Expected Response total_characters = 1368640955 translated_characters = 1337326221 failed_characters = 1723028396 expected_response = { "total_characters": total_characters, "translated_characters": translated_characters, "failed_characters": failed_characters, } expected_response = translation_service_pb2.BatchTranslateResponse( **expected_response) operation = operations_pb2.Operation( name="operations/test_batch_translate_text", done=True) operation.response.Pack(expected_response) # Mock the API response channel = ChannelStub(responses=[operation]) patch = mock.patch("google.api_core.grpc_helpers.create_channel") with patch as create_channel: create_channel.return_value = channel client = translate_v3.TranslationServiceClient() # Setup Request parent = client.location_path("[PROJECT]", "[LOCATION]") source_language_code = "sourceLanguageCode1687263568" target_language_codes = [] input_configs = [] output_config = {} response = client.batch_translate_text( parent, source_language_code, target_language_codes, input_configs, output_config, ) result = response.result() assert expected_response == result assert len(channel.requests) == 1 expected_request = translation_service_pb2.BatchTranslateTextRequest( parent=parent, source_language_code=source_language_code, target_language_codes=target_language_codes, input_configs=input_configs, output_config=output_config, ) actual_request = channel.requests[0][1] assert expected_request == actual_request
def translate_text(text, target='en'): """ Target must be an ISO 639-1 language code. https://cloud.google.com/translate/docs/languages """ client = translate_v3.TranslationServiceClient() result = 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
def test_translate_text_exception(self): # Mock the API response channel = ChannelStub(responses=[CustomException()]) patch = mock.patch("google.api_core.grpc_helpers.create_channel") with patch as create_channel: create_channel.return_value = channel client = translate_v3.TranslationServiceClient() # Setup request contents = [] target_language_code = "targetLanguageCode1323228230" parent = client.location_path("[PROJECT]", "[LOCATION]") with pytest.raises(CustomException): client.translate_text(contents, target_language_code, parent)
class TransLater: client = translate_v3.TranslationServiceClient() parent = None __target_language = "" __source_language = "" __input_configs = [] __output_configs = [] def callback(operation_future): # Handle result. result = operation_future.result() def __init__(self, _project, _location): self.parent = self.client.location_path(_project, _location) def set_target_language(self, target_language): try: if target_language in self.get_supported_languages(): self.__target_language = target_language else: raise Exception('spam', 'eggs') except Exception: print("This target language doesn't support!") sys.exit() def set_source_language(self, source_language): try: if source_language in self.get_supported_languages(): self.__source_language = source_language else: raise Exception('spam', 'eggs') except Exception: print("This source language doesn't support!") sys.exit() def get_supported_languages(self): dump = str(self.client.get_supported_languages(self.parent)) return re.findall('language_code: "(.+?)"', dump) def translate_text(self, text): response = self.client.translate_text(text, self.__target_language, self.parent, "text/html", self.__source_language) response_texts = [] for translation in response.translations: response_texts.append("{}".format(translation.translated_text)) return response_texts
def sample_list_glossaries(): """List Glossaries""" client = translate.TranslationServiceClient() parent = client.location_path(PROJECT_ID, "us-central1") # Iterate over all results for glossary in client.list_glossaries(parent): print('Name: {}'.format(glossary.name)) print('Entry count: {}'.format(glossary.entry_count)) print('Input uri: {}'.format( glossary.input_config.gcs_source.input_uri)) for language_code in glossary.language_codes_set.language_codes: print('Language code: {}'.format(language_code)) if glossary.language_pair: print(glossary.language_pair.source_language_code) print(glossary.language_pair.target_language_code)
def translate_ch_to_en(this_text): """ :param this_text: Chinese text as input :return: English text as output """ # this_text = "意味着。干得漂亮,电影市场的大门,不会因为流量对他关闭,反而对他有更大的期待。六公主影评人说,他不仅打破了外界流量电影的固有观念,甚至还突破了这种观念,是个演员易烊千玺了,大大大大实话!" project_id = os.environ.get("PROJECT_ID", "") assert project_id parent = f"projects/{project_id}" client = translate.TranslationServiceClient( ) # Automatically searches environment for credentials JSON response = client.translate_text(contents=[this_text], target_language_code="en-US", source_language_code="zh-CN", parent=parent) return response.translations[0].translated_text
def test_delete_glossary_exception(self): # Setup Response error = status_pb2.Status() operation = operations_pb2.Operation( name="operations/test_delete_glossary_exception", done=True) operation.error.CopyFrom(error) # Mock the API response channel = ChannelStub(responses=[operation]) patch = mock.patch("google.api_core.grpc_helpers.create_channel") with patch as create_channel: create_channel.return_value = channel client = translate_v3.TranslationServiceClient() # Setup Request name = client.glossary_path("[PROJECT]", "[LOCATION]", "[GLOSSARY]") response = client.delete_glossary(name) exception = response.exception() assert exception.errors[0] == error
def create_glossary( project_id="YOUR_PROJECT_ID", input_uri="YOUR_INPUT_URI", glossary_id="YOUR_GLOSSARY_ID", timeout=180, ): """ Create a equivalent term sets glossary. Glossary can be words or short phrases (usually fewer than five words). https://cloud.google.com/translate/docs/advanced/glossary#format-glossary """ client = translate.TranslationServiceClient() # Supported language codes: https://cloud.google.com/translate/docs/languages source_lang_code = "en" target_lang_code = "ja" location = "us-central1" # The location of the glossary name = client.glossary_path(project_id, location, glossary_id) language_codes_set = translate.types.Glossary.LanguageCodesSet( language_codes=[source_lang_code, target_lang_code] ) gcs_source = translate.types.GcsSource(input_uri=input_uri) input_config = translate.types.GlossaryInputConfig(gcs_source=gcs_source) glossary = translate.types.Glossary( name=name, language_codes_set=language_codes_set, input_config=input_config ) parent = f"projects/{project_id}/locations/{location}" # glossary is a custom dictionary Translation API uses # to translate the domain-specific terminology. operation = client.create_glossary(parent=parent, glossary=glossary) result = operation.result(timeout) print("Created: {}".format(result.name)) print("Input Uri: {}".format(result.input_config.gcs_source.input_uri))
def test_get_supported_languages(self): # Setup Expected Response expected_response = {} expected_response = translation_service_pb2.SupportedLanguages( **expected_response) # Mock the API response channel = ChannelStub(responses=[expected_response]) patch = mock.patch("google.api_core.grpc_helpers.create_channel") with patch as create_channel: create_channel.return_value = channel client = translate_v3.TranslationServiceClient() # Setup Request parent = client.location_path("[PROJECT]", "[LOCATION]") response = client.get_supported_languages(parent) assert expected_response == response assert len(channel.requests) == 1 expected_request = translation_service_pb2.GetSupportedLanguagesRequest( parent=parent) actual_request = channel.requests[0][1] assert expected_request == actual_request
import os, file, csv, config, dataset, time, collections, sys, datetime, sqlalchemy from sqlalchemy.sql import exists # Google credentials os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = file.dirname # Imports the Google Cloud client library from google.cloud import translate_v3 # Instantiates a client project = file.project location = 'global' translate_client = translate_v3.TranslationServiceClient() parent_code = 'projects/' + project + '/locations/global' #+ location input_configs = [] output_config = {} #target language target_language = 'en' colname = 'detected' # RC: That's a bad col name, should have been: detcted_lang or something USAGE = "$ python {} <appstore> <db-file>".format(sys.argv[0]) ### args ### # store store = 'android' if len(sys.argv) > 1: if (sys.argv[1] == 'android') or (sys.argv[1] == 'ios'): store = sys.argv[1] print('Store is:', store)
# -*- coding: utf-8 -*- import hashlib import json import os import sys import urllib import requests from slugify import slugify from google.cloud import translate_v3 # TODO: pip install google-cloud-translate GOOGLE_CLIENT = translate_v3.TranslationServiceClient() SOURCE_FILE, SOURCE_LANGUAGE, TARGET_FILE, TARGET_LANGUAGE = sys.stdin, "en", sys.stdout, "cs" GOOGLE_PATH, GOOGLE_BUFFER_SIZE = GOOGLE_CLIENT.location_path("supple-century-275511", "us-central1"), 200 WIKI_PATH, WIKI_BUFFER_SIZE = "https://{}.wikipedia.org/w/api.php?action=query&titles={}&prop=langlinks&format=json&lllang={}", 10 def fetch_google_response(buffer): path = "cache/_gtranslate_" + hashlib.md5("".join(buffer).encode('utf-8')).hexdigest() + ".json" if not os.path.exists(path): response = GOOGLE_CLIENT.translate_text(parent=GOOGLE_PATH, contents=buffer, mime_type="text/plain", source_language_code=SOURCE_LANGUAGE, target_language_code=TARGET_LANGUAGE) result = [translation.translated_text for translation in response.translations] with open(path, 'w') as cache: json.dump(result, cache) return result else: with open(path, 'r') as cache: return json.load(cache)
from bs4 import BeautifulSoup import os import json import warnings warnings.filterwarnings("ignore", category=UserWarning) CREDENTIAL_FILE = 'project-service-account.json' os.environ['GOOGLE_APPLICATION_CREDENTIALS'] = CREDENTIAL_FILE from google.cloud import translate_v3 as translate client = translate.TranslationServiceClient() project_id = json.load(open(CREDENTIAL_FILE))['project_id'] location = 'global' def get_all_langs(): lang = [] response = client.get_supported_languages( parent='projects/{}'.format(project_id), display_language_code='en') for language in response.languages: lang.append((language.language_code, language.display_name)) return lang def is_directory(path): return os.path.exists(path) and not os.path.isfile(path)
def __init__(self, projectid, location): self.project_id = projectid self.location = location self.client = translate.TranslationServiceClient() self.parent = self.client.location_path(self.project_id, self.location) logger.debug("TranslateClient initialized")