Como traduzir o texto de uma foto

Nesta página, você aprende a detectar texto em uma imagem, personalizar traduções e gerar falas sintéticas a partir de um texto. Neste tutorial, o Cloud Vision é usado para detectar textos em um arquivo de imagem. Em seguida, você verá como usar o Cloud Translation para traduzir o texto detectado de maneira personalizada. Por fim, o Text-to-Speech será usado para fornecer o ditado automatizado do texto traduzido.

Objetivos

Transmitir o texto reconhecido pela API Cloud Vision para a API Cloud Translation.
Criar e usar glossários do Cloud Translation para personalizar as traduções da API Cloud Translation.
Criar uma representação de áudio do texto traduzido usando a API Text-to-Speech.

Custos

Cada API do Google Cloud tem uma estrutura de preços diferente.

Para detalhes sobre preços, consulte os respectivos guias do Cloud Vision, do Cloud Translation e do Text-to-Speech.

Antes de começar

Você precisa ter o seguinte:

Um projeto no Console do Google Cloud em que a API Vision, a API Cloud Translation e a API Text-to-Speech estejam ativadas.
Noções básicas de programação em Python ou NodeJS

Como configurar bibliotecas de cliente

Neste tutorial, as bibliotecas de cliente do Vision, Translation e Text-to-Speech são usadas.

Para instalar as bibliotecas de cliente necessárias, execute os comandos a seguir no terminal.

Python

  pip install --upgrade google-cloud-vision
  pip install --upgrade google-cloud-translate
  pip install --upgrade google-cloud-texttospeech

Node.js

  npm install --save @google-cloud/vision
  npm install --save @google-cloud/translate
  npm install --save @google-cloud/text-to-speech

Como definir permissões para criar o glossário

Para criar glossários do Translation, é preciso usar uma chave de conta de serviço que tenha as permissões de editor da API Cloud Translation.

Para configurar uma chave de conta de serviço com as permissões do editor da API Cloud Translation, faça o seguinte:

Crie uma conta de serviço:
1. No Console do Google Cloud, acesse a página Contas de serviço.
  
  Acesse Contas de serviço
2. Selecione o projeto.
3. Clique em Criar conta de serviço.
4. No campo Nome da conta de serviço, insira um nome. O console do Google Cloud preenche o campo ID da conta de serviço com base nesse nome.
5. Opcional: preencha o campo Descrição da conta de serviço.
6. Clique em Criar e continuar.
7. Clique no campo Selecionar papel e selecione Cloud Translation > Editor da API Cloud Translation.
8. Clique em Concluído para terminar a criação da conta de serviço.
  
  Não feche a janela do navegador. Você vai usá-la na próxima etapa.
Faça o download de uma chave JSON para a conta de serviço que você acabou de criar:
1. No console do Google Cloud, clique no endereço de e-mail da conta de serviço que você criou.
2. Clique em Chaves.
3. Clique em Adicionar chave e em Criar nova chave.
4. Clique em Criar. O download de um arquivo de chave JSON é feito no seu computador.
  
  Armazene o arquivo de chave com segurança, porque ele pode ser usado para autenticar como sua conta de serviço. Mova e renomeie esse arquivo como quiser.
5. Clique em Fechar.
No terminal, defina a variável GOOGLE_APPLICATION_CREDENTIALS usando o comando a seguir. Substitua path_to_key pelo caminho para o arquivo JSON transferido por download que contém a nova chave de conta de serviço.
Linux ou macOS
```
export GOOGLE_APPLICATION_CREDENTIALS=path_to_key
```
Windows
```
set GOOGLE_APPLICATION_CREDENTIALS=path_to_key
```

Como importar bibliotecas

Neste tutorial, as importações de sistema e de biblioteca de cliente a seguir são usadas.

Python

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

Para autenticar no Cloud Translation, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

import html
import os

# Imports the Google Cloud client libraries
from google.api_core.exceptions import AlreadyExists
from google.cloud import texttospeech
from google.cloud import translate_v3beta1 as translate
from google.cloud import vision

Node.js

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

Para autenticar no Cloud Translation, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

// Imports the Google Cloud client library
const textToSpeech = require('@google-cloud/text-to-speech');
const translate = require('@google-cloud/translate').v3beta1;
const vision = require('@google-cloud/vision');

