Como criar e usar glossários (Advanced)

O glossário é um dicionário personalizado que a API Cloud Translation usa para traduzir com consistência a terminologia específica do domínio do cliente. Isso normalmente envolve a especificação de como traduzir uma entidade nomeada.

Os casos de uso do glossário incluem:

• Nomes de produtos: por exemplo, "Google Home" precisa ser traduzido para "Google Home".
• Palavras ambíguas: por exemplo, a palavra "morcego" pode significar um equipamento esportivo ou um animal. Se você souber que está traduzindo palavras sobre esporte, usará um glossário para alimentar o Tradutor com a tradução esportiva de "bat", não com a de animal.
• Palavras emprestadas: por exemplo, "bouillabaisse" em francês significa "bouillabaisse" em inglês. A língua inglesa pegou emprestada a palavra "bouillabaisse" do francês no século 19. Um falante de inglês sem o contexto cultural francês pode não saber que "bouillabaisse" é um prato típico de ensopado de peixe. Com os glossários, é possível substituir uma tradução para que "bouillabaisse", em francês, seja traduzido como "fish stew" (ensopado de peixe).

Observação: o número máximo de glossários para um projeto do Google Cloud é 1.000. Se você atingir esse limite, exclua os glossários atuais para criar novos.

Permissões exigidas

É preciso garantir que a conta de serviço tenha as permissões adequadas para trabalhar com glossários. É possível conceder um papel à sua conta de serviço usando um dos papéis predefinidos do Cloud IAM, como o editor da API Cloud Translation (roles/cloudtranslate.editor), ou criar um papel personalizado que concede as permissões necessárias. Consulte todas as permissões da API Cloud Translation na referência de permissões do Cloud IAM. As permissões de tradução começam com cloudtranslate.

Para criar glossários, você também precisa de permissões para ler objetos no intervalo do Cloud Storage em que seu arquivo de glossário está localizado. É possível conceder um papel à sua conta de serviço usando um dos papéis predefinidos do Cloud IAM, como o Visualizador de objetos do Storage (roles/storage.objectViewer), ou criar um papel personalizado que concede permissões para ler objetos.

Para mais informações sobre como adicionar uma conta a um papel, consulte Como conceder, alterar e revogar o acesso a recursos.

Criar um glossário

Os termos em um glossário podem ser tokens únicos (palavras) ou frases curtas (geralmente menos de cinco palavras). O limite atual para o número de glossários separados é de 1.000 por projeto.

Estas são as principais etapas para usar um glossário:

1. Criar um arquivo de glossário
2. Criar o recurso de glossário com a API Cloud Translation
3. Especificar qual glossário usar ao solicitar uma tradução

Um projeto pode ter vários glossários. É possível conseguir uma lista dos glossários disponíveis e excluir aqueles que não são mais necessários.

Como criar um arquivo de glossário

Basicamente, um glossário é um arquivo de texto em que cada linha contém termos correspondentes em vários idiomas. A API Cloud Translation é compatível com glossários unidirecionais (que especificam a tradução que você quer para um único par de idiomas de origem e de chegada) e com conjuntos de termos equivalentes (que identificam os termos equivalentes em vários idiomas).

O número total de termos em um arquivo de entrada de glossário não pode exceder 10,4 milhões (10.485.760) de bytes UTF-8 em todos os termos de todos os idiomas combinados. Qualquer termo do glossário precisa ter menos de 1.024 bytes UTF-8. Os termos com mais do que isso serão ignorados.

Glossários unidirecionais

A API Cloud Translation aceita arquivos TSV, CSV ou TMX.

Valores separados por tabulação (TSV)

A API Cloud Translation é compatível com arquivos separados por tabulação, em que cada linha tem este formato:

• Term in source language tabulação Term in target language

Por exemplo:

account\tcuenta
directions\tindicaciones

Os dados de origem separados por tabulação não incluem códigos de idioma para identificar os idiomas de origem e de chegada. Identifique os códigos de idioma de origem e de chegada ao criar o glossário on-line.

Valores separados por vírgula (CSV)

Os arquivos CSV têm o mesmo formato que os TSV, mas uma vírgula (",") é usada como um separador de colunas.

Translation Memory eXchange (TMX)

O Translation Memory eXchange (TMX) é um formato XML padrão para fornecer traduções de origem e de chegada. A API Cloud Translation é compatível com arquivos de entrada em um formato baseado na versão 1.4 do TMX. Veja neste exemplo a estrutura necessária:

<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE tmx SYSTEM "tmx14.dtd">
<tmx version="1.4">
  <header segtype="sentence" o-tmf="UTF-8"
  adminlang="en" srclang="en" datatype="PlainText"/>
  <body>
    <tu>
      <tuv xml:lang="en">
        <seg>account</seg>
      </tuv>
      <tuv xml:lang="es">
        <seg>cuenta</seg>
      </tuv>
    </tu>
    <tu>
      <tuv xml:lang="en">
        <seg>directions</seg>
      </tuv>
      <tuv xml:lang="es">
        <seg>indicaciones</seg>
      </tuv>
    </tu>
  </body>
</tmx>

O elemento <header> de um arquivo TMX bem estruturado precisa identificar o idioma de origem por meio do atributo srclang. Além disso, cada elemento <tuv> precisa identificar o idioma do texto contido por meio do atributo xml:lang. Use os códigos ISO-639-1 (em inglês) para identificar os idiomas de origem e de chegada.

Todos os elementos <tu> precisam incluir um par de elementos <tuv> com os mesmos idiomas de origem e de chegada. Se um elemento <tu> contiver mais de dois elementos <tuv>, a API Cloud Translation processará apenas o primeiro <tuv> correspondente ao idioma de origem e o primeiro correspondente ao idioma de destino, ignorando o restante. Se um elemento <tu> não tiver um par correspondente de <tuv>, a Cloud Translation API desconsiderará o elemento <tu> inválido.

O API Cloud Translation remove as tags de marcação ao redor do elemento <seg> antes de processá-lo. Se um elemento <tuv> contiver mais de um elemento <seg>, a API Cloud Translation concatenará o texto deles em um único elemento com espaço entre eles.

Se o arquivo contiver tags XML diferentes das mostradas acima, a API Cloud Translation as ignorará.

Se o arquivo não estiver em conformidade com os formatos XML e TMX adequados (por exemplo, se estiver faltando uma tag final ou um elemento <tmx>), a API Cloud Translation não o processará. A API Cloud Translation também interromperá o processamento e retornará um erro se ignorar mais de 1.024 elementos <tu> inválidos.

Conjuntos de termos equivalentes (CSV)

Para conjuntos de termos equivalentes, a API Cloud Translation aceita apenas arquivos no formato CSV. Para definir conjuntos de termos equivalentes, crie um arquivo CSV de várias colunas em que cada linha lista um único termo do glossário em vários idiomas.

A primeira linha no arquivo é uma de cabeçalho que identifica o idioma de cada coluna, usando o código de idioma ISO-639-1 ou BCP-47 (links em inglês). Também é possível incluir colunas opcionais para a classe gramatical (pos, na sigla em inglês) e uma descrição (description).

Observação: no momento, o algoritmo não usa as informações de pos, e os valores relacionados específicos não estão validados.

Cada linha posterior contém termos de glossário equivalentes nos idiomas identificados no cabeçalho. Deixe as colunas em branco se o termo não estiver disponível em todos os idiomas.

Criar um recurso de glossário

Depois de identificar os termos de glossário equivalentes, disponibilize o glossário para a API Cloud Translation criando o glossário on-line.

Glossário unidirecional

Ao criar um glossário unidirecional, é preciso indicar o par de idiomas (language_pair) especificando os idiomas de origem (source_language_code) e de chegada (target_language_code).

REST e linha de comando

Ao criar um novo glossário, você fornece um ID de glossário ou nome de recurso. Por exemplo:

projects/my-project/locations/us-central1/glossaries/my-en-to-ru-glossary

em que my-project é o project-number-or-id, e my-en-ru-glossary é o glossary-id fornecido por você.

Observação: project-id também funciona, mas é melhor usar project-number daqui em diante.

Antes de usar os dados da solicitação abaixo, faça as substituições a seguir:

• project-number-or-id: pelo número ou código do seu projeto do Google Cloud
• glossary-id: pelo código de glossário, por exemplo, my_en_ru_glossary
• bucket-name: o nome do bucket em que seu arquivo de glossário está localizado
• glossary-filename: nome de arquivo do seu glossário

Método HTTP e URL:

POST https://translation.googleapis.com/v3/projects/project-number-or-id/locations/us-central1/glossaries

Corpo JSON da solicitação:

{
  "name":"projects/project-number-or-id/locations/us-central1/glossaries/glossary-id",
  "languagePair": {
    "sourceLanguageCode": "en",
    "targetLanguageCode": "ru"
    },
  "inputConfig": {
    "gcsSource": {
      "inputUri": "gs://bucket-name/glossary-filename"
    }
  }
}

Para enviar a solicitação, escolha uma destas opções:

curl

Observação: verifique se você definiu a variável de ambiente GOOGLE_APPLICATION_CREDENTIALS como o caminho do arquivo da chave privada da conta de serviço.

Salve o corpo da solicitação em um arquivo chamado request.json e execute o comando a seguir:

curl -X POST \
-H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
-H "Content-Type: application/json; charset=utf-8" \
-d @request.json \
https://translation.googleapis.com/v3/projects/project-number-or-id/locations/us-central1/glossaries

PowerShell

Observação: verifique se você definiu a variável de ambiente GOOGLE_APPLICATION_CREDENTIALS como o caminho do arquivo da chave privada da conta de serviço.

Salve o corpo da solicitação em um arquivo chamado request.json e execute o comando a seguir:

$cred = gcloud auth application-default print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
  -Method POST `
  -Headers $headers `
  -ContentType: "application/json; charset=utf-8" `
  -InFile request.json `
  -Uri "https://translation.googleapis.com/v3/projects/project-number-or-id/locations/us-central1/glossaries
" | Select-Object -Expand Content

Você receberá uma resposta JSON semelhante a esta:

{
  "name": "projects/project-number/locations/us-central1/operations/operation-id",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.translation.v3beta1.CreateGlossaryMetadata",
    "name": "projects/project-number/locations/us-central1/glossaries/glossary-id",
    "state": "RUNNING",
    "submitTime": "2019-11-19T19:05:10.650047636Z"
  }
}

Glossário de conjuntos de termos equivalentes

Depois de identificar os termos de glossário equivalentes, disponibilize o glossário para a API Cloud Translation. Para isso, basta criar o glossário on-line.

REST e linha de comando

Antes de usar os dados da solicitação abaixo, faça as substituições a seguir:

• project-number-or-id: pelo número ou código do seu projeto do Google Cloud
• glossary-id: seu código de glossário
• bucket-name: o nome do bucket em que seu arquivo de glossário está localizado
• glossary-filename: nome de arquivo do seu glossário

Método HTTP e URL:

POST https://translation.googleapis.com/v3/projects/project-number-or-id/locations/us-central1/glossaries

Corpo JSON da solicitação:

{
  "name":"projects/project-number-or-id/locations/us-central1/glossaries/glossary-id",
  "languageCodesSet": {
    "languageCodes": ["en", "en-GB", "ru", "fr", "pt-BR", "pt-PT", "es"]
  },
  "inputConfig": {
    "gcsSource": {
"inputUri": "gs://bucket-name/glossary-file-name"
    }
  }
}

Para enviar a solicitação, escolha uma destas opções:

curl

Observação: verifique se você definiu a variável de ambiente GOOGLE_APPLICATION_CREDENTIALS como o caminho do arquivo da chave privada da conta de serviço.

Salve o corpo da solicitação em um arquivo chamado request.json e execute o comando a seguir:

curl -X POST \
-H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
-H "Content-Type: application/json; charset=utf-8" \
-d @request.json \
https://translation.googleapis.com/v3/projects/project-number-or-id/locations/us-central1/glossaries

PowerShell

Observação: verifique se você definiu a variável de ambiente GOOGLE_APPLICATION_CREDENTIALS como o caminho do arquivo da chave privada da conta de serviço.

Salve o corpo da solicitação em um arquivo chamado request.json e execute o comando a seguir:

$cred = gcloud auth application-default print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
  -Method POST `
  -Headers $headers `
  -ContentType: "application/json; charset=utf-8" `
  -InFile request.json `
  -Uri "https://translation.googleapis.com/v3/projects/project-number-or-id/locations/us-central1/glossaries
" | Select-Object -Expand Content

Você receberá uma resposta JSON semelhante a esta:

{
  "name": "projects/project-number/locations/us-central1/operations/20191103-09061569945989-5d937985-0000-21ac-816d-f4f5e80782d4",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.translation.v3beta1.CreateGlossaryMetadata",
    "name": "projects/project-number/locations/us-central1/glossaries/glossary-id",
    "state": "RUNNING",
    "submitTime": "2019-11-03T16:06:29.134496675Z"
  }
}

C#

Antes de testar esta amostra, siga as instruções de configuração para C# no Guia de início rápido do Translation: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Translation para C#.

Ver no GitHub Feedback

using Google.Api.Gax.ResourceNames;
using Google.Cloud.Translate.V3;
using System;

namespace GoogleCloudSamples
{
    public static class CreateGlossary
    {
        /// <summary>
        /// Create Glossary.
        /// </summary>
        /// <param name="projectId">Your Google Cloud Project ID.</param>
        /// <param name="glossaryId">Your glossary display name.</param>
        /// <param name="inputUri">Google Cloud Storage URI where glossary is stored in csv format.</param>
        public static void CreateGlossarySample(string projectId = "[Google Cloud Project ID]",
            string glossaryId = "your-glossary-display-name",
            string inputUri = "gs://cloud-samples-data/translation/glossary_ja.csv")
        {
            TranslationServiceClient translationServiceClient = TranslationServiceClient.Create();
            CreateGlossaryRequest request = new CreateGlossaryRequest
            {
                ParentAsLocationName = new LocationName(projectId, "us-central1"),
                Parent = new LocationName(projectId, "us-central1").ToString(),
                Glossary = new Glossary
                {
                    Name = new GlossaryName(projectId, "us-central1", glossaryId).ToString(),
                    LanguageCodesSet = new Glossary.Types.LanguageCodesSet
                    {
                        LanguageCodes =
                        {
                            "en", // source lang
                            "ja", // target lang
                        },
                    },
                    InputConfig = new GlossaryInputConfig
                    {
                        GcsSource = new GcsSource
                        {
                            InputUri = inputUri,
                        },
                    },
                },
            };
            // Poll until the returned long-running operation is complete
            Glossary response = translationServiceClient.CreateGlossary(request).PollUntilCompleted().Result;
            Console.WriteLine("Created Glossary.");
            Console.WriteLine($"Glossary name: {response.Name}");
            Console.WriteLine($"Entry count: {response.EntryCount}");
            Console.WriteLine($"Input URI: {response.InputConfig.GcsSource.InputUri}");
        }
    }

Go

Antes de testar esta amostra, siga as instruções de configuração para Go no Guia de início rápido do Translation: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Translation para Go.

Ver no GitHub Feedback

import (
	"context"
	"fmt"
	"io"

	translate "cloud.google.com/go/translate/apiv3"
	translatepb "google.golang.org/genproto/googleapis/cloud/translate/v3"
)

// createGlossary creates a glossary to use for other operations.
func createGlossary(w io.Writer, projectID string, location string, glossaryID string, glossaryInputURI string) error {
	// projectID := "my-project-id"
	// location := "us-central1"
	// glossaryID := "my-glossary-display-name"
	// glossaryInputURI := "gs://cloud-samples-data/translation/glossary.csv"

	ctx := context.Background()
	client, err := translate.NewTranslationClient(ctx)
	if err != nil {
		return fmt.Errorf("NewTranslationClient: %v", err)
	}
	defer client.Close()

	req := &translatepb.CreateGlossaryRequest{
		Parent: fmt.Sprintf("projects/%s/locations/%s", projectID, location),
		Glossary: &translatepb.Glossary{
			Name: fmt.Sprintf("projects/%s/locations/%s/glossaries/%s", projectID, location, glossaryID),
			Languages: &translatepb.Glossary_LanguageCodesSet_{
				LanguageCodesSet: &translatepb.Glossary_LanguageCodesSet{
					LanguageCodes: []string{"en", "ja"},
				},
			},
			InputConfig: &translatepb.GlossaryInputConfig{
				Source: &translatepb.GlossaryInputConfig_GcsSource{
					GcsSource: &translatepb.GcsSource{
						InputUri: glossaryInputURI,
					},
				},
			},
		},
	}

	// The CreateGlossary operation is async.
	op, err := client.CreateGlossary(ctx, req)
	if err != nil {
		return fmt.Errorf("CreateGlossary: %v", err)
	}
	fmt.Fprintf(w, "Processing operation name: %q\n", op.Name())

	resp, err := op.Wait(ctx)
	if err != nil {
		return fmt.Errorf("Wait: %v", err)
	}

	fmt.Fprintf(w, "Created: %v\n", resp.GetName())
	fmt.Fprintf(w, "Input URI: %v\n", resp.InputConfig.GetGcsSource().GetInputUri())

	return nil
}

Java

Antes de testar esta amostra, siga as instruções de configuração para Java no Guia de início rápido do Translation: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Translation para Java.

Ver no GitHub Feedback

import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.translate.v3.CreateGlossaryMetadata;
import com.google.cloud.translate.v3.CreateGlossaryRequest;
import com.google.cloud.translate.v3.GcsSource;
import com.google.cloud.translate.v3.Glossary;
import com.google.cloud.translate.v3.GlossaryInputConfig;
import com.google.cloud.translate.v3.GlossaryName;
import com.google.cloud.translate.v3.LocationName;
import com.google.cloud.translate.v3.TranslationServiceClient;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;

public class CreateGlossary {

