class Google::Cloud::Translate::V3::TranslationService::Client

Client for the TranslationService service.

Provides natural language translation operations.

Attributes

operations_client[R]

Get the associated client for long-running operations.

@return [::Google::Cloud::Translate::V3::TranslationService::Operations]

translation_service_stub[R]

@private

Public Class Methods

configure() { |configure| ... } click to toggle source

Configure the TranslationService Client class.

See {::Google::Cloud::Translate::V3::TranslationService::Client::Configuration} for a description of the configuration fields.

@example

# Modify the configuration for all TranslationService clients
::Google::Cloud::Translate::V3::TranslationService::Client.configure do |config|
  config.timeout = 10.0
end

@yield [config] Configure the Client client. @yieldparam config [Client::Configuration]

@return [Client::Configuration]

# File lib/google/cloud/translate/v3/translation_service/client.rb, line 56
def self.configure
  @configure ||= begin
    namespace = ["Google", "Cloud", "Translate", "V3"]
    parent_config = while namespace.any?
                      parent_name = namespace.join "::"
                      parent_const = const_get parent_name
                      break parent_const.configure if parent_const.respond_to? :configure
                      namespace.pop
                    end
    default_config = Client::Configuration.new parent_config

    default_config.rpcs.translate_text.timeout = 600.0

    default_config.rpcs.detect_language.timeout = 600.0

    default_config.rpcs.get_supported_languages.timeout = 600.0
    default_config.rpcs.get_supported_languages.retry_policy = {
      initial_delay: 0.1, max_delay: 60.0, multiplier: 1.3, retry_codes: [4, 14]
    }

    default_config.rpcs.translate_document.timeout = 600.0

    default_config.rpcs.batch_translate_text.timeout = 600.0

    default_config.rpcs.batch_translate_document.timeout = 600.0

    default_config.rpcs.create_glossary.timeout = 600.0

    default_config.rpcs.list_glossaries.timeout = 600.0
    default_config.rpcs.list_glossaries.retry_policy = {
      initial_delay: 0.1, max_delay: 60.0, multiplier: 1.3, retry_codes: [4, 14]
    }

    default_config.rpcs.get_glossary.timeout = 600.0
    default_config.rpcs.get_glossary.retry_policy = {
      initial_delay: 0.1, max_delay: 60.0, multiplier: 1.3, retry_codes: [4, 14]
    }

    default_config.rpcs.delete_glossary.timeout = 600.0
    default_config.rpcs.delete_glossary.retry_policy = {
      initial_delay: 0.1, max_delay: 60.0, multiplier: 1.3, retry_codes: [4, 14]
    }

    default_config
  end
  yield @configure if block_given?
  @configure
end
new() { |config| ... } click to toggle source

Create a new TranslationService client object.

@example

# Create a client using the default configuration
client = ::Google::Cloud::Translate::V3::TranslationService::Client.new

# Create a client using a custom configuration
client = ::Google::Cloud::Translate::V3::TranslationService::Client.new do |config|
  config.timeout = 10.0
end

@yield [config] Configure the TranslationService client. @yieldparam config [Client::Configuration]

# File lib/google/cloud/translate/v3/translation_service/client.rb, line 141
def initialize
  # These require statements are intentionally placed here to initialize
  # the gRPC module only when it's required.
  # See https://github.com/googleapis/toolkit/issues/446
  require "gapic/grpc"
  require "google/cloud/translate/v3/translation_service_services_pb"

  # Create the configuration object
  @config = Configuration.new Client.configure

  # Yield the configuration if needed
  yield @config if block_given?

  # Create credentials
  credentials = @config.credentials
  # Use self-signed JWT if the endpoint is unchanged from default,
  # but only if the default endpoint does not have a region prefix.
  enable_self_signed_jwt = @config.endpoint == Client.configure.endpoint &&
                           !@config.endpoint.split(".").first.include?("-")
  credentials ||= Credentials.default scope: @config.scope,
                                      enable_self_signed_jwt: enable_self_signed_jwt
  if credentials.is_a?(::String) || credentials.is_a?(::Hash)
    credentials = Credentials.new credentials, scope: @config.scope
  end
  @quota_project_id = @config.quota_project
  @quota_project_id ||= credentials.quota_project_id if credentials.respond_to? :quota_project_id

  @operations_client = Operations.new do |config|
    config.credentials = credentials
    config.endpoint = @config.endpoint
  end

  @translation_service_stub = ::Gapic::ServiceStub.new(
    ::Google::Cloud::Translate::V3::TranslationService::Stub,
    credentials:  credentials,
    endpoint:     @config.endpoint,
    channel_args: @config.channel_args,
    interceptors: @config.interceptors
  )