// Import other required libraries
const fs = require('fs');
//const escape = require('escape-html');
const util = require('util');

Como definir o ID do projeto

É preciso associar um projeto do Google Cloud a cada solicitação feita a uma API do Google Cloud. Para escolher o projeto do Google Cloud, defina a variável de ambiente GCLOUD_PROJECT no terminal.

Substitua project-id pelo ID do projeto do Google Cloud com o comando a seguir. Execute o comando a seguir no terminal.

Linux ou macOS

export GCLOUD_PROJECT=project-id

Windows

set GCLOUD_PROJECT=project-id

Como usar o Vision para detectar o texto de uma imagem

Use a API Vision para detectar e extrair o texto de uma imagem. A API Vision usa o Reconhecimento ótico de caracteres (OCR, na sigla em inglês) para fornecer dois recursos de detecção de texto: detecção de textos densos ou DOCUMENT_TEXT_DETECTION e a detecção de textos esparsos ou TEXT_DETECTION.

Veja no código a seguir como usar o recurso DOCUMENT_TEXT_DETECTION da API Vision para detectar o texto em uma foto com texto denso.

Python

Para autenticar no Cloud Translation, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

def pic_to_text(infile: str) -> str:
    """Detects text in an image file

    Args:
    infile: path to image file

    Returns:
    String of text detected in image
    """

    # Instantiates a client
    client = vision.ImageAnnotatorClient()

    # Opens the input image file
    with open(infile, "rb") as image_file:
        content = image_file.read()

    image = vision.Image(content=content)

    # For dense text, use document_text_detection
    # For less dense text, use text_detection
    response = client.document_text_detection(image=image)
    text = response.full_text_annotation.text
    print(f"Detected text: {text}")

    return text

Node.js

Para autenticar no Cloud Translation, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

/**
 * Detects text in an image file
 *
 * ARGS
 * inputFile: path to image file
 * RETURNS
 * string of text detected in the input image
 **/
async function picToText(inputFile) {
  // Creates a client
  const client = new vision.ImageAnnotatorClient();

  // Performs text detection on the local file
  const [result] = await client.textDetection(inputFile);
  return result.fullTextAnnotation.text;
}

Como usar o Translation com glossários

Após extrair o texto de uma imagem, use glossários do Translation para personalizar a tradução dele. Os glossários fornecem traduções predefinidas que modificam as traduções de certos termos da API Cloud Translation.

Os casos de uso do glossário incluem o seguinte:

Nomes de produtos: por exemplo, Google Home precisa ser mantido como "Google Home".
Palavras ambíguas: por exemplo, a palavra "bat" pode significar um equipamento esportivo ou um animal. Se você souber que está traduzindo palavras sobre esporte, usará um glossário para alimentar a API Cloud Translation com a tradução esportiva de "bat", não com a de animal.
Palavras emprestadas: do francês para o inglês, "bouillabaisse" é traduzido como "bouillabaisse". A língua inglesa pegou emprestada a palavra "bouillabaisse" do francês. 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).

Como criar um arquivo de glossário

A API Cloud Translation aceita arquivos de glossário TSV, CSV ou TMX. Neste tutorial, um arquivo CSV enviado ao Cloud Storage é usado para definir conjuntos de termos equivalentes.

Para criar um arquivo CSV do glossário:

Defina o idioma de uma coluna usando os códigos ISO-639 ou BCP-47 na primeira linha do arquivo CSV.
```
fr,en,
```
Liste pares de termos equivalentes em cada linha do arquivo CSV. Separe os termos com vírgulas. No exemplo a seguir, a tradução em inglês de várias palavras francesas sobre culinária é definida.
```
fr,en,
chèvre,goat cheese,
crème brulée,crème brulée,
bouillabaisse,fish stew,
steak frites,steak with french fries,
```

Defina variantes de uma palavra. A API Cloud Translation diferencia maiúsculas e minúsculas, além de caracteres especiais, como palavras acentuadas. Defina explicitamente várias grafias de uma palavra para garantir que o glossário processe as variações dela.

fr,en,
chevre,goat cheese,
Chevre,Goat cheese,
chèvre,goat cheese,
Chèvre,Goat cheese,
crème brulée,crème brulée,
Crème brulée,Crème brulée,
Crème Brulée,Crème Brulée,
bouillabaisse,fish stew,
Bouillabaisse,Fish stew,
steak frites,steak with french fries,
Steak frites,Steak with french fries,
Steak Frites,Steak with French Fries,