  public static void createGlossary() throws InterruptedException, ExecutionException, IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR-PROJECT-ID";
    String glossaryId = "your-glossary-display-name";
    List<String> languageCodes = new ArrayList<>();
    languageCodes.add("your-language-code");
    String inputUri = "gs://your-gcs-bucket/path/to/input/file.txt";
    createGlossary(projectId, glossaryId, languageCodes, inputUri);
  }

  // Create a equivalent term sets glossary
  // https://cloud.google.com/translate/docs/advanced/glossary#format-glossary
  public static void createGlossary(
      String projectId, String glossaryId, List<String> languageCodes, String inputUri)
      throws IOException, ExecutionException, InterruptedException {

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (TranslationServiceClient client = TranslationServiceClient.create()) {
      // Supported Locations: `global`, [glossary location], or [model location]
      // Glossaries must be hosted in `us-central1`
      // Custom Models must use the same location as your model. (us-central1)
      String location = "us-central1";
      LocationName parent = LocationName.of(projectId, location);
      GlossaryName glossaryName = GlossaryName.of(projectId, location, glossaryId);

      // Supported Languages: https://cloud.google.com/translate/docs/languages
      Glossary.LanguageCodesSet languageCodesSet =
          Glossary.LanguageCodesSet.newBuilder().addAllLanguageCodes(languageCodes).build();

      // Configure the source of the file from a GCS bucket
      GcsSource gcsSource = GcsSource.newBuilder().setInputUri(inputUri).build();
      GlossaryInputConfig inputConfig =
          GlossaryInputConfig.newBuilder().setGcsSource(gcsSource).build();

      Glossary glossary =
          Glossary.newBuilder()
              .setName(glossaryName.toString())
              .setLanguageCodesSet(languageCodesSet)
              .setInputConfig(inputConfig)
              .build();

      CreateGlossaryRequest request =
          CreateGlossaryRequest.newBuilder()
              .setParent(parent.toString())
              .setGlossary(glossary)
              .build();

      // Start an asynchronous request
      OperationFuture<Glossary, CreateGlossaryMetadata> future =
          client.createGlossaryAsync(request);

      System.out.println("Waiting for operation to complete...");
      Glossary response = future.get();
      System.out.println("Created Glossary.");
      System.out.printf("Glossary name: %s\n", response.getName());
      System.out.printf("Entry count: %s\n", response.getEntryCount());
      System.out.printf("Input URI: %s\n", response.getInputConfig().getGcsSource().getInputUri());
    }
  }
}

Node.js

Antes de testar esta amostra, siga as instruções de configuração para Node.js no Guia de início rápido do Translation: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Translation para Node.js.

Ver no GitHub Feedback

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const location = 'global';
// const glossaryId = 'your-glossary-display-name';

// Imports the Google Cloud Translation library
const {TranslationServiceClient} = require('@google-cloud/translate');

// Instantiates a client
const translationClient = new TranslationServiceClient();

async function createGlossary() {
  // Construct glossary
  const glossary = {
    languageCodesSet: {
      languageCodes: ['en', 'es'],
    },
    inputConfig: {
      gcsSource: {
        inputUri: 'gs://cloud-samples-data/translation/glossary.csv',
      },
    },
    name: `projects/${projectId}/locations/${location}/glossaries/${glossaryId}`,
  };

  // Construct request
  const request = {
    parent: `projects/${projectId}/locations/${location}`,
    glossary: glossary,
  };

  try {
    // Create glossary using a long-running operation
    const [operation] = await translationClient.createGlossary(request);

    // Wait for the operation to complete
    await operation.promise();

    console.log('Created glossary:');
    console.log(
      `InputUri ${request.glossary.inputConfig.gcsSource.inputUri}`
    );
  } catch (error) {
    console.error(error.details);
  }
}

createGlossary();

PHP

Antes de testar esta amostra, siga as instruções de configuração para PHP no Guia de início rápido do Translation: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Translation para PHP.

Ver no GitHub Feedback

use Google\Cloud\Translate\V3\GcsSource;
use Google\Cloud\Translate\V3\Glossary;
use Google\Cloud\Translate\V3\GlossaryInputConfig;
use Google\Cloud\Translate\V3\Glossary\LanguageCodesSet;
use Google\Cloud\Translate\V3\TranslationServiceClient;

$translationServiceClient = new TranslationServiceClient();

/** Uncomment and populate these variables in your code */
// $projectId = '[Google Cloud Project ID]';
// $glossaryId = 'my_glossary_id_123';
// $inputUri = 'gs://cloud-samples-data/translation/glossary.csv';
$formattedParent = $translationServiceClient->locationName(
    $projectId,
    'us-central1'
);
$formattedName = $translationServiceClient->glossaryName(
    $projectId,
    'us-central1',
    $glossaryId
);
$languageCodesElement = 'en';
$languageCodesElement2 = 'ja';
$languageCodes = [$languageCodesElement, $languageCodesElement2];
$languageCodesSet = new LanguageCodesSet();
$languageCodesSet->setLanguageCodes($languageCodes);
$gcsSource = (new GcsSource())
    ->setInputUri($inputUri);
$inputConfig = (new GlossaryInputConfig())
    ->setGcsSource($gcsSource);
$glossary = (new Glossary())
    ->setName($formattedName)
    ->setLanguageCodesSet($languageCodesSet)
    ->setInputConfig($inputConfig);

try {
    $operationResponse = $translationServiceClient->createGlossary(
        $formattedParent,
        $glossary
    );
    $operationResponse->pollUntilComplete();
    if ($operationResponse->operationSucceeded()) {
        $response = $operationResponse->getResult();
        printf('Created Glossary.' . PHP_EOL);
        printf('Glossary name: %s' . PHP_EOL, $response->getName());
        printf('Entry count: %s' . PHP_EOL, $response->getEntryCount());
        printf(
            'Input URI: %s' . PHP_EOL,
            $response->getInputConfig()
                ->getGcsSource()
                ->getInputUri()
        );
    } else {
        $error = $operationResponse->getError();
        // handleError($error)
    }
} finally {
    $translationServiceClient->close();
}

Python

Antes de testar esta amostra, siga as instruções de configuração para Python noGuia de início rápido do Translation: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Translation para Python.

Ver no GitHub Feedback

from google.cloud import translate_v3 as translate

def create_glossary(
    project_id="YOUR_PROJECT_ID",
    input_uri="YOUR_INPUT_URI",
    glossary_id="YOUR_GLOSSARY_ID",
):
    """
    Create a equivalent term sets glossary. Glossary can be words or
    short phrases (usually fewer than five words).
    https://cloud.google.com/translate/docs/advanced/glossary#format-glossary
    """
    client = translate.TranslationServiceClient()

    # Supported language codes: https://cloud.google.com/translate/docs/languages
    source_lang_code = "en"
    target_lang_code = "ja"
    location = "us-central1"  # The location of the glossary

    name = client.glossary_path(project_id, location, glossary_id)
    language_codes_set = translate.types.Glossary.LanguageCodesSet(
        language_codes=[source_lang_code, target_lang_code]
    )

    gcs_source = translate.types.GcsSource(input_uri=input_uri)

    input_config = translate.types.GlossaryInputConfig(gcs_source=gcs_source)

    glossary = translate.types.Glossary(
        name=name, language_codes_set=language_codes_set, input_config=input_config
    )

    parent = client.location_path(project_id, location)
    # glossary is a custom dictionary Translation API uses
    # to translate the domain-specific terminology.
    operation = client.create_glossary(parent=parent, glossary=glossary)

    result = operation.result(timeout=180)
    print("Created: {}".format(result.name))
    print("Input Uri: {}".format(result.input_config.gcs_source.input_uri))

Ruby

Antes de testar esta amostra, siga as instruções de configuração para Ruby no Guia de início rápido do Translation: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Translation para Ruby.