end

Public Instance Methods

batch_translate_document(request, options = nil) { |response, operation| ... } click to toggle source

Translates a large volume of document 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.

@overload batch_translate_document(request, options = nil)

Pass arguments to `batch_translate_document` via a request object, either of type
{::Google::Cloud::Translate::V3::BatchTranslateDocumentRequest} or an equivalent Hash.

@param request [::Google::Cloud::Translate::V3::BatchTranslateDocumentRequest, ::Hash]
  A request object representing the call parameters. Required. To specify no
  parameters, or to keep all the default parameter values, pass an empty Hash.
@param options [::Gapic::CallOptions, ::Hash]
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.

@overload batch_translate_document(parent: nil, source_language_code: nil, target_language_codes: nil, input_configs: nil, output_config: nil, models: nil, glossaries: nil, format_conversions: nil)

Pass arguments to `batch_translate_document` via keyword arguments. Note that at
least one keyword argument is required. To specify no parameters, or to keep all
the default parameter values, pass an empty Hash as a request object (see above).

@param parent [::String]
  Required. Location to make a regional call.

  Format: `projects/{project-number-or-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.
@param source_language_code [::String]
  Required. The BCP-47 language code of the input document if known, for
  example, "en-US" or "sr-Latn". Supported language codes are listed in
  Language Support (https://cloud.google.com/translate/docs/languages).
@param target_language_codes [::Array<::String>]
  Required. The BCP-47 language code to use for translation of the input
  document. Specify up to 10 language codes here.
@param input_configs [::Array<::Google::Cloud::Translate::V3::BatchDocumentInputConfig, ::Hash>]
  Required. Input configurations.
  The total number of files matched should be <= 100.
  The total content size to translate should be <= 100M Unicode codepoints.
  The files must use UTF-8 encoding.
@param output_config [::Google::Cloud::Translate::V3::BatchDocumentOutputConfig, ::Hash]
  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.
@param models [::Hash{::String => ::String}]
  Optional. The models to use for translation. Map's key is target language
  code. Map's value is the 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-number-or-id}/locations/{location-id}/models/{model-id}`

  - General (built-in) models:
    `projects/{project-number-or-id}/locations/{location-id}/models/general/nmt`,

  If the map is empty or a specific model is
  not requested for a language pair, then default google model (nmt) is used.
@param glossaries [::Hash{::String => ::Google::Cloud::Translate::V3::TranslateTextGlossaryConfig, ::Hash}]
  Optional. Glossaries to be applied. It's keyed by target language code.
@param format_conversions [::Hash{::String => ::String}]
  Optional. File format conversion map to be applied to all input files.
  Map's key is the original mime_type. Map's value is the target mime_type of
  translated documents.

  Supported file format conversion includes:
  - `application/pdf` to
    `application/vnd.openxmlformats-officedocument.wordprocessingml.document`

  If nothing specified, output files will be in the same format as the
  original file.

@yield [response, operation] Access the result along with the RPC operation @yieldparam response [::Gapic::Operation] @yieldparam operation [::GRPC::ActiveCall::Operation]

@return [::Gapic::Operation]

@raise [::Google::Cloud::Error] if the RPC is aborted.

# File lib/google/cloud/translate/v3/translation_service/client.rb, line 859
def batch_translate_document request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::Translate::V3::BatchTranslateDocumentRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.batch_translate_document.metadata.to_h

  # Set x-goog-api-client and x-goog-user-project headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::Translate::V3::VERSION
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {
    "parent" => request.parent
  }
  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.batch_translate_document.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.batch_translate_document.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @translation_service_stub.call_rpc :batch_translate_document, request, options: options do |response, operation|
    response = ::Gapic::Operation.new response, @operations_client, options: options
    yield response, operation if block_given?
    return response
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end
batch_translate_text(request, options = nil) { |response, operation| ... } click to toggle source

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.