Faça upload do glossário para um bucket do Cloud Storage. Neste tutorial, você não precisa fazer upload de um arquivo de glossário para um bucket do Cloud Storage nem criar esse bucket. Em vez disso, use o arquivo de glossário disponível publicamente. Ele foi criado para que não sejam gerados custos do Cloud Storage. Envie o URI de um arquivo de glossário no Cloud Storage para a API Cloud Translation para criar um recurso de glossário. O URI do arquivo de glossário disponível publicamente neste tutorial é gs://cloud-samples-data/translation/bistro_glossary.csv. Para fazer o download do glossário, clique no link do URI acima, mas não o abra em uma nova guia.

Como criar um recurso de glossário

Para usar um glossário, é preciso criar um recurso correspondente com a API Cloud Translation. Para criar um recurso de glossário, envie o URI de um arquivo de glossário no Cloud Storage para a API Cloud Translation.

Verifique se você está usando uma conta de serviço com as permissões de editor da API Cloud Translation e se definiu o ID do projeto no terminal.

Com a função a seguir, você cria um recurso de glossário. Com ele, será possível personalizar a solicitação de tradução na próxima etapa deste tutorial.

Python

Para autenticar no Cloud Translation, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

def create_glossary(
    languages: list,
    project_id: str,
    glossary_name: str,
    glossary_uri: str,
) -> str:
    """Creates a GCP glossary resource
    Assumes you've already manually uploaded a glossary to Cloud Storage

    Args:
    languages: list of languages in the glossary
    project_id: GCP project id
    glossary_name: name you want to give this glossary resource
    glossary_uri: the uri of the glossary you uploaded to Cloud Storage

    Returns:
    name of the created or existing glossary
    """

    # Instantiates a client
    client = translate.TranslationServiceClient()

    # Designates the data center location that you want to use
    location = "us-central1"

    # Set glossary resource name
    name = client.glossary_path(project_id, location, glossary_name)

    # Set language codes
    language_codes_set = translate.Glossary.LanguageCodesSet(language_codes=languages)

    gcs_source = translate.GcsSource(input_uri=glossary_uri)

    input_config = translate.GlossaryInputConfig(gcs_source=gcs_source)

    # Set glossary resource information
    glossary = translate.Glossary(
        name=name, language_codes_set=language_codes_set, input_config=input_config
    )

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

    # Create glossary resource
    # Handle exception for case in which a glossary
    #  with glossary_name already exists
    try:
        operation = client.create_glossary(parent=parent, glossary=glossary)
        operation.result(timeout=90)
        print("Created glossary " + glossary_name + ".")
    except AlreadyExists:
        print(
            "The glossary "
            + glossary_name
            + " already exists. No new glossary was created."
        )

    return glossary_name

Node.js

Para autenticar no Cloud Translation, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

/** Creates a GCP glossary resource
 * Assumes you've already manually uploaded a glossary to Cloud Storage
 *
 * ARGS
 * languages: list of languages in the glossary
 * projectId: GCP project id
 * glossaryName: name you want to give this glossary resource
 * glossaryUri: the uri of the glossary you uploaded to Cloud Storage
 * RETURNS
 * nothing
 **/
async function createGlossary(
  languages,
  projectId,
  glossaryName,
  glossaryUri
) {
  // Instantiates a client
  const translationClient = await new translate.TranslationServiceClient();

  // Construct glossary
  const glossary = {
    languageCodesSet: {
      languageCodes: languages,
    },
    inputConfig: {
      gcsSource: {
        inputUri: glossaryUri,
      },
    },
    name: translationClient.glossaryPath(
      projectId,
      'us-central1',
      glossaryName
    ),
  };

  // Construct request
  const request = {
    parent: translationClient.locationPath(projectId, 'us-central1'),
    glossary: glossary,
  };

  // Create glossary using a long-running operation.
  try {
    const [operation] = await translationClient.createGlossary(request);
    // Wait for operation to complete.
    await operation.promise();
    console.log('Created glossary ' + glossaryName + '.');
  } catch (AlreadyExists) {
    console.log(
      'The glossary ' +
        glossaryName +
        ' already exists. No new glossary was created.'
    );
  }
}

