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")