@overload batch_translate_text(request, options = nil)

Pass arguments to `batch_translate_text` via a request object, either of type
{::Google::Cloud::Translate::V3::BatchTranslateTextRequest} or an equivalent Hash.

@param request [::Google::Cloud::Translate::V3::BatchTranslateTextRequest, ::Hash]
  A request object representing the call parameters. Required. To specify no
  parameters, or to keep all the default parameter values, pass an empty Hash.
@param options [::Gapic::CallOptions, ::Hash]
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.

@overload batch_translate_text(parent: nil, source_language_code: nil, target_language_codes: nil, models: nil, input_configs: nil, output_config: nil, glossaries: nil, labels: nil)

Pass arguments to `batch_translate_text` via keyword arguments. Note that at
least one keyword argument is required. To specify no parameters, or to keep all
the default parameter values, pass an empty Hash as a request object (see above).

@param parent [::String]
  Required. Location to make a call. Must refer to a caller's project.

  Format: `projects/{project-number-or-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.
@param source_language_code [::String]
  Required. Source language code.
@param target_language_codes [::Array<::String>]
  Required. Specify up to 10 language codes here.
@param models [::Hash{::String => ::String}]
  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-number-or-id}/locations/{location-id}/models/{model-id}`

  - General (built-in) models:
    `projects/{project-number-or-id}/locations/{location-id}/models/general/nmt`,

  If the map is empty or a specific model is
  not requested for a language pair, then default google model (nmt) is used.
@param input_configs [::Array<::Google::Cloud::Translate::V3::InputConfig, ::Hash>]
  Required. Input configurations.
  The total number of files matched should be <= 100.
  The total content size should be <= 100M Unicode codepoints.
  The files must use UTF-8 encoding.
@param output_config [::Google::Cloud::Translate::V3::OutputConfig, ::Hash]
  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.
@param glossaries [::Hash{::String => ::Google::Cloud::Translate::V3::TranslateTextGlossaryConfig, ::Hash}]
  Optional. Glossaries to be applied for translation.
  It's keyed by target language code.
@param labels [::Hash{::String => ::String}]
  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://cloud.google.com/translate/docs/advanced/labels for more
  information.

@yield [response, operation] Access the result along with the RPC operation @yieldparam response [::Gapic::Operation] @yieldparam operation [::GRPC::ActiveCall::Operation]

@return [::Gapic::Operation]

@raise [::Google::Cloud::Error] if the RPC is aborted.

# File lib/google/cloud/translate/v3/translation_service/client.rb, line 731
def batch_translate_text request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::Translate::V3::BatchTranslateTextRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.batch_translate_text.metadata.to_h

  # Set x-goog-api-client and x-goog-user-project headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::Translate::V3::VERSION
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {
    "parent" => request.parent
  }
  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.batch_translate_text.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.batch_translate_text.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @translation_service_stub.call_rpc :batch_translate_text, request, options: options do |response, operation|
    response = ::Gapic::Operation.new response, @operations_client, options: options
    yield response, operation if block_given?
    return response
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end
configure() { |config| ... } click to toggle source

Configure the TranslationService Client instance.

The configuration is set to the derived mode, meaning that values can be changed, but structural changes (adding new fields, etc.) are not allowed. Structural changes should be made on {Client.configure}.

See {::Google::Cloud::Translate::V3::TranslationService::Client::Configuration} for a description of the configuration fields.

@yield [config] Configure the Client client. @yieldparam config [Client::Configuration]

@return [Client::Configuration]

# File lib/google/cloud/translate/v3/translation_service/client.rb, line 120
def configure
  yield @config if block_given?
  @config
end
create_glossary(request, options = nil) { |response, operation| ... } click to toggle source

Creates a glossary and returns the long-running operation. Returns NOT_FOUND, if the project doesn't exist.

@overload create_glossary(request, options = nil)