Ver no GitHub Feedback

require "google/cloud/translate"

client = Google::Cloud::Translate.new

project_id = "[Google Cloud Project ID]"
location_id = "[LOCATION ID]"
glossary_id = "your-glossary-display-name"

project_2 = "[Your Google Cloud Project ID]"
input_uri = "gs://translation_samples_beta/glossaries/glossary.csv"

parent = client.class.location_path project_id, location_id
glossary = {
  name:               client.class.glossary_path(project_2, location_id, glossary_id),
  language_codes_set: {
    language_codes: ["en", "ja"]
  },
  input_config:       {
    gcs_source: {
      input_uri: input_uri
    }
  }
}

operation = client.create_glossary parent, glossary

# Wait until the long running operation is done
operation.wait_until_done!
response = operation.response

puts "Created Glossary."
puts "Glossary name: #{response.name}"
puts "Entry count: #{response.entry_count}"
puts "Input URI: #{response.input_config.gcs_source.input_uri}"

Status da operação

A criação de um glossário é uma operação de longa duração. Portanto, pode levar um tempo considerável para ser concluída. É possível pesquisar o status dessa operação para ver se ela foi concluída ou cancelá-la.

Para mais informações, consulte Operações de longa duração.

Usar glossários

Traduzir texto com um glossário

Na Cloud Translation – Advanced, especifique explicitamente qual modelo de tradução usar para traduzir o texto. Também é possível identificar um glossário para usar na terminologia específica de domínio.

Observação: o glossário especificado precisa estar associado ao projeto atual do Google Cloud.

REST e linha de comando

Neste exemplo, traduzimos um texto usando o modelo NMT padrão e um glossário.

Antes de usar os dados da solicitação abaixo, faça as substituições a seguir:

• project-number-or-id: pelo número ou código do seu projeto do Google Cloud
• glossary-id: pelo código de glossário, por exemplo, my-en-ru-glossary

Método HTTP e URL:

POST https://translation.googleapis.com/v3/projects/project-number-or-id/locations/us-central1:translateText

Corpo JSON da solicitação:

{
  "sourceLanguageCode": "en",
  "targetLanguageCode": "ru",
  "contents": "Dr. Watson, please discard your trash. You've shared unsolicited email with me. Let's talk about spam and importance ranking in a confidential mode.",
  "glossaryConfig": {
    "glossary": "projects/project-number/locations/us-central1/glossaries/glossary-id"
  }
}

Para enviar a solicitação, escolha uma destas opções:

curl

Observação: verifique se você definiu a variável de ambiente GOOGLE_APPLICATION_CREDENTIALS como o caminho do arquivo da chave privada da conta de serviço.

Salve o corpo da solicitação em um arquivo chamado request.json e execute o comando a seguir:

curl -X POST \
-H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
-H "Content-Type: application/json; charset=utf-8" \
-d @request.json \
https://translation.googleapis.com/v3/projects/project-number-or-id/locations/us-central1:translateText

PowerShell

Observação: verifique se você definiu a variável de ambiente GOOGLE_APPLICATION_CREDENTIALS como o caminho do arquivo da chave privada da conta de serviço.

Salve o corpo da solicitação em um arquivo chamado request.json e execute o comando a seguir:

$cred = gcloud auth application-default print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
  -Method POST `
  -Headers $headers `
  -ContentType: "application/json; charset=utf-8" `
  -InFile request.json `
  -Uri "https://translation.googleapis.com/v3/projects/project-number-or-id/locations/us-central1:translateText
" | Select-Object -Expand Content

Você receberá uma resposta JSON semelhante a esta:

{
  "glossaryTranslations": {
    "translatedText": "Доктор Ватсон, пожалуйста, откажитесь от своего мусора. Вы поделились нежелательной электронной почтой со я . Давайте поговорим о спаме и важности рейтинга в конфиденциальном режиме.",
    "glossaryConfig": {
      "glossary": "projects/project-number/locations/us-central1/glossaries/glossary-id"
    }
  },
  "translations": {
    "translatedText": "Доктор Ватсон, пожалуйста, откажитесь от своего мусора. Вы поделились нежелательной электронной почтой со мной. Давайте поговорим о спаме и важности рейтинга в конфиденциальном режиме.",
  }
}

O campo translations contém a tradução automática normal antes da aplicação do glossário, e glossaryTranslations inclui a tradução depois que o glossário é aplicado.

C#

Antes de testar esta amostra, siga as instruções de configuração para C# no Guia de início rápido do Translation: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Translation para C#.

Ver no GitHub Feedback

using Google.Api.Gax.ResourceNames;
using Google.Cloud.Translate.V3;
using System;

namespace GoogleCloudSamples
{
    public static class TranslateTextWithGlossary
    {
        /// <summary>
        /// Translates a given text to a target language using glossary.
        /// </summary>
        /// <param name="text">The content to translate.</param>
        /// <param name="sourceLanguage">Optional. Source language code.</param>
        /// <param name="targetLanguage">Required. Target language code.</param>
        /// <param name="glossaryId">Translation Glossary ID.</param>
        /// <param name="projectId">Your Google Cloud Project ID.</param>
        public static void TranslateTextWithGlossarySample(
            string text = "[TEXT_TO_TRANSLATE]",
            string sourceLanguage = "en",
            string targetLanguage = "ja",
            string projectId = "[Google Cloud Project ID]",
            string glossaryId = "[YOUR_GLOSSARY_ID]")
        {
            TranslationServiceClient translationServiceClient = TranslationServiceClient.Create();

            string glossaryPath = $"projects/{projectId}/locations/{"us-central1"}/glossaries/{glossaryId}";
            TranslateTextRequest request = new TranslateTextRequest
            {
                Contents =
                {
                    // The content to translate.
                    text,
                },
                TargetLanguageCode = targetLanguage,
                ParentAsLocationName = new LocationName(projectId, "us-central1"),
                SourceLanguageCode = sourceLanguage,
                GlossaryConfig = new TranslateTextGlossaryConfig
                {
                    // Translation Glossary Path.
                    Glossary = glossaryPath,
                },
                MimeType = "text/plain",
            };
            TranslateTextResponse response = translationServiceClient.TranslateText(request);
            // Display the translation for given content.
            foreach (Translation translation in response.GlossaryTranslations)
            {
                Console.WriteLine($"Translated text: {translation.TranslatedText}");
            }
        }
    }

Go

Antes de testar esta amostra, siga as instruções de configuração para Go no Guia de início rápido do Translation: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Translation para Go.

Ver no GitHub Feedback

import (
	"context"
	"fmt"
	"io"

	translate "cloud.google.com/go/translate/apiv3"
	translatepb "google.golang.org/genproto/googleapis/cloud/translate/v3"
)

// translateTextWithGlossary translates input text and returns translated text.
func translateTextWithGlossary(w io.Writer, projectID string, location string, sourceLang string, targetLang string, text string, glossaryID string) error {
	// projectID := "my-project-id"
	// location := "us-central1"
	// sourceLang := "en"
	// targetLang := "ja"
	// text := "Hello world"
	// glossaryID := "your-glossary-id"

	ctx := context.Background()
	client, err := translate.NewTranslationClient(ctx)
	if err != nil {
		return fmt.Errorf("NewTranslationClient: %v", err)
	}
	defer client.Close()

	req := &translatepb.TranslateTextRequest{
		Parent:             fmt.Sprintf("projects/%s/locations/%s", projectID, location),
		SourceLanguageCode: sourceLang,
		TargetLanguageCode: targetLang,
		MimeType:           "text/plain", // Mime types: "text/plain", "text/html"
		Contents:           []string{text},
		GlossaryConfig: &translatepb.TranslateTextGlossaryConfig{
			Glossary: fmt.Sprintf("projects/%s/locations/%s/glossaries/%s", projectID, location, glossaryID),
		},
	}

	resp, err := client.TranslateText(ctx, req)
	if err != nil {
		return fmt.Errorf("TranslateText: %v", err)
	}

	// Display the translation for each input text provided
	for _, translation := range resp.GetGlossaryTranslations() {
		fmt.Fprintf(w, "Translated text: %v\n", translation.GetTranslatedText())
	}

	return nil
}

Java

Antes de testar esta amostra, siga as instruções de configuração para Java no Guia de início rápido do Translation: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Translation para Java.

Ver no GitHub Feedback

import com.google.cloud.translate.v3.GlossaryName;
import com.google.cloud.translate.v3.LocationName;
import com.google.cloud.translate.v3.TranslateTextGlossaryConfig;
import com.google.cloud.translate.v3.TranslateTextRequest;
import com.google.cloud.translate.v3.TranslateTextResponse;
import com.google.cloud.translate.v3.Translation;
import com.google.cloud.translate.v3.TranslationServiceClient;
import java.io.IOException;

public class TranslateTextWithGlossary {

