Como migrar para o Translation - Advanced

Veja nesta página as principais diferenças entre o Cloud Translation - Basic e o Advanced. Encontre também alguns exemplos de código que ajudarão você a migrar seu aplicativo. Se quiser ver somente os recursos da versão Advanced, como os glossários, consulte o artigo Introdução ao Cloud Translation - Advanced.

O Cloud Translation - Advanced é compatível com todos os recursos e modelos disponíveis no Basic. No entanto, as bibliotecas de cliente não são compatíveis com versões anteriores à integração do cliente. Em outras palavras, você precisa planejar a migração dos seus aplicativos para aproveitar os recursos da versão Advanced.

Se você estiver planejando um novo projeto, crie seu aplicativo com o Cloud Translation - Advanced para aproveitar os novos recursos e as melhorias nos serviços. O Cloud Translation - Basic continua disponível, mas não é compatível com novos recursos, como glossários, tradução em lote ou seleção de modelos.

Principais diferenças entre o Basic e o Advanced

Há diversas diferenças entre o Cloud Translation - Advanced e o Basic.

Contas de serviço

O Cloud Translation - Basic permite o uso de chaves de API para fazer a autenticação para o Translation.

O Cloud Translation - Advanced tem funcionalidades que exigem recursos gerenciados pelo cliente, como o gerenciamento de permissões e papéis do IAM. Por essa razão, não é possível usar chaves de API para autenticar para o serviço. Em vez disso, é preciso usar contas de serviço ao autenticar para o Translation.

Papéis do IAM

As contas de serviço para autenticação para o Translation anteriormente não precisavam ter papéis do IAM especializados aplicados a elas.

Com o Cloud Translation - Advanced, você tem acesso a vários papéis do IAM que podem ser atribuídos à sua conta de serviço para acessar recursos específicos no seu projeto. Por exemplo, se você quiser usar sua conta de serviço para traduzir texto, atribua o papel roles/cloudtranslate.user a ela. Consulte Introdução ao Cloud Translation - Advanced para mais informações sobre os papéis do IAM disponíveis.

Recursos, projetos e locais

Ao fazer solicitações ao Cloud Translation - Advanced, você precisa fornecer o nome dos recursos que quer usar. Um recurso geralmente é um nome qualificado que inclui o nome do projeto e o local dele, como o nome de um modelo do AutoML.

Observação: todos os seus recursos de uma solicitação para o Cloud Translation - Advanced precisam ter o mesmo local. Atualmente, apenas os locais global e us-central1 são compatíveis. Para todos os recursos personalizados, como modelos AutoML, glossários e operações de longa duração, é preciso usar us-central1. Também é possível utilizar us-central1 para tradução geral e detecção de idioma. O local global só pode ser selecionado para modelos de tradução geral e detecção de idioma.

Por exemplo, se o projeto do Google Cloud tiver o nome my-project e o local do recurso for us-central1, o nome completo dos seus recursos poderá ser semelhante a este:

projects/MY_PROJECT/locations/us-central1/...

Use também o nome do local nos URLs para os quais envia solicitações REST. O local especifica onde a solicitação é executada. Por exemplo, o URL para o qual você envia uma solicitação getSupportedLanguages pode ser semelhante ao seguinte:

https://translation.googleapis.com/v3/projects/my-project/locations/us-central1/supportedLanguages

Modelos de tradução

Ao solicitar uma tradução do Cloud Translation - Advanced, você pode usar um modelo personalizado do AutoML Translation ou os modelos gerais, a tradução automática neural (NMT, na sigla em inglês) e a tradução automática baseada em frases (SPMT, na sigla em inglês).

Para fazer a integração com modelos do AutoML, as contas de serviço usadas para solicitações de tradução precisam ter as permissões apropriadas do IAM para acessar os modelos gerais e de AutoML, definidos no seu projeto ou em outro.

Para mais informações sobre a seleção de um modelo de tradução, consulte Como traduzir textos com o Cloud Translation - Advanced.

Limite de conteúdo por solicitação

A API Cloud Translation é otimizada para tradução de solicitações menores. O tamanho máximo recomendado para cada solicitação é de 5.000 caracteres (pontos de código). No entanto, quanto mais você incluir, maior será a latência de resposta. Para a Cloud Translation - Advanced, o número máximo de pontos de código para uma única solicitação é de 30.000. O tamanho máximo para solicitações da Cloud Translation - Basic é de 100.000 bytes.