Como traduzir com glossários

Depois de criar um recurso de glossário, é possível usá-lo para personalizar traduções de textos enviados para a API Cloud Translation.

A função a seguir usa o recurso de glossário já criado para personalizar a tradução do texto.

Python

Para autenticar no Cloud Translation, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

def translate_text(
    text: str,
    source_language_code: str,
    target_language_code: str,
    project_id: str,
    glossary_name: str,
) -> str:
    """Translates text to a given language using a glossary

    Args:
    text: String of text to translate
    source_language_code: language of input text
    target_language_code: language of output text
    project_id: GCP project id
    glossary_name: name you gave your project's glossary
        resource when you created it

    Return:
    String of translated text
    """

    # Instantiates a client
    client = translate.TranslationServiceClient()

    # Designates the data center location that you want to use
    location = "us-central1"

    glossary = client.glossary_path(project_id, location, glossary_name)

    glossary_config = translate.TranslateTextGlossaryConfig(glossary=glossary)

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

    result = client.translate_text(
        request={
            "parent": parent,
            "contents": [text],
            "mime_type": "text/plain",  # mime types: text/plain, text/html
            "source_language_code": source_language_code,
            "target_language_code": target_language_code,
            "glossary_config": glossary_config,
        }
    )

    # Extract translated text from API response
    return result.glossary_translations[0].translated_text

Node.js

Para autenticar no Cloud Translation, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

/**
 * Translates text to a given language using a glossary
 *
 * ARGS
 * text: String of text to translate
 * sourceLanguageCode: language of input text
 * targetLanguageCode: language of output text
 * projectId: GCP project id
 * glossaryName: name you gave your project's glossary
 *     resource when you created it
 * RETURNS
 * String of translated text
 **/
async function translateText(
  text,
  sourceLanguageCode,
  targetLanguageCode,
  projectId,
  glossaryName
) {
  // Instantiates a client
  const translationClient = new translate.TranslationServiceClient();
  const glossary = translationClient.glossaryPath(
    projectId,
    'us-central1',
    glossaryName
  );
  const glossaryConfig = {
    glossary: glossary,
  };
  // Construct request
  const request = {
    parent: translationClient.locationPath(projectId, 'us-central1'),
    contents: [text],
    mimeType: 'text/plain', // mime types: text/plain, text/html
    sourceLanguageCode: sourceLanguageCode,
    targetLanguageCode: targetLanguageCode,
    glossaryConfig: glossaryConfig,
  };

  // Run request
  const [response] = await translationClient.translateText(request);
  // Extract the string of translated text
  return response.glossaryTranslations[0].translatedText;
}

Como usar o Text-to-Speech com a linguagem de marcação de síntese de fala

Agora que você personalizou uma tradução de texto detectado por imagem, use a API Text-to-Speech. Com ela, é possível criar áudios sintéticos do texto traduzido.

A API Text-to-Speech gera um áudio sintético a partir de uma string de texto simples ou marcada com a linguagem de marcação de síntese de fala (SSML, na sigla em inglês). A SSML é compatível com a anotação de texto com tags correspondentes. Use essas tags para determinar como a API Text-to-Speech formata a criação de fala sintética.

A função a seguir converte uma string de SSML em um arquivo MP3 de fala sintética.

Python

Para autenticar no Cloud Translation, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

def text_to_speech(text: str, outfile: str) -> str:
    """Converts plaintext to SSML and
    generates synthetic audio from SSML

    Args:

    text: text to synthesize
    outfile: filename to use to store synthetic audio

    Returns:
    String of synthesized audio
    """

    # Replace special characters with HTML Ampersand Character Codes
    # These Codes prevent the API from confusing text with
    # SSML commands
    # For example, '<' --> '&lt;' and '&' --> '&amp;'
    escaped_lines = html.escape(text)

    # Convert plaintext to SSML in order to wait two seconds
    #   between each line in synthetic speech
    ssml = "<speak>{}</speak>".format(
        escaped_lines.replace("\n", '\n<break time="2s"/>')
    )

    # Instantiates a client
    client = texttospeech.TextToSpeechClient()

    # Sets the text input to be synthesized
    synthesis_input = texttospeech.SynthesisInput(ssml=ssml)

    # Builds the voice request, selects the language code ("en-US") and
    # the SSML voice gender ("MALE")
    voice = texttospeech.VoiceSelectionParams(
        language_code="en-US", ssml_gender=texttospeech.SsmlVoiceGender.MALE
    )

    # Selects the type of audio file to return
    audio_config = texttospeech.AudioConfig(
        audio_encoding=texttospeech.AudioEncoding.MP3
    )

    # Performs the text-to-speech request on the text input with the selected
    # voice parameters and audio file type

    request = texttospeech.SynthesizeSpeechRequest(
        input=synthesis_input, voice=voice, audio_config=audio_config
    )

    response = client.synthesize_speech(request=request)

    # Writes the synthetic audio to the output file.
    with open(outfile, "wb") as out:
        out.write(response.audio_content)
        print("Audio content written to file " + outfile)