  public static void translateTextWithGlossary() throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR-PROJECT-ID";
    // Supported Languages: https://cloud.google.com/translate/docs/languages
    String sourceLanguage = "your-source-language";
    String targetLanguage = "your-target-language";
    String text = "your-text";
    String glossaryId = "your-glossary-display-name";
    translateTextWithGlossary(projectId, sourceLanguage, targetLanguage, text, glossaryId);
  }

  // Translates a given text using a glossary.
  public static void translateTextWithGlossary(
      String projectId,
      String sourceLanguage,
      String targetLanguage,
      String text,
      String glossaryId)
      throws IOException {

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (TranslationServiceClient client = TranslationServiceClient.create()) {
      // Supported Locations: `global`, [glossary location], or [model location]
      // Glossaries must be hosted in `us-central1`
      // Custom Models must use the same location as your model. (us-central1)
      String location = "us-central1";
      LocationName parent = LocationName.of(projectId, location);

      GlossaryName glossaryName = GlossaryName.of(projectId, location, glossaryId);
      TranslateTextGlossaryConfig glossaryConfig =
          TranslateTextGlossaryConfig.newBuilder().setGlossary(glossaryName.toString()).build();

      // Supported Mime Types: https://cloud.google.com/translate/docs/supported-formats
      TranslateTextRequest request =
          TranslateTextRequest.newBuilder()
              .setParent(parent.toString())
              .setMimeType("text/plain")
              .setSourceLanguageCode(sourceLanguage)
              .setTargetLanguageCode(targetLanguage)
              .addContents(text)
              .setGlossaryConfig(glossaryConfig)
              .build();

      TranslateTextResponse response = client.translateText(request);

      // Display the translation for each input text provided
      for (Translation translation : response.getGlossaryTranslationsList()) {
        System.out.printf("Translated text: %s\n", translation.getTranslatedText());
      }
    }
  }
}

Node.js

Antes de testar esta amostra, siga as instruções de configuração para Node.js no Guia de início rápido do Translation: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Translation para Node.js.

Ver no GitHub Feedback

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const location = 'global';
// const glossaryId = 'YOUR_GLOSSARY_ID';
// const text = 'text to translate';

// Imports the Google Cloud Translation library
const {TranslationServiceClient} = require('@google-cloud/translate');

// Instantiates a client
const translationClient = new TranslationServiceClient();
async function translateTextWithGlossary() {
  const glossaryConfig = {
    glossary: `projects/${projectId}/locations/${location}/glossaries/${glossaryId}`,
  };
  // Construct request
  const request = {
    parent: `projects/${projectId}/locations/${location}`,
    contents: [text],
    mimeType: 'text/plain', // mime types: text/plain, text/html
    sourceLanguageCode: 'en',
    targetLanguageCode: 'es',
    glossaryConfig: glossaryConfig,
  };

  try {
    // Run request
    const [response] = await translationClient.translateText(request);

    for (const translation of response.glossaryTranslations) {
      console.log(`Translation: ${translation.translatedText}`);
    }
  } catch (error) {
    console.error(error.details);
  }
}

translateTextWithGlossary();

PHP

Antes de testar esta amostra, siga as instruções de configuração para PHP no Guia de início rápido do Translation: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Translation para PHP.

Ver no GitHub Feedback

use Google\Cloud\Translate\V3\TranslateTextGlossaryConfig;
use Google\Cloud\Translate\V3\TranslationServiceClient;

$translationServiceClient = new TranslationServiceClient();

/** Uncomment and populate these variables in your code */
// $text = 'Hello, world!';
// $sourceLanguage = 'en';
// $targetLanguage = 'fr';
// $projectId = '[Google Cloud Project ID]';
// $glossaryId = '[YOUR_GLOSSARY_ID]';
$glossaryPath = $translationServiceClient->glossaryName(
    $projectId,
    'us-central1',
    $glossaryId
);
$contents = [$text];
$formattedParent = $translationServiceClient->locationName(
    $projectId,
    'us-central1'
);
$glossaryConfig = new TranslateTextGlossaryConfig();
$glossaryConfig->setGlossary($glossaryPath);

// Optional. Can be "text/plain" or "text/html".
$mimeType = 'text/plain';

try {
    $response = $translationServiceClient->translateText(
        $contents,
        $targetLanguage,
        $formattedParent,
        [
            'sourceLanguageCode' => $sourceLanguage,
            'glossaryConfig' => $glossaryConfig,
            'mimeType' => $mimeType
        ]
    );
    // Display the translation for each input text provided
    foreach ($response->getGlossaryTranslations() as $translation) {
        printf('Translated text: %s' . PHP_EOL, $translation->getTranslatedText());
    }
} finally {
    $translationServiceClient->close();
}

Python

Antes de testar esta amostra, siga as instruções de configuração para Python noGuia de início rápido do Translation: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Translation para Python.

Ver no GitHub Feedback

from google.cloud import translate_v3

def translate_text_with_glossary(
    text="YOUR_TEXT_TO_TRANSLATE",
    project_id="YOUR_PROJECT_ID",
    glossary_id="YOUR_GLOSSARY_ID",
):
    """Translates a given text using a glossary."""

    client = translate_v3.TranslationServiceClient()
    parent = client.location_path(project_id, "us-central1")

    glossary = client.glossary_path(
        project_id, "us-central1", glossary_id  # The location of the glossary
    )

    glossary_config = translate_v3.types.TranslateTextGlossaryConfig(
        glossary=glossary)

    # Supported language codes: https://cloud.google.com/translate/docs/languages
    response = client.translate_text(
        contents=[text],
        target_language_code="ja",
        source_language_code="en",
        parent=parent,
        glossary_config=glossary_config,
    )
    print("Translated text: \n")
    for translation in response.glossary_translations:
        print(u"\t {}".format(translation.translated_text))

Ruby

Antes de testar esta amostra, siga as instruções de configuração para Ruby no Guia de início rápido do Translation: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Translation para Ruby.

Ver no GitHub Feedback

require "google/cloud/translate"

client = Google::Cloud::Translate.new

project_id = "[Google Cloud Project ID]"
location_id = "[LOCATION ID]"
glossary_id = "[YOUR_GLOSSARY_ID]"

# The content to translate in string format
contents = ["Hello, world!"]
# Required. The BCP-47 language code to use for translation.
target_language = "fr"
# Optional. The BCP-47 language code of the input text.
source_language = "en"
glossary_config = {
  # Specifies the glossary used for this translation.
  glossary: client.class.glossary_path(project_id, location_id, glossary_id)
}
# Optional. Can be "text/plain" or "text/html".
mime_type = "text/plain"
parent = client.class.location_path project_id, location_id

response = client.translate_text(
  contents, target_language, parent,
  source_language_code: source_language,
  glossary_config:      glossary_config,
  mime_type:            mime_type
)

# Display the translation for each input text provided
response.translations.each do |translation|
  puts "Translated text: #{translation.translated_text}"
end

Ver informações sobre um glossário

REST e linha de comando

Antes de usar os dados da solicitação abaixo, faça as substituições a seguir:

• project-number-or-id: pelo número ou código do seu projeto do Google Cloud
• glossary-id: pelo código de glossário, por exemplo, "my-en-to-ru-glossary"

Método HTTP e URL:

GET https://translation.googleapis.com/v3/projects/project-number-or-id/locations/us-central1/glossaries/glossary-id

Para enviar a solicitação, escolha uma destas opções:

curl

Observação: verifique se você definiu a variável de ambiente GOOGLE_APPLICATION_CREDENTIALS como o caminho do arquivo da chave privada da conta de serviço.

Execute o comando a seguir:

curl -X GET \
-H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
https://translation.googleapis.com/v3/projects/project-number-or-id/locations/us-central1/glossaries/glossary-id

PowerShell

Observação: verifique se você definiu a variável de ambiente GOOGLE_APPLICATION_CREDENTIALS como o caminho do arquivo da chave privada da conta de serviço.

Execute o comando a seguir:

$cred = gcloud auth application-default print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
  -Method GET `
  -Headers $headers `
  -Uri "https://translation.googleapis.com/v3/projects/project-number-or-id/locations/us-central1/glossaries/glossary-id
" | Select-Object -Expand Content

Você receberá uma resposta JSON semelhante a esta:

{
  "name": "projects/project-number/locations/us-central1/glossaries/glossary-id",
  "languagePair": {
    "sourceLanguageCode": "en",
    "targetLanguageCode": "ru"
  },
  "inputConfig": {
    "gcsSource": {
  "inputUri": "gs://bucket-name/glossary-file-name"
    }
  },
  "entryCount": 9603
}

C#

Antes de testar esta amostra, siga as instruções de configuração para C# no Guia de início rápido do Translation: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Translation para C#.

Ver no GitHub Feedback

using Google.Cloud.Translate.V3;
using System;

namespace GoogleCloudSamples
{
    public static class GetGlossary
    {
        /// <summary>
        /// Retrieves a glossary.
        /// </summary>
        /// <param name="projectId">Your Google Cloud Project ID.</param>
        /// <param name="glossaryId">Glossary ID.</param>
        public static void GetGlossarySample(string projectId = "[Google Cloud Project ID]",
            string glossaryId = "[YOUR_GLOSSARY_ID]")
        {
            TranslationServiceClient translationServiceClient = TranslationServiceClient.Create();
            GetGlossaryRequest request = new GetGlossaryRequest
            {
                GlossaryName = new GlossaryName(projectId, "us-central1", glossaryId),
            };
            Glossary response = translationServiceClient.GetGlossary(request);
            Console.WriteLine($"Glossary name: {response.Name}");
            Console.WriteLine($"Entry count: {response.EntryCount}");
            Console.WriteLine($"Input URI: {response.InputConfig.GcsSource.InputUri}");
        }
    }

Go

Antes de testar esta amostra, siga as instruções de configuração para Go no Guia de início rápido do Translation: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Translation para Go.

Ver no GitHub Feedback

import (
	"context"
	"fmt"
	"io"

	translate "cloud.google.com/go/translate/apiv3"
	translatepb "google.golang.org/genproto/googleapis/cloud/translate/v3"
)

// getGlossary gets the specified glossary.
func getGlossary(w io.Writer, projectID string, location string, glossaryID string) error {
	// projectID := "my-project-id"
	// location := "us-central1"
	// glossaryID := "glossary-id"

	ctx := context.Background()
	client, err := translate.NewTranslationClient(ctx)
	if err != nil {
		return fmt.Errorf("NewTranslationClient: %v", err)
	}
	defer client.Close()

	req := &translatepb.GetGlossaryRequest{
		Name: fmt.Sprintf("projects/%s/locations/%s/glossaries/%s", projectID, location, glossaryID),
	}

	resp, err := client.GetGlossary(ctx, req)
	if err != nil {
		return fmt.Errorf("GetGlossary: %v", err)
	}

	fmt.Fprintf(w, "Glossary name: %v\n", resp.GetName())
	fmt.Fprintf(w, "Entry count: %v\n", resp.GetEntryCount())
	fmt.Fprintf(w, "Input URI: %v\n", resp.GetInputConfig().GetGcsSource().GetInputUri())

	return nil
}

Java

Antes de testar esta amostra, siga as instruções de configuração para Java no Guia de início rápido do Translation: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Translation para Java.

Ver no GitHub Feedback

import com.google.cloud.translate.v3.GetGlossaryRequest;
import com.google.cloud.translate.v3.Glossary;
import com.google.cloud.translate.v3.GlossaryName;
import com.google.cloud.translate.v3.TranslationServiceClient;
import java.io.IOException;

public class GetGlossary {

  public static void getGlossary() throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR-PROJECT-ID";
    String glossaryId = "your-glossary-display-name";
    getGlossary(projectId, glossaryId);
  }

  // Get a particular glossary based on the glossary ID
  public static void getGlossary(String projectId, String glossaryId) throws IOException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (TranslationServiceClient client = TranslationServiceClient.create()) {
      // Supported Locations: `global`, [glossary location], or [model location]
      // Glossaries must be hosted in `us-central1`
      // Custom Models must use the same location as your model. (us-central1)
      GlossaryName glossaryName = GlossaryName.of(projectId, "us-central1", glossaryId);
      GetGlossaryRequest request =
          GetGlossaryRequest.newBuilder().setName(glossaryName.toString()).build();

      Glossary response = client.getGlossary(request);

      System.out.printf("Glossary name: %s\n", response.getName());
      System.out.printf("Entry count: %s\n", response.getEntryCount());
      System.out.printf("Input URI: %s\n", response.getInputConfig().getGcsSource().getInputUri());
    }
  }
}

Node.js

Antes de testar esta amostra, siga as instruções de configuração para Node.js no Guia de início rápido do Translation: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Translation para Node.js.

Ver no GitHub Feedback

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const location = 'global';
// const glossaryId = 'YOUR_GLOSSARY_ID';

// Imports the Google Cloud Translation library
const {TranslationServiceClient} = require('@google-cloud/translate');

// Instantiates a client
const translationClient = new TranslationServiceClient();

async function getGlossary() {
  // Construct request
  const request = {
    parent: `projects/${projectId}/locations/${location}`,
    name: `projects/${projectId}/locations/${location}/glossaries/${glossaryId}`,
  };

  try {
    // Get glossary
    const [response] = await translationClient.getGlossary(request);

    console.log(`Got glossary: ${response.name}`);
  } catch (error) {
    console.error(error.details);
  }
}

getGlossary();

PHP

Antes de testar esta amostra, siga as instruções de configuração para PHP no Guia de início rápido do Translation: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Translation para PHP.

Ver no GitHub Feedback

use Google\Cloud\Translate\V3\TranslationServiceClient;

$translationServiceClient = new TranslationServiceClient();

/** Uncomment and populate these variables in your code */
// $projectId = '[Google Cloud Project ID]';
// $glossaryId = '[Glossary ID]';
$formattedName = $translationServiceClient->glossaryName(
    $projectId,
    'us-central1',
    $glossaryId
);

try {
    $response = $translationServiceClient->getGlossary($formattedName);
    printf('Glossary name: %s' . PHP_EOL, $response->getName());
    printf('Entry count: %s' . PHP_EOL, $response->getEntryCount());
    printf(
        'Input URI: %s' . PHP_EOL,
        $response->getInputConfig()
            ->getGcsSource()
            ->getInputUri()
    );
} finally {
    $translationServiceClient->close();
}

Python

Antes de testar esta amostra, siga as instruções de configuração para Python noGuia de início rápido do Translation: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Translation para Python.

Ver no GitHub Feedback

from google.cloud import translate_v3 as translate

def get_glossary(project_id="YOUR_PROJECT_ID", glossary_id="YOUR_GLOSSARY_ID"):
    """Get a particular glossary based on the glossary ID."""

    client = translate.TranslationServiceClient()

    name = client.glossary_path(project_id, "us-central1", glossary_id)

    response = client.get_glossary(name)
    print(u"Glossary name: {}".format(response.name))
    print(u"Entry count: {}".format(response.entry_count))
    print(u"Input URI: {}".format(response.input_config.gcs_source.input_uri))

Ruby

Antes de testar esta amostra, siga as instruções de configuração para Ruby no Guia de início rápido do Translation: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Translation para Ruby.

Ver no GitHub Feedback

require "google/cloud/translate"

client = Google::Cloud::Translate.new

project_id = "[Google Cloud Project ID]"
location_id = "[LOCATION ID]"
glossary_id = "[YOUR_GLOSSARY_ID]"

name = client.class.glossary_path project_id, location_id, glossary_id

response = client.get_glossary name

puts "Glossary name: #{response.name}"
puts "Entry count: #{response.entry_count}"
puts "Input URI: #{response.input_config.gcs_source.input_uri}"

Listar glossários

Um projeto pode incluir vários glossários. Nesta seção, descreveremos como recuperar uma lista dos glossários disponíveis para um projeto.

REST e linha de comando

Neste exemplo, listamos todos os glossários associados ao projeto especificado.

Antes de usar os dados da solicitação abaixo, faça as substituições a seguir:

• project-number-or-id: pelo número ou código do seu projeto do Google Cloud

Método HTTP e URL:

GET https://translation.googleapis.com/v3/projects/project-number-or-id/locations/us-central1/glossaries

Para enviar a solicitação, escolha uma destas opções:

curl

Observação: verifique se você definiu a variável de ambiente GOOGLE_APPLICATION_CREDENTIALS como o caminho do arquivo da chave privada da conta de serviço.

Execute o comando a seguir:

curl -X GET \
-H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
https://translation.googleapis.com/v3/projects/project-number-or-id/locations/us-central1/glossaries

PowerShell

Observação: verifique se você definiu a variável de ambiente GOOGLE_APPLICATION_CREDENTIALS como o caminho do arquivo da chave privada da conta de serviço.

Execute o seguinte comando:

$cred = gcloud auth application-default print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
  -Method GET `
  -Headers $headers `
  -Uri "https://translation.googleapis.com/v3/projects/project-number-or-id/locations/us-central1/glossaries
" | Select-Object -Expand Content

Você receberá um código de status bem-sucedido (2xx) e uma resposta vazia.

C#

Antes de testar esta amostra, siga as instruções de configuração para C# no Guia de início rápido do Translation: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Translation para C#.

Ver no GitHub Feedback

using Google.Api.Gax;
using Google.Api.Gax.ResourceNames;
using Google.Cloud.Translate.V3;
using System;

namespace GoogleCloudSamples
{
    public static class ListGlossary
    {
        /// <summary>
        /// Lists all the glossaries for a given project.
        /// </summary>
        /// <param name="projectId">Your Google Cloud Project ID.</param>
        public static void ListGlossariesSample(string projectId = "[Google Cloud Project ID]")
        {
            TranslationServiceClient translationServiceClient = TranslationServiceClient.Create();
            ListGlossariesRequest request = new ListGlossariesRequest
            {
                ParentAsLocationName = new LocationName(projectId, "us-central1"),
            };
            PagedEnumerable<ListGlossariesResponse, Glossary> response = translationServiceClient.ListGlossaries(request);
            // Iterate over glossaries and display each glossary's details.
            foreach (Glossary item in response)
            {
                Console.WriteLine($"Glossary name: {item.Name}");
                Console.WriteLine($"Entry count: {item.EntryCount}");
                Console.WriteLine($"Input URI: {item.InputConfig.GcsSource.InputUri}");
            }
        }
    }

Go

Antes de testar esta amostra, siga as instruções de configuração para Go no Guia de início rápido do Translation: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Translation para Go.

Ver no GitHub Feedback

import (
	"context"
	"fmt"
	"io"

	translate "cloud.google.com/go/translate/apiv3"
	"google.golang.org/api/iterator"
	translatepb "google.golang.org/genproto/googleapis/cloud/translate/v3"
)

// listGlossaries gets the specified glossary.
func listGlossaries(w io.Writer, projectID string, location string) error {
	// projectID := "my-project-id"
	// location := "us-central1"

	ctx := context.Background()
	client, err := translate.NewTranslationClient(ctx)
	if err != nil {
		return fmt.Errorf("NewTranslationClient: %v", err)
	}
	defer client.Close()

	req := &translatepb.ListGlossariesRequest{
		Parent: fmt.Sprintf("projects/%s/locations/%s", projectID, location),
	}

	it := client.ListGlossaries(ctx, req)

	// Iterate over all results
	for {
		glossary, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return fmt.Errorf("ListGlossaries.Next: %v", err)
		}
		fmt.Fprintf(w, "Name: %v\n", glossary.GetName())
		fmt.Fprintf(w, "Entry count: %v\n", glossary.GetEntryCount())
		fmt.Fprintf(w, "Input URI: %v\n", glossary.GetInputConfig().GetGcsSource().GetInputUri())
		for _, languageCode := range glossary.GetLanguageCodesSet().GetLanguageCodes() {
			fmt.Fprintf(w, "Language code: %v\n", languageCode)
		}
		if languagePair := glossary.GetLanguagePair(); languagePair != nil {
			fmt.Fprintf(w, "Language pair: %v, %v\n",
				languagePair.GetSourceLanguageCode(), languagePair.GetTargetLanguageCode())
		}
	}

	return nil
}

Java

Antes de testar esta amostra, siga as instruções de configuração para Java no Guia de início rápido do Translation: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Translation para Java.

Ver no GitHub Feedback

import com.google.cloud.translate.v3.Glossary;
import com.google.cloud.translate.v3.ListGlossariesRequest;
import com.google.cloud.translate.v3.LocationName;
import com.google.cloud.translate.v3.TranslationServiceClient;
import java.io.IOException;

public class ListGlossaries {

  public static void listGlossaries() throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR-PROJECT-ID";
    listGlossaries(projectId);
  }

  // List all the glossaries in a specified location
  public static void listGlossaries(String projectId) throws IOException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (TranslationServiceClient client = TranslationServiceClient.create()) {
      // Supported Locations: `global`, [glossary location], or [model location]
      // Glossaries must be hosted in `us-central1`
      // Custom Models must use the same location as your model. (us-central1)
      LocationName parent = LocationName.of(projectId, "us-central1");
      ListGlossariesRequest request =
          ListGlossariesRequest.newBuilder().setParent(parent.toString()).build();

      for (Glossary responseItem : client.listGlossaries(request).iterateAll()) {
        System.out.printf("Glossary name: %s\n", responseItem.getName());
        System.out.printf("Entry count: %s\n", responseItem.getEntryCount());
        System.out.printf(
            "Input URI: %s\n", responseItem.getInputConfig().getGcsSource().getInputUri());
      }
    }
  }
}

Node.js

Antes de testar esta amostra, siga as instruções de configuração para Node.js no Guia de início rápido do Translation: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Translation para Node.js.

Ver no GitHub Feedback

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const location = 'global';

// Imports the Google Cloud Translation library
const {TranslationServiceClient} = require('@google-cloud/translate');

// Instantiates a client
const translationClient = new TranslationServiceClient();

async function listGlossaries() {
  // Construct request
  const request = {
    parent: `projects/${projectId}/locations/${location}`,
  };

  try {
    // Run request
    const [response] = await translationClient.listGlossaries(request);

    for (const glossary of response) {
      console.log(`Name: ${glossary.name}`);
      console.log(`Entry count: ${glossary.entryCount}`);
      console.log(`Input uri: ${glossary.inputConfig.gcsSource.inputUri}`);
      for (const languageCode of glossary.languageCodesSet.languageCodes) {
        console.log(`Language code: ${languageCode}`);
      }
    }
  } catch (error) {
    console.error(error.details);
  }
}

listGlossaries();

PHP

Antes de testar esta amostra, siga as instruções de configuração para PHP no Guia de início rápido do Translation: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Translation para PHP.

Ver no GitHub Feedback

use Google\Cloud\Translate\V3\TranslationServiceClient;

$translationServiceClient = new TranslationServiceClient();

/** Uncomment and populate these variables in your code */
// $projectId = '[Google Cloud Project ID]';
$formattedParent = $translationServiceClient->locationName(
    $projectId,
    'us-central1'
);

try {
    // Iterate through all elements
    $pagedResponse = $translationServiceClient->listGlossaries($formattedParent);
    foreach ($pagedResponse->iterateAllElements() as $responseItem) {
        printf('Glossary name: %s' . PHP_EOL, $responseItem->getName());
        printf('Entry count: %s' . PHP_EOL, $responseItem->getEntryCount());
        printf(
            'Input URI: %s' . PHP_EOL,
            $responseItem->getInputConfig()
                ->getGcsSource()
                ->getInputUri()
        );
    }
} finally {
    $translationServiceClient->close();
}

Python

Antes de testar esta amostra, siga as instruções de configuração para Python noGuia de início rápido do Translation: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Translation para Python.

Ver no GitHub Feedback

from google.cloud import translate

def list_glossaries(project_id="YOUR_PROJECT_ID"):
    """List Glossaries."""

    client = translate.TranslationServiceClient()

    parent = client.location_path(project_id, "us-central1")

    # Iterate over all results
    for glossary in client.list_glossaries(parent):
        print("Name: {}".format(glossary.name))
        print("Entry count: {}".format(glossary.entry_count))
        print("Input uri: {}".format(glossary.input_config.gcs_source.input_uri))

        # Note: You can create a glossary using one of two modes:
        # language_code_set or language_pair. When listing the information for
        # a glossary, you can only get information for the mode you used
        # when creating the glossary.
        for language_code in glossary.language_codes_set.language_codes:
            print("Language code: {}".format(language_code))

Ruby

Antes de testar esta amostra, siga as instruções de configuração para Ruby no Guia de início rápido do Translation: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Translation para Ruby.

Ver no GitHub Feedback

require "google/cloud/translate"

client = Google::Cloud::Translate.new

project_id = "[Google Cloud Project ID]"
location_id = "[LOCATION ID]"

parent = client.class.location_path project_id, location_id

responses = client.list_glossaries parent

responses.each do |response|
  puts "Glossary name: #{response.name}"
  puts "Entry count: #{response.entry_count}"
  puts "Input URI: #{response.input_config.gcs_source.input_uri}"
end

Excluir um glossário

No exemplo a seguir, excluímos um glossário.

REST e linha de comando

Antes de usar os dados da solicitação abaixo, faça as substituições a seguir:

• project-number-or-id: pelo número ou código do seu projeto do Google Cloud
• glossary-id: seu código de glossário