Pass arguments to `create_glossary` via a request object, either of type
{::Google::Cloud::Translate::V3::CreateGlossaryRequest} or an equivalent Hash.

@param request [::Google::Cloud::Translate::V3::CreateGlossaryRequest, ::Hash]
  A request object representing the call parameters. Required. To specify no
  parameters, or to keep all the default parameter values, pass an empty Hash.
@param options [::Gapic::CallOptions, ::Hash]
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.

@overload create_glossary(parent: nil, glossary: nil)

Pass arguments to `create_glossary` via keyword arguments. Note that at
least one keyword argument is required. To specify no parameters, or to keep all
the default parameter values, pass an empty Hash as a request object (see above).

@param parent [::String]
  Required. The project name.
@param glossary [::Google::Cloud::Translate::V3::Glossary, ::Hash]
  Required. The glossary to create.

@yield [response, operation] Access the result along with the RPC operation @yieldparam response [::Gapic::Operation] @yieldparam operation [::GRPC::ActiveCall::Operation]

@return [::Gapic::Operation]

@raise [::Google::Cloud::Error] if the RPC is aborted.

# File lib/google/cloud/translate/v3/translation_service/client.rb, line 931
def create_glossary request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::Translate::V3::CreateGlossaryRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.create_glossary.metadata.to_h

  # Set x-goog-api-client and x-goog-user-project headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::Translate::V3::VERSION
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {
    "parent" => request.parent
  }
  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.create_glossary.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.create_glossary.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @translation_service_stub.call_rpc :create_glossary, request, options: options do |response, operation|
    response = ::Gapic::Operation.new response, @operations_client, options: options
    yield response, operation if block_given?
    return response
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end
delete_glossary(request, options = nil) { |response, operation| ... } click to toggle source

Deletes a glossary, or cancels glossary construction if the glossary isn't created yet. Returns NOT_FOUND, if the glossary doesn't exist.

@overload delete_glossary(request, options = nil)

Pass arguments to `delete_glossary` via a request object, either of type
{::Google::Cloud::Translate::V3::DeleteGlossaryRequest} or an equivalent Hash.

@param request [::Google::Cloud::Translate::V3::DeleteGlossaryRequest, ::Hash]
  A request object representing the call parameters. Required. To specify no
  parameters, or to keep all the default parameter values, pass an empty Hash.
@param options [::Gapic::CallOptions, ::Hash]
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.

@overload delete_glossary(name: nil)

Pass arguments to `delete_glossary` via keyword arguments. Note that at
least one keyword argument is required. To specify no parameters, or to keep all
the default parameter values, pass an empty Hash as a request object (see above).

@param name [::String]
  Required. The name of the glossary to delete.

@yield [response, operation] Access the result along with the RPC operation @yieldparam response [::Gapic::Operation] @yieldparam operation [::GRPC::ActiveCall::Operation]

@return [::Gapic::Operation]

@raise [::Google::Cloud::Error] if the RPC is aborted.

# File lib/google/cloud/translate/v3/translation_service/client.rb, line 1166
def delete_glossary request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::Translate::V3::DeleteGlossaryRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.delete_glossary.metadata.to_h

  # Set x-goog-api-client and x-goog-user-project headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::Translate::V3::VERSION
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {
    "name" => request.name
  }
  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.delete_glossary.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.delete_glossary.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @translation_service_stub.call_rpc :delete_glossary, request, options: options do |response, operation|
    response = ::Gapic::Operation.new response, @operations_client, options: options
    yield response, operation if block_given?
    return response
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end
detect_language(request, options = nil) { |response, operation| ... } click to toggle source

Detects the language of text within a request.

@overload detect_language(request, options = nil)

Pass arguments to `detect_language` via a request object, either of type
{::Google::Cloud::Translate::V3::DetectLanguageRequest} or an equivalent Hash.

@param request [::Google::Cloud::Translate::V3::DetectLanguageRequest, ::Hash]
  A request object representing the call parameters. Required. To specify no
  parameters, or to keep all the default parameter values, pass an empty Hash.
@param options [::Gapic::CallOptions, ::Hash]
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.