A API Cloud Translation rejeitará solicitações maiores que o limite e enviará um erro 400 INVALID_ARGUMENT, independentemente da cota disponível.

Para mais informações sobre cotas e limites, consulte esta página.

Etapas recomendadas na migração para o Advanced

Consulte as etapas a seguir para atualizar seu aplicativo do Cloud Translation - Basic para o Advanced.

1. Faça um inventário dos seus projetos, aplicativos e usuários do Google Cloud que acessam a API Basic.
2. Configure contas de serviço e autenticação para seu aplicativo. Consulte o material sobre os papéis do IAM, com atenção especial aos papéis do AutoML, Cloud Storage e Cloud Translation.
3. Ative o Cloud Translation - Advanced para seu projeto. Se você usa modelos AutoML com a versão Advanced, também precisa ativar o AutoML.
4. Use os métodos e as bibliotecas de cliente do Cloud Translation - Advanced. Para solicitações do Cloud Translation - Advanced, inclua o número (ou ID) do projeto e o local do projeto, que costuma ser global ou us-central1. Saiba mais em Diferenças entre API e bibliotecas de cliente.
5. Atualize seu fluxo de trabalho de aplicativo ou de tradução para aproveitar os novos recursos. Para integrar seu aplicativo com o AutoML e o Cloud Storage, é preciso aplicar os papéis e permissões de IAM apropriados às suas contas de serviço para que eles possam acessar seus recursos.
6. Verifique se o tamanho das suas solicitações de tradução para o Cloud Translation - Advanced não excede o limite.
7. Planeje seu monitoramento de cota de solicitação de tradução. As duas versões da API compartilham as mesmas cotas diárias e mensais.
8. Analise as possíveis alterações no faturamento.

Diferenças de API e bibliotecas de cliente

As seções a seguir descrevem as diferenças específicas entre fazer chamadas com o Cloud Translation - Basic e com o Advanced.

Como importar as bibliotecas de cliente do Cloud Translation - Advanced

Para importar as bibliotecas de cliente do Cloud Translation - Advanced, use o código a seguir.

C#

nuget install Google.Cloud.Translate.V3 -Pre

Go

go get -u cloud.google.com/go/translate/apiv3

Java

Cuidado: a biblioteca de cliente do Java não é compatível com o Android.

Se você estiver usando o Maven, adicione o código abaixo ao arquivo pom.xml. Para mais informações sobre BOMs, consulte BOM das bibliotecas do Google Cloud Platform.

<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>com.google.cloud</groupId>
      <artifactId>libraries-bom</artifactId>
      <version>20.1.0</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
  </dependencies>
</dependencyManagement>

<dependencies>
  <dependency>
    <groupId>com.google.cloud</groupId>
    <artifactId>google-cloud-translate</artifactId>
  </dependency>
</dependencies>

Se você estiver usando o Gradle, adicione isto às dependências:

implementation platform('com.google.cloud:libraries-bom:20.1.0')

compile 'com.google.cloud:google-cloud-translate'

Se você estiver usando o sbt, adicione o seguinte às suas dependências:

libraryDependencies += "com.google.cloud" % "google-cloud-translate" % "1.97.0"

Caso você esteja usando o IntelliJ ou o Eclipse, poderá adicionar bibliotecas de cliente ao seu projeto usando estes plug-ins de ambiente de desenvolvimento integrado:

• Cloud Code para IntelliJ
• Cloud Tools for Eclipse

Os plug-ins também oferecem outras funcionalidades, como gerenciamento de chaves de contas de serviço. Consulte a documentação de cada plug-in para mais detalhes.

Observação: as bibliotecas de cliente Java para Google Cloud atualmente não são compatíveis com Android.

Node.js

Para mais informações sobre a configuração do ambiente de desenvolvimento do Node.js, consulte o Guia de configuração do ambiente de desenvolvimento do Node.js.

npm install --save @google-cloud/translate

PHP

composer require google/cloud-translate

Python

Para mais informações sobre a configuração do ambiente de desenvolvimento do Python, consulte o Guia de configuração do ambiente de desenvolvimento do Python.

pip install --upgrade google-cloud-translate

Ruby

Consulte o Guia de configuração do ambiente para desenvolvedores do Ruby para mais informações sobre esse assunto.

gem install google-cloud-translate

Como traduzir textos