Método HTTP e URL:

DELETE https://translation.googleapis.com/v3/projects/project-number-or-id/locations/us-central1/glossaries/glossary-id

Para enviar a solicitação, escolha uma destas opções:

curl

Observação: verifique se você definiu a variável de ambiente GOOGLE_APPLICATION_CREDENTIALS como o caminho do arquivo da chave privada da conta de serviço.

Execute o comando a seguir:

curl -X DELETE \
-H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
https://translation.googleapis.com/v3/projects/project-number-or-id/locations/us-central1/glossaries/glossary-id

PowerShell

Observação: verifique se você definiu a variável de ambiente GOOGLE_APPLICATION_CREDENTIALS como o caminho do arquivo da chave privada da conta de serviço.

Execute o seguinte comando:

$cred = gcloud auth application-default print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
  -Method DELETE `
  -Headers $headers `
  -Uri "https://translation.googleapis.com/v3/projects/project-number-or-id/locations/us-central1/glossaries/glossary-id
" | Select-Object -Expand Content

Você receberá um código de status bem-sucedido (2xx) e uma resposta vazia.

C#

Antes de testar esta amostra, siga as instruções de configuração para C# no Guia de início rápido do Translation: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Translation para C#.

Ver no GitHub Feedback

using Google.Cloud.Translate.V3;
using System;

namespace GoogleCloudSamples
{
    public static class DeleteGlossary
    {
        /// <summary>
        /// Deletes a Glossary.
        /// </summary>
        /// <param name="projectId">Your Google Cloud Project ID.</param>
        /// <param name="glossaryId">Glossary ID.</param>
        public static void DeleteGlossarySample(string projectId = "[Google Cloud Project ID]",
            string glossaryId = "[YOUR_GLOSSARY_ID]")
        {
            TranslationServiceClient translationServiceClient = TranslationServiceClient.Create();
            DeleteGlossaryRequest request = new DeleteGlossaryRequest
            {
                GlossaryName = new GlossaryName(projectId, "us-central1", glossaryId),
            };
            // Poll until the returned long-running operation is complete
            DeleteGlossaryResponse response = translationServiceClient.DeleteGlossary(request).PollUntilCompleted().Result;
            Console.WriteLine("Deleted Glossary.");
        }
    }

Go

Antes de testar esta amostra, siga as instruções de configuração para Go no Guia de início rápido do Translation: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Translation para Go.

Ver no GitHub Feedback

import (
	"context"
	"fmt"
	"io"

	translate "cloud.google.com/go/translate/apiv3"
	translatepb "google.golang.org/genproto/googleapis/cloud/translate/v3"
)

// deleteGlossary deletes a glossary.
func deleteGlossary(w io.Writer, projectID string, location string, glossaryID string) error {
	// projectID := "my-project-id"
	// location := "us-central1"
	// glossaryID := "glossary-id"

	ctx := context.Background()
	client, err := translate.NewTranslationClient(ctx)
	if err != nil {
		return fmt.Errorf("NewTranslationClient: %v", err)
	}
	defer client.Close()

	req := &translatepb.DeleteGlossaryRequest{
		Name: fmt.Sprintf("projects/%s/locations/%s/glossaries/%s", projectID, location, glossaryID),
	}

	// The DeleteGlossary operation is async.
	op, err := client.DeleteGlossary(ctx, req)
	if err != nil {
		return fmt.Errorf("DeleteGlossary: %v", err)
	}
	fmt.Fprintf(w, "Processing operation name: %q\n", op.Name())

	resp, err := op.Wait(ctx)
	if err != nil {
		return fmt.Errorf("Wait: %v", err)
	}

	fmt.Fprintf(w, "Deleted: %v\n", resp.GetName())

	return nil
}

Java

Antes de testar esta amostra, siga as instruções de configuração para Java no Guia de início rápido do Translation: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Translation para Java.

Ver no GitHub Feedback

import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.translate.v3.DeleteGlossaryMetadata;
import com.google.cloud.translate.v3.DeleteGlossaryRequest;
import com.google.cloud.translate.v3.DeleteGlossaryResponse;
import com.google.cloud.translate.v3.GlossaryName;
import com.google.cloud.translate.v3.TranslationServiceClient;
import java.io.IOException;
import java.util.concurrent.ExecutionException;

public class DeleteGlossary {

  public static void deleteGlossary() throws InterruptedException, ExecutionException, IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR-PROJECT-ID";
    String glossaryId = "your-glossary-display-name";
    deleteGlossary(projectId, glossaryId);
  }

  // Delete a specific glossary based on the glossary ID
  public static void deleteGlossary(String projectId, String glossaryId)
      throws InterruptedException, ExecutionException, IOException {

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (TranslationServiceClient client = TranslationServiceClient.create()) {
      // Supported Locations: `global`, [glossary location], or [model location]
      // Glossaries must be hosted in `us-central1`
      // Custom Models must use the same location as your model. (us-central1)
      GlossaryName glossaryName = GlossaryName.of(projectId, "us-central1", glossaryId);
      DeleteGlossaryRequest request =
          DeleteGlossaryRequest.newBuilder().setName(glossaryName.toString()).build();

      // Start an asynchronous request
      OperationFuture<DeleteGlossaryResponse, DeleteGlossaryMetadata> future =
          client.deleteGlossaryAsync(request);

      System.out.println("Waiting for operation to complete...");
      DeleteGlossaryResponse response = future.get();
      System.out.format("Deleted Glossary: %s\n", response.getName());
    }
  }
}

Node.js

Antes de testar esta amostra, siga as instruções de configuração para Node.js no Guia de início rápido do Translation: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Translation para Node.js.

Ver no GitHub Feedback

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const location = 'global';
// const glossaryId = 'YOUR_GLOSSARY_ID';

// Imports the Google Cloud Translation library
const {TranslationServiceClient} = require('@google-cloud/translate');

// Instantiates a client
const translationClient = new TranslationServiceClient();

async function deleteGlossary() {
  // Construct request
  const request = {
    parent: `projects/${projectId}/locations/${location}`,
    name: `projects/${projectId}/locations/${location}/glossaries/${glossaryId}`,
  };

  try {
    // Delete glossary using a long-running operation
    const [operation] = await translationClient.deleteGlossary(request);

    // Wait for operation to complete.
    const [response] = await operation.promise();

    console.log(`Deleted glossary: ${response.name}`);
  } catch (error) {
    console.error(error.details);
  }
}

deleteGlossary();

PHP

Antes de testar esta amostra, siga as instruções de configuração para PHP no Guia de início rápido do Translation: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Translation para PHP.

Ver no GitHub Feedback

use Google\Cloud\Translate\V3\TranslationServiceClient;

$translationServiceClient = new TranslationServiceClient();

/** Uncomment and populate these variables in your code */
// $projectId = '[Google Cloud Project ID]';
// $glossaryId = '[Glossary ID]';
$formattedName = $translationServiceClient->glossaryName(
    $projectId,
    'us-central1',
    $glossaryId
);

try {
    $operationResponse = $translationServiceClient->deleteGlossary($formattedName);
    $operationResponse->pollUntilComplete();
    if ($operationResponse->operationSucceeded()) {
        $response = $operationResponse->getResult();
        printf('Deleted Glossary.' . PHP_EOL);
    } else {
        $error = $operationResponse->getError();
        // handleError($error)
    }
} finally {
    $translationServiceClient->close();
}

Python

Antes de testar esta amostra, siga as instruções de configuração para Python noGuia de início rápido do Translation: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Translation para Python.

Ver no GitHub Feedback

from google.cloud import translate_v3 as translate

def delete_glossary(
    project_id="YOUR_PROJECT_ID", glossary_id="YOUR_GLOSSARY_ID"
):
    """Delete a specific glossary based on the glossary ID."""
    client = translate.TranslationServiceClient()

    parent = client.glossary_path(project_id, "us-central1", glossary_id)

    operation = client.delete_glossary(parent)
    result = operation.result(timeout=180)
    print("Deleted: {}".format(result.name))

Ruby

Antes de testar esta amostra, siga as instruções de configuração para Ruby no Guia de início rápido do Translation: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Translation para Ruby.

Ver no GitHub Feedback

require "google/cloud/translate"

client = Google::Cloud::Translate.new

project_id = "[Google Cloud Project ID]"
location_id = "[LOCATION ID]"
glossary_id = "[YOUR_GLOSSARY_ID]"

name = client.class.glossary_path project_id, location_id, glossary_id

operation = client.delete_glossary name

# Wait until the long running operation is done
operation.wait_until_done!
response = operation.response

puts "Deleted Glossary."