@overload detect_language(parent: nil, model: nil, content: nil, mime_type: nil, labels: nil)

Pass arguments to `detect_language` via keyword arguments. Note that at
least one keyword argument is required. To specify no parameters, or to keep all
the default parameter values, pass an empty Hash as a request object (see above).

@param parent [::String]
  Required. Project or location to make a call. Must refer to a caller's
  project.

  Format: `projects/{project-number-or-id}/locations/{location-id}` or
  `projects/{project-number-or-id}`.

  For global calls, use `projects/{project-number-or-id}/locations/global` or
  `projects/{project-number-or-id}`.

  Only models within the same region (has same location-id) can be used.
  Otherwise an INVALID_ARGUMENT (400) error is returned.
@param model [::String]
  Optional. The language detection model to be used.

  Format:
  `projects/{project-number-or-id}/locations/{location-id}/models/language-detection/{model-id}`

  Only one language detection model is currently supported:
  `projects/{project-number-or-id}/locations/{location-id}/models/language-detection/default`.

  If not specified, the default model is used.
@param content [::String]
  The content of the input stored as a string.
@param mime_type [::String]
  Optional. The format of the source text, for example, "text/html",
  "text/plain". If left blank, the MIME type defaults to "text/html".
@param labels [::Hash{::String => ::String}]
  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://cloud.google.com/translate/docs/advanced/labels for more
  information.

@yield [response, operation] Access the result along with the RPC operation @yieldparam response [::Google::Cloud::Translate::V3::DetectLanguageResponse] @yieldparam operation [::GRPC::ActiveCall::Operation]

@return [::Google::Cloud::Translate::V3::DetectLanguageResponse]

@raise [::Google::Cloud::Error] if the RPC is aborted.

# File lib/google/cloud/translate/v3/translation_service/client.rb, line 384
def detect_language request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::Translate::V3::DetectLanguageRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.detect_language.metadata.to_h

  # Set x-goog-api-client and x-goog-user-project headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::Translate::V3::VERSION
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {
    "parent" => request.parent
  }
  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.detect_language.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.detect_language.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @translation_service_stub.call_rpc :detect_language, request, options: options do |response, operation|
    yield response, operation if block_given?
    return response
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end
get_glossary(request, options = nil) { |response, operation| ... } click to toggle source

Gets a glossary. Returns NOT_FOUND, if the glossary doesn't exist.

@overload get_glossary(request, options = nil)

Pass arguments to `get_glossary` via a request object, either of type
{::Google::Cloud::Translate::V3::GetGlossaryRequest} or an equivalent Hash.

@param request [::Google::Cloud::Translate::V3::GetGlossaryRequest, ::Hash]
  A request object representing the call parameters. Required. To specify no
  parameters, or to keep all the default parameter values, pass an empty Hash.
@param options [::Gapic::CallOptions, ::Hash]
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.

@overload get_glossary(name: nil)

Pass arguments to `get_glossary` via keyword arguments. Note that at
least one keyword argument is required. To specify no parameters, or to keep all
the default parameter values, pass an empty Hash as a request object (see above).

@param name [::String]
  Required. The name of the glossary to retrieve.

@yield [response, operation] Access the result along with the RPC operation @yieldparam response [::Google::Cloud::Translate::V3::Glossary] @yieldparam operation [::GRPC::ActiveCall::Operation]

@return [::Google::Cloud::Translate::V3::Glossary]

@raise [::Google::Cloud::Error] if the RPC is aborted.

# File lib/google/cloud/translate/v3/translation_service/client.rb, line 1096
def get_glossary request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::Translate::V3::GetGlossaryRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.get_glossary.metadata.to_h

  # Set x-goog-api-client and x-goog-user-project headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::Translate::V3::VERSION
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {
    "name" => request.name
  }
  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.get_glossary.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.get_glossary.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @translation_service_stub.call_rpc :get_glossary, request, options: options do |response, operation|
    yield response, operation if block_given?
    return response
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end
get_supported_languages(request, options = nil) { |response, operation| ... } click to toggle source

Returns a list of supported languages for translation.

@overload get_supported_languages(request, options = nil)