Node.js

Para autenticar no Cloud Translation, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

/**
 * Generates synthetic audio from plaintext tagged with SSML.
 *
 * Given the name of a text file and an output file name, this function
 * tags the text in the text file with SSML. This function then
 * calls the Text-to-Speech API. The API returns a synthetic audio
 * version of the text, formatted according to the SSML commands. This
 * function saves the synthetic audio to the designated output file.
 *
 * ARGS
 * text: String of plaintext
 * outFile: String name of file under which to save audio output
 * RETURNS
 * nothing
 *
 */
async function syntheticAudio(text, outFile) {
  // Replace special characters with HTML Ampersand Character Codes
  // These codes prevent the API from confusing text with SSML tags
  // For example, '<' --> '&lt;' and '&' --> '&amp;'
  let escapedLines = text.replace(/&/g, '&amp;');
  escapedLines = escapedLines.replace(/"/g, '&quot;');
  escapedLines = escapedLines.replace(/</g, '&lt;');
  escapedLines = escapedLines.replace(/>/g, '&gt;');

  // Convert plaintext to SSML
  // Tag SSML so that there is a 2 second pause between each address
  const expandedNewline = escapedLines.replace(/\n/g, '\n<break time="2s"/>');
  const ssmlText = '<speak>' + expandedNewline + '</speak>';

  // Creates a client
  const client = new textToSpeech.TextToSpeechClient();

  // Constructs the request
  const request = {
    // Select the text to synthesize
    input: {ssml: ssmlText},
    // Select the language and SSML Voice Gender (optional)
    voice: {languageCode: 'en-US', ssmlGender: 'MALE'},
    // Select the type of audio encoding
    audioConfig: {audioEncoding: 'MP3'},
  };

  // Performs the Text-to-Speech request
  const [response] = await client.synthesizeSpeech(request);
  // Write the binary audio content to a local file
  const writeFile = util.promisify(fs.writeFile);
  await writeFile(outFile, response.audioContent, 'binary');
  console.log('Audio content written to file ' + outFile);
}

Como tudo funciona em conjunto

Nas etapas anteriores, você definiu funções em hybrid_glossaries.py que usam o Vision, o Translation e o Text-to-Speech. Agora, utilize-as para gerar a fala sintética do texto traduzido da foto a seguir.

O código a seguir chama funções definidas em hybrid_glossaries.py para:

criar um recurso de glossário da API Cloud Translation;
usar a API Vision para detectar o texto na imagem acima;
realizar uma tradução do glossário da API Cloud Translation do texto detectado;
gerar a fala sintética do Text-to-Speech do texto traduzido.

Python

Para autenticar no Cloud Translation, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

def main() -> None:
    """This method is called when the tutorial is run in the Google Cloud
    Translation API. It creates a glossary, translates text to
    French, and speaks the translated text.

    Args:
    None

    Returns:
    None
    """
    # Photo from which to extract text
    infile = "resources/example.png"
    # Name of file that will hold synthetic speech
    outfile = "resources/example.mp3"

    # Defines the languages in the glossary
    # This list must match the languages in the glossary
    #   Here, the glossary includes French and English
    glossary_langs = ["fr", "en"]
    # Name that will be assigned to your project's glossary resource
    glossary_name = "bistro-glossary"
    # uri of .csv file uploaded to Cloud Storage
    glossary_uri = "gs://cloud-samples-data/translation/bistro_glossary.csv"

    created_glossary_name = create_glossary(
        glossary_langs, PROJECT_ID, glossary_name, glossary_uri
    )

    # photo -> detected text
    text_to_translate = pic_to_text(infile)
    # detected text -> translated text
    text_to_speak = translate_text(
        text_to_translate, "fr", "en", PROJECT_ID, created_glossary_name
    )
    # translated text -> synthetic audio
    text_to_speech(text_to_speak, outfile)

Node.js

Para autenticar no Cloud Translation, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

await createGlossary(glossaryLangs, projectId, glossaryName, glossaryUri);
const text = await picToText(inFile);
const translatedText = await translateText(
  text,
  'fr',
  'en',
  projectId,
  glossaryName
);
syntheticAudio(translatedText, outFile);

Como executar o código

Para executar o código, digite o seguinte comando no terminal no diretório em que o código está localizado:

Python

python hybrid_tutorial.py

Node.js

  node hybridGlossaries.js

A seguinte resposta é exibida:

Created glossary bistro-glossary.
Audio content written to file resources/example.mp3

Depois de executar o código, navegue até o diretório resources no diretório hybrid_glossaries. Verifique o diretório de recursos de um arquivo example.mp3.

Ouça o áudio a seguir para verificar se o arquivo example.mp3 é igual.

Como solucionar mensagens de erro

```
403 IAM permission 'cloudtranslate.glossaries.create' denied.
```
Essa exceção é gerada pelo uso de uma chave de conta de serviço sem as permissões de editor da API Cloud Translation.
```
KeyError: 'GCLOUD_PROJECT'
```
Esse erro é gerado ao não configurar a variável GCLOUD_PROJECT.
```
400 Invalid resource name project id
```
Essa exceção é gerada pelo uso de um nome de glossário que contenha caracteres diferentes de letras minúsculas, dígitos, pontos, dois-pontos e hifens ou de uma chave da conta de serviço sem as permissões de editor da API Cloud Translation.
```
File filename was not found.
```
Essa exceção é gerada pela definição da variável GOOGLE_APPLICATION_CREDENTIALS em um caminho de arquivo inválido.

Could not automatically determine credentials. Please set GOOGLE_APPLICATION_CREDENTIALS or explicitly create credentials and re-run the application

Essa exceção é gerada ao não configurar a variável GOOGLE_APPLICATION_CREDENTIALS.

```
Forbidden: 403 POST API has not been used or is disabled
```
Esse aviso é gerado ao chamar a API Cloud Translation, a API Cloud Vision ou a API Text-to-Speech sem ativar as APIs.
```
AttributeError: 'module' object has no attribute 'escape'
```
O Python 2.7.10 ou anterior não é compatível com HTML. Para corrigir esse erro, use um ambiente virtual em Python (em inglês). Ele usará a versão mais recente do Python.
```
UnicodeEncodeError
```
O Python 2.7.10 ou anterior não é compatível com HTML. Para corrigir esse erro, use um ambiente virtual em Python (em inglês). Ele usará a versão mais recente do Python.

Limpeza

Se você não precisar do projeto, use o Console do Google Cloud para excluí-lo. A exclusão do projeto evita outros custos da conta de faturamento do Cloud pelos recursos usados neste tutorial.

Como excluir o projeto

No console do Google Cloud, abra a página "Projetos".
Na lista de projetos, selecione um e clique em Excluir.
Na caixa de diálogo, insira o ID do projeto e clique em Encerrar para excluí-lo.

A seguir

Parabéns! Você acabou de usar o OCR da Vision para detectar texto em uma imagem. Depois, você criou um glossário do Translation e gerou uma tradução com ele. E então, usou o Text-to-Speech para gerar um áudio sintético do texto traduzido.

Para desenvolver seus conhecimentos sobre o Vision, o Translation e a conversão de texto em voz:

Crie seu próprio glossário. Saiba como criar um bucket do Cloud Storage e fazer upload do arquivo CSV do glossário no bucket.
Tente outras formas de usar os glossários do Translation.
Saiba como usar o Cloud Storage com o OCR do Cloud Vision.
Saiba mais sobre como usar a SSML com o Text-to-Speech.
Saiba como usar o campo imageContext da API Vision para transmitir outros contextos sobre uma foto ao usar o OCR do Vision.
Veja os tutoriais da comunidade.