diff --git a/translate/docs/gapic/v3/api.rst b/translate/docs/gapic/v3/api.rst new file mode 100644 index 000000000000..e16ef6a89d51 --- /dev/null +++ b/translate/docs/gapic/v3/api.rst @@ -0,0 +1,6 @@ +Client for Cloud Translation API +================================ + +.. automodule:: google.cloud.translate_v3 + :members: + :inherited-members: \ No newline at end of file diff --git a/translate/docs/gapic/v3/types.rst b/translate/docs/gapic/v3/types.rst new file mode 100644 index 000000000000..fb83ab0657b6 --- /dev/null +++ b/translate/docs/gapic/v3/types.rst @@ -0,0 +1,5 @@ +Types for Cloud Translation API Client +====================================== + +.. automodule:: google.cloud.translate_v3.types + :members: \ No newline at end of file diff --git a/translate/docs/index.rst b/translate/docs/index.rst index 8b370cfdae11..604ac0485f06 100644 --- a/translate/docs/index.rst +++ b/translate/docs/index.rst @@ -1,31 +1,31 @@ .. include:: README.rst -Detailed Usage Guide +v2 Usage Guide -------------------- .. toctree:: :maxdepth: 2 usage + API Reference ------------- -A new beta release, spelled ``v3beta1``, is provided to provide for preview -of upcoming features. In order to use this, you will want to import from -``google.cloud.translate_v3beta1`` in lieu of ``google.cloud.translate``. - -.. toctree:: - :maxdepth: 2 +An API and type reference is provided for ``v3``, ``v3beta1``, and ``v2``. - gapic/v3beta1/api - gapic/v3beta1/types +By default, you will get ``v3``. A beta release, spelled ``v3beta1`` is +provided for preview of upcoming features. In order to use this, you will +want to import from ``google.cloud.translate_v3beta1`` in lieu of +``google.cloud.translate``. The previous release ``v2`` is also available. +Import from ``google.cloud.translate_v2`` to use this release. -An API and type reference is provided for v2: .. toctree:: - :maxdepth: 2 - - client + :maxdepth: 2 + + v3 + v3beta1 + v2 Changelog diff --git a/translate/docs/v2.rst b/translate/docs/v2.rst new file mode 100644 index 000000000000..d8e7f23789bb --- /dev/null +++ b/translate/docs/v2.rst @@ -0,0 +1,7 @@ +v2 +=== + +.. toctree:: + :maxdepth: 2 + + client diff --git a/translate/docs/v3.rst b/translate/docs/v3.rst new file mode 100644 index 000000000000..b6b8cd17e1e6 --- /dev/null +++ b/translate/docs/v3.rst @@ -0,0 +1,8 @@ +v3 +=== + +.. toctree:: + :maxdepth: 2 + + gapic/v3/api + gapic/v3/types diff --git a/translate/docs/v3beta1.rst b/translate/docs/v3beta1.rst new file mode 100644 index 000000000000..368aed30e243 --- /dev/null +++ b/translate/docs/v3beta1.rst @@ -0,0 +1,8 @@ +v3beta1 +======= + +.. toctree:: + :maxdepth: 2 + + gapic/v3beta1/api + gapic/v3beta1/types diff --git a/translate/google/cloud/translate_v3/__init__.py b/translate/google/cloud/translate_v3/__init__.py new file mode 100644 index 000000000000..cdd64c12446a --- /dev/null +++ b/translate/google/cloud/translate_v3/__init__.py @@ -0,0 +1,30 @@ +# -*- 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_v3 import types +from google.cloud.translate_v3.gapic import enums +from google.cloud.translate_v3.gapic import translation_service_client + + +class TranslationServiceClient(translation_service_client.TranslationServiceClient): + __doc__ = translation_service_client.TranslationServiceClient.__doc__ + enums = enums + + +__all__ = ("enums", "types", "TranslationServiceClient") diff --git a/translate/google/cloud/translate_v3/gapic/__init__.py b/translate/google/cloud/translate_v3/gapic/__init__.py new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/translate/google/cloud/translate_v3/gapic/enums.py b/translate/google/cloud/translate_v3/gapic/enums.py new file mode 100644 index 000000000000..051328dab5b6 --- /dev/null +++ b/translate/google/cloud/translate_v3/gapic/enums.py @@ -0,0 +1,91 @@ +# -*- 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. + +"""Wrappers for protocol buffer enum types.""" + +import enum + + +class BatchTranslateMetadata(object): + class State(enum.IntEnum): + """ + State of the job. + + Attributes: + STATE_UNSPECIFIED (int): Invalid. + RUNNING (int): Request is being processed. + SUCCEEDED (int): The batch is processed, and at least one item was successfully + processed. + FAILED (int): The batch is done and no item was successfully processed. + CANCELLING (int): Request is in the process of being canceled after caller invoked + longrunning.Operations.CancelOperation on the request id. + CANCELLED (int): 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. + """ + + STATE_UNSPECIFIED = 0 + RUNNING = 1 + SUCCEEDED = 2 + FAILED = 3 + CANCELLING = 4 + CANCELLED = 5 + + +class CreateGlossaryMetadata(object): + class State(enum.IntEnum): + """ + Enumerates the possible states that the creation request can be in. + + Attributes: + STATE_UNSPECIFIED (int): Invalid. + RUNNING (int): Request is being processed. + SUCCEEDED (int): The glossary was successfully created. + FAILED (int): Failed to create the glossary. + CANCELLING (int): Request is in the process of being canceled after caller invoked + longrunning.Operations.CancelOperation on the request id. + CANCELLED (int): The glossary creation request was successfully canceled. + """ + + STATE_UNSPECIFIED = 0 + RUNNING = 1 + SUCCEEDED = 2 + FAILED = 3 + CANCELLING = 4 + CANCELLED = 5 + + +class DeleteGlossaryMetadata(object): + class State(enum.IntEnum): + """ + Enumerates the possible states that the creation request can be in. + + Attributes: + STATE_UNSPECIFIED (int): Invalid. + RUNNING (int): Request is being processed. + SUCCEEDED (int): The glossary was successfully deleted. + FAILED (int): Failed to delete the glossary. + CANCELLING (int): Request is in the process of being canceled after caller invoked + longrunning.Operations.CancelOperation on the request id. + CANCELLED (int): The glossary deletion request was successfully canceled. + """ + + STATE_UNSPECIFIED = 0 + RUNNING = 1 + SUCCEEDED = 2 + FAILED = 3 + CANCELLING = 4 + CANCELLED = 5 diff --git a/translate/google/cloud/translate_v3/gapic/translation_service_client.py b/translate/google/cloud/translate_v3/gapic/translation_service_client.py new file mode 100644 index 000000000000..bb173e5c2ccc --- /dev/null +++ b/translate/google/cloud/translate_v3/gapic/translation_service_client.py @@ -0,0 +1,1097 @@ +# -*- 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.v3 TranslationService API.""" + +import functools +import pkg_resources +import warnings + +from google.oauth2 import service_account +import google.api_core.client_options +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.gapic_v1.routing_header +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_v3.gapic import enums +from google.cloud.translate_v3.gapic import translation_service_client_config +from google.cloud.translate_v3.gapic.transports import ( + translation_service_grpc_transport, +) +from google.cloud.translate_v3.proto import translation_service_pb2 +from google.cloud.translate_v3.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.v3.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 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, + ) + + @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, + ) + + def __init__( + self, + transport=None, + channel=None, + credentials=None, + client_config=None, + client_info=None, + client_options=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. + client_options (Union[dict, google.api_core.client_options.ClientOptions]): + Client options used to set user options on the client. API Endpoint + should be set through client_options. + """ + # 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, + ) + + api_endpoint = self.SERVICE_ADDRESS + if client_options: + if type(client_options) == dict: + client_options = google.api_core.client_options.from_dict( + client_options + ) + if client_options.api_endpoint: + api_endpoint = client_options.api_endpoint + + # 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, + address=api_endpoint, + ) + 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=api_endpoint, 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, + parent, + mime_type=None, + source_language_code=None, + model=None, + glossary_config=None, + labels=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_v3 + >>> + >>> client = translate_v3.TranslationServiceClient() + >>> + >>> # TODO: Initialize `contents`: + >>> contents = [] + >>> + >>> # TODO: Initialize `target_language_code`: + >>> target_language_code = '' + >>> parent = client.location_path('[PROJECT]', '[LOCATION]') + >>> + >>> response = client.translate_text(contents, target_language_code, parent) + + Args: + contents (list[str]): Required. The content of the input in string format. + We recommend the total content be less than 30k codepoints. + 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. + parent (str): Required. Project or location to make a call. Must refer to a caller's + project. + + Format: ``projects/{project-id}`` or + ``projects/{project-id}/locations/{location-id}``. + + For global calls, use ``projects/{project-id}/locations/global`` or + ``projects/{project-id}``. + + Non-global location is required for requests using AutoML models or + custom glossaries. + + Models and glossaries must be within the same region (have same + location-id), otherwise an INVALID\_ARGUMENT (400) error is returned. + mime_type (str): Optional. The format of the source text, for example, "text/html", + "text/plain". If left blank, the MIME type defaults to "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 + source language within the response. + model (str): Optional. The ``model`` type requested for this translation. + + The format depends on model type: + + - AutoML Translation models: + ``projects/{project-id}/locations/{location-id}/models/{model-id}`` + + - 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_v3.types.TranslateTextGlossaryConfig]): Optional. Glossary to be applied. The glossary must be within the same + region (have the same location-id) as the model, otherwise an + INVALID\_ARGUMENT (400) error is returned. + + If a dict is provided, it must be of the same form as the protobuf + message :class:`~google.cloud.translate_v3.types.TranslateTextGlossaryConfig` + labels (dict[str -> str]): Optional. The labels with user-defined metadata for the request. + + Label keys and values can be no longer than 63 characters + (Unicode codepoints), can only contain lowercase letters, numeric + characters, underscores and dashes. International characters are allowed. + Label values are optional. Label keys must start with a letter. + + See https://goo.gl/xmQnxf for more information on and examples of labels. + retry (Optional[google.api_core.retry.Retry]): A retry object used + to retry requests. If ``None`` is specified, requests will + be retried using a default configuration. + 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_v3.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, + parent=parent, + mime_type=mime_type, + source_language_code=source_language_code, + model=model, + glossary_config=glossary_config, + labels=labels, + ) + if metadata is None: + metadata = [] + metadata = list(metadata) + try: + routing_header = [("parent", parent)] + except AttributeError: + pass + else: + routing_metadata = google.api_core.gapic_v1.routing_header.to_grpc_metadata( + routing_header + ) + metadata.append(routing_metadata) + + return self._inner_api_calls["translate_text"]( + request, retry=retry, timeout=timeout, metadata=metadata + ) + + def detect_language( + self, + parent, + model=None, + content=None, + mime_type=None, + labels=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_v3 + >>> + >>> client = translate_v3.TranslationServiceClient() + >>> + >>> parent = client.location_path('[PROJECT]', '[LOCATION]') + >>> + >>> response = client.detect_language(parent) + + Args: + parent (str): Required. Project or location to make a call. Must refer to a caller's + project. + + Format: ``projects/{project-id}/locations/{location-id}`` or + ``projects/{project-id}``. + + For global calls, use ``projects/{project-id}/locations/global`` or + ``projects/{project-id}``. + + Only models within the same region (has same location-id) can be used. + Otherwise an INVALID\_ARGUMENT (400) error is returned. + model (str): Optional. The language detection model to be used. + + Format: + ``projects/{project-id}/locations/{location-id}/models/language-detection/{model-id}`` + + Only one language detection model is currently supported: + ``projects/{project-id}/locations/{location-id}/models/language-detection/default``. + + If not specified, the default model is 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 defaults to "text/html". + labels (dict[str -> str]): Optional. The labels with user-defined metadata for the request. + + Label keys and values can be no longer than 63 characters + (Unicode codepoints), can only contain lowercase letters, numeric + characters, underscores and dashes. International characters are allowed. + Label values are optional. Label keys must start with a letter. + + See https://goo.gl/xmQnxf for more information on and examples of labels. + retry (Optional[google.api_core.retry.Retry]): A retry object used + to retry requests. If ``None`` is specified, requests will + be retried using a default configuration. + 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_v3.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, + labels=labels, + ) + if metadata is None: + metadata = [] + metadata = list(metadata) + try: + routing_header = [("parent", parent)] + except AttributeError: + pass + else: + routing_metadata = google.api_core.gapic_v1.routing_header.to_grpc_metadata( + routing_header + ) + metadata.append(routing_metadata) + + return self._inner_api_calls["detect_language"]( + request, retry=retry, timeout=timeout, metadata=metadata + ) + + def get_supported_languages( + self, + parent, + 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_v3 + >>> + >>> client = translate_v3.TranslationServiceClient() + >>> + >>> parent = client.location_path('[PROJECT]', '[LOCATION]') + >>> + >>> response = client.get_supported_languages(parent) + + Args: + parent (str): Required. Project or location to make a call. Must refer to a caller's + project. + + Format: ``projects/{project-id}`` or + ``projects/{project-id}/locations/{location-id}``. + + For global calls, use ``projects/{project-id}/locations/global`` or + ``projects/{project-id}``. + + Non-global location is required for AutoML models. + + Only models within the same region (have same location-id) can be used, + otherwise an INVALID\_ARGUMENT (400) error is returned. + display_language_code (str): Optional. The language to use to return localized, human readable names + of supported languages. If missing, then display names are not returned + in a response. + model (str): Optional. Get supported languages of this model. + + The format depends on model type: + + - AutoML Translation models: + ``projects/{project-id}/locations/{location-id}/models/{model-id}`` + + - 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 base (PBMT) model. + retry (Optional[google.api_core.retry.Retry]): A retry object used + to retry requests. If ``None`` is specified, requests will + be retried using a default configuration. + 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_v3.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 + ) + if metadata is None: + metadata = [] + metadata = list(metadata) + try: + routing_header = [("parent", parent)] + except AttributeError: + pass + else: + routing_metadata = google.api_core.gapic_v1.routing_header.to_grpc_metadata( + routing_header + ) + metadata.append(routing_metadata) + + return self._inner_api_calls["get_supported_languages"]( + request, retry=retry, timeout=timeout, metadata=metadata + ) + + def batch_translate_text( + self, + parent, + source_language_code, + target_language_codes, + input_configs, + output_config, + models=None, + glossaries=None, + labels=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_v3 + >>> + >>> client = translate_v3.TranslationServiceClient() + >>> + >>> parent = client.location_path('[PROJECT]', '[LOCATION]') + >>> + >>> # 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(parent, 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: + parent (str): Required. Location to make a call. Must refer to a caller's project. + + Format: ``projects/{project-id}/locations/{location-id}``. + + The ``global`` location is not supported for batch translation. + + Only AutoML Translation models or glossaries within the same region + (have the same location-id) can be used, otherwise an INVALID\_ARGUMENT + (400) error is returned. + 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_v3.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_v3.types.InputConfig` + output_config (Union[dict, ~google.cloud.translate_v3.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_v3.types.OutputConfig` + 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 an AutoML Translation model. + + The value format depends on model type: + + - AutoML Translation models: + ``projects/{project-id}/locations/{location-id}/models/{model-id}`` + + - 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 (nmt) is used. + glossaries (dict[str -> Union[dict, ~google.cloud.translate_v3.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_v3.types.TranslateTextGlossaryConfig` + labels (dict[str -> str]): Optional. The labels with user-defined metadata for the request. + + Label keys and values can be no longer than 63 characters + (Unicode codepoints), can only contain lowercase letters, numeric + characters, underscores and dashes. International characters are allowed. + Label values are optional. Label keys must start with a letter. + + See https://goo.gl/xmQnxf for more information on and examples of labels. + retry (Optional[google.api_core.retry.Retry]): A retry object used + to retry requests. If ``None`` is specified, requests will + be retried using a default configuration. + 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_v3.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( + parent=parent, + source_language_code=source_language_code, + target_language_codes=target_language_codes, + input_configs=input_configs, + output_config=output_config, + models=models, + glossaries=glossaries, + labels=labels, + ) + if metadata is None: + metadata = [] + metadata = list(metadata) + try: + routing_header = [("parent", parent)] + except AttributeError: + pass + else: + routing_metadata = google.api_core.gapic_v1.routing_header.to_grpc_metadata( + routing_header + ) + metadata.append(routing_metadata) + + 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_v3 + >>> + >>> client = translate_v3.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_v3.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_v3.types.Glossary` + retry (Optional[google.api_core.retry.Retry]): A retry object used + to retry requests. If ``None`` is specified, requests will + be retried using a default configuration. + 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_v3.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 + ) + if metadata is None: + metadata = [] + metadata = list(metadata) + try: + routing_header = [("parent", parent)] + except AttributeError: + pass + else: + routing_metadata = google.api_core.gapic_v1.routing_header.to_grpc_metadata( + routing_header + ) + metadata.append(routing_metadata) + + 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, + 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_v3 + >>> + >>> client = translate_v3.TranslationServiceClient() + >>> + >>> parent = client.location_path('[PROJECT]', '[LOCATION]') + >>> + >>> # Iterate over all results + >>> for element in client.list_glossaries(parent): + ... # process element + ... pass + >>> + >>> + >>> # Alternatively: + >>> + >>> # Iterate over results one page at a time + >>> for page in client.list_glossaries(parent).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. + Filtering is not supported yet, and the parameter currently has no effect. + 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 + be retried using a default configuration. + 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.api_core.page_iterator.PageIterator` instance. + An iterable of :class:`~google.cloud.translate_v3.types.Glossary` instances. + You can also iterate over the pages of the response + using its `pages` property. + + 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_ + ) + if metadata is None: + metadata = [] + metadata = list(metadata) + try: + routing_header = [("parent", parent)] + except AttributeError: + pass + else: + routing_metadata = google.api_core.gapic_v1.routing_header.to_grpc_metadata( + routing_header + ) + metadata.append(routing_metadata) + + 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_v3 + >>> + >>> client = translate_v3.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 + be retried using a default configuration. + 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_v3.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) + if metadata is None: + metadata = [] + metadata = list(metadata) + try: + routing_header = [("name", name)] + except AttributeError: + pass + else: + routing_metadata = google.api_core.gapic_v1.routing_header.to_grpc_metadata( + routing_header + ) + metadata.append(routing_metadata) + + 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_v3 + >>> + >>> client = translate_v3.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 + be retried using a default configuration. + 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_v3.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) + if metadata is None: + metadata = [] + metadata = list(metadata) + try: + routing_header = [("name", name)] + except AttributeError: + pass + else: + routing_metadata = google.api_core.gapic_v1.routing_header.to_grpc_metadata( + routing_header + ) + metadata.append(routing_metadata) + + 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/translate/google/cloud/translate_v3/gapic/translation_service_client_config.py b/translate/google/cloud/translate_v3/gapic/translation_service_client_config.py new file mode 100644 index 000000000000..20179f1a6ac1 --- /dev/null +++ b/translate/google/cloud/translate_v3/gapic/translation_service_client_config.py @@ -0,0 +1,63 @@ +config = { + "interfaces": { + "google.cloud.translation.v3.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/translate/google/cloud/translate_v3/gapic/transports/__init__.py b/translate/google/cloud/translate_v3/gapic/transports/__init__.py new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/translate/google/cloud/translate_v3/gapic/transports/translation_service_grpc_transport.py b/translate/google/cloud/translate_v3/gapic/transports/translation_service_grpc_transport.py new file mode 100644 index 000000000000..ed038e376db0 --- /dev/null +++ b/translate/google/cloud/translate_v3/gapic/transports/translation_service_grpc_transport.py @@ -0,0 +1,234 @@ +# -*- 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_v3.proto import translation_service_pb2_grpc + + +class TranslationServiceGrpcTransport(object): + """gRPC transport class providing stubs for + google.cloud.translation.v3 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, + options={ + "grpc.max_send_message_length": -1, + "grpc.max_receive_message_length": -1, + }.items(), + ) + + 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, **kwargs + ): + """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. + kwargs (dict): Keyword arguments, which are passed to the + channel creation. + + Returns: + grpc.Channel: A gRPC channel object. + """ + return google.api_core.grpc_helpers.create_channel( + address, credentials=credentials, scopes=cls._OAUTH_SCOPES, **kwargs + ) + + @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/translate/google/cloud/translate_v3/proto/__init__.py b/translate/google/cloud/translate_v3/proto/__init__.py new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/translate/google/cloud/translate_v3/proto/translation_service.proto b/translate/google/cloud/translate_v3/proto/translation_service.proto new file mode 100644 index 000000000000..91bbd7fbc8db --- /dev/null +++ b/translate/google/cloud/translate_v3/proto/translation_service.proto @@ -0,0 +1,837 @@ +// 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.v3; + +import "google/api/annotations.proto"; +import "google/api/resource.proto"; +import "google/longrunning/operations.proto"; +import "google/protobuf/timestamp.proto"; +import "google/api/client.proto"; + +option cc_enable_arenas = true; +option csharp_namespace = "Google.Cloud.Translate.V3"; +option go_package = "google.golang.org/genproto/googleapis/cloud/translate/v3;translate"; +option java_multiple_files = true; +option java_outer_classname = "TranslationServiceProto"; +option java_package = "com.google.cloud.translate.v3"; +option php_namespace = "Google\\Cloud\\Translate\\V3"; +option ruby_package = "Google::Cloud::Translate::V3"; + +// Proto file for the Cloud Translation API (v3). + +// Provides natural language translation operations. +service TranslationService { + option (google.api.default_host) = "translation.googleapis.com"; + option (google.api.oauth_scopes) = + "https://www.googleapis.com/auth/cloud-platform," + "https://www.googleapis.com/auth/cloud-translation"; + + // Translates input text and returns translated text. + rpc TranslateText(TranslateTextRequest) returns (TranslateTextResponse) { + option (google.api.http) = { + post: "/v3/{parent=projects/*/locations/*}:translateText" + body: "*" + additional_bindings { + post: "/v3/{parent=projects/*}:translateText" + body: "*" + } + }; + } + + // Detects the language of text within a request. + rpc DetectLanguage(DetectLanguageRequest) returns (DetectLanguageResponse) { + option (google.api.http) = { + post: "/v3/{parent=projects/*/locations/*}:detectLanguage" + body: "*" + additional_bindings { + post: "/v3/{parent=projects/*}:detectLanguage" + body: "*" + } + }; + } + + // Returns a list of supported languages for translation. + rpc GetSupportedLanguages(GetSupportedLanguagesRequest) returns (SupportedLanguages) { + option (google.api.http) = { + get: "/v3/{parent=projects/*/locations/*}/supportedLanguages" + additional_bindings { + get: "/v3/{parent=projects/*}/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: "/v3/{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: "/v3/{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: "/v3/{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: "/v3/{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: "/v3/{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 match is case-insensitive. + // 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 content be less than 30k codepoints. + // 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 defaults to "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 + // 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; + + // Required. Project or location to make a call. Must refer to a caller's + // project. + // + // Format: `projects/{project-id}` or + // `projects/{project-id}/locations/{location-id}`. + // + // For global calls, use `projects/{project-id}/locations/global` or + // `projects/{project-id}`. + // + // Non-global location is required for requests using AutoML models or + // custom glossaries. + // + // Models and glossaries must be within the same region (have same + // location-id), otherwise an INVALID_ARGUMENT (400) error is returned. + string parent = 8; + + // Optional. The `model` type requested for this translation. + // + // The format depends on model type: + // + // - AutoML Translation models: + // `projects/{project-id}/locations/{location-id}/models/{model-id}` + // + // - 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 must be + // within the same region (have the same location-id) as the model, otherwise + // an INVALID_ARGUMENT (400) error is returned. + TranslateTextGlossaryConfig glossary_config = 7; + + // Optional. The labels with user-defined metadata for the request. + // + // Label keys and values can be no longer than 63 characters + // (Unicode codepoints), can only contain lowercase letters, numeric + // characters, underscores and dashes. International characters are allowed. + // Label values are optional. Label keys must start with a letter. + // + // See https://goo.gl/xmQnxf for more information on and examples of labels. + map labels = 10; +} + +message TranslateTextResponse { + // Text translation responses with no glossary applied. + // This field has the same length as + // [`contents`][google.cloud.translation.v3.TranslateTextRequest.contents]. + repeated Translation translations = 1; + + // Text translation responses if a glossary is provided in the request. + // This can be the same as + // [`translations`][google.cloud.translation.v3.TranslateTextResponse.translations] if no terms apply. + // This field has the same length as + // [`contents`][google.cloud.translation.v3.TranslateTextRequest.contents]. + 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 is 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 { + // Required. Project or location to make a call. Must refer to a caller's + // project. + // + // Format: `projects/{project-id}/locations/{location-id}` or + // `projects/{project-id}`. + // + // For global calls, use `projects/{project-id}/locations/global` or + // `projects/{project-id}`. + // + // Only models within the same region (has same location-id) can be used. + // Otherwise an INVALID_ARGUMENT (400) error is returned. + string parent = 5; + + // Optional. The language detection model to be used. + // + // Format: + // `projects/{project-id}/locations/{location-id}/models/language-detection/{model-id}` + // + // Only one language detection model is currently supported: + // `projects/{project-id}/locations/{location-id}/models/language-detection/default`. + // + // If not specified, the default model is 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 defaults to "text/html". + string mime_type = 3; + + // Optional. The labels with user-defined metadata for the request. + // + // Label keys and values can be no longer than 63 characters + // (Unicode codepoints), can only contain lowercase letters, numeric + // characters, underscores and dashes. International characters are allowed. + // Label values are optional. Label keys must start with a letter. + // + // See https://goo.gl/xmQnxf for more information on and examples of labels. + map labels = 6; +} + +// 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 { + // Required. Project or location to make a call. Must refer to a caller's + // project. + // + // Format: `projects/{project-id}` or + // `projects/{project-id}/locations/{location-id}`. + // + // For global calls, use `projects/{project-id}/locations/global` or + // `projects/{project-id}`. + // + // Non-global location is required for AutoML models. + // + // Only models within the same region (have same location-id) can be used, + // otherwise an INVALID_ARGUMENT (400) error is returned. + string parent = 3; + + // Optional. The language to use to return localized, human readable names + // of supported languages. If missing, then display names are not returned + // in a response. + string display_language_code = 1; + + // Optional. Get supported languages of this model. + // + // The format depends on model type: + // + // - AutoML Translation models: + // `projects/{project-id}/locations/{location-id}/models/{model-id}` + // + // - 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 base (PBMT) 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 Google Cloud Storage location for the input content. +message GcsSource { + // Required. Source data URI. For example, `gs://my_bucket/my_object`. + string input_uri = 1; +} + +// Input configuration for BatchTranslateText request. +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. + // Note that the input tsv must be RFC 4180 compliant. + // + // You could use https://github.com/Clever/csvlint to check potential + // formatting errors in your tsv file. + // csvlint --delimiter='\t' your_input_file.tsv + // + // The other supported file extensions are `.txt` or `.html`, which is + // treated as a single large chunk of text. + GcsSource gcs_source = 2; + } +} + +// The Google Cloud Storage location for the output content. +message GcsDestination { + // Required. There must be no files under 'output_uri_prefix'. + // 'output_uri_prefix' must end with "/" and start with "gs://", otherwise an + // INVALID_ARGUMENT (400) error is returned. + string output_uri_prefix = 1; +} + +// Output configuration for BatchTranslateText request. +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 and glossary_errors_file are always empty + // strings if the 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 contains 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 { + // Required. Location to make a call. Must refer to a caller's project. + // + // Format: `projects/{project-id}/locations/{location-id}`. + // + // The `global` location is not supported for batch translation. + // + // Only AutoML Translation models or glossaries within the same region (have + // the same location-id) can be used, otherwise an INVALID_ARGUMENT (400) + // error 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 an AutoML Translation model. + // + // The value format depends on model type: + // + // - AutoML Translation models: + // `projects/{project-id}/locations/{location-id}/models/{model-id}` + // + // - 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 (nmt) 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; + + // Optional. The labels with user-defined metadata for the request. + // + // Label keys and values can be no longer than 63 characters + // (Unicode codepoints), can only contain lowercase letters, numeric + // characters, underscores and dashes. International characters are allowed. + // Label values are optional. Label keys must start with a letter. + // + // See https://goo.gl/xmQnxf for more information on and examples of labels. + map labels = 9; +} + +// 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 was successfully + // processed. + SUCCEEDED = 2; + + // The batch is done and no item was 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 and 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 the filename 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 term sets glossaries: + // + // - CSV (`.csv`): Multi-column CSV file defining equivalent glossary terms + // in multiple languages. The format is defined for Google Translation + // Toolkit and documented in [Use a + // glossary](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 glossaries. + 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 term set glossaries. + 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 glossaries. + LanguageCodePair language_pair = 3; + + // Used with equivalent term set glossaries. + 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. + // Filtering is not supported yet, and the parameter currently has no effect. + // 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 was 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 was 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 was 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/translate/google/cloud/translate_v3/proto/translation_service_pb2.py b/translate/google/cloud/translate_v3/proto/translation_service_pb2.py new file mode 100644 index 000000000000..37ac5d4514d6 --- /dev/null +++ b/translate/google/cloud/translate_v3/proto/translation_service_pb2.py @@ -0,0 +1,3835 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: google/cloud/translation_v3/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.api import resource_pb2 as google_dot_api_dot_resource__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 +from google.api import client_pb2 as google_dot_api_dot_client__pb2 + + +DESCRIPTOR = _descriptor.FileDescriptor( + name="google/cloud/translation_v3/proto/translation_service.proto", + package="google.cloud.translation.v3", + syntax="proto3", + serialized_options=_b( + "\n\035com.google.cloud.translate.v3B\027TranslationServiceProtoP\001ZBgoogle.golang.org/genproto/googleapis/cloud/translate/v3;translate\370\001\001\252\002\031Google.Cloud.Translate.V3\312\002\031Google\\Cloud\\Translate\\V3\352\002\034Google::Cloud::Translate::V3" + ), + serialized_pb=_b( + '\n;google/cloud/translation_v3/proto/translation_service.proto\x12\x1bgoogle.cloud.translation.v3\x1a\x1cgoogle/api/annotations.proto\x1a\x19google/api/resource.proto\x1a#google/longrunning/operations.proto\x1a\x1fgoogle/protobuf/timestamp.proto\x1a\x17google/api/client.proto"D\n\x1bTranslateTextGlossaryConfig\x12\x10\n\x08glossary\x18\x01 \x01(\t\x12\x13\n\x0bignore_case\x18\x02 \x01(\x08"\xe7\x02\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\x12Q\n\x0fglossary_config\x18\x07 \x01(\x0b\x32\x38.google.cloud.translation.v3.TranslateTextGlossaryConfig\x12M\n\x06labels\x18\n \x03(\x0b\x32=.google.cloud.translation.v3.TranslateTextRequest.LabelsEntry\x1a-\n\x0bLabelsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01"\xa0\x01\n\x15TranslateTextResponse\x12>\n\x0ctranslations\x18\x01 \x03(\x0b\x32(.google.cloud.translation.v3.Translation\x12G\n\x15glossary_translations\x18\x03 \x03(\x0b\x32(.google.cloud.translation.v3.Translation"\xa8\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\x12Q\n\x0fglossary_config\x18\x03 \x01(\x0b\x32\x38.google.cloud.translation.v3.TranslateTextGlossaryConfig"\xe5\x01\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(\t\x12N\n\x06labels\x18\x06 \x03(\x0b\x32>.google.cloud.translation.v3.DetectLanguageRequest.LabelsEntry\x1a-\n\x0bLabelsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\x42\x08\n\x06source"=\n\x10\x44\x65tectedLanguage\x12\x15\n\rlanguage_code\x18\x01 \x01(\t\x12\x12\n\nconfidence\x18\x02 \x01(\x02"Z\n\x16\x44\x65tectLanguageResponse\x12@\n\tlanguages\x18\x01 \x03(\x0b\x32-.google.cloud.translation.v3.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"W\n\x12SupportedLanguages\x12\x41\n\tlanguages\x18\x01 \x03(\x0b\x32..google.cloud.translation.v3.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"h\n\x0bInputConfig\x12\x11\n\tmime_type\x18\x01 \x01(\t\x12<\n\ngcs_source\x18\x02 \x01(\x0b\x32&.google.cloud.translation.v3.GcsSourceH\x00\x42\x08\n\x06source"+\n\x0eGcsDestination\x12\x19\n\x11output_uri_prefix\x18\x01 \x01(\t"e\n\x0cOutputConfig\x12\x46\n\x0fgcs_destination\x18\x01 \x01(\x0b\x32+.google.cloud.translation.v3.GcsDestinationH\x00\x42\r\n\x0b\x64\x65stination"\xba\x05\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\x12R\n\x06models\x18\x04 \x03(\x0b\x32\x42.google.cloud.translation.v3.BatchTranslateTextRequest.ModelsEntry\x12?\n\rinput_configs\x18\x05 \x03(\x0b\x32(.google.cloud.translation.v3.InputConfig\x12@\n\routput_config\x18\x06 \x01(\x0b\x32).google.cloud.translation.v3.OutputConfig\x12Z\n\nglossaries\x18\x07 \x03(\x0b\x32\x46.google.cloud.translation.v3.BatchTranslateTextRequest.GlossariesEntry\x12R\n\x06labels\x18\t \x03(\x0b\x32\x42.google.cloud.translation.v3.BatchTranslateTextRequest.LabelsEntry\x1a-\n\x0bModelsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\x1ak\n\x0fGlossariesEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12G\n\x05value\x18\x02 \x01(\x0b\x32\x38.google.cloud.translation.v3.TranslateTextGlossaryConfig:\x02\x38\x01\x1a-\n\x0bLabelsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01"\xce\x02\n\x16\x42\x61tchTranslateMetadata\x12H\n\x05state\x18\x01 \x01(\x0e\x32\x39.google.cloud.translation.v3.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"]\n\x13GlossaryInputConfig\x12<\n\ngcs_source\x18\x01 \x01(\x0b\x32&.google.cloud.translation.v3.GcsSourceH\x00\x42\x08\n\x06source"\x84\x04\n\x08Glossary\x12\x0c\n\x04name\x18\x01 \x01(\t\x12O\n\rlanguage_pair\x18\x03 \x01(\x0b\x32\x36.google.cloud.translation.v3.Glossary.LanguageCodePairH\x00\x12T\n\x12language_codes_set\x18\x04 \x01(\x0b\x32\x36.google.cloud.translation.v3.Glossary.LanguageCodesSetH\x00\x12\x46\n\x0cinput_config\x18\x05 \x01(\x0b\x32\x30.google.cloud.translation.v3.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"`\n\x15\x43reateGlossaryRequest\x12\x0e\n\x06parent\x18\x01 \x01(\t\x12\x37\n\x08glossary\x18\x02 \x01(\x0b\x32%.google.cloud.translation.v3.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"l\n\x16ListGlossariesResponse\x12\x39\n\nglossaries\x18\x01 \x03(\x0b\x32%.google.cloud.translation.v3.Glossary\x12\x17\n\x0fnext_page_token\x18\x02 \x01(\t"\x88\x02\n\x16\x43reateGlossaryMetadata\x12\x0c\n\x04name\x18\x01 \x01(\t\x12H\n\x05state\x18\x02 \x01(\x0e\x32\x39.google.cloud.translation.v3.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"\x88\x02\n\x16\x44\x65leteGlossaryMetadata\x12\x0c\n\x04name\x18\x01 \x01(\t\x12H\n\x05state\x18\x02 \x01(\x0e\x32\x39.google.cloud.translation.v3.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\xa1\r\n\x12TranslationService\x12\xe0\x01\n\rTranslateText\x12\x31.google.cloud.translation.v3.TranslateTextRequest\x1a\x32.google.cloud.translation.v3.TranslateTextResponse"h\x82\xd3\xe4\x93\x02\x62"1/v3/{parent=projects/*/locations/*}:translateText:\x01*Z*"%/v3/{parent=projects/*}:translateText:\x01*\x12\xe5\x01\n\x0e\x44\x65tectLanguage\x12\x32.google.cloud.translation.v3.DetectLanguageRequest\x1a\x33.google.cloud.translation.v3.DetectLanguageResponse"j\x82\xd3\xe4\x93\x02\x64"2/v3/{parent=projects/*/locations/*}:detectLanguage:\x01*Z+"&/v3/{parent=projects/*}:detectLanguage:\x01*\x12\xf1\x01\n\x15GetSupportedLanguages\x12\x39.google.cloud.translation.v3.GetSupportedLanguagesRequest\x1a/.google.cloud.translation.v3.SupportedLanguages"l\x82\xd3\xe4\x93\x02\x66\x12\x36/v3/{parent=projects/*/locations/*}/supportedLanguagesZ,\x12*/v3/{parent=projects/*}/supportedLanguages\x12\xae\x01\n\x12\x42\x61tchTranslateText\x12\x36.google.cloud.translation.v3.BatchTranslateTextRequest\x1a\x1d.google.longrunning.Operation"A\x82\xd3\xe4\x93\x02;"6/v3/{parent=projects/*/locations/*}:batchTranslateText:\x01*\x12\xa5\x01\n\x0e\x43reateGlossary\x12\x32.google.cloud.translation.v3.CreateGlossaryRequest\x1a\x1d.google.longrunning.Operation"@\x82\xd3\xe4\x93\x02:"./v3/{parent=projects/*/locations/*}/glossaries:\x08glossary\x12\xb1\x01\n\x0eListGlossaries\x12\x32.google.cloud.translation.v3.ListGlossariesRequest\x1a\x33.google.cloud.translation.v3.ListGlossariesResponse"6\x82\xd3\xe4\x93\x02\x30\x12./v3/{parent=projects/*/locations/*}/glossaries\x12\x9d\x01\n\x0bGetGlossary\x12/.google.cloud.translation.v3.GetGlossaryRequest\x1a%.google.cloud.translation.v3.Glossary"6\x82\xd3\xe4\x93\x02\x30\x12./v3/{name=projects/*/locations/*/glossaries/*}\x12\x9b\x01\n\x0e\x44\x65leteGlossary\x12\x32.google.cloud.translation.v3.DeleteGlossaryRequest\x1a\x1d.google.longrunning.Operation"6\x82\xd3\xe4\x93\x02\x30*./v3/{name=projects/*/locations/*/glossaries/*}\x1a\x80\x01\xca\x41\x1atranslation.googleapis.com\xd2\x41`https://www.googleapis.com/auth/cloud-platform,https://www.googleapis.com/auth/cloud-translationB\xd8\x01\n\x1d\x63om.google.cloud.translate.v3B\x17TranslationServiceProtoP\x01ZBgoogle.golang.org/genproto/googleapis/cloud/translate/v3;translate\xf8\x01\x01\xaa\x02\x19Google.Cloud.Translate.V3\xca\x02\x19Google\\Cloud\\Translate\\V3\xea\x02\x1cGoogle::Cloud::Translate::V3b\x06proto3' + ), + dependencies=[ + google_dot_api_dot_annotations__pb2.DESCRIPTOR, + google_dot_api_dot_resource__pb2.DESCRIPTOR, + google_dot_longrunning_dot_operations__pb2.DESCRIPTOR, + google_dot_protobuf_dot_timestamp__pb2.DESCRIPTOR, + google_dot_api_dot_client__pb2.DESCRIPTOR, + ], +) + + +_BATCHTRANSLATEMETADATA_STATE = _descriptor.EnumDescriptor( + name="State", + full_name="google.cloud.translation.v3.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=2915, + serialized_end=3016, +) +_sym_db.RegisterEnumDescriptor(_BATCHTRANSLATEMETADATA_STATE) + +_CREATEGLOSSARYMETADATA_STATE = _descriptor.EnumDescriptor( + name="State", + full_name="google.cloud.translation.v3.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=2915, + serialized_end=3016, +) +_sym_db.RegisterEnumDescriptor(_CREATEGLOSSARYMETADATA_STATE) + +_DELETEGLOSSARYMETADATA_STATE = _descriptor.EnumDescriptor( + name="State", + full_name="google.cloud.translation.v3.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=2915, + serialized_end=3016, +) +_sym_db.RegisterEnumDescriptor(_DELETEGLOSSARYMETADATA_STATE) + + +_TRANSLATETEXTGLOSSARYCONFIG = _descriptor.Descriptor( + name="TranslateTextGlossaryConfig", + full_name="google.cloud.translation.v3.TranslateTextGlossaryConfig", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="glossary", + full_name="google.cloud.translation.v3.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.v3.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=244, + serialized_end=312, +) + + +_TRANSLATETEXTREQUEST_LABELSENTRY = _descriptor.Descriptor( + name="LabelsEntry", + full_name="google.cloud.translation.v3.TranslateTextRequest.LabelsEntry", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="key", + full_name="google.cloud.translation.v3.TranslateTextRequest.LabelsEntry.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.v3.TranslateTextRequest.LabelsEntry.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=629, + serialized_end=674, +) + +_TRANSLATETEXTREQUEST = _descriptor.Descriptor( + name="TranslateTextRequest", + full_name="google.cloud.translation.v3.TranslateTextRequest", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="contents", + full_name="google.cloud.translation.v3.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.v3.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.v3.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.v3.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.v3.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.v3.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.v3.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, + ), + _descriptor.FieldDescriptor( + name="labels", + full_name="google.cloud.translation.v3.TranslateTextRequest.labels", + index=7, + number=10, + 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=[_TRANSLATETEXTREQUEST_LABELSENTRY], + enum_types=[], + serialized_options=None, + is_extendable=False, + syntax="proto3", + extension_ranges=[], + oneofs=[], + serialized_start=315, + serialized_end=674, +) + + +_TRANSLATETEXTRESPONSE = _descriptor.Descriptor( + name="TranslateTextResponse", + full_name="google.cloud.translation.v3.TranslateTextResponse", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="translations", + full_name="google.cloud.translation.v3.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.v3.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=677, + serialized_end=837, +) + + +_TRANSLATION = _descriptor.Descriptor( + name="Translation", + full_name="google.cloud.translation.v3.Translation", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="translated_text", + full_name="google.cloud.translation.v3.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.v3.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.v3.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.v3.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=840, + serialized_end=1008, +) + + +_DETECTLANGUAGEREQUEST_LABELSENTRY = _descriptor.Descriptor( + name="LabelsEntry", + full_name="google.cloud.translation.v3.DetectLanguageRequest.LabelsEntry", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="key", + full_name="google.cloud.translation.v3.DetectLanguageRequest.LabelsEntry.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.v3.DetectLanguageRequest.LabelsEntry.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=629, + serialized_end=674, +) + +_DETECTLANGUAGEREQUEST = _descriptor.Descriptor( + name="DetectLanguageRequest", + full_name="google.cloud.translation.v3.DetectLanguageRequest", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="parent", + full_name="google.cloud.translation.v3.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.v3.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.v3.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.v3.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, + ), + _descriptor.FieldDescriptor( + name="labels", + full_name="google.cloud.translation.v3.DetectLanguageRequest.labels", + index=4, + number=6, + 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=[_DETECTLANGUAGEREQUEST_LABELSENTRY], + enum_types=[], + serialized_options=None, + is_extendable=False, + syntax="proto3", + extension_ranges=[], + oneofs=[ + _descriptor.OneofDescriptor( + name="source", + full_name="google.cloud.translation.v3.DetectLanguageRequest.source", + index=0, + containing_type=None, + fields=[], + ) + ], + serialized_start=1011, + serialized_end=1240, +) + + +_DETECTEDLANGUAGE = _descriptor.Descriptor( + name="DetectedLanguage", + full_name="google.cloud.translation.v3.DetectedLanguage", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="language_code", + full_name="google.cloud.translation.v3.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.v3.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=1242, + serialized_end=1303, +) + + +_DETECTLANGUAGERESPONSE = _descriptor.Descriptor( + name="DetectLanguageResponse", + full_name="google.cloud.translation.v3.DetectLanguageResponse", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="languages", + full_name="google.cloud.translation.v3.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=1305, + serialized_end=1395, +) + + +_GETSUPPORTEDLANGUAGESREQUEST = _descriptor.Descriptor( + name="GetSupportedLanguagesRequest", + full_name="google.cloud.translation.v3.GetSupportedLanguagesRequest", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="parent", + full_name="google.cloud.translation.v3.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.v3.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.v3.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=1397, + serialized_end=1489, +) + + +_SUPPORTEDLANGUAGES = _descriptor.Descriptor( + name="SupportedLanguages", + full_name="google.cloud.translation.v3.SupportedLanguages", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="languages", + full_name="google.cloud.translation.v3.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=1491, + serialized_end=1578, +) + + +_SUPPORTEDLANGUAGE = _descriptor.Descriptor( + name="SupportedLanguage", + full_name="google.cloud.translation.v3.SupportedLanguage", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="language_code", + full_name="google.cloud.translation.v3.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.v3.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.v3.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.v3.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=1580, + serialized_end=1692, +) + + +_GCSSOURCE = _descriptor.Descriptor( + name="GcsSource", + full_name="google.cloud.translation.v3.GcsSource", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="input_uri", + full_name="google.cloud.translation.v3.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=1694, + serialized_end=1724, +) + + +_INPUTCONFIG = _descriptor.Descriptor( + name="InputConfig", + full_name="google.cloud.translation.v3.InputConfig", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="mime_type", + full_name="google.cloud.translation.v3.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.v3.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.v3.InputConfig.source", + index=0, + containing_type=None, + fields=[], + ) + ], + serialized_start=1726, + serialized_end=1830, +) + + +_GCSDESTINATION = _descriptor.Descriptor( + name="GcsDestination", + full_name="google.cloud.translation.v3.GcsDestination", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="output_uri_prefix", + full_name="google.cloud.translation.v3.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=1832, + serialized_end=1875, +) + + +_OUTPUTCONFIG = _descriptor.Descriptor( + name="OutputConfig", + full_name="google.cloud.translation.v3.OutputConfig", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="gcs_destination", + full_name="google.cloud.translation.v3.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.v3.OutputConfig.destination", + index=0, + containing_type=None, + fields=[], + ) + ], + serialized_start=1877, + serialized_end=1978, +) + + +_BATCHTRANSLATETEXTREQUEST_MODELSENTRY = _descriptor.Descriptor( + name="ModelsEntry", + full_name="google.cloud.translation.v3.BatchTranslateTextRequest.ModelsEntry", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="key", + full_name="google.cloud.translation.v3.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.v3.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=2478, + serialized_end=2523, +) + +_BATCHTRANSLATETEXTREQUEST_GLOSSARIESENTRY = _descriptor.Descriptor( + name="GlossariesEntry", + full_name="google.cloud.translation.v3.BatchTranslateTextRequest.GlossariesEntry", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="key", + full_name="google.cloud.translation.v3.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.v3.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=2525, + serialized_end=2632, +) + +_BATCHTRANSLATETEXTREQUEST_LABELSENTRY = _descriptor.Descriptor( + name="LabelsEntry", + full_name="google.cloud.translation.v3.BatchTranslateTextRequest.LabelsEntry", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="key", + full_name="google.cloud.translation.v3.BatchTranslateTextRequest.LabelsEntry.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.v3.BatchTranslateTextRequest.LabelsEntry.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=629, + serialized_end=674, +) + +_BATCHTRANSLATETEXTREQUEST = _descriptor.Descriptor( + name="BatchTranslateTextRequest", + full_name="google.cloud.translation.v3.BatchTranslateTextRequest", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="parent", + full_name="google.cloud.translation.v3.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.v3.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.v3.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.v3.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.v3.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.v3.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.v3.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, + ), + _descriptor.FieldDescriptor( + name="labels", + full_name="google.cloud.translation.v3.BatchTranslateTextRequest.labels", + index=7, + number=9, + 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, + _BATCHTRANSLATETEXTREQUEST_LABELSENTRY, + ], + enum_types=[], + serialized_options=None, + is_extendable=False, + syntax="proto3", + extension_ranges=[], + oneofs=[], + serialized_start=1981, + serialized_end=2679, +) + + +_BATCHTRANSLATEMETADATA = _descriptor.Descriptor( + name="BatchTranslateMetadata", + full_name="google.cloud.translation.v3.BatchTranslateMetadata", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="state", + full_name="google.cloud.translation.v3.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.v3.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.v3.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.v3.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.v3.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=2682, + serialized_end=3016, +) + + +_BATCHTRANSLATERESPONSE = _descriptor.Descriptor( + name="BatchTranslateResponse", + full_name="google.cloud.translation.v3.BatchTranslateResponse", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="total_characters", + full_name="google.cloud.translation.v3.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.v3.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.v3.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.v3.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.v3.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=3019, + serialized_end=3222, +) + + +_GLOSSARYINPUTCONFIG = _descriptor.Descriptor( + name="GlossaryInputConfig", + full_name="google.cloud.translation.v3.GlossaryInputConfig", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="gcs_source", + full_name="google.cloud.translation.v3.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.v3.GlossaryInputConfig.source", + index=0, + containing_type=None, + fields=[], + ) + ], + serialized_start=3224, + serialized_end=3317, +) + + +_GLOSSARY_LANGUAGECODEPAIR = _descriptor.Descriptor( + name="LanguageCodePair", + full_name="google.cloud.translation.v3.Glossary.LanguageCodePair", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="source_language_code", + full_name="google.cloud.translation.v3.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.v3.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=3701, + serialized_end=3779, +) + +_GLOSSARY_LANGUAGECODESSET = _descriptor.Descriptor( + name="LanguageCodesSet", + full_name="google.cloud.translation.v3.Glossary.LanguageCodesSet", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="language_codes", + full_name="google.cloud.translation.v3.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=3781, + serialized_end=3823, +) + +_GLOSSARY = _descriptor.Descriptor( + name="Glossary", + full_name="google.cloud.translation.v3.Glossary", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="name", + full_name="google.cloud.translation.v3.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.v3.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.v3.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.v3.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.v3.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.v3.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.v3.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.v3.Glossary.languages", + index=0, + containing_type=None, + fields=[], + ) + ], + serialized_start=3320, + serialized_end=3836, +) + + +_CREATEGLOSSARYREQUEST = _descriptor.Descriptor( + name="CreateGlossaryRequest", + full_name="google.cloud.translation.v3.CreateGlossaryRequest", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="parent", + full_name="google.cloud.translation.v3.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.v3.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=3838, + serialized_end=3934, +) + + +_GETGLOSSARYREQUEST = _descriptor.Descriptor( + name="GetGlossaryRequest", + full_name="google.cloud.translation.v3.GetGlossaryRequest", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="name", + full_name="google.cloud.translation.v3.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=3936, + serialized_end=3970, +) + + +_DELETEGLOSSARYREQUEST = _descriptor.Descriptor( + name="DeleteGlossaryRequest", + full_name="google.cloud.translation.v3.DeleteGlossaryRequest", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="name", + full_name="google.cloud.translation.v3.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=3972, + serialized_end=4009, +) + + +_LISTGLOSSARIESREQUEST = _descriptor.Descriptor( + name="ListGlossariesRequest", + full_name="google.cloud.translation.v3.ListGlossariesRequest", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="parent", + full_name="google.cloud.translation.v3.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.v3.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.v3.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.v3.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=4011, + serialized_end=4105, +) + + +_LISTGLOSSARIESRESPONSE = _descriptor.Descriptor( + name="ListGlossariesResponse", + full_name="google.cloud.translation.v3.ListGlossariesResponse", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="glossaries", + full_name="google.cloud.translation.v3.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.v3.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=4107, + serialized_end=4215, +) + + +_CREATEGLOSSARYMETADATA = _descriptor.Descriptor( + name="CreateGlossaryMetadata", + full_name="google.cloud.translation.v3.CreateGlossaryMetadata", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="name", + full_name="google.cloud.translation.v3.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.v3.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.v3.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=4218, + serialized_end=4482, +) + + +_DELETEGLOSSARYMETADATA = _descriptor.Descriptor( + name="DeleteGlossaryMetadata", + full_name="google.cloud.translation.v3.DeleteGlossaryMetadata", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="name", + full_name="google.cloud.translation.v3.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.v3.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.v3.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=4485, + serialized_end=4749, +) + + +_DELETEGLOSSARYRESPONSE = _descriptor.Descriptor( + name="DeleteGlossaryResponse", + full_name="google.cloud.translation.v3.DeleteGlossaryResponse", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="name", + full_name="google.cloud.translation.v3.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.v3.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.v3.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=4752, + serialized_end=4885, +) + +_TRANSLATETEXTREQUEST_LABELSENTRY.containing_type = _TRANSLATETEXTREQUEST +_TRANSLATETEXTREQUEST.fields_by_name[ + "glossary_config" +].message_type = _TRANSLATETEXTGLOSSARYCONFIG +_TRANSLATETEXTREQUEST.fields_by_name[ + "labels" +].message_type = _TRANSLATETEXTREQUEST_LABELSENTRY +_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_LABELSENTRY.containing_type = _DETECTLANGUAGEREQUEST +_DETECTLANGUAGEREQUEST.fields_by_name[ + "labels" +].message_type = _DETECTLANGUAGEREQUEST_LABELSENTRY +_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_LABELSENTRY.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 +_BATCHTRANSLATETEXTREQUEST.fields_by_name[ + "labels" +].message_type = _BATCHTRANSLATETEXTREQUEST_LABELSENTRY +_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_v3.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 match is case-insensitive. Default value + is false if missing. + """, + # @@protoc_insertion_point(class_scope:google.cloud.translation.v3.TranslateTextGlossaryConfig) + ), +) +_sym_db.RegisterMessage(TranslateTextGlossaryConfig) + +TranslateTextRequest = _reflection.GeneratedProtocolMessageType( + "TranslateTextRequest", + (_message.Message,), + dict( + LabelsEntry=_reflection.GeneratedProtocolMessageType( + "LabelsEntry", + (_message.Message,), + dict( + DESCRIPTOR=_TRANSLATETEXTREQUEST_LABELSENTRY, + __module__="google.cloud.translation_v3.proto.translation_service_pb2" + # @@protoc_insertion_point(class_scope:google.cloud.translation.v3.TranslateTextRequest.LabelsEntry) + ), + ), + DESCRIPTOR=_TRANSLATETEXTREQUEST, + __module__="google.cloud.translation_v3.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 content be less than 30k codepoints. 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 + defaults to "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 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: + Required. Project or location to make a call. Must refer to a + caller's project. Format: ``projects/{project-id}`` or + ``projects/{project-id}/locations/{location-id}``. For global + calls, use ``projects/{project-id}/locations/global`` or + ``projects/{project-id}``. Non-global location is required + for requests using AutoML models or custom glossaries. Models + and glossaries must be within the same region (have same + location-id), otherwise an INVALID\_ARGUMENT (400) error is + returned. + model: + Optional. The ``model`` type requested for this translation. + The format depends on model type: - AutoML Translation + models: ``projects/{project-id}/locations/{location- + id}/models/{model-id}`` - 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 must be within + the same region (have the same location-id) as the model, + otherwise an INVALID\_ARGUMENT (400) error is returned. + labels: + Optional. The labels with user-defined metadata for the + request. Label keys and values can be no longer than 63 + characters (Unicode codepoints), can only contain lowercase + letters, numeric characters, underscores and dashes. + International characters are allowed. Label values are + optional. Label keys must start with a letter. See + https://goo.gl/xmQnxf for more information on and examples of + labels. + """, + # @@protoc_insertion_point(class_scope:google.cloud.translation.v3.TranslateTextRequest) + ), +) +_sym_db.RegisterMessage(TranslateTextRequest) +_sym_db.RegisterMessage(TranslateTextRequest.LabelsEntry) + +TranslateTextResponse = _reflection.GeneratedProtocolMessageType( + "TranslateTextResponse", + (_message.Message,), + dict( + DESCRIPTOR=_TRANSLATETEXTRESPONSE, + __module__="google.cloud.translation_v3.proto.translation_service_pb2", + __doc__=""" + Attributes: + translations: + Text translation responses with no glossary applied. This + field has the same length as [``contents``][google.cloud.trans + lation.v3.TranslateTextRequest.contents]. + glossary_translations: + Text translation responses if a glossary is provided in the + request. This can be the same as [``translations``][google.clo + ud.translation.v3.TranslateTextResponse.translations] if no + terms apply. This field has the same length as [``contents``][ + google.cloud.translation.v3.TranslateTextRequest.contents]. + """, + # @@protoc_insertion_point(class_scope:google.cloud.translation.v3.TranslateTextResponse) + ), +) +_sym_db.RegisterMessage(TranslateTextResponse) + +Translation = _reflection.GeneratedProtocolMessageType( + "Translation", + (_message.Message,), + dict( + DESCRIPTOR=_TRANSLATION, + __module__="google.cloud.translation_v3.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 is empty. + glossary_config: + The ``glossary_config`` used for this translation. + """, + # @@protoc_insertion_point(class_scope:google.cloud.translation.v3.Translation) + ), +) +_sym_db.RegisterMessage(Translation) + +DetectLanguageRequest = _reflection.GeneratedProtocolMessageType( + "DetectLanguageRequest", + (_message.Message,), + dict( + LabelsEntry=_reflection.GeneratedProtocolMessageType( + "LabelsEntry", + (_message.Message,), + dict( + DESCRIPTOR=_DETECTLANGUAGEREQUEST_LABELSENTRY, + __module__="google.cloud.translation_v3.proto.translation_service_pb2" + # @@protoc_insertion_point(class_scope:google.cloud.translation.v3.DetectLanguageRequest.LabelsEntry) + ), + ), + DESCRIPTOR=_DETECTLANGUAGEREQUEST, + __module__="google.cloud.translation_v3.proto.translation_service_pb2", + __doc__="""The request message for language detection. + + + Attributes: + parent: + Required. Project or location to make a call. Must refer to a + caller's project. Format: ``projects/{project- + id}/locations/{location-id}`` or ``projects/{project-id}``. + For global calls, use ``projects/{project- + id}/locations/global`` or ``projects/{project-id}``. Only + models within the same region (has same location-id) can be + used. Otherwise an INVALID\_ARGUMENT (400) error is returned. + model: + Optional. The language detection model to be used. Format: + ``projects/{project-id}/locations/{location- + id}/models/language-detection/{model-id}`` Only one language + detection model is currently supported: ``projects/{project- + id}/locations/{location-id}/models/language- + detection/default``. If not specified, the default model is + 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 + defaults to "text/html". + labels: + Optional. The labels with user-defined metadata for the + request. Label keys and values can be no longer than 63 + characters (Unicode codepoints), can only contain lowercase + letters, numeric characters, underscores and dashes. + International characters are allowed. Label values are + optional. Label keys must start with a letter. See + https://goo.gl/xmQnxf for more information on and examples of + labels. + """, + # @@protoc_insertion_point(class_scope:google.cloud.translation.v3.DetectLanguageRequest) + ), +) +_sym_db.RegisterMessage(DetectLanguageRequest) +_sym_db.RegisterMessage(DetectLanguageRequest.LabelsEntry) + +DetectedLanguage = _reflection.GeneratedProtocolMessageType( + "DetectedLanguage", + (_message.Message,), + dict( + DESCRIPTOR=_DETECTEDLANGUAGE, + __module__="google.cloud.translation_v3.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.v3.DetectedLanguage) + ), +) +_sym_db.RegisterMessage(DetectedLanguage) + +DetectLanguageResponse = _reflection.GeneratedProtocolMessageType( + "DetectLanguageResponse", + (_message.Message,), + dict( + DESCRIPTOR=_DETECTLANGUAGERESPONSE, + __module__="google.cloud.translation_v3.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.v3.DetectLanguageResponse) + ), +) +_sym_db.RegisterMessage(DetectLanguageResponse) + +GetSupportedLanguagesRequest = _reflection.GeneratedProtocolMessageType( + "GetSupportedLanguagesRequest", + (_message.Message,), + dict( + DESCRIPTOR=_GETSUPPORTEDLANGUAGESREQUEST, + __module__="google.cloud.translation_v3.proto.translation_service_pb2", + __doc__="""The request message for discovering supported languages. + + + Attributes: + parent: + Required. Project or location to make a call. Must refer to a + caller's project. Format: ``projects/{project-id}`` or + ``projects/{project-id}/locations/{location-id}``. For global + calls, use ``projects/{project-id}/locations/global`` or + ``projects/{project-id}``. Non-global location is required + for AutoML models. Only models within the same region (have + same location-id) can be used, otherwise an INVALID\_ARGUMENT + (400) error is returned. + display_language_code: + Optional. The language to use to return localized, human + readable names of supported languages. If missing, then + display names are not returned in a response. + model: + Optional. Get supported languages of this model. The format + depends on model type: - AutoML Translation models: + ``projects/{project-id}/locations/{location-id}/models/{model- + id}`` - 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 base (PBMT) model. + """, + # @@protoc_insertion_point(class_scope:google.cloud.translation.v3.GetSupportedLanguagesRequest) + ), +) +_sym_db.RegisterMessage(GetSupportedLanguagesRequest) + +SupportedLanguages = _reflection.GeneratedProtocolMessageType( + "SupportedLanguages", + (_message.Message,), + dict( + DESCRIPTOR=_SUPPORTEDLANGUAGES, + __module__="google.cloud.translation_v3.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.v3.SupportedLanguages) + ), +) +_sym_db.RegisterMessage(SupportedLanguages) + +SupportedLanguage = _reflection.GeneratedProtocolMessageType( + "SupportedLanguage", + (_message.Message,), + dict( + DESCRIPTOR=_SUPPORTEDLANGUAGE, + __module__="google.cloud.translation_v3.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.v3.SupportedLanguage) + ), +) +_sym_db.RegisterMessage(SupportedLanguage) + +GcsSource = _reflection.GeneratedProtocolMessageType( + "GcsSource", + (_message.Message,), + dict( + DESCRIPTOR=_GCSSOURCE, + __module__="google.cloud.translation_v3.proto.translation_service_pb2", + __doc__="""The Google Cloud Storage 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.v3.GcsSource) + ), +) +_sym_db.RegisterMessage(GcsSource) + +InputConfig = _reflection.GeneratedProtocolMessageType( + "InputConfig", + (_message.Message,), + dict( + DESCRIPTOR=_INPUTCONFIG, + __module__="google.cloud.translation_v3.proto.translation_service_pb2", + __doc__="""Input configuration for BatchTranslateText request. + + + 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. Note + that the input tsv must be RFC 4180 compliant. You could use + https://github.com/Clever/csvlint to check potential + formatting errors in your tsv file. csvlint --delimiter=':raw- + latex:`\t`' your\_input\_file.tsv 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.v3.InputConfig) + ), +) +_sym_db.RegisterMessage(InputConfig) + +GcsDestination = _reflection.GeneratedProtocolMessageType( + "GcsDestination", + (_message.Message,), + dict( + DESCRIPTOR=_GCSDESTINATION, + __module__="google.cloud.translation_v3.proto.translation_service_pb2", + __doc__="""The Google Cloud Storage 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 "/" and start with + "gs://", otherwise an INVALID\_ARGUMENT (400) error is + returned. + """, + # @@protoc_insertion_point(class_scope:google.cloud.translation.v3.GcsDestination) + ), +) +_sym_db.RegisterMessage(GcsDestination) + +OutputConfig = _reflection.GeneratedProtocolMessageType( + "OutputConfig", + (_message.Message,), + dict( + DESCRIPTOR=_OUTPUTCONFIG, + __module__="google.cloud.translation_v3.proto.translation_service_pb2", + __doc__="""Output configuration for BatchTranslateText request. + + + 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 ``\\\\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 and + glossary\_errors\_file are always empty strings if the + 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 contains 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.v3.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_v3.proto.translation_service_pb2" + # @@protoc_insertion_point(class_scope:google.cloud.translation.v3.BatchTranslateTextRequest.ModelsEntry) + ), + ), + GlossariesEntry=_reflection.GeneratedProtocolMessageType( + "GlossariesEntry", + (_message.Message,), + dict( + DESCRIPTOR=_BATCHTRANSLATETEXTREQUEST_GLOSSARIESENTRY, + __module__="google.cloud.translation_v3.proto.translation_service_pb2" + # @@protoc_insertion_point(class_scope:google.cloud.translation.v3.BatchTranslateTextRequest.GlossariesEntry) + ), + ), + LabelsEntry=_reflection.GeneratedProtocolMessageType( + "LabelsEntry", + (_message.Message,), + dict( + DESCRIPTOR=_BATCHTRANSLATETEXTREQUEST_LABELSENTRY, + __module__="google.cloud.translation_v3.proto.translation_service_pb2" + # @@protoc_insertion_point(class_scope:google.cloud.translation.v3.BatchTranslateTextRequest.LabelsEntry) + ), + ), + DESCRIPTOR=_BATCHTRANSLATETEXTREQUEST, + __module__="google.cloud.translation_v3.proto.translation_service_pb2", + __doc__="""The batch translation request. + + + Attributes: + parent: + Required. Location to make a call. Must refer to a caller's + project. Format: ``projects/{project-id}/locations/{location- + id}``. The ``global`` location is not supported for batch + translation. Only AutoML Translation models or glossaries + within the same region (have the same location-id) can be + used, otherwise an INVALID\_ARGUMENT (400) error 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 an AutoML Translation model. The + value format depends on model type: - AutoML Translation + models: ``projects/{project-id}/locations/{location- + id}/models/{model-id}`` - 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 (nmt) 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. + labels: + Optional. The labels with user-defined metadata for the + request. Label keys and values can be no longer than 63 + characters (Unicode codepoints), can only contain lowercase + letters, numeric characters, underscores and dashes. + International characters are allowed. Label values are + optional. Label keys must start with a letter. See + https://goo.gl/xmQnxf for more information on and examples of + labels. + """, + # @@protoc_insertion_point(class_scope:google.cloud.translation.v3.BatchTranslateTextRequest) + ), +) +_sym_db.RegisterMessage(BatchTranslateTextRequest) +_sym_db.RegisterMessage(BatchTranslateTextRequest.ModelsEntry) +_sym_db.RegisterMessage(BatchTranslateTextRequest.GlossariesEntry) +_sym_db.RegisterMessage(BatchTranslateTextRequest.LabelsEntry) + +BatchTranslateMetadata = _reflection.GeneratedProtocolMessageType( + "BatchTranslateMetadata", + (_message.Message,), + dict( + DESCRIPTOR=_BATCHTRANSLATEMETADATA, + __module__="google.cloud.translation_v3.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 and appears here shortly after the call is + submitted. + submit_time: + Time when the operation was submitted. + """, + # @@protoc_insertion_point(class_scope:google.cloud.translation.v3.BatchTranslateMetadata) + ), +) +_sym_db.RegisterMessage(BatchTranslateMetadata) + +BatchTranslateResponse = _reflection.GeneratedProtocolMessageType( + "BatchTranslateResponse", + (_message.Message,), + dict( + DESCRIPTOR=_BATCHTRANSLATERESPONSE, + __module__="google.cloud.translation_v3.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.v3.BatchTranslateResponse) + ), +) +_sym_db.RegisterMessage(BatchTranslateResponse) + +GlossaryInputConfig = _reflection.GeneratedProtocolMessageType( + "GlossaryInputConfig", + (_message.Message,), + dict( + DESCRIPTOR=_GLOSSARYINPUTCONFIG, + __module__="google.cloud.translation_v3.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 the filename 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 + term sets glossaries: - CSV (``.csv``): Multi-column CSV + file defining equivalent glossary terms in multiple + languages. The format is defined for Google Translation + Toolkit and documented in `Use a glossary `__. + """, + # @@protoc_insertion_point(class_scope:google.cloud.translation.v3.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_v3.proto.translation_service_pb2", + __doc__="""Used with unidirectional glossaries. + + + 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.v3.Glossary.LanguageCodePair) + ), + ), + LanguageCodesSet=_reflection.GeneratedProtocolMessageType( + "LanguageCodesSet", + (_message.Message,), + dict( + DESCRIPTOR=_GLOSSARY_LANGUAGECODESSET, + __module__="google.cloud.translation_v3.proto.translation_service_pb2", + __doc__="""Used with equivalent term set glossaries. + + + 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.v3.Glossary.LanguageCodesSet) + ), + ), + DESCRIPTOR=_GLOSSARY, + __module__="google.cloud.translation_v3.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 glossaries. + language_codes_set: + Used with equivalent term set glossaries. + 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.v3.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_v3.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.v3.CreateGlossaryRequest) + ), +) +_sym_db.RegisterMessage(CreateGlossaryRequest) + +GetGlossaryRequest = _reflection.GeneratedProtocolMessageType( + "GetGlossaryRequest", + (_message.Message,), + dict( + DESCRIPTOR=_GETGLOSSARYREQUEST, + __module__="google.cloud.translation_v3.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.v3.GetGlossaryRequest) + ), +) +_sym_db.RegisterMessage(GetGlossaryRequest) + +DeleteGlossaryRequest = _reflection.GeneratedProtocolMessageType( + "DeleteGlossaryRequest", + (_message.Message,), + dict( + DESCRIPTOR=_DELETEGLOSSARYREQUEST, + __module__="google.cloud.translation_v3.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.v3.DeleteGlossaryRequest) + ), +) +_sym_db.RegisterMessage(DeleteGlossaryRequest) + +ListGlossariesRequest = _reflection.GeneratedProtocolMessageType( + "ListGlossariesRequest", + (_message.Message,), + dict( + DESCRIPTOR=_LISTGLOSSARIESREQUEST, + __module__="google.cloud.translation_v3.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. + Filtering is not supported yet, and the parameter currently + has no effect. If missing, no filtering is performed. + """, + # @@protoc_insertion_point(class_scope:google.cloud.translation.v3.ListGlossariesRequest) + ), +) +_sym_db.RegisterMessage(ListGlossariesRequest) + +ListGlossariesResponse = _reflection.GeneratedProtocolMessageType( + "ListGlossariesResponse", + (_message.Message,), + dict( + DESCRIPTOR=_LISTGLOSSARIESRESPONSE, + __module__="google.cloud.translation_v3.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.v3.ListGlossariesResponse) + ), +) +_sym_db.RegisterMessage(ListGlossariesResponse) + +CreateGlossaryMetadata = _reflection.GeneratedProtocolMessageType( + "CreateGlossaryMetadata", + (_message.Message,), + dict( + DESCRIPTOR=_CREATEGLOSSARYMETADATA, + __module__="google.cloud.translation_v3.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.v3.CreateGlossaryMetadata) + ), +) +_sym_db.RegisterMessage(CreateGlossaryMetadata) + +DeleteGlossaryMetadata = _reflection.GeneratedProtocolMessageType( + "DeleteGlossaryMetadata", + (_message.Message,), + dict( + DESCRIPTOR=_DELETEGLOSSARYMETADATA, + __module__="google.cloud.translation_v3.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.v3.DeleteGlossaryMetadata) + ), +) +_sym_db.RegisterMessage(DeleteGlossaryMetadata) + +DeleteGlossaryResponse = _reflection.GeneratedProtocolMessageType( + "DeleteGlossaryResponse", + (_message.Message,), + dict( + DESCRIPTOR=_DELETEGLOSSARYRESPONSE, + __module__="google.cloud.translation_v3.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.v3.DeleteGlossaryResponse) + ), +) +_sym_db.RegisterMessage(DeleteGlossaryResponse) + + +DESCRIPTOR._options = None +_TRANSLATETEXTREQUEST_LABELSENTRY._options = None +_DETECTLANGUAGEREQUEST_LABELSENTRY._options = None +_BATCHTRANSLATETEXTREQUEST_MODELSENTRY._options = None +_BATCHTRANSLATETEXTREQUEST_GLOSSARIESENTRY._options = None +_BATCHTRANSLATETEXTREQUEST_LABELSENTRY._options = None + +_TRANSLATIONSERVICE = _descriptor.ServiceDescriptor( + name="TranslationService", + full_name="google.cloud.translation.v3.TranslationService", + file=DESCRIPTOR, + index=0, + serialized_options=_b( + "\312A\032translation.googleapis.com\322A`https://www.googleapis.com/auth/cloud-platform,https://www.googleapis.com/auth/cloud-translation" + ), + serialized_start=4888, + serialized_end=6585, + methods=[ + _descriptor.MethodDescriptor( + name="TranslateText", + full_name="google.cloud.translation.v3.TranslationService.TranslateText", + index=0, + containing_service=None, + input_type=_TRANSLATETEXTREQUEST, + output_type=_TRANSLATETEXTRESPONSE, + serialized_options=_b( + '\202\323\344\223\002b"1/v3/{parent=projects/*/locations/*}:translateText:\001*Z*"%/v3/{parent=projects/*}:translateText:\001*' + ), + ), + _descriptor.MethodDescriptor( + name="DetectLanguage", + full_name="google.cloud.translation.v3.TranslationService.DetectLanguage", + index=1, + containing_service=None, + input_type=_DETECTLANGUAGEREQUEST, + output_type=_DETECTLANGUAGERESPONSE, + serialized_options=_b( + '\202\323\344\223\002d"2/v3/{parent=projects/*/locations/*}:detectLanguage:\001*Z+"&/v3/{parent=projects/*}:detectLanguage:\001*' + ), + ), + _descriptor.MethodDescriptor( + name="GetSupportedLanguages", + full_name="google.cloud.translation.v3.TranslationService.GetSupportedLanguages", + index=2, + containing_service=None, + input_type=_GETSUPPORTEDLANGUAGESREQUEST, + output_type=_SUPPORTEDLANGUAGES, + serialized_options=_b( + "\202\323\344\223\002f\0226/v3/{parent=projects/*/locations/*}/supportedLanguagesZ,\022*/v3/{parent=projects/*}/supportedLanguages" + ), + ), + _descriptor.MethodDescriptor( + name="BatchTranslateText", + full_name="google.cloud.translation.v3.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;"6/v3/{parent=projects/*/locations/*}:batchTranslateText:\001*' + ), + ), + _descriptor.MethodDescriptor( + name="CreateGlossary", + full_name="google.cloud.translation.v3.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:"./v3/{parent=projects/*/locations/*}/glossaries:\010glossary' + ), + ), + _descriptor.MethodDescriptor( + name="ListGlossaries", + full_name="google.cloud.translation.v3.TranslationService.ListGlossaries", + index=5, + containing_service=None, + input_type=_LISTGLOSSARIESREQUEST, + output_type=_LISTGLOSSARIESRESPONSE, + serialized_options=_b( + "\202\323\344\223\0020\022./v3/{parent=projects/*/locations/*}/glossaries" + ), + ), + _descriptor.MethodDescriptor( + name="GetGlossary", + full_name="google.cloud.translation.v3.TranslationService.GetGlossary", + index=6, + containing_service=None, + input_type=_GETGLOSSARYREQUEST, + output_type=_GLOSSARY, + serialized_options=_b( + "\202\323\344\223\0020\022./v3/{name=projects/*/locations/*/glossaries/*}" + ), + ), + _descriptor.MethodDescriptor( + name="DeleteGlossary", + full_name="google.cloud.translation.v3.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\0020*./v3/{name=projects/*/locations/*/glossaries/*}" + ), + ), + ], +) +_sym_db.RegisterServiceDescriptor(_TRANSLATIONSERVICE) + +DESCRIPTOR.services_by_name["TranslationService"] = _TRANSLATIONSERVICE + +# @@protoc_insertion_point(module_scope) diff --git a/translate/google/cloud/translate_v3/proto/translation_service_pb2_grpc.py b/translate/google/cloud/translate_v3/proto/translation_service_pb2_grpc.py new file mode 100644 index 000000000000..5869a268e404 --- /dev/null +++ b/translate/google/cloud/translate_v3/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_v3.proto import ( + translation_service_pb2 as google_dot_cloud_dot_translation__v3_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 (v3). + + Provides natural language translation operations. + """ + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.TranslateText = channel.unary_unary( + "/google.cloud.translation.v3.TranslationService/TranslateText", + request_serializer=google_dot_cloud_dot_translation__v3_dot_proto_dot_translation__service__pb2.TranslateTextRequest.SerializeToString, + response_deserializer=google_dot_cloud_dot_translation__v3_dot_proto_dot_translation__service__pb2.TranslateTextResponse.FromString, + ) + self.DetectLanguage = channel.unary_unary( + "/google.cloud.translation.v3.TranslationService/DetectLanguage", + request_serializer=google_dot_cloud_dot_translation__v3_dot_proto_dot_translation__service__pb2.DetectLanguageRequest.SerializeToString, + response_deserializer=google_dot_cloud_dot_translation__v3_dot_proto_dot_translation__service__pb2.DetectLanguageResponse.FromString, + ) + self.GetSupportedLanguages = channel.unary_unary( + "/google.cloud.translation.v3.TranslationService/GetSupportedLanguages", + request_serializer=google_dot_cloud_dot_translation__v3_dot_proto_dot_translation__service__pb2.GetSupportedLanguagesRequest.SerializeToString, + response_deserializer=google_dot_cloud_dot_translation__v3_dot_proto_dot_translation__service__pb2.SupportedLanguages.FromString, + ) + self.BatchTranslateText = channel.unary_unary( + "/google.cloud.translation.v3.TranslationService/BatchTranslateText", + request_serializer=google_dot_cloud_dot_translation__v3_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.v3.TranslationService/CreateGlossary", + request_serializer=google_dot_cloud_dot_translation__v3_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.v3.TranslationService/ListGlossaries", + request_serializer=google_dot_cloud_dot_translation__v3_dot_proto_dot_translation__service__pb2.ListGlossariesRequest.SerializeToString, + response_deserializer=google_dot_cloud_dot_translation__v3_dot_proto_dot_translation__service__pb2.ListGlossariesResponse.FromString, + ) + self.GetGlossary = channel.unary_unary( + "/google.cloud.translation.v3.TranslationService/GetGlossary", + request_serializer=google_dot_cloud_dot_translation__v3_dot_proto_dot_translation__service__pb2.GetGlossaryRequest.SerializeToString, + response_deserializer=google_dot_cloud_dot_translation__v3_dot_proto_dot_translation__service__pb2.Glossary.FromString, + ) + self.DeleteGlossary = channel.unary_unary( + "/google.cloud.translation.v3.TranslationService/DeleteGlossary", + request_serializer=google_dot_cloud_dot_translation__v3_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 (v3). + + 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__v3_dot_proto_dot_translation__service__pb2.TranslateTextRequest.FromString, + response_serializer=google_dot_cloud_dot_translation__v3_dot_proto_dot_translation__service__pb2.TranslateTextResponse.SerializeToString, + ), + "DetectLanguage": grpc.unary_unary_rpc_method_handler( + servicer.DetectLanguage, + request_deserializer=google_dot_cloud_dot_translation__v3_dot_proto_dot_translation__service__pb2.DetectLanguageRequest.FromString, + response_serializer=google_dot_cloud_dot_translation__v3_dot_proto_dot_translation__service__pb2.DetectLanguageResponse.SerializeToString, + ), + "GetSupportedLanguages": grpc.unary_unary_rpc_method_handler( + servicer.GetSupportedLanguages, + request_deserializer=google_dot_cloud_dot_translation__v3_dot_proto_dot_translation__service__pb2.GetSupportedLanguagesRequest.FromString, + response_serializer=google_dot_cloud_dot_translation__v3_dot_proto_dot_translation__service__pb2.SupportedLanguages.SerializeToString, + ), + "BatchTranslateText": grpc.unary_unary_rpc_method_handler( + servicer.BatchTranslateText, + request_deserializer=google_dot_cloud_dot_translation__v3_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__v3_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__v3_dot_proto_dot_translation__service__pb2.ListGlossariesRequest.FromString, + response_serializer=google_dot_cloud_dot_translation__v3_dot_proto_dot_translation__service__pb2.ListGlossariesResponse.SerializeToString, + ), + "GetGlossary": grpc.unary_unary_rpc_method_handler( + servicer.GetGlossary, + request_deserializer=google_dot_cloud_dot_translation__v3_dot_proto_dot_translation__service__pb2.GetGlossaryRequest.FromString, + response_serializer=google_dot_cloud_dot_translation__v3_dot_proto_dot_translation__service__pb2.Glossary.SerializeToString, + ), + "DeleteGlossary": grpc.unary_unary_rpc_method_handler( + servicer.DeleteGlossary, + request_deserializer=google_dot_cloud_dot_translation__v3_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.v3.TranslationService", rpc_method_handlers + ) + server.add_generic_rpc_handlers((generic_handler,)) diff --git a/translate/google/cloud/translate_v3/types.py b/translate/google/cloud/translate_v3/types.py new file mode 100644 index 000000000000..14c494adc850 --- /dev/null +++ b/translate/google/cloud/translate_v3/types.py @@ -0,0 +1,47 @@ +# -*- 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_v3.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: # pragma: NO COVER + 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_v3.types" + setattr(sys.modules[__name__], name, message) + names.append(name) + + +__all__ = tuple(sorted(names)) diff --git a/translate/synth.metadata b/translate/synth.metadata index 6b7bee295581..c2465480bc9c 100644 --- a/translate/synth.metadata +++ b/translate/synth.metadata @@ -34,6 +34,16 @@ "generator": "gapic", "config": "google/cloud/translate/artman_translate_v3beta1.yaml" } + }, + { + "client": { + "source": "googleapis", + "apiName": "translate", + "apiVersion": "v3", + "language": "python", + "generator": "gapic", + "config": "google/cloud/translate/artman_translate_v3.yaml" + } } ] } \ No newline at end of file diff --git a/translate/synth.py b/translate/synth.py index dd81273af78b..f9f3dbc9ecc7 100644 --- a/translate/synth.py +++ b/translate/synth.py @@ -19,7 +19,7 @@ gapic = gcp.GAPICGenerator() common = gcp.CommonTemplates() -versions = ["v3beta1"] +versions = ["v3beta1", "v3"] excludes = [ "setup.py", @@ -41,12 +41,12 @@ s.move(library / "tests") s.move(library / f"docs/gapic/{version}") -# translation -> translate -s.replace( - "google/**/translation_service_pb2_grpc.py", - "google.cloud.translation_v3beta1.proto", - "google.cloud.translate_v3beta1.proto", -) + # translation -> translate + s.replace( + "google/**/translation_service_pb2_grpc.py", + f"google.cloud.translation_{version}.proto", + f"google.cloud.translate_{version}.proto", + ) s.replace( "google/cloud/**/translation_service_pb2.py", diff --git a/translate/tests/unit/gapic/v3/test_translation_service_client_v3.py b/translate/tests/unit/gapic/v3/test_translation_service_client_v3.py new file mode 100644 index 000000000000..16180aace4ad --- /dev/null +++ b/translate/tests/unit/gapic/v3/test_translation_service_client_v3.py @@ -0,0 +1,470 @@ +# -*- 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_v3 +from google.cloud.translate_v3.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_v3.TranslationServiceClient() + + # Setup Request + contents = [] + target_language_code = "targetLanguageCode1323228230" + parent = client.location_path("[PROJECT]", "[LOCATION]") + + response = client.translate_text(contents, target_language_code, parent) + assert expected_response == response + + assert len(channel.requests) == 1 + expected_request = translation_service_pb2.TranslateTextRequest( + contents=contents, target_language_code=target_language_code, parent=parent + ) + actual_request = channel.requests[0][1] + assert expected_request == actual_request + + def test_translate_text_exception(self): + # Mock the API response + channel = ChannelStub(responses=[CustomException()]) + patch = mock.patch("google.api_core.grpc_helpers.create_channel") + with patch as create_channel: + create_channel.return_value = channel + client = translate_v3.TranslationServiceClient() + + # Setup request + contents = [] + target_language_code = "targetLanguageCode1323228230" + parent = client.location_path("[PROJECT]", "[LOCATION]") + + with pytest.raises(CustomException): + client.translate_text(contents, target_language_code, parent) + + 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_v3.TranslationServiceClient() + + # Setup Request + parent = client.location_path("[PROJECT]", "[LOCATION]") + + response = client.detect_language(parent) + assert expected_response == response + + assert len(channel.requests) == 1 + expected_request = translation_service_pb2.DetectLanguageRequest(parent=parent) + 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_v3.TranslationServiceClient() + + # Setup request + parent = client.location_path("[PROJECT]", "[LOCATION]") + + with pytest.raises(CustomException): + client.detect_language(parent) + + def test_get_supported_languages(self): + # Setup Expected Response + expected_response = {} + expected_response = translation_service_pb2.SupportedLanguages( + **expected_response + ) + + # Mock the API response + channel = ChannelStub(responses=[expected_response]) + patch = mock.patch("google.api_core.grpc_helpers.create_channel") + with patch as create_channel: + create_channel.return_value = channel + client = translate_v3.TranslationServiceClient() + + # Setup Request + parent = client.location_path("[PROJECT]", "[LOCATION]") + + response = client.get_supported_languages(parent) + assert expected_response == response + + assert len(channel.requests) == 1 + expected_request = translation_service_pb2.GetSupportedLanguagesRequest( + parent=parent + ) + actual_request = channel.requests[0][1] + assert expected_request == actual_request + + 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_v3.TranslationServiceClient() + + # Setup request + parent = client.location_path("[PROJECT]", "[LOCATION]") + + with pytest.raises(CustomException): + client.get_supported_languages(parent) + + def test_batch_translate_text(self): + # Setup Expected Response + total_characters = 1368640955 + translated_characters = 1337326221 + failed_characters = 1723028396 + expected_response = { + "total_characters": total_characters, + "translated_characters": translated_characters, + "failed_characters": failed_characters, + } + expected_response = translation_service_pb2.BatchTranslateResponse( + **expected_response + ) + operation = operations_pb2.Operation( + name="operations/test_batch_translate_text", done=True + ) + operation.response.Pack(expected_response) + + # Mock the API response + channel = ChannelStub(responses=[operation]) + patch = mock.patch("google.api_core.grpc_helpers.create_channel") + with patch as create_channel: + create_channel.return_value = channel + client = translate_v3.TranslationServiceClient() + + # Setup Request + parent = client.location_path("[PROJECT]", "[LOCATION]") + source_language_code = "sourceLanguageCode1687263568" + target_language_codes = [] + input_configs = [] + output_config = {} + + response = client.batch_translate_text( + parent, + source_language_code, + target_language_codes, + input_configs, + output_config, + ) + result = response.result() + assert expected_response == result + + assert len(channel.requests) == 1 + expected_request = translation_service_pb2.BatchTranslateTextRequest( + parent=parent, + source_language_code=source_language_code, + target_language_codes=target_language_codes, + input_configs=input_configs, + output_config=output_config, + ) + actual_request = channel.requests[0][1] + assert expected_request == actual_request + + def test_batch_translate_text_exception(self): + # Setup Response + error = status_pb2.Status() + operation = operations_pb2.Operation( + name="operations/test_batch_translate_text_exception", done=True + ) + operation.error.CopyFrom(error) + + # Mock the API response + channel = ChannelStub(responses=[operation]) + patch = mock.patch("google.api_core.grpc_helpers.create_channel") + with patch as create_channel: + create_channel.return_value = channel + client = translate_v3.TranslationServiceClient() + + # Setup Request + parent = client.location_path("[PROJECT]", "[LOCATION]") + source_language_code = "sourceLanguageCode1687263568" + target_language_codes = [] + input_configs = [] + output_config = {} + + response = client.batch_translate_text( + parent, + source_language_code, + target_language_codes, + input_configs, + output_config, + ) + exception = response.exception() + assert exception.errors[0] == error + + def test_create_glossary(self): + # Setup Expected Response + name = "name3373707" + entry_count = 811131134 + expected_response = {"name": name, "entry_count": entry_count} + expected_response = translation_service_pb2.Glossary(**expected_response) + operation = operations_pb2.Operation( + name="operations/test_create_glossary", done=True + ) + operation.response.Pack(expected_response) + + # Mock the API response + channel = ChannelStub(responses=[operation]) + patch = mock.patch("google.api_core.grpc_helpers.create_channel") + with patch as create_channel: + create_channel.return_value = channel + client = translate_v3.TranslationServiceClient() + + # Setup Request + parent = client.location_path("[PROJECT]", "[LOCATION]") + glossary = {} + + response = client.create_glossary(parent, glossary) + result = response.result() + assert expected_response == result + + assert len(channel.requests) == 1 + expected_request = translation_service_pb2.CreateGlossaryRequest( + parent=parent, glossary=glossary + ) + actual_request = channel.requests[0][1] + assert expected_request == actual_request + + def test_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_v3.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_v3.TranslationServiceClient() + + # Setup Request + parent = client.location_path("[PROJECT]", "[LOCATION]") + + paged_list_response = client.list_glossaries(parent) + resources = list(paged_list_response) + assert len(resources) == 1 + + assert expected_response.glossaries[0] == resources[0] + + assert len(channel.requests) == 1 + expected_request = translation_service_pb2.ListGlossariesRequest(parent=parent) + actual_request = channel.requests[0][1] + assert expected_request == actual_request + + def test_list_glossaries_exception(self): + channel = ChannelStub(responses=[CustomException()]) + patch = mock.patch("google.api_core.grpc_helpers.create_channel") + with patch as create_channel: + create_channel.return_value = channel + client = translate_v3.TranslationServiceClient() + + # Setup request + parent = client.location_path("[PROJECT]", "[LOCATION]") + + paged_list_response = client.list_glossaries(parent) + with pytest.raises(CustomException): + list(paged_list_response) + + def test_get_glossary(self): + # Setup Expected Response + name_2 = "name2-1052831874" + entry_count = 811131134 + expected_response = {"name": name_2, "entry_count": entry_count} + expected_response = translation_service_pb2.Glossary(**expected_response) + + # Mock the API response + channel = ChannelStub(responses=[expected_response]) + patch = mock.patch("google.api_core.grpc_helpers.create_channel") + with patch as create_channel: + create_channel.return_value = channel + client = translate_v3.TranslationServiceClient() + + # Setup Request + name = client.glossary_path("[PROJECT]", "[LOCATION]", "[GLOSSARY]") + + response = client.get_glossary(name) + assert expected_response == response + + assert len(channel.requests) == 1 + expected_request = translation_service_pb2.GetGlossaryRequest(name=name) + actual_request = channel.requests[0][1] + assert expected_request == actual_request + + def test_get_glossary_exception(self): + # Mock the API response + channel = ChannelStub(responses=[CustomException()]) + patch = mock.patch("google.api_core.grpc_helpers.create_channel") + with patch as create_channel: + create_channel.return_value = channel + client = translate_v3.TranslationServiceClient() + + # Setup request + name = client.glossary_path("[PROJECT]", "[LOCATION]", "[GLOSSARY]") + + with pytest.raises(CustomException): + client.get_glossary(name) + + def test_delete_glossary(self): + # Setup Expected Response + name_2 = "name2-1052831874" + expected_response = {"name": name_2} + expected_response = translation_service_pb2.DeleteGlossaryResponse( + **expected_response + ) + operation = operations_pb2.Operation( + name="operations/test_delete_glossary", done=True + ) + operation.response.Pack(expected_response) + + # Mock the API response + channel = ChannelStub(responses=[operation]) + patch = mock.patch("google.api_core.grpc_helpers.create_channel") + with patch as create_channel: + create_channel.return_value = channel + client = translate_v3.TranslationServiceClient() + + # Setup Request + name = client.glossary_path("[PROJECT]", "[LOCATION]", "[GLOSSARY]") + + response = client.delete_glossary(name) + result = response.result() + assert expected_response == result + + assert len(channel.requests) == 1 + expected_request = translation_service_pb2.DeleteGlossaryRequest(name=name) + actual_request = channel.requests[0][1] + assert expected_request == actual_request + + def test_delete_glossary_exception(self): + # Setup Response + error = status_pb2.Status() + operation = operations_pb2.Operation( + name="operations/test_delete_glossary_exception", done=True + ) + operation.error.CopyFrom(error) + + # Mock the API response + channel = ChannelStub(responses=[operation]) + patch = mock.patch("google.api_core.grpc_helpers.create_channel") + with patch as create_channel: + create_channel.return_value = channel + client = translate_v3.TranslationServiceClient() + + # Setup Request + name = client.glossary_path("[PROJECT]", "[LOCATION]", "[GLOSSARY]") + + response = client.delete_glossary(name) + exception = response.exception() + assert exception.errors[0] == error