Pass arguments to `get_supported_languages` via a request object, either of type
{::Google::Cloud::Translate::V3::GetSupportedLanguagesRequest} or an equivalent Hash.

@param request [::Google::Cloud::Translate::V3::GetSupportedLanguagesRequest, ::Hash]
  A request object representing the call parameters. Required. To specify no
  parameters, or to keep all the default parameter values, pass an empty Hash.
@param options [::Gapic::CallOptions, ::Hash]
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.

@overload get_supported_languages(parent: nil, display_language_code: nil, model: nil)

Pass arguments to `get_supported_languages` via keyword arguments. Note that at
least one keyword argument is required. To specify no parameters, or to keep all
the default parameter values, pass an empty Hash as a request object (see above).

@param parent [::String]
  Required. Project or location to make a call. Must refer to a caller's
  project.

  Format: `projects/{project-number-or-id}` or
  `projects/{project-number-or-id}/locations/{location-id}`.

  For global calls, use `projects/{project-number-or-id}/locations/global` or
  `projects/{project-number-or-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.
@param display_language_code [::String]
  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.
@param model [::String]
  Optional. Get supported languages of this model.

  The format depends on model type:

  - AutoML Translation models:
    `projects/{project-number-or-id}/locations/{location-id}/models/{model-id}`

  - General (built-in) models:
    `projects/{project-number-or-id}/locations/{location-id}/models/general/nmt`,

  Returns languages supported by the specified model.
  If missing, we get supported languages of Google general NMT model.

@yield [response, operation] Access the result along with the RPC operation @yieldparam response [::Google::Cloud::Translate::V3::SupportedLanguages] @yieldparam operation [::GRPC::ActiveCall::Operation]

@return [::Google::Cloud::Translate::V3::SupportedLanguages]

@raise [::Google::Cloud::Error] if the RPC is aborted.

# File lib/google/cloud/translate/v3/translation_service/client.rb, line 482
def get_supported_languages request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::Translate::V3::GetSupportedLanguagesRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.get_supported_languages.metadata.to_h

  # Set x-goog-api-client and x-goog-user-project headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::Translate::V3::VERSION
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {
    "parent" => request.parent
  }
  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.get_supported_languages.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.get_supported_languages.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @translation_service_stub.call_rpc :get_supported_languages, request, options: options do |response, operation|
    yield response, operation if block_given?
    return response
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end
list_glossaries(request, options = nil) { |response, operation| ... } click to toggle source

Lists glossaries in a project. Returns NOT_FOUND, if the project doesn't exist.

@overload list_glossaries(request, options = nil)

Pass arguments to `list_glossaries` via a request object, either of type
{::Google::Cloud::Translate::V3::ListGlossariesRequest} or an equivalent Hash.

@param request [::Google::Cloud::Translate::V3::ListGlossariesRequest, ::Hash]
  A request object representing the call parameters. Required. To specify no
  parameters, or to keep all the default parameter values, pass an empty Hash.
@param options [::Gapic::CallOptions, ::Hash]
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.

@overload list_glossaries(parent: nil, page_size: nil, page_token: nil, filter: nil)

Pass arguments to `list_glossaries` via keyword arguments. Note that at
least one keyword argument is required. To specify no parameters, or to keep all
the default parameter values, pass an empty Hash as a request object (see above).

@param parent [::String]
  Required. The name of the project from which to list all of the glossaries.
@param page_size [::Integer]
  Optional. Requested page size. The server may return fewer glossaries than
  requested. If unspecified, the server picks an appropriate default.
@param page_token [::String]
  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.
@param filter [::String]
  Optional. Filter specifying constraints of a list operation.
  Specify the constraint by the format of "key=value", where key must be
  "src" or "tgt", and the value must be a valid language code.
  For multiple restrictions, concatenate them by "AND" (uppercase only),
  such as: "src=en-US AND tgt=zh-CN". Notice that the exact match is used
  here, which means using 'en-US' and 'en' can lead to different results,
  which depends on the language code you used when you create the glossary.
  For the unidirectional glossaries, the "src" and "tgt" add restrictions
  on the source and target language code separately.
  For the equivalent term set glossaries, the "src" and/or "tgt" add
  restrictions on the term set.
  For example: "src=en-US AND tgt=zh-CN" will only pick the unidirectional
  glossaries which exactly match the source language code as "en-US" and the
  target language code "zh-CN", but all equivalent term set glossaries which
  contain "en-US" and "zh-CN" in their language set will be picked.
  If missing, no filtering is performed.

@yield [response, operation] Access the result along with the RPC operation @yieldparam response [::Gapic::PagedEnumerable<::Google::Cloud::Translate::V3::Glossary>] @yieldparam operation [::GRPC::ActiveCall::Operation]

@return [::Gapic::PagedEnumerable<::Google::Cloud::Translate::V3::Glossary>]

@raise [::Google::Cloud::Error] if the RPC is aborted.

# File lib/google/cloud/translate/v3/translation_service/client.rb, line 1026
def list_glossaries request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::Translate::V3::ListGlossariesRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.list_glossaries.metadata.to_h

  # Set x-goog-api-client and x-goog-user-project headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::Translate::V3::VERSION
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {
    "parent" => request.parent
  }
  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.list_glossaries.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.list_glossaries.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @translation_service_stub.call_rpc :list_glossaries, request, options: options do |response, operation|
    response = ::Gapic::PagedEnumerable.new @translation_service_stub, :list_glossaries, request, response, operation, options
    yield response, operation if block_given?
    return response
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end
translate_document(request, options = nil) { |response, operation| ... } click to toggle source

Translates documents in synchronous mode.

@overload translate_document(request, options = nil)

Pass arguments to `translate_document` via a request object, either of type
{::Google::Cloud::Translate::V3::TranslateDocumentRequest} or an equivalent Hash.

@param request [::Google::Cloud::Translate::V3::TranslateDocumentRequest, ::Hash]
  A request object representing the call parameters. Required. To specify no
  parameters, or to keep all the default parameter values, pass an empty Hash.
@param options [::Gapic::CallOptions, ::Hash]
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.

@overload translate_document(parent: nil, source_language_code: nil, target_language_code: nil, document_input_config: nil, document_output_config: nil, model: nil, glossary_config: nil, labels: nil)

Pass arguments to `translate_document` via keyword arguments. Note that at
least one keyword argument is required. To specify no parameters, or to keep all
the default parameter values, pass an empty Hash as a request object (see above).

@param parent [::String]
  Required. Location to make a regional call.

  Format: `projects/{project-number-or-id}/locations/{location-id}`.

  For global calls, use `projects/{project-number-or-id}/locations/global` or
  `projects/{project-number-or-id}`.

  Non-global location is required for requests using AutoML models or custom
  glossaries.

  Models and glossaries must be within the same region (have the same
  location-id), otherwise an INVALID_ARGUMENT (400) error is returned.
@param source_language_code [::String]
  Optional. The BCP-47 language code of the input document 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. Source language must be specified if the
  request contains a glossary or a custom model.
@param target_language_code [::String]
  Required. The BCP-47 language code to use for translation of the input
  document, set to one of the language codes listed in Language Support.
@param document_input_config [::Google::Cloud::Translate::V3::DocumentInputConfig, ::Hash]
  Required. Input configurations.
@param document_output_config [::Google::Cloud::Translate::V3::DocumentOutputConfig, ::Hash]
  Optional. Output configurations.
  Defines if the output file should be stored within Cloud Storage as well
  as the desired output format. If not provided the translated file will
  only be returned through a byte-stream and its output mime type will be
  the same as the input file's mime type.
@param model [::String]
  Optional. The `model` type requested for this translation.

  The format depends on model type:

  - AutoML Translation models:
    `projects/{project-number-or-id}/locations/{location-id}/models/{model-id}`

  - General (built-in) models:
    `projects/{project-number-or-id}/locations/{location-id}/models/general/nmt`,

  If not provided, the default Google model (NMT) will be used for
  translation.
@param glossary_config [::Google::Cloud::Translate::V3::TranslateTextGlossaryConfig, ::Hash]
  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.
@param labels [::Hash{::String => ::String}]
  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://cloud.google.com/translate/docs/advanced/labels for more
  information.

@yield [response, operation] Access the result along with the RPC operation @yieldparam response [::Google::Cloud::Translate::V3::TranslateDocumentResponse] @yieldparam operation [::GRPC::ActiveCall::Operation]

@return [::Google::Cloud::Translate::V3::TranslateDocumentResponse]

@raise [::Google::Cloud::Error] if the RPC is aborted.

# File lib/google/cloud/translate/v3/translation_service/client.rb, line 607
def translate_document request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::Translate::V3::TranslateDocumentRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.translate_document.metadata.to_h

  # Set x-goog-api-client and x-goog-user-project headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::Translate::V3::VERSION
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {
    "parent" => request.parent
  }
  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.translate_document.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.translate_document.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @translation_service_stub.call_rpc :translate_document, request, options: options do |response, operation|
    yield response, operation if block_given?
    return response
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end
translate_text(request, options = nil) { |response, operation| ... } click to toggle source

Translates input text and returns translated text.

@overload translate_text(request, options = nil)

Pass arguments to `translate_text` via a request object, either of type
{::Google::Cloud::Translate::V3::TranslateTextRequest} or an equivalent Hash.

@param request [::Google::Cloud::Translate::V3::TranslateTextRequest, ::Hash]
  A request object representing the call parameters. Required. To specify no
  parameters, or to keep all the default parameter values, pass an empty Hash.
@param options [::Gapic::CallOptions, ::Hash]
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.

@overload translate_text(contents: nil, mime_type: nil, source_language_code: nil, target_language_code: nil, parent: nil, model: nil, glossary_config: nil, labels: nil)

Pass arguments to `translate_text` via keyword arguments. Note that at
least one keyword argument is required. To specify no parameters, or to keep all
the default parameter values, pass an empty Hash as a request object (see above).

@param contents [::Array<::String>]
  Required. The content of the input in string format.
  We recommend the total content be less than 30k codepoints. The max length
  of this field is 1024.
  Use BatchTranslateText for larger text.
@param mime_type [::String]
  Optional. The format of the source text, for example, "text/html",
   "text/plain". If left blank, the MIME type defaults to "text/html".
@param source_language_code [::String]
  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.
@param target_language_code [::String]
  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.
@param parent [::String]
  Required. Project or location to make a call. Must refer to a caller's
  project.

  Format: `projects/{project-number-or-id}` or
  `projects/{project-number-or-id}/locations/{location-id}`.

  For global calls, use `projects/{project-number-or-id}/locations/global` or
  `projects/{project-number-or-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.
@param model [::String]
  Optional. The `model` type requested for this translation.

  The format depends on model type:

  - AutoML Translation models:
    `projects/{project-number-or-id}/locations/{location-id}/models/{model-id}`

  - General (built-in) models:
    `projects/{project-number-or-id}/locations/{location-id}/models/general/nmt`,

  For global (non-regionalized) requests, use `location-id` `global`.
  For example,
  `projects/{project-number-or-id}/locations/global/models/general/nmt`.

  If not provided, the default Google model (NMT) will be used.
@param glossary_config [::Google::Cloud::Translate::V3::TranslateTextGlossaryConfig, ::Hash]
  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.
@param labels [::Hash{::String => ::String}]
  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://cloud.google.com/translate/docs/advanced/labels for more
  information.

@yield [response, operation] Access the result along with the RPC operation @yieldparam response [::Google::Cloud::Translate::V3::TranslateTextResponse] @yieldparam operation [::GRPC::ActiveCall::Operation]

@return [::Google::Cloud::Translate::V3::TranslateTextResponse]

@raise [::Google::Cloud::Error] if the RPC is aborted.

# File lib/google/cloud/translate/v3/translation_service/client.rb, line 281
def translate_text request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::Translate::V3::TranslateTextRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.translate_text.metadata.to_h

  # Set x-goog-api-client and x-goog-user-project headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::Translate::V3::VERSION
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {
    "parent" => request.parent
  }
  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.translate_text.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.translate_text.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @translation_service_stub.call_rpc :translate_text, request, options: options do |response, operation|
    yield response, operation if block_given?
    return response
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end