diff --git a/packages/google-cloud-translate/.coveragerc b/packages/google-cloud-translate/.coveragerc index 098720f672e1..6b9ab9da4a1b 100644 --- a/packages/google-cloud-translate/.coveragerc +++ b/packages/google-cloud-translate/.coveragerc @@ -14,3 +14,5 @@ exclude_lines = omit = */gapic/*.py */proto/*.py + */core/*.py + */site-packages/*.py \ No newline at end of file diff --git a/packages/google-cloud-translate/LICENSE b/packages/google-cloud-translate/LICENSE index d64569567334..a8ee855de2aa 100644 --- a/packages/google-cloud-translate/LICENSE +++ b/packages/google-cloud-translate/LICENSE @@ -1,7 +1,6 @@ - - Apache License + Apache License Version 2.0, January 2004 - http://www.apache.org/licenses/ + https://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION @@ -193,7 +192,7 @@ you may not use this file except in compliance with the License. You may obtain a copy of the License at - http://www.apache.org/licenses/LICENSE-2.0 + https://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, diff --git a/packages/google-cloud-translate/MANIFEST.in b/packages/google-cloud-translate/MANIFEST.in index fc77f8c82ff0..9cbf175afe6b 100644 --- a/packages/google-cloud-translate/MANIFEST.in +++ b/packages/google-cloud-translate/MANIFEST.in @@ -1,4 +1,5 @@ include README.rst LICENSE recursive-include google *.json *.proto recursive-include tests * -global-exclude *.pyc __pycache__ +global-exclude *.py[co] +global-exclude __pycache__ diff --git a/packages/google-cloud-translate/google/__init__.py b/packages/google-cloud-translate/google/__init__.py index 0e1bc5131ba6..8fcc60e2b9c6 100644 --- a/packages/google-cloud-translate/google/__init__.py +++ b/packages/google-cloud-translate/google/__init__.py @@ -1,10 +1,12 @@ -# Copyright 2016 Google LLC +# -*- coding: utf-8 -*- +# +# Copyright 2019 Google LLC # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # -# http://www.apache.org/licenses/LICENSE-2.0 +# https://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, diff --git a/packages/google-cloud-translate/google/cloud/__init__.py b/packages/google-cloud-translate/google/cloud/__init__.py index 0e1bc5131ba6..8fcc60e2b9c6 100644 --- a/packages/google-cloud-translate/google/cloud/__init__.py +++ b/packages/google-cloud-translate/google/cloud/__init__.py @@ -1,10 +1,12 @@ -# Copyright 2016 Google LLC +# -*- coding: utf-8 -*- +# +# Copyright 2019 Google LLC # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # -# http://www.apache.org/licenses/LICENSE-2.0 +# https://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, diff --git a/packages/google-cloud-translate/google/cloud/translate_v3beta1/__init__.py b/packages/google-cloud-translate/google/cloud/translate_v3beta1/__init__.py new file mode 100644 index 000000000000..13626b5fa2f0 --- /dev/null +++ b/packages/google-cloud-translate/google/cloud/translate_v3beta1/__init__.py @@ -0,0 +1,27 @@ +# -*- coding: utf-8 -*- +# +# Copyright 2019 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from __future__ import absolute_import + +from google.cloud.translate_v3beta1 import types +from google.cloud.translate_v3beta1.gapic import translation_service_client + + +class TranslationServiceClient(translation_service_client.TranslationServiceClient): + __doc__ = translation_service_client.TranslationServiceClient.__doc__ + + +__all__ = ("types", "TranslationServiceClient") diff --git a/packages/google-cloud-translate/google/cloud/translate_v3beta1/gapic/__init__.py b/packages/google-cloud-translate/google/cloud/translate_v3beta1/gapic/__init__.py new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/packages/google-cloud-translate/google/cloud/translate_v3beta1/gapic/translation_service_client.py b/packages/google-cloud-translate/google/cloud/translate_v3beta1/gapic/translation_service_client.py new file mode 100644 index 000000000000..133a4743d66f --- /dev/null +++ b/packages/google-cloud-translate/google/cloud/translate_v3beta1/gapic/translation_service_client.py @@ -0,0 +1,892 @@ +# -*- coding: utf-8 -*- +# +# Copyright 2019 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +"""Accesses the google.cloud.translation.v3beta1 TranslationService API.""" + +import functools +import pkg_resources +import warnings + +from google.oauth2 import service_account +import google.api_core.gapic_v1.client_info +import google.api_core.gapic_v1.config +import google.api_core.gapic_v1.method +import google.api_core.grpc_helpers +import google.api_core.operation +import google.api_core.operations_v1 +import google.api_core.page_iterator +import google.api_core.path_template +import google.api_core.protobuf_helpers +import grpc + +from google.cloud.translate_v3beta1.gapic import translation_service_client_config +from google.cloud.translate_v3beta1.gapic.transports import ( + translation_service_grpc_transport, +) +from google.cloud.translate_v3beta1.proto import translation_service_pb2 +from google.cloud.translate_v3beta1.proto import translation_service_pb2_grpc +from google.longrunning import operations_pb2 + +_GAPIC_LIBRARY_VERSION = pkg_resources.get_distribution( + "google-cloud-translate" +).version + + +class TranslationServiceClient(object): + """Provides natural language translation operations.""" + + SERVICE_ADDRESS = "translate.googleapis.com:443" + """The default address of the service.""" + + # The name of the interface for this client. This is the key used to + # find the method configuration in the client_config dictionary. + _INTERFACE_NAME = "google.cloud.translation.v3beta1.TranslationService" + + @classmethod + def from_service_account_file(cls, filename, *args, **kwargs): + """Creates an instance of this client using the provided credentials + file. + + Args: + filename (str): The path to the service account private key json + file. + args: Additional arguments to pass to the constructor. + kwargs: Additional arguments to pass to the constructor. + + Returns: + TranslationServiceClient: The constructed client. + """ + credentials = service_account.Credentials.from_service_account_file(filename) + kwargs["credentials"] = credentials + return cls(*args, **kwargs) + + from_service_account_json = from_service_account_file + + @classmethod + def location_path(cls, project, location): + """Return a fully-qualified location string.""" + return google.api_core.path_template.expand( + "projects/{project}/locations/{location}", + project=project, + location=location, + ) + + @classmethod + def glossary_path(cls, project, location, glossary): + """Return a fully-qualified glossary string.""" + return google.api_core.path_template.expand( + "projects/{project}/locations/{location}/glossaries/{glossary}", + project=project, + location=location, + glossary=glossary, + ) + + def __init__( + self, + transport=None, + channel=None, + credentials=None, + client_config=None, + client_info=None, + ): + """Constructor. + + Args: + transport (Union[~.TranslationServiceGrpcTransport, + Callable[[~.Credentials, type], ~.TranslationServiceGrpcTransport]): A transport + instance, responsible for actually making the API calls. + The default transport uses the gRPC protocol. + This argument may also be a callable which returns a + transport instance. Callables will be sent the credentials + as the first argument and the default transport class as + the second argument. + channel (grpc.Channel): DEPRECATED. A ``Channel`` instance + through which to make calls. This argument is mutually exclusive + with ``credentials``; providing both will raise an exception. + credentials (google.auth.credentials.Credentials): The + authorization credentials to attach to requests. These + credentials identify this application to the service. If none + are specified, the client will attempt to ascertain the + credentials from the environment. + This argument is mutually exclusive with providing a + transport instance to ``transport``; doing so will raise + an exception. + client_config (dict): DEPRECATED. A dictionary of call options for + each method. If not specified, the default configuration is used. + client_info (google.api_core.gapic_v1.client_info.ClientInfo): + The client info used to send a user-agent string along with + API requests. If ``None``, then default info will be used. + Generally, you only need to set this if you're developing + your own client library. + """ + # Raise deprecation warnings for things we want to go away. + if client_config is not None: + warnings.warn( + "The `client_config` argument is deprecated.", + PendingDeprecationWarning, + stacklevel=2, + ) + else: + client_config = translation_service_client_config.config + + if channel: + warnings.warn( + "The `channel` argument is deprecated; use " "`transport` instead.", + PendingDeprecationWarning, + stacklevel=2, + ) + + # Instantiate the transport. + # The transport is responsible for handling serialization and + # deserialization and actually sending data to the service. + if transport: + if callable(transport): + self.transport = transport( + credentials=credentials, + default_class=translation_service_grpc_transport.TranslationServiceGrpcTransport, + ) + else: + if credentials: + raise ValueError( + "Received both a transport instance and " + "credentials; these are mutually exclusive." + ) + self.transport = transport + else: + self.transport = translation_service_grpc_transport.TranslationServiceGrpcTransport( + address=self.SERVICE_ADDRESS, channel=channel, credentials=credentials + ) + + if client_info is None: + client_info = google.api_core.gapic_v1.client_info.ClientInfo( + gapic_version=_GAPIC_LIBRARY_VERSION + ) + else: + client_info.gapic_version = _GAPIC_LIBRARY_VERSION + self._client_info = client_info + + # Parse out the default settings for retry and timeout for each RPC + # from the client configuration. + # (Ordinarily, these are the defaults specified in the `*_config.py` + # file next to this one.) + self._method_configs = google.api_core.gapic_v1.config.parse_method_configs( + client_config["interfaces"][self._INTERFACE_NAME] + ) + + # Save a dictionary of cached API call functions. + # These are the actual callables which invoke the proper + # transport methods, wrapped with `wrap_method` to add retry, + # timeout, and the like. + self._inner_api_calls = {} + + # Service calls + def translate_text( + self, + contents, + target_language_code, + mime_type=None, + source_language_code=None, + parent=None, + model=None, + glossary_config=None, + retry=google.api_core.gapic_v1.method.DEFAULT, + timeout=google.api_core.gapic_v1.method.DEFAULT, + metadata=None, + ): + """ + Translates input text and returns translated text. + + Example: + >>> from google.cloud import translate_v3beta1 + >>> + >>> client = translate_v3beta1.TranslationServiceClient() + >>> + >>> # TODO: Initialize `contents`: + >>> contents = [] + >>> + >>> # TODO: Initialize `target_language_code`: + >>> target_language_code = '' + >>> + >>> response = client.translate_text(contents, target_language_code) + + Args: + contents (list[str]): Required. The content of the input in string format. + We recommend the total contents to be less than 30k codepoints. + Please use BatchTranslateText for larger text. + target_language_code (str): Required. The BCP-47 language code to use for translation of the input + text, set to one of the language codes listed in Language Support. + mime_type (str): Optional. The format of the source text, for example, "text/html", + "text/plain". If left blank, the MIME type is assumed to be "text/html". + source_language_code (str): Optional. The BCP-47 language code of the input text if + known, for example, "en-US" or "sr-Latn". Supported language codes are + listed in Language Support. If the source language isn't specified, the API + attempts to identify the source language automatically and returns the + the source language within the response. + parent (str): Optional. Only used when making regionalized call. + Format: + projects/{project-id}/locations/{location-id}. + + Only custom model/glossary within the same location-id can be used. + Otherwise 400 is returned. + model (str): Optional. The ``model`` type requested for this translation. + + The format depends on model type: 1. Custom models: + projects/{project-id}/locations/{location-id}/models/{model-id}. 2. + General (built-in) models: + projects/{project-id}/locations/{location-id}/models/general/nmt + projects/{project-id}/locations/{location-id}/models/general/base + + For global (non-regionalized) requests, use {location-id} 'global'. For + example, projects/{project-id}/locations/global/models/general/nmt + + If missing, the system decides which google base model to use. + glossary_config (Union[dict, ~google.cloud.translate_v3beta1.types.TranslateTextGlossaryConfig]): Optional. Glossary to be applied. The glossary needs to be in the same + region as the model, otherwise an INVALID\_ARGUMENT error is returned. + + If a dict is provided, it must be of the same form as the protobuf + message :class:`~google.cloud.translate_v3beta1.types.TranslateTextGlossaryConfig` + retry (Optional[google.api_core.retry.Retry]): A retry object used + to retry requests. If ``None`` is specified, requests will not + be retried. + timeout (Optional[float]): The amount of time, in seconds, to wait + for the request to complete. Note that if ``retry`` is + specified, the timeout applies to each individual attempt. + metadata (Optional[Sequence[Tuple[str, str]]]): Additional metadata + that is provided to the method. + + Returns: + A :class:`~google.cloud.translate_v3beta1.types.TranslateTextResponse` instance. + + Raises: + google.api_core.exceptions.GoogleAPICallError: If the request + failed for any reason. + google.api_core.exceptions.RetryError: If the request failed due + to a retryable error and retry attempts failed. + ValueError: If the parameters are invalid. + """ + # Wrap the transport method to add retry and timeout logic. + if "translate_text" not in self._inner_api_calls: + self._inner_api_calls[ + "translate_text" + ] = google.api_core.gapic_v1.method.wrap_method( + self.transport.translate_text, + default_retry=self._method_configs["TranslateText"].retry, + default_timeout=self._method_configs["TranslateText"].timeout, + client_info=self._client_info, + ) + + request = translation_service_pb2.TranslateTextRequest( + contents=contents, + target_language_code=target_language_code, + mime_type=mime_type, + source_language_code=source_language_code, + parent=parent, + model=model, + glossary_config=glossary_config, + ) + return self._inner_api_calls["translate_text"]( + request, retry=retry, timeout=timeout, metadata=metadata + ) + + def detect_language( + self, + parent=None, + model=None, + content=None, + mime_type=None, + retry=google.api_core.gapic_v1.method.DEFAULT, + timeout=google.api_core.gapic_v1.method.DEFAULT, + metadata=None, + ): + """ + Detects the language of text within a request. + + Example: + >>> from google.cloud import translate_v3beta1 + >>> + >>> client = translate_v3beta1.TranslationServiceClient() + >>> + >>> response = client.detect_language() + + Args: + parent (str): Optional. Only used when making regionalized call. + Format: + projects/{project-id}/locations/{location-id}. + + Only custom model within the same location-id can be used. + Otherwise 400 is returned. + model (str): Optional. The language detection model to be used. + projects/{project-id}/locations/{location-id}/models/language-detection/{model-id} + If not specified, default will be used. + content (str): The content of the input stored as a string. + mime_type (str): Optional. The format of the source text, for example, "text/html", + "text/plain". If left blank, the MIME type is assumed to be "text/html". + retry (Optional[google.api_core.retry.Retry]): A retry object used + to retry requests. If ``None`` is specified, requests will not + be retried. + timeout (Optional[float]): The amount of time, in seconds, to wait + for the request to complete. Note that if ``retry`` is + specified, the timeout applies to each individual attempt. + metadata (Optional[Sequence[Tuple[str, str]]]): Additional metadata + that is provided to the method. + + Returns: + A :class:`~google.cloud.translate_v3beta1.types.DetectLanguageResponse` instance. + + Raises: + google.api_core.exceptions.GoogleAPICallError: If the request + failed for any reason. + google.api_core.exceptions.RetryError: If the request failed due + to a retryable error and retry attempts failed. + ValueError: If the parameters are invalid. + """ + # Wrap the transport method to add retry and timeout logic. + if "detect_language" not in self._inner_api_calls: + self._inner_api_calls[ + "detect_language" + ] = google.api_core.gapic_v1.method.wrap_method( + self.transport.detect_language, + default_retry=self._method_configs["DetectLanguage"].retry, + default_timeout=self._method_configs["DetectLanguage"].timeout, + client_info=self._client_info, + ) + + # Sanity check: We have some fields which are mutually exclusive; + # raise ValueError if more than one is sent. + google.api_core.protobuf_helpers.check_oneof(content=content) + + request = translation_service_pb2.DetectLanguageRequest( + parent=parent, model=model, content=content, mime_type=mime_type + ) + return self._inner_api_calls["detect_language"]( + request, retry=retry, timeout=timeout, metadata=metadata + ) + + def get_supported_languages( + self, + parent=None, + display_language_code=None, + model=None, + retry=google.api_core.gapic_v1.method.DEFAULT, + timeout=google.api_core.gapic_v1.method.DEFAULT, + metadata=None, + ): + """ + Returns a list of supported languages for translation. + + Example: + >>> from google.cloud import translate_v3beta1 + >>> + >>> client = translate_v3beta1.TranslationServiceClient() + >>> + >>> response = client.get_supported_languages() + + Args: + parent (str): Optional. Used for making regionalized calls. + Format: projects/{project-id}/locations/{location-id}. + For global calls, use projects/{project-id}/locations/global. + If missing, the call is treated as a global call. + + Only custom model within the same location-id can be used. + Otherwise 400 is returned. + display_language_code (str): Optional. The language to use to return localized, human readable names + of supported languages. If missing, default language is ENGLISH. + model (str): Optional. Get supported languages of this model. + The format depends on model type: + 1. Custom models: + projects/{project-id}/locations/{location-id}/models/{model-id}. + 2. General (built-in) models: + projects/{project-id}/locations/{location-id}/models/general/nmt + projects/{project-id}/locations/{location-id}/models/general/base + Returns languages supported by the specified model. + If missing, we get supported languages of Google general NMT model. + retry (Optional[google.api_core.retry.Retry]): A retry object used + to retry requests. If ``None`` is specified, requests will not + be retried. + timeout (Optional[float]): The amount of time, in seconds, to wait + for the request to complete. Note that if ``retry`` is + specified, the timeout applies to each individual attempt. + metadata (Optional[Sequence[Tuple[str, str]]]): Additional metadata + that is provided to the method. + + Returns: + A :class:`~google.cloud.translate_v3beta1.types.SupportedLanguages` instance. + + Raises: + google.api_core.exceptions.GoogleAPICallError: If the request + failed for any reason. + google.api_core.exceptions.RetryError: If the request failed due + to a retryable error and retry attempts failed. + ValueError: If the parameters are invalid. + """ + # Wrap the transport method to add retry and timeout logic. + if "get_supported_languages" not in self._inner_api_calls: + self._inner_api_calls[ + "get_supported_languages" + ] = google.api_core.gapic_v1.method.wrap_method( + self.transport.get_supported_languages, + default_retry=self._method_configs["GetSupportedLanguages"].retry, + default_timeout=self._method_configs["GetSupportedLanguages"].timeout, + client_info=self._client_info, + ) + + request = translation_service_pb2.GetSupportedLanguagesRequest( + parent=parent, display_language_code=display_language_code, model=model + ) + return self._inner_api_calls["get_supported_languages"]( + request, retry=retry, timeout=timeout, metadata=metadata + ) + + def batch_translate_text( + self, + source_language_code, + target_language_codes, + input_configs, + output_config, + parent=None, + models=None, + glossaries=None, + retry=google.api_core.gapic_v1.method.DEFAULT, + timeout=google.api_core.gapic_v1.method.DEFAULT, + metadata=None, + ): + """ + Translates a large volume of text in asynchronous batch mode. + This function provides real-time output as the inputs are being processed. + If caller cancels a request, the partial results (for an input file, it's + all or nothing) may still be available on the specified output location. + + This call returns immediately and you can + use google.longrunning.Operation.name to poll the status of the call. + + Example: + >>> from google.cloud import translate_v3beta1 + >>> + >>> client = translate_v3beta1.TranslationServiceClient() + >>> + >>> # TODO: Initialize `source_language_code`: + >>> source_language_code = '' + >>> + >>> # TODO: Initialize `target_language_codes`: + >>> target_language_codes = [] + >>> + >>> # TODO: Initialize `input_configs`: + >>> input_configs = [] + >>> + >>> # TODO: Initialize `output_config`: + >>> output_config = {} + >>> + >>> response = client.batch_translate_text(source_language_code, target_language_codes, input_configs, output_config) + >>> + >>> def callback(operation_future): + ... # Handle result. + ... result = operation_future.result() + >>> + >>> response.add_done_callback(callback) + >>> + >>> # Handle metadata. + >>> metadata = response.metadata() + + Args: + source_language_code (str): Required. Source language code. + target_language_codes (list[str]): Required. Specify up to 10 language codes here. + input_configs (list[Union[dict, ~google.cloud.translate_v3beta1.types.InputConfig]]): Required. Input configurations. + The total number of files matched should be <= 1000. + The total content size should be <= 100M Unicode codepoints. + The files must use UTF-8 encoding. + + If a dict is provided, it must be of the same form as the protobuf + message :class:`~google.cloud.translate_v3beta1.types.InputConfig` + output_config (Union[dict, ~google.cloud.translate_v3beta1.types.OutputConfig]): Required. Output configuration. + If 2 input configs match to the same file (that is, same input path), + we don't generate output for duplicate inputs. + + If a dict is provided, it must be of the same form as the protobuf + message :class:`~google.cloud.translate_v3beta1.types.OutputConfig` + parent (str): Optional. Only used when making regionalized call. + Format: + projects/{project-id}/locations/{location-id}. + + Only custom models/glossaries within the same location-id can be used. + Otherwise 400 is returned. + models (dict[str -> str]): Optional. The models to use for translation. Map's key is target language + code. Map's value is model name. Value can be a built-in general model, + or a custom model built by AutoML. + + The value format depends on model type: + 1. Custom models: + projects/{project-id}/locations/{location-id}/models/{model-id}. + 2. General (built-in) models: + projects/{project-id}/locations/{location-id}/models/general/nmt + projects/{project-id}/locations/{location-id}/models/general/base + + If the map is empty or a specific model is + not requested for a language pair, then default google model is used. + glossaries (dict[str -> Union[dict, ~google.cloud.translate_v3beta1.types.TranslateTextGlossaryConfig]]): Optional. Glossaries to be applied for translation. + It's keyed by target language code. + + If a dict is provided, it must be of the same form as the protobuf + message :class:`~google.cloud.translate_v3beta1.types.TranslateTextGlossaryConfig` + retry (Optional[google.api_core.retry.Retry]): A retry object used + to retry requests. If ``None`` is specified, requests will not + be retried. + timeout (Optional[float]): The amount of time, in seconds, to wait + for the request to complete. Note that if ``retry`` is + specified, the timeout applies to each individual attempt. + metadata (Optional[Sequence[Tuple[str, str]]]): Additional metadata + that is provided to the method. + + Returns: + A :class:`~google.cloud.translate_v3beta1.types._OperationFuture` instance. + + Raises: + google.api_core.exceptions.GoogleAPICallError: If the request + failed for any reason. + google.api_core.exceptions.RetryError: If the request failed due + to a retryable error and retry attempts failed. + ValueError: If the parameters are invalid. + """ + # Wrap the transport method to add retry and timeout logic. + if "batch_translate_text" not in self._inner_api_calls: + self._inner_api_calls[ + "batch_translate_text" + ] = google.api_core.gapic_v1.method.wrap_method( + self.transport.batch_translate_text, + default_retry=self._method_configs["BatchTranslateText"].retry, + default_timeout=self._method_configs["BatchTranslateText"].timeout, + client_info=self._client_info, + ) + + request = translation_service_pb2.BatchTranslateTextRequest( + source_language_code=source_language_code, + target_language_codes=target_language_codes, + input_configs=input_configs, + output_config=output_config, + parent=parent, + models=models, + glossaries=glossaries, + ) + operation = self._inner_api_calls["batch_translate_text"]( + request, retry=retry, timeout=timeout, metadata=metadata + ) + return google.api_core.operation.from_gapic( + operation, + self.transport._operations_client, + translation_service_pb2.BatchTranslateResponse, + metadata_type=translation_service_pb2.BatchTranslateMetadata, + ) + + def create_glossary( + self, + parent, + glossary, + retry=google.api_core.gapic_v1.method.DEFAULT, + timeout=google.api_core.gapic_v1.method.DEFAULT, + metadata=None, + ): + """ + Creates a glossary and returns the long-running operation. Returns + NOT\_FOUND, if the project doesn't exist. + + Example: + >>> from google.cloud import translate_v3beta1 + >>> + >>> client = translate_v3beta1.TranslationServiceClient() + >>> + >>> parent = client.location_path('[PROJECT]', '[LOCATION]') + >>> + >>> # TODO: Initialize `glossary`: + >>> glossary = {} + >>> + >>> response = client.create_glossary(parent, glossary) + >>> + >>> def callback(operation_future): + ... # Handle result. + ... result = operation_future.result() + >>> + >>> response.add_done_callback(callback) + >>> + >>> # Handle metadata. + >>> metadata = response.metadata() + + Args: + parent (str): Required. The project name. + glossary (Union[dict, ~google.cloud.translate_v3beta1.types.Glossary]): Required. The glossary to create. + + If a dict is provided, it must be of the same form as the protobuf + message :class:`~google.cloud.translate_v3beta1.types.Glossary` + retry (Optional[google.api_core.retry.Retry]): A retry object used + to retry requests. If ``None`` is specified, requests will not + be retried. + timeout (Optional[float]): The amount of time, in seconds, to wait + for the request to complete. Note that if ``retry`` is + specified, the timeout applies to each individual attempt. + metadata (Optional[Sequence[Tuple[str, str]]]): Additional metadata + that is provided to the method. + + Returns: + A :class:`~google.cloud.translate_v3beta1.types._OperationFuture` instance. + + Raises: + google.api_core.exceptions.GoogleAPICallError: If the request + failed for any reason. + google.api_core.exceptions.RetryError: If the request failed due + to a retryable error and retry attempts failed. + ValueError: If the parameters are invalid. + """ + # Wrap the transport method to add retry and timeout logic. + if "create_glossary" not in self._inner_api_calls: + self._inner_api_calls[ + "create_glossary" + ] = google.api_core.gapic_v1.method.wrap_method( + self.transport.create_glossary, + default_retry=self._method_configs["CreateGlossary"].retry, + default_timeout=self._method_configs["CreateGlossary"].timeout, + client_info=self._client_info, + ) + + request = translation_service_pb2.CreateGlossaryRequest( + parent=parent, glossary=glossary + ) + operation = self._inner_api_calls["create_glossary"]( + request, retry=retry, timeout=timeout, metadata=metadata + ) + return google.api_core.operation.from_gapic( + operation, + self.transport._operations_client, + translation_service_pb2.Glossary, + metadata_type=translation_service_pb2.CreateGlossaryMetadata, + ) + + def list_glossaries( + self, + parent=None, + page_size=None, + filter_=None, + retry=google.api_core.gapic_v1.method.DEFAULT, + timeout=google.api_core.gapic_v1.method.DEFAULT, + metadata=None, + ): + """ + Lists glossaries in a project. Returns NOT\_FOUND, if the project + doesn't exist. + + Example: + >>> from google.cloud import translate_v3beta1 + >>> + >>> client = translate_v3beta1.TranslationServiceClient() + >>> + >>> # Iterate over all results + >>> for element in client.list_glossaries(): + ... # process element + ... pass + >>> + >>> + >>> # Alternatively: + >>> + >>> # Iterate over results one page at a time + >>> for page in client.list_glossaries().pages: + ... for element in page: + ... # process element + ... pass + + Args: + parent (str): Required. The name of the project from which to list all of the glossaries. + page_size (int): The maximum number of resources contained in the + underlying API response. If page streaming is performed per- + resource, this parameter does not affect the return value. If page + streaming is performed per-page, this determines the maximum number + of resources in a page. + filter_ (str): Optional. Filter specifying constraints of a list operation. For + example, ``tags.glossary_name="products*"``. If missing, no filtering is + performed. + retry (Optional[google.api_core.retry.Retry]): A retry object used + to retry requests. If ``None`` is specified, requests will not + be retried. + timeout (Optional[float]): The amount of time, in seconds, to wait + for the request to complete. Note that if ``retry`` is + specified, the timeout applies to each individual attempt. + metadata (Optional[Sequence[Tuple[str, str]]]): Additional metadata + that is provided to the method. + + Returns: + A :class:`~google.gax.PageIterator` instance. By default, this + is an iterable of :class:`~google.cloud.translate_v3beta1.types.Glossary` instances. + This object can also be configured to iterate over the pages + of the response through the `options` parameter. + + Raises: + google.api_core.exceptions.GoogleAPICallError: If the request + failed for any reason. + google.api_core.exceptions.RetryError: If the request failed due + to a retryable error and retry attempts failed. + ValueError: If the parameters are invalid. + """ + # Wrap the transport method to add retry and timeout logic. + if "list_glossaries" not in self._inner_api_calls: + self._inner_api_calls[ + "list_glossaries" + ] = google.api_core.gapic_v1.method.wrap_method( + self.transport.list_glossaries, + default_retry=self._method_configs["ListGlossaries"].retry, + default_timeout=self._method_configs["ListGlossaries"].timeout, + client_info=self._client_info, + ) + + request = translation_service_pb2.ListGlossariesRequest( + parent=parent, page_size=page_size, filter=filter_ + ) + iterator = google.api_core.page_iterator.GRPCIterator( + client=None, + method=functools.partial( + self._inner_api_calls["list_glossaries"], + retry=retry, + timeout=timeout, + metadata=metadata, + ), + request=request, + items_field="glossaries", + request_token_field="page_token", + response_token_field="next_page_token", + ) + return iterator + + def get_glossary( + self, + name, + retry=google.api_core.gapic_v1.method.DEFAULT, + timeout=google.api_core.gapic_v1.method.DEFAULT, + metadata=None, + ): + """ + Gets a glossary. Returns NOT\_FOUND, if the glossary doesn't exist. + + Example: + >>> from google.cloud import translate_v3beta1 + >>> + >>> client = translate_v3beta1.TranslationServiceClient() + >>> + >>> name = client.glossary_path('[PROJECT]', '[LOCATION]', '[GLOSSARY]') + >>> + >>> response = client.get_glossary(name) + + Args: + name (str): Required. The name of the glossary to retrieve. + retry (Optional[google.api_core.retry.Retry]): A retry object used + to retry requests. If ``None`` is specified, requests will not + be retried. + timeout (Optional[float]): The amount of time, in seconds, to wait + for the request to complete. Note that if ``retry`` is + specified, the timeout applies to each individual attempt. + metadata (Optional[Sequence[Tuple[str, str]]]): Additional metadata + that is provided to the method. + + Returns: + A :class:`~google.cloud.translate_v3beta1.types.Glossary` instance. + + Raises: + google.api_core.exceptions.GoogleAPICallError: If the request + failed for any reason. + google.api_core.exceptions.RetryError: If the request failed due + to a retryable error and retry attempts failed. + ValueError: If the parameters are invalid. + """ + # Wrap the transport method to add retry and timeout logic. + if "get_glossary" not in self._inner_api_calls: + self._inner_api_calls[ + "get_glossary" + ] = google.api_core.gapic_v1.method.wrap_method( + self.transport.get_glossary, + default_retry=self._method_configs["GetGlossary"].retry, + default_timeout=self._method_configs["GetGlossary"].timeout, + client_info=self._client_info, + ) + + request = translation_service_pb2.GetGlossaryRequest(name=name) + return self._inner_api_calls["get_glossary"]( + request, retry=retry, timeout=timeout, metadata=metadata + ) + + def delete_glossary( + self, + name, + retry=google.api_core.gapic_v1.method.DEFAULT, + timeout=google.api_core.gapic_v1.method.DEFAULT, + metadata=None, + ): + """ + Deletes a glossary, or cancels glossary construction if the glossary + isn't created yet. Returns NOT\_FOUND, if the glossary doesn't exist. + + Example: + >>> from google.cloud import translate_v3beta1 + >>> + >>> client = translate_v3beta1.TranslationServiceClient() + >>> + >>> name = client.glossary_path('[PROJECT]', '[LOCATION]', '[GLOSSARY]') + >>> + >>> response = client.delete_glossary(name) + >>> + >>> def callback(operation_future): + ... # Handle result. + ... result = operation_future.result() + >>> + >>> response.add_done_callback(callback) + >>> + >>> # Handle metadata. + >>> metadata = response.metadata() + + Args: + name (str): Required. The name of the glossary to delete. + retry (Optional[google.api_core.retry.Retry]): A retry object used + to retry requests. If ``None`` is specified, requests will not + be retried. + timeout (Optional[float]): The amount of time, in seconds, to wait + for the request to complete. Note that if ``retry`` is + specified, the timeout applies to each individual attempt. + metadata (Optional[Sequence[Tuple[str, str]]]): Additional metadata + that is provided to the method. + + Returns: + A :class:`~google.cloud.translate_v3beta1.types._OperationFuture` instance. + + Raises: + google.api_core.exceptions.GoogleAPICallError: If the request + failed for any reason. + google.api_core.exceptions.RetryError: If the request failed due + to a retryable error and retry attempts failed. + ValueError: If the parameters are invalid. + """ + # Wrap the transport method to add retry and timeout logic. + if "delete_glossary" not in self._inner_api_calls: + self._inner_api_calls[ + "delete_glossary" + ] = google.api_core.gapic_v1.method.wrap_method( + self.transport.delete_glossary, + default_retry=self._method_configs["DeleteGlossary"].retry, + default_timeout=self._method_configs["DeleteGlossary"].timeout, + client_info=self._client_info, + ) + + request = translation_service_pb2.DeleteGlossaryRequest(name=name) + operation = self._inner_api_calls["delete_glossary"]( + request, retry=retry, timeout=timeout, metadata=metadata + ) + return google.api_core.operation.from_gapic( + operation, + self.transport._operations_client, + translation_service_pb2.DeleteGlossaryResponse, + metadata_type=translation_service_pb2.DeleteGlossaryMetadata, + ) diff --git a/packages/google-cloud-translate/google/cloud/translate_v3beta1/gapic/translation_service_client_config.py b/packages/google-cloud-translate/google/cloud/translate_v3beta1/gapic/translation_service_client_config.py new file mode 100644 index 000000000000..21b7872180e8 --- /dev/null +++ b/packages/google-cloud-translate/google/cloud/translate_v3beta1/gapic/translation_service_client_config.py @@ -0,0 +1,63 @@ +config = { + "interfaces": { + "google.cloud.translation.v3beta1.TranslationService": { + "retry_codes": { + "idempotent": ["DEADLINE_EXCEEDED", "UNAVAILABLE"], + "non_idempotent": [], + }, + "retry_params": { + "default": { + "initial_retry_delay_millis": 100, + "retry_delay_multiplier": 1.3, + "max_retry_delay_millis": 60000, + "initial_rpc_timeout_millis": 20000, + "rpc_timeout_multiplier": 1.0, + "max_rpc_timeout_millis": 20000, + "total_timeout_millis": 600000, + } + }, + "methods": { + "TranslateText": { + "timeout_millis": 60000, + "retry_codes_name": "non_idempotent", + "retry_params_name": "default", + }, + "DetectLanguage": { + "timeout_millis": 60000, + "retry_codes_name": "non_idempotent", + "retry_params_name": "default", + }, + "GetSupportedLanguages": { + "timeout_millis": 60000, + "retry_codes_name": "idempotent", + "retry_params_name": "default", + }, + "BatchTranslateText": { + "timeout_millis": 60000, + "retry_codes_name": "non_idempotent", + "retry_params_name": "default", + }, + "CreateGlossary": { + "timeout_millis": 60000, + "retry_codes_name": "non_idempotent", + "retry_params_name": "default", + }, + "ListGlossaries": { + "timeout_millis": 60000, + "retry_codes_name": "idempotent", + "retry_params_name": "default", + }, + "GetGlossary": { + "timeout_millis": 60000, + "retry_codes_name": "idempotent", + "retry_params_name": "default", + }, + "DeleteGlossary": { + "timeout_millis": 60000, + "retry_codes_name": "idempotent", + "retry_params_name": "default", + }, + }, + } + } +} diff --git a/packages/google-cloud-translate/google/cloud/translate_v3beta1/gapic/transports/__init__.py b/packages/google-cloud-translate/google/cloud/translate_v3beta1/gapic/transports/__init__.py new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/packages/google-cloud-translate/google/cloud/translate_v3beta1/gapic/transports/translation_service_grpc_transport.py b/packages/google-cloud-translate/google/cloud/translate_v3beta1/gapic/transports/translation_service_grpc_transport.py new file mode 100644 index 000000000000..8b00b7ed7398 --- /dev/null +++ b/packages/google-cloud-translate/google/cloud/translate_v3beta1/gapic/transports/translation_service_grpc_transport.py @@ -0,0 +1,222 @@ +# -*- coding: utf-8 -*- +# +# Copyright 2019 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import google.api_core.grpc_helpers +import google.api_core.operations_v1 + +from google.cloud.translate_v3beta1.proto import translation_service_pb2_grpc + + +class TranslationServiceGrpcTransport(object): + """gRPC transport class providing stubs for + google.cloud.translation.v3beta1 TranslationService API. + + The transport provides access to the raw gRPC stubs, + which can be used to take advantage of advanced + features of gRPC. + """ + + # The scopes needed to make gRPC calls to all of the methods defined + # in this service. + _OAUTH_SCOPES = ( + "https://www.googleapis.com/auth/cloud-platform", + "https://www.googleapis.com/auth/cloud-translation", + ) + + def __init__( + self, channel=None, credentials=None, address="translate.googleapis.com:443" + ): + """Instantiate the transport class. + + Args: + channel (grpc.Channel): A ``Channel`` instance through + which to make calls. This argument is mutually exclusive + with ``credentials``; providing both will raise an exception. + credentials (google.auth.credentials.Credentials): The + authorization credentials to attach to requests. These + credentials identify this application to the service. If none + are specified, the client will attempt to ascertain the + credentials from the environment. + address (str): The address where the service is hosted. + """ + # If both `channel` and `credentials` are specified, raise an + # exception (channels come with credentials baked in already). + if channel is not None and credentials is not None: + raise ValueError( + "The `channel` and `credentials` arguments are mutually " "exclusive." + ) + + # Create the channel. + if channel is None: + channel = self.create_channel(address=address, credentials=credentials) + + self._channel = channel + + # gRPC uses objects called "stubs" that are bound to the + # channel and provide a basic method for each RPC. + self._stubs = { + "translation_service_stub": translation_service_pb2_grpc.TranslationServiceStub( + channel + ) + } + + # Because this API includes a method that returns a + # long-running operation (proto: google.longrunning.Operation), + # instantiate an LRO client. + self._operations_client = google.api_core.operations_v1.OperationsClient( + channel + ) + + @classmethod + def create_channel(cls, address="translate.googleapis.com:443", credentials=None): + """Create and return a gRPC channel object. + + Args: + address (str): The host for the channel to use. + credentials (~.Credentials): The + authorization credentials to attach to requests. These + credentials identify this application to the service. If + none are specified, the client will attempt to ascertain + the credentials from the environment. + + Returns: + grpc.Channel: A gRPC channel object. + """ + return google.api_core.grpc_helpers.create_channel( + address, credentials=credentials, scopes=cls._OAUTH_SCOPES + ) + + @property + def channel(self): + """The gRPC channel used by the transport. + + Returns: + grpc.Channel: A gRPC channel object. + """ + return self._channel + + @property + def translate_text(self): + """Return the gRPC stub for :meth:`TranslationServiceClient.translate_text`. + + Translates input text and returns translated text. + + Returns: + Callable: A callable which accepts the appropriate + deserialized request object and returns a + deserialized response object. + """ + return self._stubs["translation_service_stub"].TranslateText + + @property + def detect_language(self): + """Return the gRPC stub for :meth:`TranslationServiceClient.detect_language`. + + Detects the language of text within a request. + + Returns: + Callable: A callable which accepts the appropriate + deserialized request object and returns a + deserialized response object. + """ + return self._stubs["translation_service_stub"].DetectLanguage + + @property + def get_supported_languages(self): + """Return the gRPC stub for :meth:`TranslationServiceClient.get_supported_languages`. + + Returns a list of supported languages for translation. + + Returns: + Callable: A callable which accepts the appropriate + deserialized request object and returns a + deserialized response object. + """ + return self._stubs["translation_service_stub"].GetSupportedLanguages + + @property + def batch_translate_text(self): + """Return the gRPC stub for :meth:`TranslationServiceClient.batch_translate_text`. + + Translates a large volume of text in asynchronous batch mode. + This function provides real-time output as the inputs are being processed. + If caller cancels a request, the partial results (for an input file, it's + all or nothing) may still be available on the specified output location. + + This call returns immediately and you can + use google.longrunning.Operation.name to poll the status of the call. + + Returns: + Callable: A callable which accepts the appropriate + deserialized request object and returns a + deserialized response object. + """ + return self._stubs["translation_service_stub"].BatchTranslateText + + @property + def create_glossary(self): + """Return the gRPC stub for :meth:`TranslationServiceClient.create_glossary`. + + Creates a glossary and returns the long-running operation. Returns + NOT\_FOUND, if the project doesn't exist. + + Returns: + Callable: A callable which accepts the appropriate + deserialized request object and returns a + deserialized response object. + """ + return self._stubs["translation_service_stub"].CreateGlossary + + @property + def list_glossaries(self): + """Return the gRPC stub for :meth:`TranslationServiceClient.list_glossaries`. + + Lists glossaries in a project. Returns NOT\_FOUND, if the project + doesn't exist. + + Returns: + Callable: A callable which accepts the appropriate + deserialized request object and returns a + deserialized response object. + """ + return self._stubs["translation_service_stub"].ListGlossaries + + @property + def get_glossary(self): + """Return the gRPC stub for :meth:`TranslationServiceClient.get_glossary`. + + Gets a glossary. Returns NOT\_FOUND, if the glossary doesn't exist. + + Returns: + Callable: A callable which accepts the appropriate + deserialized request object and returns a + deserialized response object. + """ + return self._stubs["translation_service_stub"].GetGlossary + + @property + def delete_glossary(self): + """Return the gRPC stub for :meth:`TranslationServiceClient.delete_glossary`. + + Deletes a glossary, or cancels glossary construction if the glossary + isn't created yet. Returns NOT\_FOUND, if the glossary doesn't exist. + + Returns: + Callable: A callable which accepts the appropriate + deserialized request object and returns a + deserialized response object. + """ + return self._stubs["translation_service_stub"].DeleteGlossary diff --git a/packages/google-cloud-translate/google/cloud/translate_v3beta1/proto/__init__.py b/packages/google-cloud-translate/google/cloud/translate_v3beta1/proto/__init__.py new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/packages/google-cloud-translate/google/cloud/translate_v3beta1/proto/translation_service.proto b/packages/google-cloud-translate/google/cloud/translate_v3beta1/proto/translation_service.proto new file mode 100644 index 000000000000..e9e65baa35b5 --- /dev/null +++ b/packages/google-cloud-translate/google/cloud/translate_v3beta1/proto/translation_service.proto @@ -0,0 +1,740 @@ +// Copyright 2019 Google LLC. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +syntax = "proto3"; + +package google.cloud.translation.v3beta1; + +import "google/api/annotations.proto"; +import "google/longrunning/operations.proto"; +import "google/protobuf/timestamp.proto"; + +option cc_enable_arenas = true; +option csharp_namespace = "Google.Cloud.Translate.V3Beta1"; +option go_package = "google.golang.org/genproto/googleapis/cloud/translate/v3beta1;translate"; +option java_multiple_files = true; +option java_outer_classname = "TranslationServiceProto"; +option java_package = "com.google.cloud.translate.v3beta1"; +option php_namespace = "Google\\Cloud\\Translate\\V3beta1"; +option ruby_package = "Google::Cloud::Translate::V3beta1"; + +// Proto file for the Cloud Translation API (v3beta1). + +// Provides natural language translation operations. +service TranslationService { + // Translates input text and returns translated text. + rpc TranslateText(TranslateTextRequest) returns (TranslateTextResponse) { + option (google.api.http) = { + post: "/v3beta1/{parent=projects/*/locations/*}:translateText" + body: "*" + }; + } + + // Detects the language of text within a request. + rpc DetectLanguage(DetectLanguageRequest) returns (DetectLanguageResponse) { + option (google.api.http) = { + post: "/v3beta1/{parent=projects/*/locations/*}:detectLanguage" + body: "*" + }; + } + + // Returns a list of supported languages for translation. + rpc GetSupportedLanguages(GetSupportedLanguagesRequest) returns (SupportedLanguages) { + option (google.api.http) = { + get: "/v3beta1/{parent=projects/*/locations/*}/supportedLanguages" + }; + } + + // Translates a large volume of text in asynchronous batch mode. + // This function provides real-time output as the inputs are being processed. + // If caller cancels a request, the partial results (for an input file, it's + // all or nothing) may still be available on the specified output location. + // + // This call returns immediately and you can + // use google.longrunning.Operation.name to poll the status of the call. + rpc BatchTranslateText(BatchTranslateTextRequest) returns (google.longrunning.Operation) { + option (google.api.http) = { + post: "/v3beta1/{parent=projects/*/locations/*}:batchTranslateText" + body: "*" + }; + } + + // Creates a glossary and returns the long-running operation. Returns + // NOT_FOUND, if the project doesn't exist. + rpc CreateGlossary(CreateGlossaryRequest) returns (google.longrunning.Operation) { + option (google.api.http) = { + post: "/v3beta1/{parent=projects/*/locations/*}/glossaries" + body: "glossary" + }; + } + + // Lists glossaries in a project. Returns NOT_FOUND, if the project doesn't + // exist. + rpc ListGlossaries(ListGlossariesRequest) returns (ListGlossariesResponse) { + option (google.api.http) = { + get: "/v3beta1/{parent=projects/*/locations/*}/glossaries" + }; + } + + // Gets a glossary. Returns NOT_FOUND, if the glossary doesn't + // exist. + rpc GetGlossary(GetGlossaryRequest) returns (Glossary) { + option (google.api.http) = { + get: "/v3beta1/{name=projects/*/locations/*/glossaries/*}" + }; + } + + // Deletes a glossary, or cancels glossary construction + // if the glossary isn't created yet. + // Returns NOT_FOUND, if the glossary doesn't exist. + rpc DeleteGlossary(DeleteGlossaryRequest) returns (google.longrunning.Operation) { + option (google.api.http) = { + delete: "/v3beta1/{name=projects/*/locations/*/glossaries/*}" + }; + } +} + +// Configures which glossary should be used for a specific target language, +// and defines options for applying that glossary. +message TranslateTextGlossaryConfig { + // Required. Specifies the glossary used for this translation. Use + // this format: projects/*/locations/*/glossaries/* + string glossary = 1; + + // Optional. Indicates whether we should do a case-insensitive match. + // Default value is false if missing. + bool ignore_case = 2; +} + +// The request message for synchronous translation. +message TranslateTextRequest { + // Required. The content of the input in string format. + // We recommend the total contents to be less than 30k codepoints. + // Please use BatchTranslateText for larger text. + repeated string contents = 1; + + // Optional. The format of the source text, for example, "text/html", + // "text/plain". If left blank, the MIME type is assumed to be "text/html". + string mime_type = 3; + + // Optional. The BCP-47 language code of the input text if + // known, for example, "en-US" or "sr-Latn". Supported language codes are + // listed in Language Support. If the source language isn't specified, the API + // attempts to identify the source language automatically and returns the + // the source language within the response. + string source_language_code = 4; + + // Required. The BCP-47 language code to use for translation of the input + // text, set to one of the language codes listed in Language Support. + string target_language_code = 5; + + // Optional. Only used when making regionalized call. + // Format: + // projects/{project-id}/locations/{location-id}. + // + // Only custom model/glossary within the same location-id can be used. + // Otherwise 400 is returned. + string parent = 8; + + // Optional. The `model` type requested for this translation. + // + // The format depends on model type: + // 1. Custom models: + // projects/{project-id}/locations/{location-id}/models/{model-id}. + // 2. General (built-in) models: + // projects/{project-id}/locations/{location-id}/models/general/nmt + // projects/{project-id}/locations/{location-id}/models/general/base + // + // For global (non-regionalized) requests, use {location-id} 'global'. + // For example, + // projects/{project-id}/locations/global/models/general/nmt + // + // If missing, the system decides which google base model to use. + string model = 6; + + // Optional. Glossary to be applied. The glossary needs to be in the same + // region as the model, otherwise an INVALID_ARGUMENT error is returned. + TranslateTextGlossaryConfig glossary_config = 7; +} + +// The main language translation response message. +message TranslateTextResponse { + // Text translation responses with no glossary applied. + // This field has the same length as `contents` in TranslateTextRequest. + repeated Translation translations = 1; + + // Text translation responses if a glossary is provided in the request. + // This could be the same as 'translation' above if no terms apply. + // This field has the same length as `contents` in TranslateTextRequest. + repeated Translation glossary_translations = 3; +} + +// A single translation response. +message Translation { + // Text translated into the target language. + string translated_text = 1; + + // Only present when `model` is present in the request. + // This is same as `model` provided in the request. + string model = 2; + + // The BCP-47 language code of source text in the initial request, detected + // automatically, if no source language was passed within the initial + // request. If the source language was passed, auto-detection of the language + // does not occur and this field will be empty. + string detected_language_code = 4; + + // The `glossary_config` used for this translation. + TranslateTextGlossaryConfig glossary_config = 3; +} + +// The request message for language detection. +message DetectLanguageRequest { + // Optional. Only used when making regionalized call. + // Format: + // projects/{project-id}/locations/{location-id}. + // + // Only custom model within the same location-id can be used. + // Otherwise 400 is returned. + string parent = 5; + + // Optional. The language detection model to be used. + // projects/{project-id}/locations/{location-id}/models/language-detection/{model-id} + // If not specified, default will be used. + string model = 4; + + // Required. The source of the document from which to detect the language. + oneof source { + // The content of the input stored as a string. + string content = 1; + } + + // Optional. The format of the source text, for example, "text/html", + // "text/plain". If left blank, the MIME type is assumed to be "text/html". + string mime_type = 3; +} + +// The response message for language detection. +message DetectedLanguage { + // The BCP-47 language code of source content in the request, detected + // automatically. + string language_code = 1; + + // The confidence of the detection result for this language. + float confidence = 2; +} + +// The response message for language detection. +message DetectLanguageResponse { + // A list of detected languages sorted by detection confidence in descending + // order. The most probable language first. + repeated DetectedLanguage languages = 1; +} + +// The request message for discovering supported languages. +message GetSupportedLanguagesRequest { + // Optional. Used for making regionalized calls. + // Format: projects/{project-id}/locations/{location-id}. + // For global calls, use projects/{project-id}/locations/global. + // If missing, the call is treated as a global call. + // + // Only custom model within the same location-id can be used. + // Otherwise 400 is returned. + string parent = 3; + + // Optional. The language to use to return localized, human readable names + // of supported languages. If missing, default language is ENGLISH. + string display_language_code = 1; + + // Optional. Get supported languages of this model. + // The format depends on model type: + // 1. Custom models: + // projects/{project-id}/locations/{location-id}/models/{model-id}. + // 2. General (built-in) models: + // projects/{project-id}/locations/{location-id}/models/general/nmt + // projects/{project-id}/locations/{location-id}/models/general/base + // Returns languages supported by the specified model. + // If missing, we get supported languages of Google general NMT model. + string model = 2; +} + +// The response message for discovering supported languages. +message SupportedLanguages { + // A list of supported language responses. This list contains an entry + // for each language the Translation API supports. + repeated SupportedLanguage languages = 1; +} + +// A single supported language response corresponds to information related +// to one supported language. +message SupportedLanguage { + // Supported language code, generally consisting of its ISO 639-1 + // identifier, for example, 'en', 'ja'. In certain cases, BCP-47 codes + // including language and region identifiers are returned (for example, + // 'zh-TW' and 'zh-CN') + string language_code = 1; + + // Human readable name of the language localized in the display language + // specified in the request. + string display_name = 2; + + // Can be used as source language. + bool support_source = 3; + + // Can be used as target language. + bool support_target = 4; +} + +// The GCS location for the input content. +message GcsSource { + // Required. Source data URI. For example, `gs://my_bucket/my_object`. + string input_uri = 1; +} + +// Input configuration. +message InputConfig { + // Optional. Can be "text/plain" or "text/html". + // For `.tsv`, "text/html" is used if mime_type is missing. + // For `.html`, this field must be "text/html" or empty. + // For `.txt`, this field must be "text/plain" or empty. + string mime_type = 1; + + // Required. Specify the input. + oneof source { + // Required. Google Cloud Storage location for the source input. + // This can be a single file (for example, + // `gs://translation-test/input.tsv`) or a wildcard (for example, + // `gs://translation-test/*`). If a file extension is `.tsv`, it can + // contain either one or two columns. The first column (optional) is the id + // of the text request. If the first column is missing, we use the row + // number (0-based) from the input file as the ID in the output file. The + // second column is the actual text to be + // translated. We recommend each row be <= 10K Unicode codepoints, + // otherwise an error might be returned. + // + // The other supported file extensions are `.txt` or `.html`, which is + // treated as a single large chunk of text. + GcsSource gcs_source = 2; + } +} + +// The GCS location for the output content +message GcsDestination { + // Required. There must be no files under 'output_uri_prefix'. + // 'output_uri_prefix' must end with "/". Otherwise error 400 is returned. + string output_uri_prefix = 1; +} + +// Output configuration. +message OutputConfig { + // Required. The destination of output. + oneof destination { + // Google Cloud Storage destination for output content. + // For every single input file (for example, gs://a/b/c.[extension]), we + // generate at most 2 * n output files. (n is the # of target_language_codes + // in the BatchTranslateTextRequest). + // + // Output files (tsv) generated are compliant with RFC 4180 except that + // record delimiters are '\n' instead of '\r\n'. We don't provide any way to + // change record delimiters. + // + // While the input files are being processed, we write/update an index file + // 'index.csv' under 'output_uri_prefix' (for example, + // gs://translation-test/index.csv) The index file is generated/updated as + // new files are being translated. The format is: + // + // input_file,target_language_code,translations_file,errors_file, + // glossary_translations_file,glossary_errors_file + // + // input_file is one file we matched using gcs_source.input_uri. + // target_language_code is provided in the request. + // translations_file contains the translations. (details provided below) + // errors_file contains the errors during processing of the file. (details + // below). Both translations_file and errors_file could be empty + // strings if we have no content to output. + // glossary_translations_file,glossary_errors_file are always empty string + // if input_file is tsv. They could also be empty if we have no content to + // output. + // + // Once a row is present in index.csv, the input/output matching never + // changes. Callers should also expect all the content in input_file are + // processed and ready to be consumed (that is, No partial output file is + // written). + // + // The format of translations_file (for target language code 'trg') is: + // gs://translation_test/a_b_c_'trg'_translations.[extension] + // + // If the input file extension is tsv, the output has the following + // columns: + // Column 1: ID of the request provided in the input, if it's not + // provided in the input, then the input row number is used (0-based). + // Column 2: source sentence. + // Column 3: translation without applying a glossary. Empty string if there + // is an error. + // Column 4 (only present if a glossary is provided in the request): + // translation after applying the glossary. Empty string if there is an + // error applying the glossary. Could be same string as column 3 if there is + // no glossary applied. + // + // If input file extension is a txt or html, the translation is directly + // written to the output file. If glossary is requested, a separate + // glossary_translations_file has format of + // gs://translation_test/a_b_c_'trg'_glossary_translations.[extension] + // + // The format of errors file (for target language code 'trg') is: + // gs://translation_test/a_b_c_'trg'_errors.[extension] + // + // If the input file extension is tsv, errors_file has the + // following Column 1: ID of the request provided in the input, if it's not + // provided in the input, then the input row number is used (0-based). + // Column 2: source sentence. + // Column 3: Error detail for the translation. Could be empty. + // Column 4 (only present if a glossary is provided in the request): + // Error when applying the glossary. + // + // If the input file extension is txt or html, glossary_error_file will be + // generated that contains error details. glossary_error_file has format of + // gs://translation_test/a_b_c_'trg'_glossary_errors.[extension] + GcsDestination gcs_destination = 1; + } +} + +// The batch translation request. +message BatchTranslateTextRequest { + // Optional. Only used when making regionalized call. + // Format: + // projects/{project-id}/locations/{location-id}. + // + // Only custom models/glossaries within the same location-id can be used. + // Otherwise 400 is returned. + string parent = 1; + + // Required. Source language code. + string source_language_code = 2; + + // Required. Specify up to 10 language codes here. + repeated string target_language_codes = 3; + + // Optional. The models to use for translation. Map's key is target language + // code. Map's value is model name. Value can be a built-in general model, + // or a custom model built by AutoML. + // + // The value format depends on model type: + // 1. Custom models: + // projects/{project-id}/locations/{location-id}/models/{model-id}. + // 2. General (built-in) models: + // projects/{project-id}/locations/{location-id}/models/general/nmt + // projects/{project-id}/locations/{location-id}/models/general/base + // + // If the map is empty or a specific model is + // not requested for a language pair, then default google model is used. + map models = 4; + + // Required. Input configurations. + // The total number of files matched should be <= 1000. + // The total content size should be <= 100M Unicode codepoints. + // The files must use UTF-8 encoding. + repeated InputConfig input_configs = 5; + + // Required. Output configuration. + // If 2 input configs match to the same file (that is, same input path), + // we don't generate output for duplicate inputs. + OutputConfig output_config = 6; + + // Optional. Glossaries to be applied for translation. + // It's keyed by target language code. + map glossaries = 7; +} + +// State metadata for the batch translation operation. +message BatchTranslateMetadata { + // State of the job. + enum State { + // Invalid. + STATE_UNSPECIFIED = 0; + + // Request is being processed. + RUNNING = 1; + + // The batch is processed, and at least one item has been successfully + // processed. + SUCCEEDED = 2; + + // The batch is done and no item has been successfully processed. + FAILED = 3; + + // Request is in the process of being canceled after caller invoked + // longrunning.Operations.CancelOperation on the request id. + CANCELLING = 4; + + // The batch is done after the user has called the + // longrunning.Operations.CancelOperation. Any records processed before the + // cancel command are output as specified in the request. + CANCELLED = 5; + } + + // The state of the operation. + State state = 1; + + // Number of successfully translated characters so far (Unicode codepoints). + int64 translated_characters = 2; + + // Number of characters that have failed to process so far (Unicode + // codepoints). + int64 failed_characters = 3; + + // Total number of characters (Unicode codepoints). + // This is the total number of codepoints from input files times the number of + // target languages. It appears here shortly after the call is submitted. + int64 total_characters = 4; + + // Time when the operation was submitted. + google.protobuf.Timestamp submit_time = 5; +} + +// Stored in the [google.longrunning.Operation.response][google.longrunning.Operation.response] field returned by +// BatchTranslateText if at least one sentence is translated successfully. +message BatchTranslateResponse { + // Total number of characters (Unicode codepoints). + int64 total_characters = 1; + + // Number of successfully translated characters (Unicode codepoints). + int64 translated_characters = 2; + + // Number of characters that have failed to process (Unicode codepoints). + int64 failed_characters = 3; + + // Time when the operation was submitted. + google.protobuf.Timestamp submit_time = 4; + + // The time when the operation is finished and + // [google.longrunning.Operation.done][google.longrunning.Operation.done] is set to true. + google.protobuf.Timestamp end_time = 5; +} + +// Input configuration for glossaries. +message GlossaryInputConfig { + // Required. Specify the input. + oneof source { + // Required. Google Cloud Storage location of glossary data. + // File format is determined based on file name extension. API returns + // [google.rpc.Code.INVALID_ARGUMENT] for unsupported URI-s and file + // formats. Wildcards are not allowed. This must be a single file in one of + // the following formats: + // + // For `UNIDIRECTIONAL` glossaries: + // + // - TSV/CSV (`.tsv`/`.csv`): 2 column file, tab- or comma-separated. + // The first column is source text. The second column is target text. + // The file must not contain headers. That is, the first row is data, not + // column names. + // + // - TMX (`.tmx`): TMX file with parallel data defining source/target term + // pairs. + // + // For `EQUIVALENT_TERMS_SET` glossaries: + // + // - CSV (`.csv`): Multi-column CSV file defining equivalent glossary terms + // in multiple languages. The format is defined for Google Translation + // Toolkit and documented here: + // `https://support.google.com/translatortoolkit/answer/6306379?hl=en`. + GcsSource gcs_source = 1; + } +} + +// Represents a glossary built from user provided data. +message Glossary { + // Used with UNIDIRECTIONAL. + message LanguageCodePair { + // Required. The BCP-47 language code of the input text, for example, + // "en-US". Expected to be an exact match for GlossaryTerm.language_code. + string source_language_code = 1; + + // Required. The BCP-47 language code for translation output, for example, + // "zh-CN". Expected to be an exact match for GlossaryTerm.language_code. + string target_language_code = 2; + } + + // Used with EQUIVALENT_TERMS_SET. + message LanguageCodesSet { + // The BCP-47 language code(s) for terms defined in the glossary. + // All entries are unique. The list contains at least two entries. + // Expected to be an exact match for GlossaryTerm.language_code. + repeated string language_codes = 1; + } + + // Required. The resource name of the glossary. Glossary names have the form + // `projects/{project-id}/locations/{location-id}/glossaries/{glossary-id}`. + string name = 1; + + // Languages supported by the glossary. + oneof languages { + // Used with UNIDIRECTIONAL. + LanguageCodePair language_pair = 3; + + // Used with EQUIVALENT_TERMS_SET. + LanguageCodesSet language_codes_set = 4; + } + + // Required. Provides examples to build the glossary from. + // Total glossary must not exceed 10M Unicode codepoints. + GlossaryInputConfig input_config = 5; + + // Output only. The number of entries defined in the glossary. + int32 entry_count = 6; + + // Output only. When CreateGlossary was called. + google.protobuf.Timestamp submit_time = 7; + + // Output only. When the glossary creation was finished. + google.protobuf.Timestamp end_time = 8; +} + +// Request message for CreateGlossary. +message CreateGlossaryRequest { + // Required. The project name. + string parent = 1; + + // Required. The glossary to create. + Glossary glossary = 2; +} + +// Request message for GetGlossary. +message GetGlossaryRequest { + // Required. The name of the glossary to retrieve. + string name = 1; +} + +// Request message for DeleteGlossary. +message DeleteGlossaryRequest { + // Required. The name of the glossary to delete. + string name = 1; +} + +// Request message for ListGlossaries. +message ListGlossariesRequest { + // Required. The name of the project from which to list all of the glossaries. + string parent = 1; + + // Optional. Requested page size. The server may return fewer glossaries than + // requested. If unspecified, the server picks an appropriate default. + int32 page_size = 2; + + // Optional. A token identifying a page of results the server should return. + // Typically, this is the value of [ListGlossariesResponse.next_page_token] + // returned from the previous call to `ListGlossaries` method. + // The first page is returned if `page_token`is empty or missing. + string page_token = 3; + + // Optional. Filter specifying constraints of a list operation. + // For example, `tags.glossary_name="products*"`. + // If missing, no filtering is performed. + string filter = 4; +} + +// Response message for ListGlossaries. +message ListGlossariesResponse { + // The list of glossaries for a project. + repeated Glossary glossaries = 1; + + // A token to retrieve a page of results. Pass this value in the + // [ListGlossariesRequest.page_token] field in the subsequent call to + // `ListGlossaries` method to retrieve the next page of results. + string next_page_token = 2; +} + +// Stored in the [google.longrunning.Operation.metadata][google.longrunning.Operation.metadata] field returned by +// CreateGlossary. +message CreateGlossaryMetadata { + // Enumerates the possible states that the creation request can be in. + enum State { + // Invalid. + STATE_UNSPECIFIED = 0; + + // Request is being processed. + RUNNING = 1; + + // The glossary has been successfully created. + SUCCEEDED = 2; + + // Failed to create the glossary. + FAILED = 3; + + // Request is in the process of being canceled after caller invoked + // longrunning.Operations.CancelOperation on the request id. + CANCELLING = 4; + + // The glossary creation request has been successfully canceled. + CANCELLED = 5; + } + + // The name of the glossary that is being created. + string name = 1; + + // The current state of the glossary creation operation. + State state = 2; + + // The time when the operation was submitted to the server. + google.protobuf.Timestamp submit_time = 3; +} + +// Stored in the [google.longrunning.Operation.metadata][google.longrunning.Operation.metadata] field returned by +// DeleteGlossary. +message DeleteGlossaryMetadata { + // Enumerates the possible states that the creation request can be in. + enum State { + // Invalid. + STATE_UNSPECIFIED = 0; + + // Request is being processed. + RUNNING = 1; + + // The glossary was successfully deleted. + SUCCEEDED = 2; + + // Failed to delete the glossary. + FAILED = 3; + + // Request is in the process of being canceled after caller invoked + // longrunning.Operations.CancelOperation on the request id. + CANCELLING = 4; + + // The glossary deletion request has been successfully canceled. + CANCELLED = 5; + } + + // The name of the glossary that is being deleted. + string name = 1; + + // The current state of the glossary deletion operation. + State state = 2; + + // The time when the operation was submitted to the server. + google.protobuf.Timestamp submit_time = 3; +} + +// Stored in the [google.longrunning.Operation.response][google.longrunning.Operation.response] field returned by +// DeleteGlossary. +message DeleteGlossaryResponse { + // The name of the deleted glossary. + string name = 1; + + // The time when the operation was submitted to the server. + google.protobuf.Timestamp submit_time = 2; + + // The time when the glossary deletion is finished and + // [google.longrunning.Operation.done][google.longrunning.Operation.done] is set to true. + google.protobuf.Timestamp end_time = 3; +} diff --git a/packages/google-cloud-translate/google/cloud/translate_v3beta1/proto/translation_service_pb2.py b/packages/google-cloud-translate/google/cloud/translate_v3beta1/proto/translation_service_pb2.py new file mode 100644 index 000000000000..d25701491f05 --- /dev/null +++ b/packages/google-cloud-translate/google/cloud/translate_v3beta1/proto/translation_service_pb2.py @@ -0,0 +1,3511 @@ +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: google/cloud/translation_v3beta1/proto/translation_service.proto + +import sys + +_b = sys.version_info[0] < 3 and (lambda x: x) or (lambda x: x.encode("latin1")) +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database + +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from google.api import annotations_pb2 as google_dot_api_dot_annotations__pb2 +from google.longrunning import ( + operations_pb2 as google_dot_longrunning_dot_operations__pb2, +) +from google.protobuf import timestamp_pb2 as google_dot_protobuf_dot_timestamp__pb2 + + +DESCRIPTOR = _descriptor.FileDescriptor( + name="google/cloud/translation_v3beta1/proto/translation_service.proto", + package="google.cloud.translation.v3beta1", + syntax="proto3", + serialized_options=_b( + '\n"com.google.cloud.translate.v3beta1B\027TranslationServiceProtoP\001ZGgoogle.golang.org/genproto/googleapis/cloud/translate/v3beta1;translate\370\001\001\252\002\036Google.Cloud.Translate.V3Beta1\312\002\036Google\\Cloud\\Translate\\V3beta1\352\002!Google::Cloud::Translate::V3beta1' + ), + serialized_pb=_b( + '\n@google/cloud/translation_v3beta1/proto/translation_service.proto\x12 google.cloud.translation.v3beta1\x1a\x1cgoogle/api/annotations.proto\x1a#google/longrunning/operations.proto\x1a\x1fgoogle/protobuf/timestamp.proto"D\n\x1bTranslateTextGlossaryConfig\x12\x10\n\x08glossary\x18\x01 \x01(\t\x12\x13\n\x0bignore_case\x18\x02 \x01(\x08"\xee\x01\n\x14TranslateTextRequest\x12\x10\n\x08\x63ontents\x18\x01 \x03(\t\x12\x11\n\tmime_type\x18\x03 \x01(\t\x12\x1c\n\x14source_language_code\x18\x04 \x01(\t\x12\x1c\n\x14target_language_code\x18\x05 \x01(\t\x12\x0e\n\x06parent\x18\x08 \x01(\t\x12\r\n\x05model\x18\x06 \x01(\t\x12V\n\x0fglossary_config\x18\x07 \x01(\x0b\x32=.google.cloud.translation.v3beta1.TranslateTextGlossaryConfig"\xaa\x01\n\x15TranslateTextResponse\x12\x43\n\x0ctranslations\x18\x01 \x03(\x0b\x32-.google.cloud.translation.v3beta1.Translation\x12L\n\x15glossary_translations\x18\x03 \x03(\x0b\x32-.google.cloud.translation.v3beta1.Translation"\xad\x01\n\x0bTranslation\x12\x17\n\x0ftranslated_text\x18\x01 \x01(\t\x12\r\n\x05model\x18\x02 \x01(\t\x12\x1e\n\x16\x64\x65tected_language_code\x18\x04 \x01(\t\x12V\n\x0fglossary_config\x18\x03 \x01(\x0b\x32=.google.cloud.translation.v3beta1.TranslateTextGlossaryConfig"f\n\x15\x44\x65tectLanguageRequest\x12\x0e\n\x06parent\x18\x05 \x01(\t\x12\r\n\x05model\x18\x04 \x01(\t\x12\x11\n\x07\x63ontent\x18\x01 \x01(\tH\x00\x12\x11\n\tmime_type\x18\x03 \x01(\tB\x08\n\x06source"=\n\x10\x44\x65tectedLanguage\x12\x15\n\rlanguage_code\x18\x01 \x01(\t\x12\x12\n\nconfidence\x18\x02 \x01(\x02"_\n\x16\x44\x65tectLanguageResponse\x12\x45\n\tlanguages\x18\x01 \x03(\x0b\x32\x32.google.cloud.translation.v3beta1.DetectedLanguage"\\\n\x1cGetSupportedLanguagesRequest\x12\x0e\n\x06parent\x18\x03 \x01(\t\x12\x1d\n\x15\x64isplay_language_code\x18\x01 \x01(\t\x12\r\n\x05model\x18\x02 \x01(\t"\\\n\x12SupportedLanguages\x12\x46\n\tlanguages\x18\x01 \x03(\x0b\x32\x33.google.cloud.translation.v3beta1.SupportedLanguage"p\n\x11SupportedLanguage\x12\x15\n\rlanguage_code\x18\x01 \x01(\t\x12\x14\n\x0c\x64isplay_name\x18\x02 \x01(\t\x12\x16\n\x0esupport_source\x18\x03 \x01(\x08\x12\x16\n\x0esupport_target\x18\x04 \x01(\x08"\x1e\n\tGcsSource\x12\x11\n\tinput_uri\x18\x01 \x01(\t"m\n\x0bInputConfig\x12\x11\n\tmime_type\x18\x01 \x01(\t\x12\x41\n\ngcs_source\x18\x02 \x01(\x0b\x32+.google.cloud.translation.v3beta1.GcsSourceH\x00\x42\x08\n\x06source"+\n\x0eGcsDestination\x12\x19\n\x11output_uri_prefix\x18\x01 \x01(\t"j\n\x0cOutputConfig\x12K\n\x0fgcs_destination\x18\x01 \x01(\x0b\x32\x30.google.cloud.translation.v3beta1.GcsDestinationH\x00\x42\r\n\x0b\x64\x65stination"\xd0\x04\n\x19\x42\x61tchTranslateTextRequest\x12\x0e\n\x06parent\x18\x01 \x01(\t\x12\x1c\n\x14source_language_code\x18\x02 \x01(\t\x12\x1d\n\x15target_language_codes\x18\x03 \x03(\t\x12W\n\x06models\x18\x04 \x03(\x0b\x32G.google.cloud.translation.v3beta1.BatchTranslateTextRequest.ModelsEntry\x12\x44\n\rinput_configs\x18\x05 \x03(\x0b\x32-.google.cloud.translation.v3beta1.InputConfig\x12\x45\n\routput_config\x18\x06 \x01(\x0b\x32..google.cloud.translation.v3beta1.OutputConfig\x12_\n\nglossaries\x18\x07 \x03(\x0b\x32K.google.cloud.translation.v3beta1.BatchTranslateTextRequest.GlossariesEntry\x1a-\n\x0bModelsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\x1ap\n\x0fGlossariesEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12L\n\x05value\x18\x02 \x01(\x0b\x32=.google.cloud.translation.v3beta1.TranslateTextGlossaryConfig:\x02\x38\x01"\xd3\x02\n\x16\x42\x61tchTranslateMetadata\x12M\n\x05state\x18\x01 \x01(\x0e\x32>.google.cloud.translation.v3beta1.BatchTranslateMetadata.State\x12\x1d\n\x15translated_characters\x18\x02 \x01(\x03\x12\x19\n\x11\x66\x61iled_characters\x18\x03 \x01(\x03\x12\x18\n\x10total_characters\x18\x04 \x01(\x03\x12/\n\x0bsubmit_time\x18\x05 \x01(\x0b\x32\x1a.google.protobuf.Timestamp"e\n\x05State\x12\x15\n\x11STATE_UNSPECIFIED\x10\x00\x12\x0b\n\x07RUNNING\x10\x01\x12\r\n\tSUCCEEDED\x10\x02\x12\n\n\x06\x46\x41ILED\x10\x03\x12\x0e\n\nCANCELLING\x10\x04\x12\r\n\tCANCELLED\x10\x05"\xcb\x01\n\x16\x42\x61tchTranslateResponse\x12\x18\n\x10total_characters\x18\x01 \x01(\x03\x12\x1d\n\x15translated_characters\x18\x02 \x01(\x03\x12\x19\n\x11\x66\x61iled_characters\x18\x03 \x01(\x03\x12/\n\x0bsubmit_time\x18\x04 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12,\n\x08\x65nd_time\x18\x05 \x01(\x0b\x32\x1a.google.protobuf.Timestamp"b\n\x13GlossaryInputConfig\x12\x41\n\ngcs_source\x18\x01 \x01(\x0b\x32+.google.cloud.translation.v3beta1.GcsSourceH\x00\x42\x08\n\x06source"\x93\x04\n\x08Glossary\x12\x0c\n\x04name\x18\x01 \x01(\t\x12T\n\rlanguage_pair\x18\x03 \x01(\x0b\x32;.google.cloud.translation.v3beta1.Glossary.LanguageCodePairH\x00\x12Y\n\x12language_codes_set\x18\x04 \x01(\x0b\x32;.google.cloud.translation.v3beta1.Glossary.LanguageCodesSetH\x00\x12K\n\x0cinput_config\x18\x05 \x01(\x0b\x32\x35.google.cloud.translation.v3beta1.GlossaryInputConfig\x12\x13\n\x0b\x65ntry_count\x18\x06 \x01(\x05\x12/\n\x0bsubmit_time\x18\x07 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12,\n\x08\x65nd_time\x18\x08 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x1aN\n\x10LanguageCodePair\x12\x1c\n\x14source_language_code\x18\x01 \x01(\t\x12\x1c\n\x14target_language_code\x18\x02 \x01(\t\x1a*\n\x10LanguageCodesSet\x12\x16\n\x0elanguage_codes\x18\x01 \x03(\tB\x0b\n\tlanguages"e\n\x15\x43reateGlossaryRequest\x12\x0e\n\x06parent\x18\x01 \x01(\t\x12<\n\x08glossary\x18\x02 \x01(\x0b\x32*.google.cloud.translation.v3beta1.Glossary""\n\x12GetGlossaryRequest\x12\x0c\n\x04name\x18\x01 \x01(\t"%\n\x15\x44\x65leteGlossaryRequest\x12\x0c\n\x04name\x18\x01 \x01(\t"^\n\x15ListGlossariesRequest\x12\x0e\n\x06parent\x18\x01 \x01(\t\x12\x11\n\tpage_size\x18\x02 \x01(\x05\x12\x12\n\npage_token\x18\x03 \x01(\t\x12\x0e\n\x06\x66ilter\x18\x04 \x01(\t"q\n\x16ListGlossariesResponse\x12>\n\nglossaries\x18\x01 \x03(\x0b\x32*.google.cloud.translation.v3beta1.Glossary\x12\x17\n\x0fnext_page_token\x18\x02 \x01(\t"\x8d\x02\n\x16\x43reateGlossaryMetadata\x12\x0c\n\x04name\x18\x01 \x01(\t\x12M\n\x05state\x18\x02 \x01(\x0e\x32>.google.cloud.translation.v3beta1.CreateGlossaryMetadata.State\x12/\n\x0bsubmit_time\x18\x03 \x01(\x0b\x32\x1a.google.protobuf.Timestamp"e\n\x05State\x12\x15\n\x11STATE_UNSPECIFIED\x10\x00\x12\x0b\n\x07RUNNING\x10\x01\x12\r\n\tSUCCEEDED\x10\x02\x12\n\n\x06\x46\x41ILED\x10\x03\x12\x0e\n\nCANCELLING\x10\x04\x12\r\n\tCANCELLED\x10\x05"\x8d\x02\n\x16\x44\x65leteGlossaryMetadata\x12\x0c\n\x04name\x18\x01 \x01(\t\x12M\n\x05state\x18\x02 \x01(\x0e\x32>.google.cloud.translation.v3beta1.DeleteGlossaryMetadata.State\x12/\n\x0bsubmit_time\x18\x03 \x01(\x0b\x32\x1a.google.protobuf.Timestamp"e\n\x05State\x12\x15\n\x11STATE_UNSPECIFIED\x10\x00\x12\x0b\n\x07RUNNING\x10\x01\x12\r\n\tSUCCEEDED\x10\x02\x12\n\n\x06\x46\x41ILED\x10\x03\x12\x0e\n\nCANCELLING\x10\x04\x12\r\n\tCANCELLED\x10\x05"\x85\x01\n\x16\x44\x65leteGlossaryResponse\x12\x0c\n\x04name\x18\x01 \x01(\t\x12/\n\x0bsubmit_time\x18\x02 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12,\n\x08\x65nd_time\x18\x03 \x01(\x0b\x32\x1a.google.protobuf.Timestamp2\x80\x0c\n\x12TranslationService\x12\xc3\x01\n\rTranslateText\x12\x36.google.cloud.translation.v3beta1.TranslateTextRequest\x1a\x37.google.cloud.translation.v3beta1.TranslateTextResponse"A\x82\xd3\xe4\x93\x02;"6/v3beta1/{parent=projects/*/locations/*}:translateText:\x01*\x12\xc7\x01\n\x0e\x44\x65tectLanguage\x12\x37.google.cloud.translation.v3beta1.DetectLanguageRequest\x1a\x38.google.cloud.translation.v3beta1.DetectLanguageResponse"B\x82\xd3\xe4\x93\x02<"7/v3beta1/{parent=projects/*/locations/*}:detectLanguage:\x01*\x12\xd2\x01\n\x15GetSupportedLanguages\x12>.google.cloud.translation.v3beta1.GetSupportedLanguagesRequest\x1a\x34.google.cloud.translation.v3beta1.SupportedLanguages"C\x82\xd3\xe4\x93\x02=\x12;/v3beta1/{parent=projects/*/locations/*}/supportedLanguages\x12\xb8\x01\n\x12\x42\x61tchTranslateText\x12;.google.cloud.translation.v3beta1.BatchTranslateTextRequest\x1a\x1d.google.longrunning.Operation"F\x82\xd3\xe4\x93\x02@";/v3beta1/{parent=projects/*/locations/*}:batchTranslateText:\x01*\x12\xaf\x01\n\x0e\x43reateGlossary\x12\x37.google.cloud.translation.v3beta1.CreateGlossaryRequest\x1a\x1d.google.longrunning.Operation"E\x82\xd3\xe4\x93\x02?"3/v3beta1/{parent=projects/*/locations/*}/glossaries:\x08glossary\x12\xc0\x01\n\x0eListGlossaries\x12\x37.google.cloud.translation.v3beta1.ListGlossariesRequest\x1a\x38.google.cloud.translation.v3beta1.ListGlossariesResponse";\x82\xd3\xe4\x93\x02\x35\x12\x33/v3beta1/{parent=projects/*/locations/*}/glossaries\x12\xac\x01\n\x0bGetGlossary\x12\x34.google.cloud.translation.v3beta1.GetGlossaryRequest\x1a*.google.cloud.translation.v3beta1.Glossary";\x82\xd3\xe4\x93\x02\x35\x12\x33/v3beta1/{name=projects/*/locations/*/glossaries/*}\x12\xa5\x01\n\x0e\x44\x65leteGlossary\x12\x37.google.cloud.translation.v3beta1.DeleteGlossaryRequest\x1a\x1d.google.longrunning.Operation";\x82\xd3\xe4\x93\x02\x35*3/v3beta1/{name=projects/*/locations/*/glossaries/*}B\xf1\x01\n"com.google.cloud.translate.v3beta1B\x17TranslationServiceProtoP\x01ZGgoogle.golang.org/genproto/googleapis/cloud/translate/v3beta1;translate\xf8\x01\x01\xaa\x02\x1eGoogle.Cloud.Translate.V3Beta1\xca\x02\x1eGoogle\\Cloud\\Translate\\V3beta1\xea\x02!Google::Cloud::Translate::V3beta1b\x06proto3' + ), + dependencies=[ + google_dot_api_dot_annotations__pb2.DESCRIPTOR, + google_dot_longrunning_dot_operations__pb2.DESCRIPTOR, + google_dot_protobuf_dot_timestamp__pb2.DESCRIPTOR, + ], +) + + +_BATCHTRANSLATEMETADATA_STATE = _descriptor.EnumDescriptor( + name="State", + full_name="google.cloud.translation.v3beta1.BatchTranslateMetadata.State", + filename=None, + file=DESCRIPTOR, + values=[ + _descriptor.EnumValueDescriptor( + name="STATE_UNSPECIFIED", + index=0, + number=0, + serialized_options=None, + type=None, + ), + _descriptor.EnumValueDescriptor( + name="RUNNING", index=1, number=1, serialized_options=None, type=None + ), + _descriptor.EnumValueDescriptor( + name="SUCCEEDED", index=2, number=2, serialized_options=None, type=None + ), + _descriptor.EnumValueDescriptor( + name="FAILED", index=3, number=3, serialized_options=None, type=None + ), + _descriptor.EnumValueDescriptor( + name="CANCELLING", index=4, number=4, serialized_options=None, type=None + ), + _descriptor.EnumValueDescriptor( + name="CANCELLED", index=5, number=5, serialized_options=None, type=None + ), + ], + containing_type=None, + serialized_options=None, + serialized_start=2558, + serialized_end=2659, +) +_sym_db.RegisterEnumDescriptor(_BATCHTRANSLATEMETADATA_STATE) + +_CREATEGLOSSARYMETADATA_STATE = _descriptor.EnumDescriptor( + name="State", + full_name="google.cloud.translation.v3beta1.CreateGlossaryMetadata.State", + filename=None, + file=DESCRIPTOR, + values=[ + _descriptor.EnumValueDescriptor( + name="STATE_UNSPECIFIED", + index=0, + number=0, + serialized_options=None, + type=None, + ), + _descriptor.EnumValueDescriptor( + name="RUNNING", index=1, number=1, serialized_options=None, type=None + ), + _descriptor.EnumValueDescriptor( + name="SUCCEEDED", index=2, number=2, serialized_options=None, type=None + ), + _descriptor.EnumValueDescriptor( + name="FAILED", index=3, number=3, serialized_options=None, type=None + ), + _descriptor.EnumValueDescriptor( + name="CANCELLING", index=4, number=4, serialized_options=None, type=None + ), + _descriptor.EnumValueDescriptor( + name="CANCELLED", index=5, number=5, serialized_options=None, type=None + ), + ], + containing_type=None, + serialized_options=None, + serialized_start=2558, + serialized_end=2659, +) +_sym_db.RegisterEnumDescriptor(_CREATEGLOSSARYMETADATA_STATE) + +_DELETEGLOSSARYMETADATA_STATE = _descriptor.EnumDescriptor( + name="State", + full_name="google.cloud.translation.v3beta1.DeleteGlossaryMetadata.State", + filename=None, + file=DESCRIPTOR, + values=[ + _descriptor.EnumValueDescriptor( + name="STATE_UNSPECIFIED", + index=0, + number=0, + serialized_options=None, + type=None, + ), + _descriptor.EnumValueDescriptor( + name="RUNNING", index=1, number=1, serialized_options=None, type=None + ), + _descriptor.EnumValueDescriptor( + name="SUCCEEDED", index=2, number=2, serialized_options=None, type=None + ), + _descriptor.EnumValueDescriptor( + name="FAILED", index=3, number=3, serialized_options=None, type=None + ), + _descriptor.EnumValueDescriptor( + name="CANCELLING", index=4, number=4, serialized_options=None, type=None + ), + _descriptor.EnumValueDescriptor( + name="CANCELLED", index=5, number=5, serialized_options=None, type=None + ), + ], + containing_type=None, + serialized_options=None, + serialized_start=2558, + serialized_end=2659, +) +_sym_db.RegisterEnumDescriptor(_DELETEGLOSSARYMETADATA_STATE) + + +_TRANSLATETEXTGLOSSARYCONFIG = _descriptor.Descriptor( + name="TranslateTextGlossaryConfig", + full_name="google.cloud.translation.v3beta1.TranslateTextGlossaryConfig", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="glossary", + full_name="google.cloud.translation.v3beta1.TranslateTextGlossaryConfig.glossary", + index=0, + number=1, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="ignore_case", + full_name="google.cloud.translation.v3beta1.TranslateTextGlossaryConfig.ignore_case", + index=1, + number=2, + type=8, + cpp_type=7, + label=1, + has_default_value=False, + default_value=False, + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + ], + extensions=[], + nested_types=[], + enum_types=[], + serialized_options=None, + is_extendable=False, + syntax="proto3", + extension_ranges=[], + oneofs=[], + serialized_start=202, + serialized_end=270, +) + + +_TRANSLATETEXTREQUEST = _descriptor.Descriptor( + name="TranslateTextRequest", + full_name="google.cloud.translation.v3beta1.TranslateTextRequest", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="contents", + full_name="google.cloud.translation.v3beta1.TranslateTextRequest.contents", + index=0, + number=1, + type=9, + cpp_type=9, + label=3, + has_default_value=False, + default_value=[], + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="mime_type", + full_name="google.cloud.translation.v3beta1.TranslateTextRequest.mime_type", + index=1, + number=3, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="source_language_code", + full_name="google.cloud.translation.v3beta1.TranslateTextRequest.source_language_code", + index=2, + number=4, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="target_language_code", + full_name="google.cloud.translation.v3beta1.TranslateTextRequest.target_language_code", + index=3, + number=5, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="parent", + full_name="google.cloud.translation.v3beta1.TranslateTextRequest.parent", + index=4, + number=8, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="model", + full_name="google.cloud.translation.v3beta1.TranslateTextRequest.model", + index=5, + number=6, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="glossary_config", + full_name="google.cloud.translation.v3beta1.TranslateTextRequest.glossary_config", + index=6, + number=7, + type=11, + cpp_type=10, + label=1, + has_default_value=False, + default_value=None, + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + ], + extensions=[], + nested_types=[], + enum_types=[], + serialized_options=None, + is_extendable=False, + syntax="proto3", + extension_ranges=[], + oneofs=[], + serialized_start=273, + serialized_end=511, +) + + +_TRANSLATETEXTRESPONSE = _descriptor.Descriptor( + name="TranslateTextResponse", + full_name="google.cloud.translation.v3beta1.TranslateTextResponse", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="translations", + full_name="google.cloud.translation.v3beta1.TranslateTextResponse.translations", + index=0, + number=1, + type=11, + cpp_type=10, + label=3, + has_default_value=False, + default_value=[], + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="glossary_translations", + full_name="google.cloud.translation.v3beta1.TranslateTextResponse.glossary_translations", + index=1, + number=3, + type=11, + cpp_type=10, + label=3, + has_default_value=False, + default_value=[], + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + ], + extensions=[], + nested_types=[], + enum_types=[], + serialized_options=None, + is_extendable=False, + syntax="proto3", + extension_ranges=[], + oneofs=[], + serialized_start=514, + serialized_end=684, +) + + +_TRANSLATION = _descriptor.Descriptor( + name="Translation", + full_name="google.cloud.translation.v3beta1.Translation", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="translated_text", + full_name="google.cloud.translation.v3beta1.Translation.translated_text", + index=0, + number=1, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="model", + full_name="google.cloud.translation.v3beta1.Translation.model", + index=1, + number=2, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="detected_language_code", + full_name="google.cloud.translation.v3beta1.Translation.detected_language_code", + index=2, + number=4, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="glossary_config", + full_name="google.cloud.translation.v3beta1.Translation.glossary_config", + index=3, + number=3, + type=11, + cpp_type=10, + label=1, + has_default_value=False, + default_value=None, + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + ], + extensions=[], + nested_types=[], + enum_types=[], + serialized_options=None, + is_extendable=False, + syntax="proto3", + extension_ranges=[], + oneofs=[], + serialized_start=687, + serialized_end=860, +) + + +_DETECTLANGUAGEREQUEST = _descriptor.Descriptor( + name="DetectLanguageRequest", + full_name="google.cloud.translation.v3beta1.DetectLanguageRequest", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="parent", + full_name="google.cloud.translation.v3beta1.DetectLanguageRequest.parent", + index=0, + number=5, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="model", + full_name="google.cloud.translation.v3beta1.DetectLanguageRequest.model", + index=1, + number=4, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="content", + full_name="google.cloud.translation.v3beta1.DetectLanguageRequest.content", + index=2, + number=1, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="mime_type", + full_name="google.cloud.translation.v3beta1.DetectLanguageRequest.mime_type", + index=3, + number=3, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + ], + extensions=[], + nested_types=[], + enum_types=[], + serialized_options=None, + is_extendable=False, + syntax="proto3", + extension_ranges=[], + oneofs=[ + _descriptor.OneofDescriptor( + name="source", + full_name="google.cloud.translation.v3beta1.DetectLanguageRequest.source", + index=0, + containing_type=None, + fields=[], + ) + ], + serialized_start=862, + serialized_end=964, +) + + +_DETECTEDLANGUAGE = _descriptor.Descriptor( + name="DetectedLanguage", + full_name="google.cloud.translation.v3beta1.DetectedLanguage", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="language_code", + full_name="google.cloud.translation.v3beta1.DetectedLanguage.language_code", + index=0, + number=1, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="confidence", + full_name="google.cloud.translation.v3beta1.DetectedLanguage.confidence", + index=1, + number=2, + type=2, + cpp_type=6, + label=1, + has_default_value=False, + default_value=float(0), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + ], + extensions=[], + nested_types=[], + enum_types=[], + serialized_options=None, + is_extendable=False, + syntax="proto3", + extension_ranges=[], + oneofs=[], + serialized_start=966, + serialized_end=1027, +) + + +_DETECTLANGUAGERESPONSE = _descriptor.Descriptor( + name="DetectLanguageResponse", + full_name="google.cloud.translation.v3beta1.DetectLanguageResponse", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="languages", + full_name="google.cloud.translation.v3beta1.DetectLanguageResponse.languages", + index=0, + number=1, + type=11, + cpp_type=10, + label=3, + has_default_value=False, + default_value=[], + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ) + ], + extensions=[], + nested_types=[], + enum_types=[], + serialized_options=None, + is_extendable=False, + syntax="proto3", + extension_ranges=[], + oneofs=[], + serialized_start=1029, + serialized_end=1124, +) + + +_GETSUPPORTEDLANGUAGESREQUEST = _descriptor.Descriptor( + name="GetSupportedLanguagesRequest", + full_name="google.cloud.translation.v3beta1.GetSupportedLanguagesRequest", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="parent", + full_name="google.cloud.translation.v3beta1.GetSupportedLanguagesRequest.parent", + index=0, + number=3, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="display_language_code", + full_name="google.cloud.translation.v3beta1.GetSupportedLanguagesRequest.display_language_code", + index=1, + number=1, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="model", + full_name="google.cloud.translation.v3beta1.GetSupportedLanguagesRequest.model", + index=2, + number=2, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + ], + extensions=[], + nested_types=[], + enum_types=[], + serialized_options=None, + is_extendable=False, + syntax="proto3", + extension_ranges=[], + oneofs=[], + serialized_start=1126, + serialized_end=1218, +) + + +_SUPPORTEDLANGUAGES = _descriptor.Descriptor( + name="SupportedLanguages", + full_name="google.cloud.translation.v3beta1.SupportedLanguages", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="languages", + full_name="google.cloud.translation.v3beta1.SupportedLanguages.languages", + index=0, + number=1, + type=11, + cpp_type=10, + label=3, + has_default_value=False, + default_value=[], + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ) + ], + extensions=[], + nested_types=[], + enum_types=[], + serialized_options=None, + is_extendable=False, + syntax="proto3", + extension_ranges=[], + oneofs=[], + serialized_start=1220, + serialized_end=1312, +) + + +_SUPPORTEDLANGUAGE = _descriptor.Descriptor( + name="SupportedLanguage", + full_name="google.cloud.translation.v3beta1.SupportedLanguage", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="language_code", + full_name="google.cloud.translation.v3beta1.SupportedLanguage.language_code", + index=0, + number=1, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="display_name", + full_name="google.cloud.translation.v3beta1.SupportedLanguage.display_name", + index=1, + number=2, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="support_source", + full_name="google.cloud.translation.v3beta1.SupportedLanguage.support_source", + index=2, + number=3, + type=8, + cpp_type=7, + label=1, + has_default_value=False, + default_value=False, + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="support_target", + full_name="google.cloud.translation.v3beta1.SupportedLanguage.support_target", + index=3, + number=4, + type=8, + cpp_type=7, + label=1, + has_default_value=False, + default_value=False, + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + ], + extensions=[], + nested_types=[], + enum_types=[], + serialized_options=None, + is_extendable=False, + syntax="proto3", + extension_ranges=[], + oneofs=[], + serialized_start=1314, + serialized_end=1426, +) + + +_GCSSOURCE = _descriptor.Descriptor( + name="GcsSource", + full_name="google.cloud.translation.v3beta1.GcsSource", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="input_uri", + full_name="google.cloud.translation.v3beta1.GcsSource.input_uri", + index=0, + number=1, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ) + ], + extensions=[], + nested_types=[], + enum_types=[], + serialized_options=None, + is_extendable=False, + syntax="proto3", + extension_ranges=[], + oneofs=[], + serialized_start=1428, + serialized_end=1458, +) + + +_INPUTCONFIG = _descriptor.Descriptor( + name="InputConfig", + full_name="google.cloud.translation.v3beta1.InputConfig", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="mime_type", + full_name="google.cloud.translation.v3beta1.InputConfig.mime_type", + index=0, + number=1, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="gcs_source", + full_name="google.cloud.translation.v3beta1.InputConfig.gcs_source", + index=1, + number=2, + type=11, + cpp_type=10, + label=1, + has_default_value=False, + default_value=None, + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + ], + extensions=[], + nested_types=[], + enum_types=[], + serialized_options=None, + is_extendable=False, + syntax="proto3", + extension_ranges=[], + oneofs=[ + _descriptor.OneofDescriptor( + name="source", + full_name="google.cloud.translation.v3beta1.InputConfig.source", + index=0, + containing_type=None, + fields=[], + ) + ], + serialized_start=1460, + serialized_end=1569, +) + + +_GCSDESTINATION = _descriptor.Descriptor( + name="GcsDestination", + full_name="google.cloud.translation.v3beta1.GcsDestination", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="output_uri_prefix", + full_name="google.cloud.translation.v3beta1.GcsDestination.output_uri_prefix", + index=0, + number=1, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ) + ], + extensions=[], + nested_types=[], + enum_types=[], + serialized_options=None, + is_extendable=False, + syntax="proto3", + extension_ranges=[], + oneofs=[], + serialized_start=1571, + serialized_end=1614, +) + + +_OUTPUTCONFIG = _descriptor.Descriptor( + name="OutputConfig", + full_name="google.cloud.translation.v3beta1.OutputConfig", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="gcs_destination", + full_name="google.cloud.translation.v3beta1.OutputConfig.gcs_destination", + index=0, + number=1, + type=11, + cpp_type=10, + label=1, + has_default_value=False, + default_value=None, + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ) + ], + extensions=[], + nested_types=[], + enum_types=[], + serialized_options=None, + is_extendable=False, + syntax="proto3", + extension_ranges=[], + oneofs=[ + _descriptor.OneofDescriptor( + name="destination", + full_name="google.cloud.translation.v3beta1.OutputConfig.destination", + index=0, + containing_type=None, + fields=[], + ) + ], + serialized_start=1616, + serialized_end=1722, +) + + +_BATCHTRANSLATETEXTREQUEST_MODELSENTRY = _descriptor.Descriptor( + name="ModelsEntry", + full_name="google.cloud.translation.v3beta1.BatchTranslateTextRequest.ModelsEntry", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="key", + full_name="google.cloud.translation.v3beta1.BatchTranslateTextRequest.ModelsEntry.key", + index=0, + number=1, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="value", + full_name="google.cloud.translation.v3beta1.BatchTranslateTextRequest.ModelsEntry.value", + index=1, + number=2, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + ], + extensions=[], + nested_types=[], + enum_types=[], + serialized_options=_b("8\001"), + is_extendable=False, + syntax="proto3", + extension_ranges=[], + oneofs=[], + serialized_start=2158, + serialized_end=2203, +) + +_BATCHTRANSLATETEXTREQUEST_GLOSSARIESENTRY = _descriptor.Descriptor( + name="GlossariesEntry", + full_name="google.cloud.translation.v3beta1.BatchTranslateTextRequest.GlossariesEntry", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="key", + full_name="google.cloud.translation.v3beta1.BatchTranslateTextRequest.GlossariesEntry.key", + index=0, + number=1, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="value", + full_name="google.cloud.translation.v3beta1.BatchTranslateTextRequest.GlossariesEntry.value", + index=1, + number=2, + type=11, + cpp_type=10, + label=1, + has_default_value=False, + default_value=None, + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + ], + extensions=[], + nested_types=[], + enum_types=[], + serialized_options=_b("8\001"), + is_extendable=False, + syntax="proto3", + extension_ranges=[], + oneofs=[], + serialized_start=2205, + serialized_end=2317, +) + +_BATCHTRANSLATETEXTREQUEST = _descriptor.Descriptor( + name="BatchTranslateTextRequest", + full_name="google.cloud.translation.v3beta1.BatchTranslateTextRequest", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="parent", + full_name="google.cloud.translation.v3beta1.BatchTranslateTextRequest.parent", + index=0, + number=1, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="source_language_code", + full_name="google.cloud.translation.v3beta1.BatchTranslateTextRequest.source_language_code", + index=1, + number=2, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="target_language_codes", + full_name="google.cloud.translation.v3beta1.BatchTranslateTextRequest.target_language_codes", + index=2, + number=3, + type=9, + cpp_type=9, + label=3, + has_default_value=False, + default_value=[], + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="models", + full_name="google.cloud.translation.v3beta1.BatchTranslateTextRequest.models", + index=3, + number=4, + type=11, + cpp_type=10, + label=3, + has_default_value=False, + default_value=[], + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="input_configs", + full_name="google.cloud.translation.v3beta1.BatchTranslateTextRequest.input_configs", + index=4, + number=5, + type=11, + cpp_type=10, + label=3, + has_default_value=False, + default_value=[], + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="output_config", + full_name="google.cloud.translation.v3beta1.BatchTranslateTextRequest.output_config", + index=5, + number=6, + type=11, + cpp_type=10, + label=1, + has_default_value=False, + default_value=None, + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="glossaries", + full_name="google.cloud.translation.v3beta1.BatchTranslateTextRequest.glossaries", + index=6, + number=7, + type=11, + cpp_type=10, + label=3, + has_default_value=False, + default_value=[], + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + ], + extensions=[], + nested_types=[ + _BATCHTRANSLATETEXTREQUEST_MODELSENTRY, + _BATCHTRANSLATETEXTREQUEST_GLOSSARIESENTRY, + ], + enum_types=[], + serialized_options=None, + is_extendable=False, + syntax="proto3", + extension_ranges=[], + oneofs=[], + serialized_start=1725, + serialized_end=2317, +) + + +_BATCHTRANSLATEMETADATA = _descriptor.Descriptor( + name="BatchTranslateMetadata", + full_name="google.cloud.translation.v3beta1.BatchTranslateMetadata", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="state", + full_name="google.cloud.translation.v3beta1.BatchTranslateMetadata.state", + index=0, + number=1, + type=14, + cpp_type=8, + label=1, + has_default_value=False, + default_value=0, + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="translated_characters", + full_name="google.cloud.translation.v3beta1.BatchTranslateMetadata.translated_characters", + index=1, + number=2, + type=3, + cpp_type=2, + label=1, + has_default_value=False, + default_value=0, + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="failed_characters", + full_name="google.cloud.translation.v3beta1.BatchTranslateMetadata.failed_characters", + index=2, + number=3, + type=3, + cpp_type=2, + label=1, + has_default_value=False, + default_value=0, + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="total_characters", + full_name="google.cloud.translation.v3beta1.BatchTranslateMetadata.total_characters", + index=3, + number=4, + type=3, + cpp_type=2, + label=1, + has_default_value=False, + default_value=0, + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="submit_time", + full_name="google.cloud.translation.v3beta1.BatchTranslateMetadata.submit_time", + index=4, + number=5, + type=11, + cpp_type=10, + label=1, + has_default_value=False, + default_value=None, + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + ], + extensions=[], + nested_types=[], + enum_types=[_BATCHTRANSLATEMETADATA_STATE], + serialized_options=None, + is_extendable=False, + syntax="proto3", + extension_ranges=[], + oneofs=[], + serialized_start=2320, + serialized_end=2659, +) + + +_BATCHTRANSLATERESPONSE = _descriptor.Descriptor( + name="BatchTranslateResponse", + full_name="google.cloud.translation.v3beta1.BatchTranslateResponse", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="total_characters", + full_name="google.cloud.translation.v3beta1.BatchTranslateResponse.total_characters", + index=0, + number=1, + type=3, + cpp_type=2, + label=1, + has_default_value=False, + default_value=0, + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="translated_characters", + full_name="google.cloud.translation.v3beta1.BatchTranslateResponse.translated_characters", + index=1, + number=2, + type=3, + cpp_type=2, + label=1, + has_default_value=False, + default_value=0, + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="failed_characters", + full_name="google.cloud.translation.v3beta1.BatchTranslateResponse.failed_characters", + index=2, + number=3, + type=3, + cpp_type=2, + label=1, + has_default_value=False, + default_value=0, + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="submit_time", + full_name="google.cloud.translation.v3beta1.BatchTranslateResponse.submit_time", + index=3, + number=4, + type=11, + cpp_type=10, + label=1, + has_default_value=False, + default_value=None, + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="end_time", + full_name="google.cloud.translation.v3beta1.BatchTranslateResponse.end_time", + index=4, + number=5, + type=11, + cpp_type=10, + label=1, + has_default_value=False, + default_value=None, + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + ], + extensions=[], + nested_types=[], + enum_types=[], + serialized_options=None, + is_extendable=False, + syntax="proto3", + extension_ranges=[], + oneofs=[], + serialized_start=2662, + serialized_end=2865, +) + + +_GLOSSARYINPUTCONFIG = _descriptor.Descriptor( + name="GlossaryInputConfig", + full_name="google.cloud.translation.v3beta1.GlossaryInputConfig", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="gcs_source", + full_name="google.cloud.translation.v3beta1.GlossaryInputConfig.gcs_source", + index=0, + number=1, + type=11, + cpp_type=10, + label=1, + has_default_value=False, + default_value=None, + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ) + ], + extensions=[], + nested_types=[], + enum_types=[], + serialized_options=None, + is_extendable=False, + syntax="proto3", + extension_ranges=[], + oneofs=[ + _descriptor.OneofDescriptor( + name="source", + full_name="google.cloud.translation.v3beta1.GlossaryInputConfig.source", + index=0, + containing_type=None, + fields=[], + ) + ], + serialized_start=2867, + serialized_end=2965, +) + + +_GLOSSARY_LANGUAGECODEPAIR = _descriptor.Descriptor( + name="LanguageCodePair", + full_name="google.cloud.translation.v3beta1.Glossary.LanguageCodePair", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="source_language_code", + full_name="google.cloud.translation.v3beta1.Glossary.LanguageCodePair.source_language_code", + index=0, + number=1, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="target_language_code", + full_name="google.cloud.translation.v3beta1.Glossary.LanguageCodePair.target_language_code", + index=1, + number=2, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + ], + extensions=[], + nested_types=[], + enum_types=[], + serialized_options=None, + is_extendable=False, + syntax="proto3", + extension_ranges=[], + oneofs=[], + serialized_start=3364, + serialized_end=3442, +) + +_GLOSSARY_LANGUAGECODESSET = _descriptor.Descriptor( + name="LanguageCodesSet", + full_name="google.cloud.translation.v3beta1.Glossary.LanguageCodesSet", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="language_codes", + full_name="google.cloud.translation.v3beta1.Glossary.LanguageCodesSet.language_codes", + index=0, + number=1, + type=9, + cpp_type=9, + label=3, + has_default_value=False, + default_value=[], + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ) + ], + extensions=[], + nested_types=[], + enum_types=[], + serialized_options=None, + is_extendable=False, + syntax="proto3", + extension_ranges=[], + oneofs=[], + serialized_start=3444, + serialized_end=3486, +) + +_GLOSSARY = _descriptor.Descriptor( + name="Glossary", + full_name="google.cloud.translation.v3beta1.Glossary", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="name", + full_name="google.cloud.translation.v3beta1.Glossary.name", + index=0, + number=1, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="language_pair", + full_name="google.cloud.translation.v3beta1.Glossary.language_pair", + index=1, + number=3, + type=11, + cpp_type=10, + label=1, + has_default_value=False, + default_value=None, + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="language_codes_set", + full_name="google.cloud.translation.v3beta1.Glossary.language_codes_set", + index=2, + number=4, + type=11, + cpp_type=10, + label=1, + has_default_value=False, + default_value=None, + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="input_config", + full_name="google.cloud.translation.v3beta1.Glossary.input_config", + index=3, + number=5, + type=11, + cpp_type=10, + label=1, + has_default_value=False, + default_value=None, + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="entry_count", + full_name="google.cloud.translation.v3beta1.Glossary.entry_count", + index=4, + number=6, + type=5, + cpp_type=1, + label=1, + has_default_value=False, + default_value=0, + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="submit_time", + full_name="google.cloud.translation.v3beta1.Glossary.submit_time", + index=5, + number=7, + type=11, + cpp_type=10, + label=1, + has_default_value=False, + default_value=None, + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="end_time", + full_name="google.cloud.translation.v3beta1.Glossary.end_time", + index=6, + number=8, + type=11, + cpp_type=10, + label=1, + has_default_value=False, + default_value=None, + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + ], + extensions=[], + nested_types=[_GLOSSARY_LANGUAGECODEPAIR, _GLOSSARY_LANGUAGECODESSET], + enum_types=[], + serialized_options=None, + is_extendable=False, + syntax="proto3", + extension_ranges=[], + oneofs=[ + _descriptor.OneofDescriptor( + name="languages", + full_name="google.cloud.translation.v3beta1.Glossary.languages", + index=0, + containing_type=None, + fields=[], + ) + ], + serialized_start=2968, + serialized_end=3499, +) + + +_CREATEGLOSSARYREQUEST = _descriptor.Descriptor( + name="CreateGlossaryRequest", + full_name="google.cloud.translation.v3beta1.CreateGlossaryRequest", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="parent", + full_name="google.cloud.translation.v3beta1.CreateGlossaryRequest.parent", + index=0, + number=1, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="glossary", + full_name="google.cloud.translation.v3beta1.CreateGlossaryRequest.glossary", + index=1, + number=2, + type=11, + cpp_type=10, + label=1, + has_default_value=False, + default_value=None, + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + ], + extensions=[], + nested_types=[], + enum_types=[], + serialized_options=None, + is_extendable=False, + syntax="proto3", + extension_ranges=[], + oneofs=[], + serialized_start=3501, + serialized_end=3602, +) + + +_GETGLOSSARYREQUEST = _descriptor.Descriptor( + name="GetGlossaryRequest", + full_name="google.cloud.translation.v3beta1.GetGlossaryRequest", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="name", + full_name="google.cloud.translation.v3beta1.GetGlossaryRequest.name", + index=0, + number=1, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ) + ], + extensions=[], + nested_types=[], + enum_types=[], + serialized_options=None, + is_extendable=False, + syntax="proto3", + extension_ranges=[], + oneofs=[], + serialized_start=3604, + serialized_end=3638, +) + + +_DELETEGLOSSARYREQUEST = _descriptor.Descriptor( + name="DeleteGlossaryRequest", + full_name="google.cloud.translation.v3beta1.DeleteGlossaryRequest", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="name", + full_name="google.cloud.translation.v3beta1.DeleteGlossaryRequest.name", + index=0, + number=1, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ) + ], + extensions=[], + nested_types=[], + enum_types=[], + serialized_options=None, + is_extendable=False, + syntax="proto3", + extension_ranges=[], + oneofs=[], + serialized_start=3640, + serialized_end=3677, +) + + +_LISTGLOSSARIESREQUEST = _descriptor.Descriptor( + name="ListGlossariesRequest", + full_name="google.cloud.translation.v3beta1.ListGlossariesRequest", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="parent", + full_name="google.cloud.translation.v3beta1.ListGlossariesRequest.parent", + index=0, + number=1, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="page_size", + full_name="google.cloud.translation.v3beta1.ListGlossariesRequest.page_size", + index=1, + number=2, + type=5, + cpp_type=1, + label=1, + has_default_value=False, + default_value=0, + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="page_token", + full_name="google.cloud.translation.v3beta1.ListGlossariesRequest.page_token", + index=2, + number=3, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="filter", + full_name="google.cloud.translation.v3beta1.ListGlossariesRequest.filter", + index=3, + number=4, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + ], + extensions=[], + nested_types=[], + enum_types=[], + serialized_options=None, + is_extendable=False, + syntax="proto3", + extension_ranges=[], + oneofs=[], + serialized_start=3679, + serialized_end=3773, +) + + +_LISTGLOSSARIESRESPONSE = _descriptor.Descriptor( + name="ListGlossariesResponse", + full_name="google.cloud.translation.v3beta1.ListGlossariesResponse", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="glossaries", + full_name="google.cloud.translation.v3beta1.ListGlossariesResponse.glossaries", + index=0, + number=1, + type=11, + cpp_type=10, + label=3, + has_default_value=False, + default_value=[], + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="next_page_token", + full_name="google.cloud.translation.v3beta1.ListGlossariesResponse.next_page_token", + index=1, + number=2, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + ], + extensions=[], + nested_types=[], + enum_types=[], + serialized_options=None, + is_extendable=False, + syntax="proto3", + extension_ranges=[], + oneofs=[], + serialized_start=3775, + serialized_end=3888, +) + + +_CREATEGLOSSARYMETADATA = _descriptor.Descriptor( + name="CreateGlossaryMetadata", + full_name="google.cloud.translation.v3beta1.CreateGlossaryMetadata", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="name", + full_name="google.cloud.translation.v3beta1.CreateGlossaryMetadata.name", + index=0, + number=1, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="state", + full_name="google.cloud.translation.v3beta1.CreateGlossaryMetadata.state", + index=1, + number=2, + type=14, + cpp_type=8, + label=1, + has_default_value=False, + default_value=0, + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="submit_time", + full_name="google.cloud.translation.v3beta1.CreateGlossaryMetadata.submit_time", + index=2, + number=3, + type=11, + cpp_type=10, + label=1, + has_default_value=False, + default_value=None, + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + ], + extensions=[], + nested_types=[], + enum_types=[_CREATEGLOSSARYMETADATA_STATE], + serialized_options=None, + is_extendable=False, + syntax="proto3", + extension_ranges=[], + oneofs=[], + serialized_start=3891, + serialized_end=4160, +) + + +_DELETEGLOSSARYMETADATA = _descriptor.Descriptor( + name="DeleteGlossaryMetadata", + full_name="google.cloud.translation.v3beta1.DeleteGlossaryMetadata", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="name", + full_name="google.cloud.translation.v3beta1.DeleteGlossaryMetadata.name", + index=0, + number=1, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="state", + full_name="google.cloud.translation.v3beta1.DeleteGlossaryMetadata.state", + index=1, + number=2, + type=14, + cpp_type=8, + label=1, + has_default_value=False, + default_value=0, + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="submit_time", + full_name="google.cloud.translation.v3beta1.DeleteGlossaryMetadata.submit_time", + index=2, + number=3, + type=11, + cpp_type=10, + label=1, + has_default_value=False, + default_value=None, + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + ], + extensions=[], + nested_types=[], + enum_types=[_DELETEGLOSSARYMETADATA_STATE], + serialized_options=None, + is_extendable=False, + syntax="proto3", + extension_ranges=[], + oneofs=[], + serialized_start=4163, + serialized_end=4432, +) + + +_DELETEGLOSSARYRESPONSE = _descriptor.Descriptor( + name="DeleteGlossaryResponse", + full_name="google.cloud.translation.v3beta1.DeleteGlossaryResponse", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="name", + full_name="google.cloud.translation.v3beta1.DeleteGlossaryResponse.name", + index=0, + number=1, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="submit_time", + full_name="google.cloud.translation.v3beta1.DeleteGlossaryResponse.submit_time", + index=1, + number=2, + type=11, + cpp_type=10, + label=1, + has_default_value=False, + default_value=None, + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="end_time", + full_name="google.cloud.translation.v3beta1.DeleteGlossaryResponse.end_time", + index=2, + number=3, + type=11, + cpp_type=10, + label=1, + has_default_value=False, + default_value=None, + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + ], + extensions=[], + nested_types=[], + enum_types=[], + serialized_options=None, + is_extendable=False, + syntax="proto3", + extension_ranges=[], + oneofs=[], + serialized_start=4435, + serialized_end=4568, +) + +_TRANSLATETEXTREQUEST.fields_by_name[ + "glossary_config" +].message_type = _TRANSLATETEXTGLOSSARYCONFIG +_TRANSLATETEXTRESPONSE.fields_by_name["translations"].message_type = _TRANSLATION +_TRANSLATETEXTRESPONSE.fields_by_name[ + "glossary_translations" +].message_type = _TRANSLATION +_TRANSLATION.fields_by_name[ + "glossary_config" +].message_type = _TRANSLATETEXTGLOSSARYCONFIG +_DETECTLANGUAGEREQUEST.oneofs_by_name["source"].fields.append( + _DETECTLANGUAGEREQUEST.fields_by_name["content"] +) +_DETECTLANGUAGEREQUEST.fields_by_name[ + "content" +].containing_oneof = _DETECTLANGUAGEREQUEST.oneofs_by_name["source"] +_DETECTLANGUAGERESPONSE.fields_by_name["languages"].message_type = _DETECTEDLANGUAGE +_SUPPORTEDLANGUAGES.fields_by_name["languages"].message_type = _SUPPORTEDLANGUAGE +_INPUTCONFIG.fields_by_name["gcs_source"].message_type = _GCSSOURCE +_INPUTCONFIG.oneofs_by_name["source"].fields.append( + _INPUTCONFIG.fields_by_name["gcs_source"] +) +_INPUTCONFIG.fields_by_name[ + "gcs_source" +].containing_oneof = _INPUTCONFIG.oneofs_by_name["source"] +_OUTPUTCONFIG.fields_by_name["gcs_destination"].message_type = _GCSDESTINATION +_OUTPUTCONFIG.oneofs_by_name["destination"].fields.append( + _OUTPUTCONFIG.fields_by_name["gcs_destination"] +) +_OUTPUTCONFIG.fields_by_name[ + "gcs_destination" +].containing_oneof = _OUTPUTCONFIG.oneofs_by_name["destination"] +_BATCHTRANSLATETEXTREQUEST_MODELSENTRY.containing_type = _BATCHTRANSLATETEXTREQUEST +_BATCHTRANSLATETEXTREQUEST_GLOSSARIESENTRY.fields_by_name[ + "value" +].message_type = _TRANSLATETEXTGLOSSARYCONFIG +_BATCHTRANSLATETEXTREQUEST_GLOSSARIESENTRY.containing_type = _BATCHTRANSLATETEXTREQUEST +_BATCHTRANSLATETEXTREQUEST.fields_by_name[ + "models" +].message_type = _BATCHTRANSLATETEXTREQUEST_MODELSENTRY +_BATCHTRANSLATETEXTREQUEST.fields_by_name["input_configs"].message_type = _INPUTCONFIG +_BATCHTRANSLATETEXTREQUEST.fields_by_name["output_config"].message_type = _OUTPUTCONFIG +_BATCHTRANSLATETEXTREQUEST.fields_by_name[ + "glossaries" +].message_type = _BATCHTRANSLATETEXTREQUEST_GLOSSARIESENTRY +_BATCHTRANSLATEMETADATA.fields_by_name[ + "state" +].enum_type = _BATCHTRANSLATEMETADATA_STATE +_BATCHTRANSLATEMETADATA.fields_by_name[ + "submit_time" +].message_type = google_dot_protobuf_dot_timestamp__pb2._TIMESTAMP +_BATCHTRANSLATEMETADATA_STATE.containing_type = _BATCHTRANSLATEMETADATA +_BATCHTRANSLATERESPONSE.fields_by_name[ + "submit_time" +].message_type = google_dot_protobuf_dot_timestamp__pb2._TIMESTAMP +_BATCHTRANSLATERESPONSE.fields_by_name[ + "end_time" +].message_type = google_dot_protobuf_dot_timestamp__pb2._TIMESTAMP +_GLOSSARYINPUTCONFIG.fields_by_name["gcs_source"].message_type = _GCSSOURCE +_GLOSSARYINPUTCONFIG.oneofs_by_name["source"].fields.append( + _GLOSSARYINPUTCONFIG.fields_by_name["gcs_source"] +) +_GLOSSARYINPUTCONFIG.fields_by_name[ + "gcs_source" +].containing_oneof = _GLOSSARYINPUTCONFIG.oneofs_by_name["source"] +_GLOSSARY_LANGUAGECODEPAIR.containing_type = _GLOSSARY +_GLOSSARY_LANGUAGECODESSET.containing_type = _GLOSSARY +_GLOSSARY.fields_by_name["language_pair"].message_type = _GLOSSARY_LANGUAGECODEPAIR +_GLOSSARY.fields_by_name["language_codes_set"].message_type = _GLOSSARY_LANGUAGECODESSET +_GLOSSARY.fields_by_name["input_config"].message_type = _GLOSSARYINPUTCONFIG +_GLOSSARY.fields_by_name[ + "submit_time" +].message_type = google_dot_protobuf_dot_timestamp__pb2._TIMESTAMP +_GLOSSARY.fields_by_name[ + "end_time" +].message_type = google_dot_protobuf_dot_timestamp__pb2._TIMESTAMP +_GLOSSARY.oneofs_by_name["languages"].fields.append( + _GLOSSARY.fields_by_name["language_pair"] +) +_GLOSSARY.fields_by_name["language_pair"].containing_oneof = _GLOSSARY.oneofs_by_name[ + "languages" +] +_GLOSSARY.oneofs_by_name["languages"].fields.append( + _GLOSSARY.fields_by_name["language_codes_set"] +) +_GLOSSARY.fields_by_name[ + "language_codes_set" +].containing_oneof = _GLOSSARY.oneofs_by_name["languages"] +_CREATEGLOSSARYREQUEST.fields_by_name["glossary"].message_type = _GLOSSARY +_LISTGLOSSARIESRESPONSE.fields_by_name["glossaries"].message_type = _GLOSSARY +_CREATEGLOSSARYMETADATA.fields_by_name[ + "state" +].enum_type = _CREATEGLOSSARYMETADATA_STATE +_CREATEGLOSSARYMETADATA.fields_by_name[ + "submit_time" +].message_type = google_dot_protobuf_dot_timestamp__pb2._TIMESTAMP +_CREATEGLOSSARYMETADATA_STATE.containing_type = _CREATEGLOSSARYMETADATA +_DELETEGLOSSARYMETADATA.fields_by_name[ + "state" +].enum_type = _DELETEGLOSSARYMETADATA_STATE +_DELETEGLOSSARYMETADATA.fields_by_name[ + "submit_time" +].message_type = google_dot_protobuf_dot_timestamp__pb2._TIMESTAMP +_DELETEGLOSSARYMETADATA_STATE.containing_type = _DELETEGLOSSARYMETADATA +_DELETEGLOSSARYRESPONSE.fields_by_name[ + "submit_time" +].message_type = google_dot_protobuf_dot_timestamp__pb2._TIMESTAMP +_DELETEGLOSSARYRESPONSE.fields_by_name[ + "end_time" +].message_type = google_dot_protobuf_dot_timestamp__pb2._TIMESTAMP +DESCRIPTOR.message_types_by_name[ + "TranslateTextGlossaryConfig" +] = _TRANSLATETEXTGLOSSARYCONFIG +DESCRIPTOR.message_types_by_name["TranslateTextRequest"] = _TRANSLATETEXTREQUEST +DESCRIPTOR.message_types_by_name["TranslateTextResponse"] = _TRANSLATETEXTRESPONSE +DESCRIPTOR.message_types_by_name["Translation"] = _TRANSLATION +DESCRIPTOR.message_types_by_name["DetectLanguageRequest"] = _DETECTLANGUAGEREQUEST +DESCRIPTOR.message_types_by_name["DetectedLanguage"] = _DETECTEDLANGUAGE +DESCRIPTOR.message_types_by_name["DetectLanguageResponse"] = _DETECTLANGUAGERESPONSE +DESCRIPTOR.message_types_by_name[ + "GetSupportedLanguagesRequest" +] = _GETSUPPORTEDLANGUAGESREQUEST +DESCRIPTOR.message_types_by_name["SupportedLanguages"] = _SUPPORTEDLANGUAGES +DESCRIPTOR.message_types_by_name["SupportedLanguage"] = _SUPPORTEDLANGUAGE +DESCRIPTOR.message_types_by_name["GcsSource"] = _GCSSOURCE +DESCRIPTOR.message_types_by_name["InputConfig"] = _INPUTCONFIG +DESCRIPTOR.message_types_by_name["GcsDestination"] = _GCSDESTINATION +DESCRIPTOR.message_types_by_name["OutputConfig"] = _OUTPUTCONFIG +DESCRIPTOR.message_types_by_name[ + "BatchTranslateTextRequest" +] = _BATCHTRANSLATETEXTREQUEST +DESCRIPTOR.message_types_by_name["BatchTranslateMetadata"] = _BATCHTRANSLATEMETADATA +DESCRIPTOR.message_types_by_name["BatchTranslateResponse"] = _BATCHTRANSLATERESPONSE +DESCRIPTOR.message_types_by_name["GlossaryInputConfig"] = _GLOSSARYINPUTCONFIG +DESCRIPTOR.message_types_by_name["Glossary"] = _GLOSSARY +DESCRIPTOR.message_types_by_name["CreateGlossaryRequest"] = _CREATEGLOSSARYREQUEST +DESCRIPTOR.message_types_by_name["GetGlossaryRequest"] = _GETGLOSSARYREQUEST +DESCRIPTOR.message_types_by_name["DeleteGlossaryRequest"] = _DELETEGLOSSARYREQUEST +DESCRIPTOR.message_types_by_name["ListGlossariesRequest"] = _LISTGLOSSARIESREQUEST +DESCRIPTOR.message_types_by_name["ListGlossariesResponse"] = _LISTGLOSSARIESRESPONSE +DESCRIPTOR.message_types_by_name["CreateGlossaryMetadata"] = _CREATEGLOSSARYMETADATA +DESCRIPTOR.message_types_by_name["DeleteGlossaryMetadata"] = _DELETEGLOSSARYMETADATA +DESCRIPTOR.message_types_by_name["DeleteGlossaryResponse"] = _DELETEGLOSSARYRESPONSE +_sym_db.RegisterFileDescriptor(DESCRIPTOR) + +TranslateTextGlossaryConfig = _reflection.GeneratedProtocolMessageType( + "TranslateTextGlossaryConfig", + (_message.Message,), + dict( + DESCRIPTOR=_TRANSLATETEXTGLOSSARYCONFIG, + __module__="google.cloud.translation_v3beta1.proto.translation_service_pb2", + __doc__="""Configures which glossary should be used for a specific target language, + and defines options for applying that glossary. + + + Attributes: + glossary: + Required. Specifies the glossary used for this translation. + Use this format: projects/\ */locations/*/glossaries/\* + ignore_case: + Optional. Indicates whether we should do a case-insensitive + match. Default value is false if missing. + """, + # @@protoc_insertion_point(class_scope:google.cloud.translation.v3beta1.TranslateTextGlossaryConfig) + ), +) +_sym_db.RegisterMessage(TranslateTextGlossaryConfig) + +TranslateTextRequest = _reflection.GeneratedProtocolMessageType( + "TranslateTextRequest", + (_message.Message,), + dict( + DESCRIPTOR=_TRANSLATETEXTREQUEST, + __module__="google.cloud.translation_v3beta1.proto.translation_service_pb2", + __doc__="""The request message for synchronous translation. + + + Attributes: + contents: + Required. The content of the input in string format. We + recommend the total contents to be less than 30k codepoints. + Please use BatchTranslateText for larger text. + mime_type: + Optional. The format of the source text, for example, + "text/html", "text/plain". If left blank, the MIME type is + assumed to be "text/html". + source_language_code: + Optional. The BCP-47 language code of the input text if known, + for example, "en-US" or "sr-Latn". Supported language codes + are listed in Language Support. If the source language isn't + specified, the API attempts to identify the source language + automatically and returns the the source language within the + response. + target_language_code: + Required. The BCP-47 language code to use for translation of + the input text, set to one of the language codes listed in + Language Support. + parent: + Optional. Only used when making regionalized call. Format: + projects/{project-id}/locations/{location-id}. Only custom + model/glossary within the same location-id can be used. + Otherwise 400 is returned. + model: + Optional. The ``model`` type requested for this translation. + The format depends on model type: 1. Custom models: + projects/{project-id}/locations/{location-id}/models/{model- + id}. 2. General (built-in) models: projects/{project- + id}/locations/{location-id}/models/general/nmt + projects/{project-id}/locations/{location- + id}/models/general/base For global (non-regionalized) + requests, use {location-id} 'global'. For example, + projects/{project-id}/locations/global/models/general/nmt If + missing, the system decides which google base model to use. + glossary_config: + Optional. Glossary to be applied. The glossary needs to be in + the same region as the model, otherwise an INVALID\_ARGUMENT + error is returned. + """, + # @@protoc_insertion_point(class_scope:google.cloud.translation.v3beta1.TranslateTextRequest) + ), +) +_sym_db.RegisterMessage(TranslateTextRequest) + +TranslateTextResponse = _reflection.GeneratedProtocolMessageType( + "TranslateTextResponse", + (_message.Message,), + dict( + DESCRIPTOR=_TRANSLATETEXTRESPONSE, + __module__="google.cloud.translation_v3beta1.proto.translation_service_pb2", + __doc__="""The main language translation response message. + + + Attributes: + translations: + Text translation responses with no glossary applied. This + field has the same length as ``contents`` in + TranslateTextRequest. + glossary_translations: + Text translation responses if a glossary is provided in the + request. This could be the same as 'translation' above if no + terms apply. This field has the same length as ``contents`` in + TranslateTextRequest. + """, + # @@protoc_insertion_point(class_scope:google.cloud.translation.v3beta1.TranslateTextResponse) + ), +) +_sym_db.RegisterMessage(TranslateTextResponse) + +Translation = _reflection.GeneratedProtocolMessageType( + "Translation", + (_message.Message,), + dict( + DESCRIPTOR=_TRANSLATION, + __module__="google.cloud.translation_v3beta1.proto.translation_service_pb2", + __doc__="""A single translation response. + + + Attributes: + translated_text: + Text translated into the target language. + model: + Only present when ``model`` is present in the request. This is + same as ``model`` provided in the request. + detected_language_code: + The BCP-47 language code of source text in the initial + request, detected automatically, if no source language was + passed within the initial request. If the source language was + passed, auto-detection of the language does not occur and this + field will be empty. + glossary_config: + The ``glossary_config`` used for this translation. + """, + # @@protoc_insertion_point(class_scope:google.cloud.translation.v3beta1.Translation) + ), +) +_sym_db.RegisterMessage(Translation) + +DetectLanguageRequest = _reflection.GeneratedProtocolMessageType( + "DetectLanguageRequest", + (_message.Message,), + dict( + DESCRIPTOR=_DETECTLANGUAGEREQUEST, + __module__="google.cloud.translation_v3beta1.proto.translation_service_pb2", + __doc__="""The request message for language detection. + + + Attributes: + parent: + Optional. Only used when making regionalized call. Format: + projects/{project-id}/locations/{location-id}. Only custom + model within the same location-id can be used. Otherwise 400 + is returned. + model: + Optional. The language detection model to be used. + projects/{project-id}/locations/{location-id}/models/language- + detection/{model-id} If not specified, default will be used. + source: + Required. The source of the document from which to detect the + language. + content: + The content of the input stored as a string. + mime_type: + Optional. The format of the source text, for example, + "text/html", "text/plain". If left blank, the MIME type is + assumed to be "text/html". + """, + # @@protoc_insertion_point(class_scope:google.cloud.translation.v3beta1.DetectLanguageRequest) + ), +) +_sym_db.RegisterMessage(DetectLanguageRequest) + +DetectedLanguage = _reflection.GeneratedProtocolMessageType( + "DetectedLanguage", + (_message.Message,), + dict( + DESCRIPTOR=_DETECTEDLANGUAGE, + __module__="google.cloud.translation_v3beta1.proto.translation_service_pb2", + __doc__="""The response message for language detection. + + + Attributes: + language_code: + The BCP-47 language code of source content in the request, + detected automatically. + confidence: + The confidence of the detection result for this language. + """, + # @@protoc_insertion_point(class_scope:google.cloud.translation.v3beta1.DetectedLanguage) + ), +) +_sym_db.RegisterMessage(DetectedLanguage) + +DetectLanguageResponse = _reflection.GeneratedProtocolMessageType( + "DetectLanguageResponse", + (_message.Message,), + dict( + DESCRIPTOR=_DETECTLANGUAGERESPONSE, + __module__="google.cloud.translation_v3beta1.proto.translation_service_pb2", + __doc__="""The response message for language detection. + + + Attributes: + languages: + A list of detected languages sorted by detection confidence in + descending order. The most probable language first. + """, + # @@protoc_insertion_point(class_scope:google.cloud.translation.v3beta1.DetectLanguageResponse) + ), +) +_sym_db.RegisterMessage(DetectLanguageResponse) + +GetSupportedLanguagesRequest = _reflection.GeneratedProtocolMessageType( + "GetSupportedLanguagesRequest", + (_message.Message,), + dict( + DESCRIPTOR=_GETSUPPORTEDLANGUAGESREQUEST, + __module__="google.cloud.translation_v3beta1.proto.translation_service_pb2", + __doc__="""The request message for discovering supported languages. + + + Attributes: + parent: + Optional. Used for making regionalized calls. Format: + projects/{project-id}/locations/{location-id}. For global + calls, use projects/{project-id}/locations/global. If missing, + the call is treated as a global call. Only custom model + within the same location-id can be used. Otherwise 400 is + returned. + display_language_code: + Optional. The language to use to return localized, human + readable names of supported languages. If missing, default + language is ENGLISH. + model: + Optional. Get supported languages of this model. The format + depends on model type: 1. Custom models: projects/{project- + id}/locations/{location-id}/models/{model-id}. 2. General + (built-in) models: projects/{project-id}/locations/{location- + id}/models/general/nmt projects/{project- + id}/locations/{location-id}/models/general/base Returns + languages supported by the specified model. If missing, we get + supported languages of Google general NMT model. + """, + # @@protoc_insertion_point(class_scope:google.cloud.translation.v3beta1.GetSupportedLanguagesRequest) + ), +) +_sym_db.RegisterMessage(GetSupportedLanguagesRequest) + +SupportedLanguages = _reflection.GeneratedProtocolMessageType( + "SupportedLanguages", + (_message.Message,), + dict( + DESCRIPTOR=_SUPPORTEDLANGUAGES, + __module__="google.cloud.translation_v3beta1.proto.translation_service_pb2", + __doc__="""The response message for discovering supported languages. + + + Attributes: + languages: + A list of supported language responses. This list contains an + entry for each language the Translation API supports. + """, + # @@protoc_insertion_point(class_scope:google.cloud.translation.v3beta1.SupportedLanguages) + ), +) +_sym_db.RegisterMessage(SupportedLanguages) + +SupportedLanguage = _reflection.GeneratedProtocolMessageType( + "SupportedLanguage", + (_message.Message,), + dict( + DESCRIPTOR=_SUPPORTEDLANGUAGE, + __module__="google.cloud.translation_v3beta1.proto.translation_service_pb2", + __doc__="""A single supported language response corresponds to information related + to one supported language. + + + Attributes: + language_code: + Supported language code, generally consisting of its ISO 639-1 + identifier, for example, 'en', 'ja'. In certain cases, BCP-47 + codes including language and region identifiers are returned + (for example, 'zh-TW' and 'zh-CN') + display_name: + Human readable name of the language localized in the display + language specified in the request. + support_source: + Can be used as source language. + support_target: + Can be used as target language. + """, + # @@protoc_insertion_point(class_scope:google.cloud.translation.v3beta1.SupportedLanguage) + ), +) +_sym_db.RegisterMessage(SupportedLanguage) + +GcsSource = _reflection.GeneratedProtocolMessageType( + "GcsSource", + (_message.Message,), + dict( + DESCRIPTOR=_GCSSOURCE, + __module__="google.cloud.translation_v3beta1.proto.translation_service_pb2", + __doc__="""The GCS location for the input content. + + + Attributes: + input_uri: + Required. Source data URI. For example, + ``gs://my_bucket/my_object``. + """, + # @@protoc_insertion_point(class_scope:google.cloud.translation.v3beta1.GcsSource) + ), +) +_sym_db.RegisterMessage(GcsSource) + +InputConfig = _reflection.GeneratedProtocolMessageType( + "InputConfig", + (_message.Message,), + dict( + DESCRIPTOR=_INPUTCONFIG, + __module__="google.cloud.translation_v3beta1.proto.translation_service_pb2", + __doc__="""Input configuration. + + + Attributes: + mime_type: + Optional. Can be "text/plain" or "text/html". For ``.tsv``, + "text/html" is used if mime\_type is missing. For ``.html``, + this field must be "text/html" or empty. For ``.txt``, this + field must be "text/plain" or empty. + source: + Required. Specify the input. + gcs_source: + Required. Google Cloud Storage location for the source input. + This can be a single file (for example, ``gs://translation- + test/input.tsv``) or a wildcard (for example, + ``gs://translation-test/*``). If a file extension is ``.tsv``, + it can contain either one or two columns. The first column + (optional) is the id of the text request. If the first column + is missing, we use the row number (0-based) from the input + file as the ID in the output file. The second column is the + actual text to be translated. We recommend each row be <= 10K + Unicode codepoints, otherwise an error might be returned. The + other supported file extensions are ``.txt`` or ``.html``, + which is treated as a single large chunk of text. + """, + # @@protoc_insertion_point(class_scope:google.cloud.translation.v3beta1.InputConfig) + ), +) +_sym_db.RegisterMessage(InputConfig) + +GcsDestination = _reflection.GeneratedProtocolMessageType( + "GcsDestination", + (_message.Message,), + dict( + DESCRIPTOR=_GCSDESTINATION, + __module__="google.cloud.translation_v3beta1.proto.translation_service_pb2", + __doc__="""The GCS location for the output content + + + Attributes: + output_uri_prefix: + Required. There must be no files under 'output\_uri\_prefix'. + 'output\_uri\_prefix' must end with "/". Otherwise error 400 + is returned. + """, + # @@protoc_insertion_point(class_scope:google.cloud.translation.v3beta1.GcsDestination) + ), +) +_sym_db.RegisterMessage(GcsDestination) + +OutputConfig = _reflection.GeneratedProtocolMessageType( + "OutputConfig", + (_message.Message,), + dict( + DESCRIPTOR=_OUTPUTCONFIG, + __module__="google.cloud.translation_v3beta1.proto.translation_service_pb2", + __doc__="""Output configuration. + + + Attributes: + destination: + Required. The destination of output. + gcs_destination: + Google Cloud Storage destination for output content. For every + single input file (for example, gs://a/b/c.[extension]), we + generate at most 2 \* n output files. (n is the # of + target\_language\_codes in the BatchTranslateTextRequest). + Output files (tsv) generated are compliant with RFC 4180 + except that record delimiters are ':raw-latex:`\n`' instead of + ':raw-latex:`\r`:raw-latex:`\n`'. We don't provide any way to + change record delimiters. While the input files are being + processed, we write/update an index file 'index.csv' under + 'output\_uri\_prefix' (for example, gs://translation- + test/index.csv) The index file is generated/updated as new + files are being translated. The format is: input\_file,target + \_language\_code,translations\_file,errors\_file, + glossary\_translations\_file,glossary\_errors\_file + input\_file is one file we matched using + gcs\_source.input\_uri. target\_language\_code is provided in + the request. translations\_file contains the translations. + (details provided below) errors\_file contains the errors + during processing of the file. (details below). Both + translations\_file and errors\_file could be empty strings if + we have no content to output. + glossary\_translations\_file,glossary\_errors\_file are always + empty string if input\_file is tsv. They could also be empty + if we have no content to output. Once a row is present in + index.csv, the input/output matching never changes. Callers + should also expect all the content in input\_file are + processed and ready to be consumed (that is, No partial output + file is written). The format of translations\_file (for + target language code 'trg') is: gs://translation\_test/a\_b\_c + \_'trg'\_translations.[extension] If the input file extension + is tsv, the output has the following columns: Column 1: ID of + the request provided in the input, if it's not provided in the + input, then the input row number is used (0-based). Column 2: + source sentence. Column 3: translation without applying a + glossary. Empty string if there is an error. Column 4 (only + present if a glossary is provided in the request): translation + after applying the glossary. Empty string if there is an error + applying the glossary. Could be same string as column 3 if + there is no glossary applied. If input file extension is a + txt or html, the translation is directly written to the output + file. If glossary is requested, a separate + glossary\_translations\_file has format of gs://translation\_t + est/a\_b\_c\_'trg'\_glossary\_translations.[extension] The + format of errors file (for target language code 'trg') is: + gs://translation\_test/a\_b\_c\_'trg'\_errors.[extension] If + the input file extension is tsv, errors\_file has the + following Column 1: ID of the request provided in the input, + if it's not provided in the input, then the input row number + is used (0-based). Column 2: source sentence. Column 3: Error + detail for the translation. Could be empty. Column 4 (only + present if a glossary is provided in the request): Error when + applying the glossary. If the input file extension is txt or + html, glossary\_error\_file will be generated that contains + error details. glossary\_error\_file has format of gs://transl + ation\_test/a\_b\_c\_'trg'\_glossary\_errors.[extension] + """, + # @@protoc_insertion_point(class_scope:google.cloud.translation.v3beta1.OutputConfig) + ), +) +_sym_db.RegisterMessage(OutputConfig) + +BatchTranslateTextRequest = _reflection.GeneratedProtocolMessageType( + "BatchTranslateTextRequest", + (_message.Message,), + dict( + ModelsEntry=_reflection.GeneratedProtocolMessageType( + "ModelsEntry", + (_message.Message,), + dict( + DESCRIPTOR=_BATCHTRANSLATETEXTREQUEST_MODELSENTRY, + __module__="google.cloud.translation_v3beta1.proto.translation_service_pb2" + # @@protoc_insertion_point(class_scope:google.cloud.translation.v3beta1.BatchTranslateTextRequest.ModelsEntry) + ), + ), + GlossariesEntry=_reflection.GeneratedProtocolMessageType( + "GlossariesEntry", + (_message.Message,), + dict( + DESCRIPTOR=_BATCHTRANSLATETEXTREQUEST_GLOSSARIESENTRY, + __module__="google.cloud.translation_v3beta1.proto.translation_service_pb2" + # @@protoc_insertion_point(class_scope:google.cloud.translation.v3beta1.BatchTranslateTextRequest.GlossariesEntry) + ), + ), + DESCRIPTOR=_BATCHTRANSLATETEXTREQUEST, + __module__="google.cloud.translation_v3beta1.proto.translation_service_pb2", + __doc__="""The batch translation request. + + + Attributes: + parent: + Optional. Only used when making regionalized call. Format: + projects/{project-id}/locations/{location-id}. Only custom + models/glossaries within the same location-id can be used. + Otherwise 400 is returned. + source_language_code: + Required. Source language code. + target_language_codes: + Required. Specify up to 10 language codes here. + models: + Optional. The models to use for translation. Map's key is + target language code. Map's value is model name. Value can be + a built-in general model, or a custom model built by AutoML. + The value format depends on model type: 1. Custom models: + projects/{project-id}/locations/{location-id}/models/{model- + id}. 2. General (built-in) models: projects/{project- + id}/locations/{location-id}/models/general/nmt + projects/{project-id}/locations/{location- + id}/models/general/base If the map is empty or a specific + model is not requested for a language pair, then default + google model is used. + input_configs: + Required. Input configurations. The total number of files + matched should be <= 1000. The total content size should be <= + 100M Unicode codepoints. The files must use UTF-8 encoding. + output_config: + Required. Output configuration. If 2 input configs match to + the same file (that is, same input path), we don't generate + output for duplicate inputs. + glossaries: + Optional. Glossaries to be applied for translation. It's keyed + by target language code. + """, + # @@protoc_insertion_point(class_scope:google.cloud.translation.v3beta1.BatchTranslateTextRequest) + ), +) +_sym_db.RegisterMessage(BatchTranslateTextRequest) +_sym_db.RegisterMessage(BatchTranslateTextRequest.ModelsEntry) +_sym_db.RegisterMessage(BatchTranslateTextRequest.GlossariesEntry) + +BatchTranslateMetadata = _reflection.GeneratedProtocolMessageType( + "BatchTranslateMetadata", + (_message.Message,), + dict( + DESCRIPTOR=_BATCHTRANSLATEMETADATA, + __module__="google.cloud.translation_v3beta1.proto.translation_service_pb2", + __doc__="""State metadata for the batch translation operation. + + + Attributes: + state: + The state of the operation. + translated_characters: + Number of successfully translated characters so far (Unicode + codepoints). + failed_characters: + Number of characters that have failed to process so far + (Unicode codepoints). + total_characters: + Total number of characters (Unicode codepoints). This is the + total number of codepoints from input files times the number + of target languages. It appears here shortly after the call is + submitted. + submit_time: + Time when the operation was submitted. + """, + # @@protoc_insertion_point(class_scope:google.cloud.translation.v3beta1.BatchTranslateMetadata) + ), +) +_sym_db.RegisterMessage(BatchTranslateMetadata) + +BatchTranslateResponse = _reflection.GeneratedProtocolMessageType( + "BatchTranslateResponse", + (_message.Message,), + dict( + DESCRIPTOR=_BATCHTRANSLATERESPONSE, + __module__="google.cloud.translation_v3beta1.proto.translation_service_pb2", + __doc__="""Stored in the + [google.longrunning.Operation.response][google.longrunning.Operation.response] + field returned by BatchTranslateText if at least one sentence is + translated successfully. + + + Attributes: + total_characters: + Total number of characters (Unicode codepoints). + translated_characters: + Number of successfully translated characters (Unicode + codepoints). + failed_characters: + Number of characters that have failed to process (Unicode + codepoints). + submit_time: + Time when the operation was submitted. + end_time: + The time when the operation is finished and [google.longrunnin + g.Operation.done][google.longrunning.Operation.done] is set to + true. + """, + # @@protoc_insertion_point(class_scope:google.cloud.translation.v3beta1.BatchTranslateResponse) + ), +) +_sym_db.RegisterMessage(BatchTranslateResponse) + +GlossaryInputConfig = _reflection.GeneratedProtocolMessageType( + "GlossaryInputConfig", + (_message.Message,), + dict( + DESCRIPTOR=_GLOSSARYINPUTCONFIG, + __module__="google.cloud.translation_v3beta1.proto.translation_service_pb2", + __doc__="""Input configuration for glossaries. + + + Attributes: + source: + Required. Specify the input. + gcs_source: + Required. Google Cloud Storage location of glossary data. File + format is determined based on file name extension. API returns + [google.rpc.Code.INVALID\_ARGUMENT] for unsupported URI-s and + file formats. Wildcards are not allowed. This must be a single + file in one of the following formats: For ``UNIDIRECTIONAL`` + glossaries: - TSV/CSV (``.tsv``/``.csv``): 2 column file, + tab- or comma-separated. The first column is source text. + The second column is target text. The file must not contain + headers. That is, the first row is data, not column names. + - TMX (``.tmx``): TMX file with parallel data defining + source/target term pairs. For ``EQUIVALENT_TERMS_SET`` + glossaries: - CSV (``.csv``): Multi-column CSV file defining + equivalent glossary terms in multiple languages. The format + is defined for Google Translation Toolkit and documented + here: ``https://support.google.com/translatortoolkit/answer + /6306379?hl=en``. + """, + # @@protoc_insertion_point(class_scope:google.cloud.translation.v3beta1.GlossaryInputConfig) + ), +) +_sym_db.RegisterMessage(GlossaryInputConfig) + +Glossary = _reflection.GeneratedProtocolMessageType( + "Glossary", + (_message.Message,), + dict( + LanguageCodePair=_reflection.GeneratedProtocolMessageType( + "LanguageCodePair", + (_message.Message,), + dict( + DESCRIPTOR=_GLOSSARY_LANGUAGECODEPAIR, + __module__="google.cloud.translation_v3beta1.proto.translation_service_pb2", + __doc__="""Used with UNIDIRECTIONAL. + + + Attributes: + source_language_code: + Required. The BCP-47 language code of the input text, for + example, "en-US". Expected to be an exact match for + GlossaryTerm.language\_code. + target_language_code: + Required. The BCP-47 language code for translation output, for + example, "zh-CN". Expected to be an exact match for + GlossaryTerm.language\_code. + """, + # @@protoc_insertion_point(class_scope:google.cloud.translation.v3beta1.Glossary.LanguageCodePair) + ), + ), + LanguageCodesSet=_reflection.GeneratedProtocolMessageType( + "LanguageCodesSet", + (_message.Message,), + dict( + DESCRIPTOR=_GLOSSARY_LANGUAGECODESSET, + __module__="google.cloud.translation_v3beta1.proto.translation_service_pb2", + __doc__="""Used with EQUIVALENT\_TERMS\_SET. + + + Attributes: + language_codes: + The BCP-47 language code(s) for terms defined in the glossary. + All entries are unique. The list contains at least two + entries. Expected to be an exact match for + GlossaryTerm.language\_code. + """, + # @@protoc_insertion_point(class_scope:google.cloud.translation.v3beta1.Glossary.LanguageCodesSet) + ), + ), + DESCRIPTOR=_GLOSSARY, + __module__="google.cloud.translation_v3beta1.proto.translation_service_pb2", + __doc__="""Represents a glossary built from user provided data. + + + Attributes: + name: + Required. The resource name of the glossary. Glossary names + have the form ``projects/{project-id}/locations/{location- + id}/glossaries/{glossary-id}``. + languages: + Languages supported by the glossary. + language_pair: + Used with UNIDIRECTIONAL. + language_codes_set: + Used with EQUIVALENT\_TERMS\_SET. + input_config: + Required. Provides examples to build the glossary from. Total + glossary must not exceed 10M Unicode codepoints. + entry_count: + Output only. The number of entries defined in the glossary. + submit_time: + Output only. When CreateGlossary was called. + end_time: + Output only. When the glossary creation was finished. + """, + # @@protoc_insertion_point(class_scope:google.cloud.translation.v3beta1.Glossary) + ), +) +_sym_db.RegisterMessage(Glossary) +_sym_db.RegisterMessage(Glossary.LanguageCodePair) +_sym_db.RegisterMessage(Glossary.LanguageCodesSet) + +CreateGlossaryRequest = _reflection.GeneratedProtocolMessageType( + "CreateGlossaryRequest", + (_message.Message,), + dict( + DESCRIPTOR=_CREATEGLOSSARYREQUEST, + __module__="google.cloud.translation_v3beta1.proto.translation_service_pb2", + __doc__="""Request message for CreateGlossary. + + + Attributes: + parent: + Required. The project name. + glossary: + Required. The glossary to create. + """, + # @@protoc_insertion_point(class_scope:google.cloud.translation.v3beta1.CreateGlossaryRequest) + ), +) +_sym_db.RegisterMessage(CreateGlossaryRequest) + +GetGlossaryRequest = _reflection.GeneratedProtocolMessageType( + "GetGlossaryRequest", + (_message.Message,), + dict( + DESCRIPTOR=_GETGLOSSARYREQUEST, + __module__="google.cloud.translation_v3beta1.proto.translation_service_pb2", + __doc__="""Request message for GetGlossary. + + + Attributes: + name: + Required. The name of the glossary to retrieve. + """, + # @@protoc_insertion_point(class_scope:google.cloud.translation.v3beta1.GetGlossaryRequest) + ), +) +_sym_db.RegisterMessage(GetGlossaryRequest) + +DeleteGlossaryRequest = _reflection.GeneratedProtocolMessageType( + "DeleteGlossaryRequest", + (_message.Message,), + dict( + DESCRIPTOR=_DELETEGLOSSARYREQUEST, + __module__="google.cloud.translation_v3beta1.proto.translation_service_pb2", + __doc__="""Request message for DeleteGlossary. + + + Attributes: + name: + Required. The name of the glossary to delete. + """, + # @@protoc_insertion_point(class_scope:google.cloud.translation.v3beta1.DeleteGlossaryRequest) + ), +) +_sym_db.RegisterMessage(DeleteGlossaryRequest) + +ListGlossariesRequest = _reflection.GeneratedProtocolMessageType( + "ListGlossariesRequest", + (_message.Message,), + dict( + DESCRIPTOR=_LISTGLOSSARIESREQUEST, + __module__="google.cloud.translation_v3beta1.proto.translation_service_pb2", + __doc__="""Request message for ListGlossaries. + + + Attributes: + parent: + Required. The name of the project from which to list all of + the glossaries. + page_size: + Optional. Requested page size. The server may return fewer + glossaries than requested. If unspecified, the server picks an + appropriate default. + page_token: + Optional. A token identifying a page of results the server + should return. Typically, this is the value of + [ListGlossariesResponse.next\_page\_token] returned from the + previous call to ``ListGlossaries`` method. The first page is + returned if ``page_token``\ is empty or missing. + filter: + Optional. Filter specifying constraints of a list operation. + For example, ``tags.glossary_name="products*"``. If missing, + no filtering is performed. + """, + # @@protoc_insertion_point(class_scope:google.cloud.translation.v3beta1.ListGlossariesRequest) + ), +) +_sym_db.RegisterMessage(ListGlossariesRequest) + +ListGlossariesResponse = _reflection.GeneratedProtocolMessageType( + "ListGlossariesResponse", + (_message.Message,), + dict( + DESCRIPTOR=_LISTGLOSSARIESRESPONSE, + __module__="google.cloud.translation_v3beta1.proto.translation_service_pb2", + __doc__="""Response message for ListGlossaries. + + + Attributes: + glossaries: + The list of glossaries for a project. + next_page_token: + A token to retrieve a page of results. Pass this value in the + [ListGlossariesRequest.page\_token] field in the subsequent + call to ``ListGlossaries`` method to retrieve the next page of + results. + """, + # @@protoc_insertion_point(class_scope:google.cloud.translation.v3beta1.ListGlossariesResponse) + ), +) +_sym_db.RegisterMessage(ListGlossariesResponse) + +CreateGlossaryMetadata = _reflection.GeneratedProtocolMessageType( + "CreateGlossaryMetadata", + (_message.Message,), + dict( + DESCRIPTOR=_CREATEGLOSSARYMETADATA, + __module__="google.cloud.translation_v3beta1.proto.translation_service_pb2", + __doc__="""Stored in the + [google.longrunning.Operation.metadata][google.longrunning.Operation.metadata] + field returned by CreateGlossary. + + + Attributes: + name: + The name of the glossary that is being created. + state: + The current state of the glossary creation operation. + submit_time: + The time when the operation was submitted to the server. + """, + # @@protoc_insertion_point(class_scope:google.cloud.translation.v3beta1.CreateGlossaryMetadata) + ), +) +_sym_db.RegisterMessage(CreateGlossaryMetadata) + +DeleteGlossaryMetadata = _reflection.GeneratedProtocolMessageType( + "DeleteGlossaryMetadata", + (_message.Message,), + dict( + DESCRIPTOR=_DELETEGLOSSARYMETADATA, + __module__="google.cloud.translation_v3beta1.proto.translation_service_pb2", + __doc__="""Stored in the + [google.longrunning.Operation.metadata][google.longrunning.Operation.metadata] + field returned by DeleteGlossary. + + + Attributes: + name: + The name of the glossary that is being deleted. + state: + The current state of the glossary deletion operation. + submit_time: + The time when the operation was submitted to the server. + """, + # @@protoc_insertion_point(class_scope:google.cloud.translation.v3beta1.DeleteGlossaryMetadata) + ), +) +_sym_db.RegisterMessage(DeleteGlossaryMetadata) + +DeleteGlossaryResponse = _reflection.GeneratedProtocolMessageType( + "DeleteGlossaryResponse", + (_message.Message,), + dict( + DESCRIPTOR=_DELETEGLOSSARYRESPONSE, + __module__="google.cloud.translation_v3beta1.proto.translation_service_pb2", + __doc__="""Stored in the + [google.longrunning.Operation.response][google.longrunning.Operation.response] + field returned by DeleteGlossary. + + + Attributes: + name: + The name of the deleted glossary. + submit_time: + The time when the operation was submitted to the server. + end_time: + The time when the glossary deletion is finished and [google.lo + ngrunning.Operation.done][google.longrunning.Operation.done] + is set to true. + """, + # @@protoc_insertion_point(class_scope:google.cloud.translation.v3beta1.DeleteGlossaryResponse) + ), +) +_sym_db.RegisterMessage(DeleteGlossaryResponse) + + +DESCRIPTOR._options = None +_BATCHTRANSLATETEXTREQUEST_MODELSENTRY._options = None +_BATCHTRANSLATETEXTREQUEST_GLOSSARIESENTRY._options = None + +_TRANSLATIONSERVICE = _descriptor.ServiceDescriptor( + name="TranslationService", + full_name="google.cloud.translation.v3beta1.TranslationService", + file=DESCRIPTOR, + index=0, + serialized_options=None, + serialized_start=4571, + serialized_end=6107, + methods=[ + _descriptor.MethodDescriptor( + name="TranslateText", + full_name="google.cloud.translation.v3beta1.TranslationService.TranslateText", + index=0, + containing_service=None, + input_type=_TRANSLATETEXTREQUEST, + output_type=_TRANSLATETEXTRESPONSE, + serialized_options=_b( + '\202\323\344\223\002;"6/v3beta1/{parent=projects/*/locations/*}:translateText:\001*' + ), + ), + _descriptor.MethodDescriptor( + name="DetectLanguage", + full_name="google.cloud.translation.v3beta1.TranslationService.DetectLanguage", + index=1, + containing_service=None, + input_type=_DETECTLANGUAGEREQUEST, + output_type=_DETECTLANGUAGERESPONSE, + serialized_options=_b( + '\202\323\344\223\002<"7/v3beta1/{parent=projects/*/locations/*}:detectLanguage:\001*' + ), + ), + _descriptor.MethodDescriptor( + name="GetSupportedLanguages", + full_name="google.cloud.translation.v3beta1.TranslationService.GetSupportedLanguages", + index=2, + containing_service=None, + input_type=_GETSUPPORTEDLANGUAGESREQUEST, + output_type=_SUPPORTEDLANGUAGES, + serialized_options=_b( + "\202\323\344\223\002=\022;/v3beta1/{parent=projects/*/locations/*}/supportedLanguages" + ), + ), + _descriptor.MethodDescriptor( + name="BatchTranslateText", + full_name="google.cloud.translation.v3beta1.TranslationService.BatchTranslateText", + index=3, + containing_service=None, + input_type=_BATCHTRANSLATETEXTREQUEST, + output_type=google_dot_longrunning_dot_operations__pb2._OPERATION, + serialized_options=_b( + '\202\323\344\223\002@";/v3beta1/{parent=projects/*/locations/*}:batchTranslateText:\001*' + ), + ), + _descriptor.MethodDescriptor( + name="CreateGlossary", + full_name="google.cloud.translation.v3beta1.TranslationService.CreateGlossary", + index=4, + containing_service=None, + input_type=_CREATEGLOSSARYREQUEST, + output_type=google_dot_longrunning_dot_operations__pb2._OPERATION, + serialized_options=_b( + '\202\323\344\223\002?"3/v3beta1/{parent=projects/*/locations/*}/glossaries:\010glossary' + ), + ), + _descriptor.MethodDescriptor( + name="ListGlossaries", + full_name="google.cloud.translation.v3beta1.TranslationService.ListGlossaries", + index=5, + containing_service=None, + input_type=_LISTGLOSSARIESREQUEST, + output_type=_LISTGLOSSARIESRESPONSE, + serialized_options=_b( + "\202\323\344\223\0025\0223/v3beta1/{parent=projects/*/locations/*}/glossaries" + ), + ), + _descriptor.MethodDescriptor( + name="GetGlossary", + full_name="google.cloud.translation.v3beta1.TranslationService.GetGlossary", + index=6, + containing_service=None, + input_type=_GETGLOSSARYREQUEST, + output_type=_GLOSSARY, + serialized_options=_b( + "\202\323\344\223\0025\0223/v3beta1/{name=projects/*/locations/*/glossaries/*}" + ), + ), + _descriptor.MethodDescriptor( + name="DeleteGlossary", + full_name="google.cloud.translation.v3beta1.TranslationService.DeleteGlossary", + index=7, + containing_service=None, + input_type=_DELETEGLOSSARYREQUEST, + output_type=google_dot_longrunning_dot_operations__pb2._OPERATION, + serialized_options=_b( + "\202\323\344\223\0025*3/v3beta1/{name=projects/*/locations/*/glossaries/*}" + ), + ), + ], +) +_sym_db.RegisterServiceDescriptor(_TRANSLATIONSERVICE) + +DESCRIPTOR.services_by_name["TranslationService"] = _TRANSLATIONSERVICE + +# @@protoc_insertion_point(module_scope) diff --git a/packages/google-cloud-translate/google/cloud/translate_v3beta1/proto/translation_service_pb2_grpc.py b/packages/google-cloud-translate/google/cloud/translate_v3beta1/proto/translation_service_pb2_grpc.py new file mode 100644 index 000000000000..695f79923a4a --- /dev/null +++ b/packages/google-cloud-translate/google/cloud/translate_v3beta1/proto/translation_service_pb2_grpc.py @@ -0,0 +1,186 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +import grpc + +from google.cloud.translate_v3beta1.proto import ( + translation_service_pb2 as google_dot_cloud_dot_translation__v3beta1_dot_proto_dot_translation__service__pb2, +) +from google.longrunning import ( + operations_pb2 as google_dot_longrunning_dot_operations__pb2, +) + + +class TranslationServiceStub(object): + """Proto file for the Cloud Translation API (v3beta1). + + Provides natural language translation operations. + """ + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.TranslateText = channel.unary_unary( + "/google.cloud.translation.v3beta1.TranslationService/TranslateText", + request_serializer=google_dot_cloud_dot_translation__v3beta1_dot_proto_dot_translation__service__pb2.TranslateTextRequest.SerializeToString, + response_deserializer=google_dot_cloud_dot_translation__v3beta1_dot_proto_dot_translation__service__pb2.TranslateTextResponse.FromString, + ) + self.DetectLanguage = channel.unary_unary( + "/google.cloud.translation.v3beta1.TranslationService/DetectLanguage", + request_serializer=google_dot_cloud_dot_translation__v3beta1_dot_proto_dot_translation__service__pb2.DetectLanguageRequest.SerializeToString, + response_deserializer=google_dot_cloud_dot_translation__v3beta1_dot_proto_dot_translation__service__pb2.DetectLanguageResponse.FromString, + ) + self.GetSupportedLanguages = channel.unary_unary( + "/google.cloud.translation.v3beta1.TranslationService/GetSupportedLanguages", + request_serializer=google_dot_cloud_dot_translation__v3beta1_dot_proto_dot_translation__service__pb2.GetSupportedLanguagesRequest.SerializeToString, + response_deserializer=google_dot_cloud_dot_translation__v3beta1_dot_proto_dot_translation__service__pb2.SupportedLanguages.FromString, + ) + self.BatchTranslateText = channel.unary_unary( + "/google.cloud.translation.v3beta1.TranslationService/BatchTranslateText", + request_serializer=google_dot_cloud_dot_translation__v3beta1_dot_proto_dot_translation__service__pb2.BatchTranslateTextRequest.SerializeToString, + response_deserializer=google_dot_longrunning_dot_operations__pb2.Operation.FromString, + ) + self.CreateGlossary = channel.unary_unary( + "/google.cloud.translation.v3beta1.TranslationService/CreateGlossary", + request_serializer=google_dot_cloud_dot_translation__v3beta1_dot_proto_dot_translation__service__pb2.CreateGlossaryRequest.SerializeToString, + response_deserializer=google_dot_longrunning_dot_operations__pb2.Operation.FromString, + ) + self.ListGlossaries = channel.unary_unary( + "/google.cloud.translation.v3beta1.TranslationService/ListGlossaries", + request_serializer=google_dot_cloud_dot_translation__v3beta1_dot_proto_dot_translation__service__pb2.ListGlossariesRequest.SerializeToString, + response_deserializer=google_dot_cloud_dot_translation__v3beta1_dot_proto_dot_translation__service__pb2.ListGlossariesResponse.FromString, + ) + self.GetGlossary = channel.unary_unary( + "/google.cloud.translation.v3beta1.TranslationService/GetGlossary", + request_serializer=google_dot_cloud_dot_translation__v3beta1_dot_proto_dot_translation__service__pb2.GetGlossaryRequest.SerializeToString, + response_deserializer=google_dot_cloud_dot_translation__v3beta1_dot_proto_dot_translation__service__pb2.Glossary.FromString, + ) + self.DeleteGlossary = channel.unary_unary( + "/google.cloud.translation.v3beta1.TranslationService/DeleteGlossary", + request_serializer=google_dot_cloud_dot_translation__v3beta1_dot_proto_dot_translation__service__pb2.DeleteGlossaryRequest.SerializeToString, + response_deserializer=google_dot_longrunning_dot_operations__pb2.Operation.FromString, + ) + + +class TranslationServiceServicer(object): + """Proto file for the Cloud Translation API (v3beta1). + + Provides natural language translation operations. + """ + + def TranslateText(self, request, context): + """Translates input text and returns translated text. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details("Method not implemented!") + raise NotImplementedError("Method not implemented!") + + def DetectLanguage(self, request, context): + """Detects the language of text within a request. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details("Method not implemented!") + raise NotImplementedError("Method not implemented!") + + def GetSupportedLanguages(self, request, context): + """Returns a list of supported languages for translation. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details("Method not implemented!") + raise NotImplementedError("Method not implemented!") + + def BatchTranslateText(self, request, context): + """Translates a large volume of text in asynchronous batch mode. + This function provides real-time output as the inputs are being processed. + If caller cancels a request, the partial results (for an input file, it's + all or nothing) may still be available on the specified output location. + + This call returns immediately and you can + use google.longrunning.Operation.name to poll the status of the call. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details("Method not implemented!") + raise NotImplementedError("Method not implemented!") + + def CreateGlossary(self, request, context): + """Creates a glossary and returns the long-running operation. Returns + NOT_FOUND, if the project doesn't exist. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details("Method not implemented!") + raise NotImplementedError("Method not implemented!") + + def ListGlossaries(self, request, context): + """Lists glossaries in a project. Returns NOT_FOUND, if the project doesn't + exist. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details("Method not implemented!") + raise NotImplementedError("Method not implemented!") + + def GetGlossary(self, request, context): + """Gets a glossary. Returns NOT_FOUND, if the glossary doesn't + exist. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details("Method not implemented!") + raise NotImplementedError("Method not implemented!") + + def DeleteGlossary(self, request, context): + """Deletes a glossary, or cancels glossary construction + if the glossary isn't created yet. + Returns NOT_FOUND, if the glossary doesn't exist. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details("Method not implemented!") + raise NotImplementedError("Method not implemented!") + + +def add_TranslationServiceServicer_to_server(servicer, server): + rpc_method_handlers = { + "TranslateText": grpc.unary_unary_rpc_method_handler( + servicer.TranslateText, + request_deserializer=google_dot_cloud_dot_translation__v3beta1_dot_proto_dot_translation__service__pb2.TranslateTextRequest.FromString, + response_serializer=google_dot_cloud_dot_translation__v3beta1_dot_proto_dot_translation__service__pb2.TranslateTextResponse.SerializeToString, + ), + "DetectLanguage": grpc.unary_unary_rpc_method_handler( + servicer.DetectLanguage, + request_deserializer=google_dot_cloud_dot_translation__v3beta1_dot_proto_dot_translation__service__pb2.DetectLanguageRequest.FromString, + response_serializer=google_dot_cloud_dot_translation__v3beta1_dot_proto_dot_translation__service__pb2.DetectLanguageResponse.SerializeToString, + ), + "GetSupportedLanguages": grpc.unary_unary_rpc_method_handler( + servicer.GetSupportedLanguages, + request_deserializer=google_dot_cloud_dot_translation__v3beta1_dot_proto_dot_translation__service__pb2.GetSupportedLanguagesRequest.FromString, + response_serializer=google_dot_cloud_dot_translation__v3beta1_dot_proto_dot_translation__service__pb2.SupportedLanguages.SerializeToString, + ), + "BatchTranslateText": grpc.unary_unary_rpc_method_handler( + servicer.BatchTranslateText, + request_deserializer=google_dot_cloud_dot_translation__v3beta1_dot_proto_dot_translation__service__pb2.BatchTranslateTextRequest.FromString, + response_serializer=google_dot_longrunning_dot_operations__pb2.Operation.SerializeToString, + ), + "CreateGlossary": grpc.unary_unary_rpc_method_handler( + servicer.CreateGlossary, + request_deserializer=google_dot_cloud_dot_translation__v3beta1_dot_proto_dot_translation__service__pb2.CreateGlossaryRequest.FromString, + response_serializer=google_dot_longrunning_dot_operations__pb2.Operation.SerializeToString, + ), + "ListGlossaries": grpc.unary_unary_rpc_method_handler( + servicer.ListGlossaries, + request_deserializer=google_dot_cloud_dot_translation__v3beta1_dot_proto_dot_translation__service__pb2.ListGlossariesRequest.FromString, + response_serializer=google_dot_cloud_dot_translation__v3beta1_dot_proto_dot_translation__service__pb2.ListGlossariesResponse.SerializeToString, + ), + "GetGlossary": grpc.unary_unary_rpc_method_handler( + servicer.GetGlossary, + request_deserializer=google_dot_cloud_dot_translation__v3beta1_dot_proto_dot_translation__service__pb2.GetGlossaryRequest.FromString, + response_serializer=google_dot_cloud_dot_translation__v3beta1_dot_proto_dot_translation__service__pb2.Glossary.SerializeToString, + ), + "DeleteGlossary": grpc.unary_unary_rpc_method_handler( + servicer.DeleteGlossary, + request_deserializer=google_dot_cloud_dot_translation__v3beta1_dot_proto_dot_translation__service__pb2.DeleteGlossaryRequest.FromString, + response_serializer=google_dot_longrunning_dot_operations__pb2.Operation.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + "google.cloud.translation.v3beta1.TranslationService", rpc_method_handlers + ) + server.add_generic_rpc_handlers((generic_handler,)) diff --git a/packages/google-cloud-translate/google/cloud/translate_v3beta1/types.py b/packages/google-cloud-translate/google/cloud/translate_v3beta1/types.py new file mode 100644 index 000000000000..959f214f2f2c --- /dev/null +++ b/packages/google-cloud-translate/google/cloud/translate_v3beta1/types.py @@ -0,0 +1,44 @@ +# -*- coding: utf-8 -*- +# +# Copyright 2019 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from __future__ import absolute_import +import sys + +from google.api_core.protobuf_helpers import get_messages + +from google.cloud.translate_v3beta1.proto import translation_service_pb2 +from google.longrunning import operations_pb2 +from google.protobuf import any_pb2 +from google.protobuf import timestamp_pb2 +from google.rpc import status_pb2 + +_shared_modules = [operations_pb2, any_pb2, timestamp_pb2, status_pb2] + +_local_modules = [translation_service_pb2] + +names = [] + +for module in _shared_modules: + for name, message in get_messages(module).items(): + setattr(sys.modules[__name__], name, message) + names.append(name) +for module in _local_modules: + for name, message in get_messages(module).items(): + message.__module__ = "google.cloud.translate_v3beta1.types" + setattr(sys.modules[__name__], name, message) + names.append(name) + +__all__ = tuple(sorted(names)) diff --git a/packages/google-cloud-translate/noxfile.py b/packages/google-cloud-translate/noxfile.py index fe9d1a8f0deb..fad9b6cc11b5 100644 --- a/packages/google-cloud-translate/noxfile.py +++ b/packages/google-cloud-translate/noxfile.py @@ -1,10 +1,12 @@ -# Copyright 2016 Google LLC +# -*- coding: utf-8 -*- +# +# Copyright 2018 Google LLC # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # -# http://www.apache.org/licenses/LICENSE-2.0 +# https://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, @@ -13,20 +15,17 @@ # limitations under the License. from __future__ import absolute_import - import os import nox -LOCAL_DEPS = ( - os.path.join('..', 'api_core'), - os.path.join('..', 'core'), -) +LOCAL_DEPS = (os.path.join("..", "api_core"), os.path.join("..", "core")) @nox.session(python="3.7") def lint(session): """Run linters. + Returns a failure if the linters find linting errors or sufficiently serious code quality issues. """ @@ -44,7 +43,12 @@ def lint(session): @nox.session(python="3.6") def blacken(session): """Run black. + Format code to uniform standard. + + This currently uses Python 3.6 due to the automated Kokoro run of synthtool. + That run uses an image that doesn't have 3.6 installed. Before updating this + check the state of the `gcp_ubuntu_config` we use for that Kokoro run. """ session.install("black") session.run( @@ -55,66 +59,82 @@ def blacken(session): ) -@nox.session(python='3.6') +@nox.session(python="3.7") def lint_setup_py(session): """Verify that setup.py is valid (including RST check).""" - session.install('docutils', 'Pygments') - session.run( - 'python', 'setup.py', 'check', '--restructuredtext', '--strict') + session.install("docutils", "pygments") + session.run("python", "setup.py", "check", "--restructuredtext", "--strict") def default(session): - """Default unit test session.""" - # Install all test dependencies, then install local packages in-place. - session.install('mock', 'pytest', 'pytest-cov') + # Install all test dependencies, then install this package in-place. + session.install("mock", "pytest", "pytest-cov") for local_dep in LOCAL_DEPS: - session.install('-e', local_dep) - session.install('-e', '.') + session.install("-e", local_dep) + session.install("-e", ".") # Run py.test against the unit tests. session.run( - 'py.test', '--quiet', - '--cov=google.cloud.translate', '--cov=tests.unit', '--cov-append', - '--cov-config=.coveragerc', '--cov-report=', '--cov-fail-under=97', - 'tests/unit', + "py.test", + "--quiet", + "--cov=google.cloud", + "--cov=tests.unit", + "--cov-append", + "--cov-config=.coveragerc", + "--cov-report=", + "--cov-fail-under=100", + os.path.join("tests", "unit"), + *session.posargs, ) -@nox.session(python=['2.7', '3.5', '3.6', '3.7']) +@nox.session(python=["2.7", "3.5", "3.6", "3.7"]) def unit(session): """Run the unit test suite.""" default(session) -@nox.session(python=['2.7', '3.6']) +@nox.session(python=["2.7", "3.7"]) def system(session): """Run the system test suite.""" - - # Sanity check: Only run system tests if the environment variable is set. - if not os.environ.get('GOOGLE_APPLICATION_CREDENTIALS', ''): - session.skip('Credentials must be set via environment variable.') + system_test_path = os.path.join("tests", "system.py") + system_test_folder_path = os.path.join("tests", "system") + # Sanity check: Only run tests if the environment variable is set. + if not os.environ.get("GOOGLE_APPLICATION_CREDENTIALS", ""): + session.skip("Credentials must be set via environment variable") + + system_test_exists = os.path.exists(system_test_path) + system_test_folder_exists = os.path.exists(system_test_folder_path) + # Sanity check: only run tests if found. + if not system_test_exists and not system_test_folder_exists: + session.skip("System tests were not found") # Use pre-release gRPC for system tests. - session.install('--pre', 'grpcio') + session.install("--pre", "grpcio") - # Install all test dependencies, then install local packages in-place. - session.install('mock', 'pytest') + # Install all test dependencies, then install this package into the + # virtualenv's dist-packages. + session.install("mock", "pytest") for local_dep in LOCAL_DEPS: - session.install('-e', local_dep) - session.install('-e', '../test_utils/') - session.install('-e', '.') + session.install("-e", local_dep) + session.install("-e", "../test_utils/") + session.install("-e", ".") # Run py.test against the system tests. - session.run('py.test', '--quiet', 'tests/system.py') + if system_test_exists: + session.run("py.test", "--quiet", system_test_path, *session.posargs) + if system_test_folder_exists: + session.run("py.test", "--quiet", system_test_folder_path, *session.posargs) -@nox.session(python='3.6') +@nox.session(python="3.7") def cover(session): """Run the final coverage report. This outputs the coverage report aggregating coverage from the unit test runs (not system test runs), and then erases coverage data. """ - session.install('coverage', 'pytest-cov') - session.run('coverage', 'report', '--show-missing', '--fail-under=100') - session.run('coverage', 'erase') + session.install("coverage", "pytest-cov") + session.run("coverage", "report", "--show-missing", "--fail-under=100") + + session.run("coverage", "erase") diff --git a/packages/google-cloud-translate/setup.py b/packages/google-cloud-translate/setup.py index 602497d2d6e4..656ad9dc334e 100644 --- a/packages/google-cloud-translate/setup.py +++ b/packages/google-cloud-translate/setup.py @@ -29,7 +29,7 @@ # 'Development Status :: 5 - Production/Stable' release_status = 'Development Status :: 5 - Production/Stable' dependencies = [ - 'google-api-core >= 1.6.0, < 2.0.0dev', + 'google-api-core[grpc] >= 1.6.0, < 2.0.0dev', 'google-cloud-core >= 0.29.0, < 0.30dev', ] extras = { diff --git a/packages/google-cloud-translate/synth.metadata b/packages/google-cloud-translate/synth.metadata new file mode 100644 index 000000000000..363e645c0b50 --- /dev/null +++ b/packages/google-cloud-translate/synth.metadata @@ -0,0 +1,39 @@ +{ + "updateTime": "2019-03-21T22:02:11.681537Z", + "sources": [ + { + "generator": { + "name": "artman", + "version": "0.16.18", + "dockerImage": "googleapis/artman@sha256:e8ac9200640e76d54643f370db71a1556bf254f565ce46b45a467bbcbacbdb37" + } + }, + { + "git": { + "name": "googleapis-private", + "remote": "https://github.com/googleapis/googleapis-private.git", + "sha": "4f336ff3519e999d1c2796880dad85034ed851ea", + "internalRef": "239614504" + } + }, + { + "template": { + "name": "python_library", + "origin": "synthtool.gcp", + "version": "2019.2.26" + } + } + ], + "destinations": [ + { + "client": { + "source": "googleapis-private", + "apiName": "translate", + "apiVersion": "v3beta1", + "language": "python", + "generator": "gapic", + "config": "google/cloud/translate/artman_translate_v3beta1.yaml" + } + } + ] +} \ No newline at end of file diff --git a/packages/google-cloud-translate/synth.py b/packages/google-cloud-translate/synth.py new file mode 100644 index 000000000000..bbbaf64c178c --- /dev/null +++ b/packages/google-cloud-translate/synth.py @@ -0,0 +1,55 @@ +# Copyright 2018 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""This script is used to synthesize generated parts of this library.""" + +import synthtool as s +from synthtool import gcp + +gapic = gcp.GAPICGenerator() +common = gcp.CommonTemplates() +versions = ["v3beta1"] + +excludes = ["setup.py", "nox*.py", "README.rst", "docs/conf.py", "docs/index.rst", + "translation.py"] + +# ---------------------------------------------------------------------------- +# Generate asset GAPIC layer +# ---------------------------------------------------------------------------- +for version in versions: + library = gapic.py_library( + "translate", + version, + include_protos=True, + private=True, + ) + + #s.move(library / f'google/cloud/translation_{version}', f'google/cloud/translate_{version}', excludes=excludes) + s.move(library / f'google/cloud/translate_{version}', excludes=excludes) + s.move(library / 'tests') + +# translation -> translate +s.replace( + "google/**/translation_service_pb2_grpc.py", + "google.cloud.translation_v3beta1.proto", + "google.cloud.translate_v3beta1.proto", +) + +# ---------------------------------------------------------------------------- +# Add templated files +# ---------------------------------------------------------------------------- +templated_files = gcp.CommonTemplates().py_library(unit_cov_level=100, cov_level=100) +s.move(templated_files) + +s.shell.run(["nox", "-s", "blacken"], hide_output=False) diff --git a/packages/google-cloud-translate/tests/unit/gapic/v3beta1/test_translation_service_client_v3beta1.py b/packages/google-cloud-translate/tests/unit/gapic/v3beta1/test_translation_service_client_v3beta1.py new file mode 100644 index 000000000000..d6685704991e --- /dev/null +++ b/packages/google-cloud-translate/tests/unit/gapic/v3beta1/test_translation_service_client_v3beta1.py @@ -0,0 +1,436 @@ +# -*- coding: utf-8 -*- +# +# Copyright 2019 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +"""Unit tests.""" + +import mock +import pytest + +from google.rpc import status_pb2 + +from google.cloud import translate_v3beta1 +from google.cloud.translate_v3beta1.proto import translation_service_pb2 +from google.longrunning import operations_pb2 + + +class MultiCallableStub(object): + """Stub for the grpc.UnaryUnaryMultiCallable interface.""" + + def __init__(self, method, channel_stub): + self.method = method + self.channel_stub = channel_stub + + def __call__(self, request, timeout=None, metadata=None, credentials=None): + self.channel_stub.requests.append((self.method, request)) + + response = None + if self.channel_stub.responses: + response = self.channel_stub.responses.pop() + + if isinstance(response, Exception): + raise response + + if response: + return response + + +class ChannelStub(object): + """Stub for the grpc.Channel interface.""" + + def __init__(self, responses=[]): + self.responses = responses + self.requests = [] + + def unary_unary(self, method, request_serializer=None, response_deserializer=None): + return MultiCallableStub(method, self) + + +class CustomException(Exception): + pass + + +class TestTranslationServiceClient(object): + 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_v3beta1.TranslationServiceClient() + + # Setup Request + contents = [] + target_language_code = "targetLanguageCode1323228230" + + response = client.translate_text(contents, target_language_code) + assert expected_response == response + + assert len(channel.requests) == 1 + expected_request = translation_service_pb2.TranslateTextRequest( + contents=contents, target_language_code=target_language_code + ) + actual_request = channel.requests[0][1] + assert expected_request == actual_request + + 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_v3beta1.TranslationServiceClient() + + # Setup request + contents = [] + target_language_code = "targetLanguageCode1323228230" + + with pytest.raises(CustomException): + client.translate_text(contents, target_language_code) + + def test_detect_language(self): + # Setup Expected Response + expected_response = {} + expected_response = translation_service_pb2.DetectLanguageResponse( + **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_v3beta1.TranslationServiceClient() + + response = client.detect_language() + assert expected_response == response + + assert len(channel.requests) == 1 + expected_request = translation_service_pb2.DetectLanguageRequest() + actual_request = channel.requests[0][1] + assert expected_request == actual_request + + 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_v3beta1.TranslationServiceClient() + + with pytest.raises(CustomException): + client.detect_language() + + 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_v3beta1.TranslationServiceClient() + + response = client.get_supported_languages() + assert expected_response == response + + assert len(channel.requests) == 1 + expected_request = translation_service_pb2.GetSupportedLanguagesRequest() + actual_request = channel.requests[0][1] + assert expected_request == actual_request + + def test_get_supported_languages_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_v3beta1.TranslationServiceClient() + + with pytest.raises(CustomException): + client.get_supported_languages() + + 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_v3beta1.TranslationServiceClient() + + # Setup Request + source_language_code = "sourceLanguageCode1687263568" + target_language_codes = [] + input_configs = [] + output_config = {} + + response = client.batch_translate_text( + 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( + 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 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_v3beta1.TranslationServiceClient() + + # Setup Request + source_language_code = "sourceLanguageCode1687263568" + target_language_codes = [] + input_configs = [] + output_config = {} + + response = client.batch_translate_text( + source_language_code, target_language_codes, input_configs, output_config + ) + exception = response.exception() + assert exception.errors[0] == error + + 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_v3beta1.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_create_glossary_exception(self): + # Setup Response + error = status_pb2.Status() + operation = operations_pb2.Operation( + name="operations/test_create_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_v3beta1.TranslationServiceClient() + + # Setup Request + parent = client.location_path("[PROJECT]", "[LOCATION]") + glossary = {} + + response = client.create_glossary(parent, glossary) + exception = response.exception() + assert exception.errors[0] == error + + 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_v3beta1.TranslationServiceClient() + + paged_list_response = client.list_glossaries() + 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() + actual_request = channel.requests[0][1] + assert expected_request == actual_request + + 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_v3beta1.TranslationServiceClient() + + paged_list_response = client.list_glossaries() + with pytest.raises(CustomException): + list(paged_list_response) + + 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_v3beta1.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_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_v3beta1.TranslationServiceClient() + + # Setup request + name = client.glossary_path("[PROJECT]", "[LOCATION]", "[GLOSSARY]") + + with pytest.raises(CustomException): + client.get_glossary(name) + + 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_v3beta1.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_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_v3beta1.TranslationServiceClient() + + # Setup Request + name = client.glossary_path("[PROJECT]", "[LOCATION]", "[GLOSSARY]") + + response = client.delete_glossary(name) + exception = response.exception() + assert exception.errors[0] == error