No Cloud Translation - Basic, use o seguinte código para enviar uma solicitação de tradução para a API:

REST e linha de comando

Método HTTP e URL:

POST https://translation.googleapis.com/language/translate/v2

Corpo JSON da solicitação:

{
  "q": ["Hello world", "My name is Jeff"],
  "target": "de"
}

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/language/translate/v2

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/language/translate/v2
" | Select-Object -Expand Content

Você receberá uma resposta JSON semelhante a esta:

{
  "data": {
    "translations": [
      {
        "translatedText": "Hallo Welt",
        "detectedSourceLanguage": "en"
      },
      {
        "translatedText": "Mein Name ist Jeff",
        "detectedSourceLanguage": "en"
      }
    ]
  }
}

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. Saiba mais na documentação de referência da API Translation para Go.

Veja no GitHub Feedback

import (
	"context"
	"fmt"

	"cloud.google.com/go/translate"
	"golang.org/x/text/language"
)

func translateText(targetLanguage, text string) (string, error) {
	// text := "The Go Gopher is cute"
	ctx := context.Background()

	lang, err := language.Parse(targetLanguage)
	if err != nil {
		return "", fmt.Errorf("language.Parse: %v", err)
	}

	client, err := translate.NewClient(ctx)
	if err != nil {
		return "", err
	}
	defer client.Close()

	resp, err := client.Translate(ctx, []string{text}, lang, nil)
	if err != nil {
		return "", fmt.Errorf("Translate: %v", err)
	}
	if len(resp) == 0 {
		return "", fmt.Errorf("Translate returned empty response to text: %s", text)
	}
	return resp[0].Text, 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. Saiba mais na documentação de referência da API Translation para Java.

Veja no GitHub Feedback

// TODO(developer): Uncomment these lines.
// import com.google.cloud.translate.*;
// Translate translate = TranslateOptions.getDefaultInstance().getService();

Translation translation = translate.translate("¡Hola Mundo!");
System.out.printf("Translated Text:\n\t%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. Saiba mais na documentação de referência da API Translation para Node.js.

Ver no GitHub Feedback

// Imports the Google Cloud client library
const {Translate} = require('@google-cloud/translate').v2;

// Creates a client
const translate = new Translate();

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const text = 'The text to translate, e.g. Hello, world!';
// const target = 'The target language, e.g. ru';

async function translateText() {
  // Translates the text into the target language. "text" can be a string for
  // translating a single piece of text, or an array of strings for translating
  // multiple texts.
  let [translations] = await translate.translate(text, target);
  translations = Array.isArray(translations) ? translations : [translations];
  console.log('Translations:');
  translations.forEach((translation, i) => {
    console.log(`${text[i]} => (${target}) ${translation}`);
  });
}

translateText();

Python

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

Ver no GitHub Feedback

def translate_text(target, text):
    """Translates text into the target language.

    Target must be an ISO 639-1 language code.
    See https://g.co/cloud/translate/v2/translate-reference#supported_languages
    """
    import six
    from google.cloud import translate_v2 as translate

    translate_client = translate.Client()

    if isinstance(text, six.binary_type):
        text = text.decode("utf-8")

    # Text can also be a sequence of strings, in which case this method
    # will return a sequence of results for each text.
    result = translate_client.translate(text, target_language=target)

    print(u"Text: {}".format(result["input"]))
    print(u"Translation: {}".format(result["translatedText"]))
    print(u"Detected source language: {}".format(result["detectedSourceLanguage"]))

Outros idiomas

C# : Siga as instruções: Instruções de configuração do C# na página de bibliotecas de cliente e acesse aDocumentação de referência do Translation para .NET.

PHP : Siga as instruções: Instruções de configuração do PHP na página de bibliotecas de cliente e acesse aDocumentação de referência do Translation para PHP.

Raquel : Siga as instruções: Instruções de configuração do Ruby na página de bibliotecas de cliente e acesse aDocumentação de referência do Translation para Ruby.

Com o Cloud Translation - Advanced, você precisa fornecer o número ou ID do projeto e o local dele (normalmente global ou us-central1) ao fazer uma solicitação translateText.

Observação: o ID do projeto também é aceito, mas é recomendado usar o número do projeto deste momento em diante.

Também é possível especificar explicitamente um modelo de tradução ou um glossário para utilizar ao traduzir o texto e até mesmo pedir para receber a tradução da resposta como text/plain ou text/html. O valor padrão é text/html.

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 o código do seu projeto do Google Cloud

Método HTTP e URL:

POST https://translation.googleapis.com/v3/projects/PROJECT_NUMBER_OR_ID:translateText

Corpo JSON da solicitação:

{
  "sourceLanguageCode": "en",
  "targetLanguageCode": "ru",
  "contents": ["Dr. Watson, come here!", "Bring me some coffee!"]
}

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: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:translateText
" | Select-Object -Expand Content

Você receberá uma resposta JSON semelhante a esta:

{
  "translations": [
    {
      "translatedText": "Доктор Ватсон, иди сюда!",
    },
    {
      "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. Saiba mais na documentação de referência da API Translation para Go.

Veja no GitHub Feedback

import (
	"context"
	"fmt"
	"io"

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

// translateText translates input text and returns translated text.
func translateText(w io.Writer, projectID string, sourceLang string, targetLang string, text string) error {
	// projectID := "my-project-id"
	// sourceLang := "en-US"
	// targetLang := "fr"
	// text := "Text you wish to translate"

	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/global", projectID),
		SourceLanguageCode: sourceLang,
		TargetLanguageCode: targetLang,
		MimeType:           "text/plain", // Mime types: "text/plain", "text/html"
		Contents:           []string{text},
	}

	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.GetTranslations() {
		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. Saiba mais na documentação de referência da API Translation para Java.

Veja no GitHub Feedback

import com.google.cloud.translate.v3.LocationName;
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 TranslateText {

  public static void translateText() 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 targetLanguage = "your-target-language";
    String text = "your-text";
    translateText(projectId, targetLanguage, text);
  }

  // Translating Text
  public static void translateText(String projectId, String targetLanguage, String text)
      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, "global");

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

      TranslateTextResponse response = client.translateText(request);

      // Display the translation for each input text provided
      for (Translation translation : response.getTranslationsList()) {
        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. Saiba mais na 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 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 translateText() {
  // Construct request
  const request = {
    parent: `projects/${projectId}/locations/${location}`,
    contents: [text],
    mimeType: 'text/plain', // mime types: text/plain, text/html
    sourceLanguageCode: 'en',
    targetLanguageCode: 'sr-Latn',
  };

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

  for (const translation of response.translations) {
    console.log(`Translation: ${translation.translatedText}`);
  }
}

translateText();

Python

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

Ver no GitHub Feedback

from google.cloud import translate

def translate_text(text="YOUR_TEXT_TO_TRANSLATE", project_id="YOUR_PROJECT_ID"):
    """Translating Text."""

    client = translate.TranslationServiceClient()

    location = "global"

    parent = f"projects/{project_id}/locations/{location}"

    # Detail on supported types can be found here:
    # https://cloud.google.com/translate/docs/supported-formats
    response = client.translate_text(
        request={
            "parent": parent,
            "contents": [text],
            "mime_type": "text/plain",  # mime types: text/plain, text/html
            "source_language_code": "en-US",
            "target_language_code": "fr",
        }
    )

    # Display the translation for each input text provided
    for translation in response.translations:
        print("Translated text: {}".format(translation.translated_text))

Outros idiomas

C# : Siga as instruções: Instruções de configuração do C# na página de bibliotecas de cliente e acesse aDocumentação de referência do Translation para .NET.

PHP : Siga as instruções: Instruções de configuração do PHP na página de bibliotecas de cliente e acesse aDocumentação de referência do Translation para PHP.

Raquel : Siga as instruções: Instruções de configuração do Ruby na página de bibliotecas de cliente e acesse aDocumentação de referência do Translation para Ruby.

Como descobrir idiomas compatíveis

Para ver a lista de idiomas compatíveis com a API no Cloud Translation - Basic, use o seguinte código:

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 o 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/global/supportedLanguages

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

curl

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

Execute o seguinte comando:

curl -X GET \
-H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
https://translation.googleapis.com/v3/projects/PROJECT_NUMBER_OR_ID/locations/global/supportedLanguages

PowerShell

Observação: veja se você definiu a variável de ambiente GOOGLE_APPLICATION_CREDENTIALS no caminho do arquivo de 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/global/supportedLanguages
" | Select-Object -Expand Content

Você receberá uma resposta JSON semelhante a esta:

{
  "languages": [
     "languageCode": "af",
      "supportSource": true,
      "supportTarget": true
    },
    {
      "languageCode": "am",
      "supportSource": true,
      "supportTarget": true
    },
    {
      "languageCode": "ar",
      "supportSource": true,
      "supportTarget": true
    },
    ....
    {
      "languageCode": "zu",
      "supportSource": true,
      "supportTarget": true
    }
   ]
}

A lista é classificada em ordem alfabética por código de idioma. Esta consulta retorna códigos ISO 639-1 para idiomas compatíveis. Alguns códigos de idioma também incluem o código do país, como zh-CN ou zh-TW. Por exemplo:

   {
      "languageCode": "zh-TW",
      "supportSource": true,
      "supportTarget": true
    },

Java

Ver no GitHub Feedback

// TODO(developer): Uncomment these lines.
// import com.google.cloud.translate.*;
// Translate translate = TranslateOptions.getDefaultInstance().getService();

List<Language> languages = translate.listSupportedLanguages();

for (Language language : languages) {
  System.out.printf("Name: %s, Code: %s\n", language.getName(), language.getCode());
}

Node.js

Ver no GitHub Feedback

// Imports the Google Cloud client library
const {Translate} = require('@google-cloud/translate').v2;

// Creates a client
const translate = new Translate();

async function listLanguages() {
  // Lists available translation language with their names in English (the default).
  const [languages] = await translate.getLanguages();

  console.log('Languages:');
  languages.forEach(language => console.log(language));
}

listLanguages();

Python

Ver no GitHub Feedback

def list_languages():
    """Lists all available languages."""
    from google.cloud import translate_v2 as translate

    translate_client = translate.Client()

    results = translate_client.get_languages()

    for language in results:
        print(u"{name} ({language})".format(**language))

Outros idiomas

C# : Siga as instruções: Instruções de configuração do C# na página de bibliotecas de cliente e acesse aDocumentação de referência do Translation para .NET.

PHP : Siga as instruções: Instruções de configuração do PHP na página de bibliotecas de cliente e acesse aDocumentação de referência do Translation para PHP.

Raquel : Siga as instruções: Instruções de configuração do Ruby na página de bibliotecas de cliente e acesse aDocumentação de referência do Translation para Ruby.

Com o Cloud Translation - Advanced, você precisa fornecer o número ou ID do projeto e o local dele (normalmente global ou us-central1) ao fazer uma solicitação getSupportedLanguages.

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 o 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/global/supportedLanguages

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

curl

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

Execute o seguinte comando:

curl -X GET \
-H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
https://translation.googleapis.com/v3/projects/PROJECT_NUMBER_OR_ID/locations/global/supportedLanguages

PowerShell

Observação: veja se você definiu a variável de ambiente GOOGLE_APPLICATION_CREDENTIALS no caminho do arquivo de 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/global/supportedLanguages
" | Select-Object -Expand Content

Você receberá uma resposta JSON semelhante a esta:

{
  "languages": [
     "languageCode": "af",
      "supportSource": true,
      "supportTarget": true
    },
    {
      "languageCode": "am",
      "supportSource": true,
      "supportTarget": true
    },
    {
      "languageCode": "ar",
      "supportSource": true,
      "supportTarget": true
    },
    ....
    {
      "languageCode": "zu",
      "supportSource": true,
      "supportTarget": true
    }
   ]
}

A lista é classificada em ordem alfabética por código de idioma. Esta consulta retorna códigos ISO 639-1 para idiomas compatíveis. Alguns códigos de idioma também incluem o código do país, como zh-CN ou zh-TW. Exemplo:

   {
      "languageCode": "zh-TW",
      "supportSource": true,
      "supportTarget": true
    },

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. Saiba mais na documentação de referência da API Translation para Go.

Veja no GitHub Feedback

import (
	"context"
	"fmt"
	"io"

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

// getSupportedLanguages gets a list of supported language codes.
func getSupportedLanguages(w io.Writer, projectID string) error {
	// projectID := "my-project-id"

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

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

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

	// List language codes of supported languages
	fmt.Fprintf(w, "Supported languages:\n")
	for _, language := range resp.GetLanguages() {
		fmt.Fprintf(w, "Language code: %v\n", language.GetLanguageCode())
	}

	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. Saiba mais na documentação de referência da API Translation para Java.

Veja no GitHub Feedback

import com.google.cloud.translate.v3.GetSupportedLanguagesRequest;
import com.google.cloud.translate.v3.LocationName;
import com.google.cloud.translate.v3.SupportedLanguage;
import com.google.cloud.translate.v3.SupportedLanguages;
import com.google.cloud.translate.v3.TranslationServiceClient;
import java.io.IOException;

public class GetSupportedLanguages {

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

  // Getting a list of supported language codes
  public static void getSupportedLanguages(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, "global");
      GetSupportedLanguagesRequest request =
          GetSupportedLanguagesRequest.newBuilder().setParent(parent.toString()).build();

      SupportedLanguages response = client.getSupportedLanguages(request);

      // List language codes of supported languages
      for (SupportedLanguage language : response.getLanguagesList()) {
        System.out.printf("Language Code: %s\n", language.getLanguageCode());
      }
    }
  }
}

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. Saiba mais na 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 getSupportedLanguages() {
  // Construct request
  const request = {
    parent: `projects/${projectId}/locations/${location}`,
  };

  // Get supported languages
  const [response] = await translationClient.getSupportedLanguages(request);

  for (const language of response.languages) {
    // Supported language code, generally consisting of its ISO 639-1 identifier, for
    // example, 'en', 'ja'. In certain cases, BCP-47 codes including language and
    // region identifiers are returned (for example, 'zh-TW' and 'zh-CN')
    console.log(`Language - Language Code: ${language.languageCode}`);
    // Human readable name of the language localized in the display language specified
    // in the request.
    console.log(`Language - Display Name: ${language.displayName}`);
    // Can be used as source language.
    console.log(`Language - Support Source: ${language.supportSource}`);
    // Can be used as target language.
    console.log(`Language - Support Target: ${language.supportTarget}`);
  }
}

getSupportedLanguages();

Python

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

Ver no GitHub Feedback

from google.cloud import translate

def get_supported_languages(project_id="YOUR_PROJECT_ID"):
    """Getting a list of supported language codes."""

    client = translate.TranslationServiceClient()

    parent = f"projects/{project_id}"

    # Supported language codes: https://cloud.google.com/translate/docs/languages
    response = client.get_supported_languages(parent=parent)

    # List language codes of supported languages.
    print("Supported Languages:")
    for language in response.languages:
        print("Language Code: {}".format(language.language_code))

Como detectar um idioma

Para detectar o idioma de origem de um texto com o Cloud Translation - Basic, use o seguinte código:

curl

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     --data "{
  'q': 'Omnia Gallia est divisa in tres partes',
}" "https://translation.googleapis.com/language/translate/v2/detect"

Quando a solicitação é bem-sucedida, o servidor retorna um código de status HTTP 200 OK e a resposta no formato JSON:

{
  "data": {
    "detections": [
      [
        {
          "confidence": 0.93554825,
          "isReliable": false,
          "language": "la"
        }
      ]
    ]
  }

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. Saiba mais na documentação de referência da API Translation para Java.

Veja no GitHub Feedback

// TODO(developer): Uncomment these lines.
// import com.google.cloud.translate.*;
// Translate translate = TranslateOptions.getDefaultInstance().getService();

List<String> texts = new LinkedList<>();
texts.add("Hello, World!");
texts.add("¡Hola Mundo!");
List<Detection> detections = translate.detect(texts);

System.out.println("Language(s) detected:");
for (Detection detection : detections) {
  System.out.printf("\t%s\n", detection);
}

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. Saiba mais na documentação de referência da API Translation para Node.js.

Ver no GitHub Feedback

// Imports the Google Cloud client library
const {Translate} = require('@google-cloud/translate').v2;

// Creates a client
const translate = new Translate();

/**
 * TODO(developer): Uncomment the following line before running the sample.
 */
// const text = 'The text for which to detect language, e.g. Hello, world!';

// Detects the language. "text" can be a string for detecting the language of
// a single piece of text, or an array of strings for detecting the languages
// of multiple texts.
async function detectLanguage() {
  let [detections] = await translate.detect(text);
  detections = Array.isArray(detections) ? detections : [detections];
  console.log('Detections:');
  detections.forEach(detection => {
    console.log(`${detection.input} => ${detection.language}`);
  });
}

detectLanguage();

Python

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

Ver no GitHub Feedback

def detect_language(text):
    """Detects the text's language."""
    from google.cloud import translate_v2 as translate

    translate_client = translate.Client()

    # Text can also be a sequence of strings, in which case this method
    # will return a sequence of results for each text.
    result = translate_client.detect_language(text)

    print("Text: {}".format(text))
    print("Confidence: {}".format(result["confidence"]))
    print("Language: {}".format(result["language"]))

Outros idiomas

C# : Siga as instruções: Instruções de configuração do C# na página de bibliotecas de cliente e acesse aDocumentação de referência do Translation para .NET.

PHP : Siga as instruções: Instruções de configuração do PHP na página de bibliotecas de cliente e acesse aDocumentação de referência do Translation para PHP.

Raquel : Siga as instruções: Instruções de configuração do Ruby na página de bibliotecas de cliente e acesse aDocumentação de referência do Translation para Ruby.

Com o Cloud Translation - Advanced, você precisa fornecer o número ou ID do projeto e o local dele (normalmente global ou us-central1) ao fazer uma solicitação detectLanguage.

Além disso, é possível configurar a solicitação feita ao Cloud Translation - Advanced para enviar diferentes tipos de MIME. Por exemplo, solicite text/html ou text/plain. O valor padrão é text/html.

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 o código do seu projeto do Google Cloud

Método HTTP e URL:

POST https://translation.googleapis.com/v3/projects/PROJECT_NUMBER_OR_ID/locations/global:detectLanguage

Corpo JSON da solicitação:

{
   "content":"Доктор Ватсон, иди сюда!"
}

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/global:detectLanguage

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/global:detectLanguage
" | Select-Object -Expand Content

Você receberá uma resposta JSON semelhante a esta:

{
  "languages": [
    {
      "languageCode": "ru",
      "confidence": 1
    }
  ]
}

Na resposta, languageCode informa o código do idioma detectado. confidence é um intervalo de 0 a 1, sendo que 1 indica confiança total.

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. Saiba mais na 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"
)

// detectLanguage detects the language of a text string.
func detectLanguage(w io.Writer, projectID string, text string) error {
	// projectID := "my-project-id"
	// text := "Hello, world!"

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

	req := &translatepb.DetectLanguageRequest{
		Parent:   fmt.Sprintf("projects/%s/locations/global", projectID),
		MimeType: "text/plain", // Mime types: "text/plain", "text/html"
		Source: &translatepb.DetectLanguageRequest_Content{
			Content: text,
		},
	}

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

	// Display list of detected languages sorted by detection confidence.
	// The most probable language is first.
	for _, language := range resp.GetLanguages() {
		// The language detected.
		fmt.Fprintf(w, "Language code: %v\n", language.GetLanguageCode())
		// Confidence of detection result for this language.
		fmt.Fprintf(w, "Confidence: %v\n", language.GetConfidence())
	}

	return nil
}

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. Saiba mais na 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 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 detectLanguage() {
  // Construct request
  const request = {
    parent: `projects/${projectId}/locations/${location}`,
    content: text,
  };

  // Run request
  const [response] = await translationClient.detectLanguage(request);

  console.log('Detected Languages:');
  for (const language of response.languages) {
    console.log(`Language Code: ${language.languageCode}`);
    console.log(`Confidence: ${language.confidence}`);
  }
}

detectLanguage();

Python

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

Ver no GitHub Feedback

from google.cloud import translate

def detect_language(project_id="YOUR_PROJECT_ID"):
    """Detecting the language of a text string."""

    client = translate.TranslationServiceClient()

    location = "global"

    parent = f"projects/{project_id}/locations/{location}"

    # Detail on supported types can be found here:
    # https://cloud.google.com/translate/docs/supported-formats
    response = client.detect_language(
        content="Hello, world!",
        parent=parent,
        mime_type="text/plain",  # mime types: text/plain, text/html
    )

    # Display list of detected languages sorted by detection confidence.
    # The most probable language is first.
    for language in response.languages:
        # The language detected
        print("Language code: {}".format(language.language_code))
        # Confidence of detection result for this language
        print("Confidence: {}".format(language.confidence))

Outros idiomas

C# : Siga as instruções: Instruções de configuração do C# na página de bibliotecas de cliente e acesse aDocumentação de referência do Translation para .NET.

PHP : Siga as instruções: Instruções de configuração do PHP na página de bibliotecas de cliente e acesse aDocumentação de referência do Translation para PHP.

Raquel : Siga as instruções: Instruções de configuração do Ruby na página de bibliotecas de cliente e acesse aDocumentação de referência do Translation para Ruby.