Creazione e utilizzo di glossari (opzione avanzata)

Un glossario è un dizionario personalizzato utilizzato dall'API Cloud Translation per tradurre in modo coerente la terminologia specifica del dominio del cliente. In genere, ciò comporta la specifica del modo in cui tradurre un'entità denominata.

Puoi utilizzare un glossario per i seguenti casi d'uso:

  • Nomi di prodotti: ad esempio, "Google Home" deve tradursi in "Google Home".
  • Parole ambigue: ad esempio, la parola "pipistrello" può significare un'attrezzatura sportiva o un animale. Se sai che traduci parole sportive, puoi utilizzare un glossario per fornire alla API Cloud Translation la traduzione sportiva di "pipistrello", non la traduzione dell'animale.
  • Parole presi in prestito: ad esempio, "bouillabaisse" in francese si traduce in "bouillabaisse" in inglese. L'inglese ha preso in prestito la parola "bouillabaisse" dal francese nel XIX secolo. Una persona anglosassone priva di contesto culturale francese potrebbe non sapere che la bouillabaisse è uno stufato di pesce. I glossari possono sostituire una traduzione, in modo che "bouillabaisse" in francese si traduca in "stufato di pesce" in inglese.

Prima di iniziare

Prima di poter iniziare a utilizzare l'API Cloud Translation, devi disporre di un progetto in cui l'API Cloud Translation sia abilitata e delle credenziali appropriate. Puoi anche installare librerie client per i linguaggi di programmazione più comuni per effettuare chiamate all'API. Per ulteriori informazioni, consulta la pagina Configurazione.

Autorizzazioni obbligatorie

Per utilizzare i glossari, l'account di servizio richiede autorizzazioni specifiche per il glossario. Puoi concedere un ruolo al tuo account di servizio utilizzando uno dei ruoli IAM predefiniti, ad esempio Editor API Cloud Translation (roles/cloudtranslate.editor), oppure creare un ruolo personalizzato che conceda le autorizzazioni necessarie. Puoi visualizzare tutte le autorizzazioni dell'API Cloud Translation nel riferimento alle autorizzazioni IAM. Le autorizzazioni di Cloud Translation iniziano con cloudtranslate.

Per creare glossari, devi anche avere le autorizzazioni per leggere gli oggetti nel bucket Cloud Storage in cui si trova il file del glossario. Puoi concedere un ruolo al tuo account di servizio utilizzando uno dei ruoli IAM predefiniti, ad esempio Visualizzatore oggetti Storage (roles/storage.objectViewer), oppure creare un ruolo personalizzato che conceda le autorizzazioni per la lettura di oggetti.

Per informazioni sull'aggiunta di un account a un ruolo, consulta Concessione, modifica e revoca dell'accesso alle risorse.

Crea un glossario

I termini in un glossario possono essere singoli token (parole) o frasi brevi (di solito meno di cinque parole). I passaggi principali per l'utilizzo di un glossario sono:

  1. Creare un file di glossario
  2. Crea la risorsa del glossario con la nostra API Cloud Translation
  3. Specifica quale glossario utilizzare quando richiedi una traduzione

Un progetto può avere più glossari. Puoi ottenere un elenco dei glossari disponibili ed eliminare i glossari che non ti servono più.

Stopword

Cloud Translation ignora alcuni termini inclusi in un glossario; questi termini sono noti come stopword. Quando traduci le stopword, Cloud Translation ignora eventuali voci di glossario corrispondenti. Per un elenco di tutte le stopword, consulta il Glossario delle stopword.

Creazione di un file di glossario

Fondamentalmente, un glossario è un file di testo in cui ogni riga contiene termini corrispondenti in più lingue. L'API Cloud Translation supporta sia glossari unidirezionali, che specificano la traduzione desiderata per una singola coppia di lingue di origine e di destinazione, sia set di termini equivalenti, che identificano i termini equivalenti in più lingue.

Il numero totale di termini in un file di input del glossario non può superare i 10,4 milioni (10.485.760) byte UTF-8 per tutti i termini in tutte le lingue combinate. Ogni singolo termine del glossario deve essere inferiore a 1024 byte UTF-8. I termini più lunghi di 1024 byte vengono ignorati.

Per impostazione predefinita, le corrispondenze del glossario sono sensibili alle maiuscole. Quando applichi un glossario, puoi ignorare maiuscole e minuscole per tutte le voci. Se disponi di una combinazione di termini sensibili alle maiuscole e senza distinzione tra maiuscole e minuscole, utilizza il comportamento predefinito e, per i termini senza distinzione tra maiuscole e minuscole, includi entrambi i moduli nel glossario.

Glossari unidirezionali

L'API Cloud Translation accetta file TSV, CSV o TMX.

TSV e CSV

Per i valori separati da tabulazioni (TSV) e i valori separati da virgole (CSV), ogni riga contiene una coppia di termini separati da una tabulazione (\t) o da una virgola (,). La prima colonna include il termine nella lingua di origine e la seconda colonna include il termine nella lingua di destinazione, come illustrato nell'esempio seguente:

Glossario unidirezionale

eXchange della memoria di traduzione (TMX)

Translation Memory eXchange (TMX) è un formato XML standard per fornire traduzioni di origine e di destinazione. L'API Cloud Translation supporta i file di input in un formato basato su TMX versione 1.4. Questo esempio illustra la struttura richiesta:

<?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>

L'elemento <header> di un file TMX corretto deve identificare la lingua di origine utilizzando l'attributo srclang, mentre ogni elemento <tuv> deve identificare la lingua del testo contenuto tramite l'attributo xml:lang. Puoi identificare le lingue di origine e di destinazione utilizzando i relativi codici ISO-639.

Tutti gli elementi <tu> devono contenere una coppia di elementi <tuv> con le stesse lingue di origine e di destinazione. Se un elemento <tu> contiene più di due elementi <tuv>, l'API Cloud Translation elabora solo il primo <tuv> che corrisponde alla lingua di origine e il primo che corrisponde alla lingua di destinazione, mentre ignora il resto. Se un elemento <tu> non ha una coppia corrispondente di elementi <tuv>, l'API Cloud Translation salta l'elemento <tu> non valido.

L'API Cloud Translation rimuove i tag di markup da un elemento <seg> prima di elaborarlo. Se un elemento <tuv> contiene più di un elemento <seg>, l'API Cloud Translation concatena il testo in un singolo elemento con uno spazio tra di loro.

Se il file contiene tag XML diversi da quelli mostrati in precedenza, l'API Cloud Translation li ignora.

Se il file non è conforme al formato XML e TMX corretto, ad esempio se manca un tag di chiusura o un elemento <tmx>, l'API Cloud Translation ne interrompe l'elaborazione. L'API Cloud Translation interrompe l'elaborazione anche se salta più di 1024 elementi <tu> non validi.

Set di termini equivalenti (CSV)

Per i set di termini equivalenti, l'API Cloud Translation accetta solo file in formato CSV. Per definire set di termini equivalenti, crea un file CSV a più colonne in cui ogni riga elenca un singolo termine del glossario in più lingue.

La prima riga del file è una riga di intestazione che identifica la lingua di ogni colonna, utilizzando il relativo codice lingua ISO-639 o BCP-47. Puoi anche includere colonne facoltative per la parte del discorso (pos) e una descrizione (description). Al momento l'algoritmo non utilizza informazioni pos e valori pos specifici non vengono convalidati.

Ogni riga successiva contiene termini del glossario equivalenti nelle lingue identificate nell'intestazione. Puoi lasciare le colonne vuote se il termine non è disponibile in tutte le lingue.

Termini equivalenti impostati

Creazione di una risorsa di glossario

Dopo aver identificato i termini del glossario equivalenti, rendi il file del glossario disponibile per l'API Cloud Translation creando una risorsa di glossario.

Glossario unidirezionale

Quando crei un glossario unidirezionale, devi indicare la coppia di lingue (language_pair), specificando la lingua di origine (source_language_code) e la lingua di destinazione (target_language_code). L'esempio seguente utilizza l'API REST e la riga di comando, ma puoi anche utilizzare le librerie client per creare un glossario unidirezionale.

REST

Quando crei un nuovo glossario, devi fornire un ID glossario (un nome risorsa). Ad esempio: 
projects/my-project/locations/us-central1/glossaries/my-en-to-ru-glossary
dove my-project è PROJECT_NUMBER_OR_ID e my-en-ru-glossary è l'ID glossario fornito da te.

Prima di utilizzare qualsiasi dato della richiesta, effettua le seguenti sostituzioni:

  • PROJECT_NUMBER_OR_ID: l'ID numerico o alfanumerico del tuo progetto Google Cloud
  • glossary-id: l'ID del glossario, ad esempio my_en_ru_glossary
  • bucket-name: nome del bucket in cui si trova il file di glossario
  • glossary-filename: nome file del glossario

Metodo HTTP e URL: 

POST https://translation.googleapis.com/v3/projects/PROJECT_NUMBER_OR_ID/locations/us-central1/glossaries

Corpo JSON della richiesta: 

{
  "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"
    }
  }
}

Per inviare la richiesta, espandi una di queste opzioni:

Dovresti ricevere una risposta JSON simile alla seguente:

{
  "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"
  }
}

Glossario degli insiemi di termini equivalenti

Dopo aver identificato i termini del glossario nel set di termini equivalente, rendi il file di glossario disponibile per l'API Cloud Translation creando una risorsa di glossario.

REST

Prima di utilizzare qualsiasi dato della richiesta, effettua le seguenti sostituzioni:

  • PROJECT_NUMBER_OR_ID: l'ID numerico o alfanumerico del tuo progetto Google Cloud
  • glossary-id: l'ID del glossario
  • bucket-name: nome del bucket in cui si trova il file di glossario
  • glossary-filename: nome file del glossario

Metodo HTTP e URL: 

POST https://translation.googleapis.com/v3/projects/PROJECT_NUMBER_OR_ID/locations/us-central1/glossaries

Corpo JSON della richiesta: 

{
  "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"
    }
  }
}

Per inviare la richiesta, espandi una di queste opzioni:

Dovresti ricevere una risposta JSON simile alla seguente:

{
  "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"
  }
}

Go

Prima di provare questo esempio, segui le istruzioni di configurazione di Go nella guida rapida di Cloud Translation utilizzando le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Cloud Translation Go.

Per autenticarti su Cloud Translation, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta la pagina Configurare l'autenticazione per un ambiente di sviluppo locale. 

import (
	"context"
	"fmt"
	"io"

	translate "cloud.google.com/go/translate/apiv3"
	"cloud.google.com/go/translate/apiv3/translatepb"
)

// 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: %w", 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: %w", err)
	}
	fmt.Fprintf(w, "Processing operation name: %q\n", op.Name())

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

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

	return nil
}

Java

Prima di provare questo esempio, segui le istruzioni di configurazione di Java nella guida rapida di Cloud Translation utilizzando le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Cloud Translation Java.

Per autenticarti su Cloud Translation, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta la pagina Configurare l'autenticazione per un ambiente di sviluppo locale. 

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

Prima di provare questo esempio, segui le istruzioni di configurazione di Node.js nella guida rapida di Cloud Translation utilizzando le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Cloud Translation Node.js.

Per autenticarti su Cloud Translation, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta la pagina Configurare l'autenticazione per un ambiente di sviluppo locale. 

/**
 * 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,
  };

  // 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}`);
}

createGlossary();

Python

Prima di provare questo esempio, segui le istruzioni di configurazione di Python nella guida rapida di Cloud Translation utilizzando le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Cloud Translation Python.

Per autenticarti su Cloud Translation, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta la pagina Configurare l'autenticazione per un ambiente di sviluppo locale. 

from google.cloud import translate_v3 as translate

def create_glossary(
    project_id: str = "YOUR_PROJECT_ID",
    input_uri: str = "YOUR_INPUT_URI",
    glossary_id: str = "YOUR_GLOSSARY_ID",
    timeout: int = 180,
) -> translate.Glossary:
    """
    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 = f"projects/{project_id}/locations/{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)
    print(f"Created: {result.name}")
    print(f"Input Uri: {result.input_config.gcs_source.input_uri}")

    return result

Linguaggi aggiuntivi

C#: segui le istruzioni di configurazione di C# nella pagina delle librerie client e consulta la documentazione di riferimento di Cloud Translation per .NET.

PHP: segui le istruzioni di configurazione dei file PHP nella pagina delle librerie client e consulta la documentazione di riferimento di Cloud Translation per PHP.

Ruby: segui le istruzioni di configurazione di Ruby nella pagina delle librerie client e poi visita la documentazione di riferimento di Cloud Translation per Ruby.

Stato operazione

La creazione di una risorsa di glossario è un'operazione a lunga esecuzione, pertanto il completamento del processo potrebbe richiedere una quantità di tempo considerevole. Puoi eseguire il polling dello stato di questa operazione per vedere se è stata completata oppure puoi annullarla.

Per ulteriori informazioni, consulta Operazioni a lunga esecuzione.

Utilizzare i glossari

Tradurre un testo con un glossario

In Cloud Translation - Advanced, devi specificare esplicitamente il modello di traduzione da utilizzare per tradurre il testo. Puoi anche identificare un glossario da utilizzare per la terminologia specifica del dominio.

REST

Questo esempio traduce il testo utilizzando il modello NMT predefinito e un glossario.

Prima di utilizzare qualsiasi dato della richiesta, effettua le seguenti sostituzioni:

  • PROJECT_NUMBER_OR_ID: l'ID numerico o alfanumerico del tuo progetto Google Cloud.
  • glossary-id: l'ID del glossario, ad esempio my-en-ru-glossary.
  • BOOLEAN: indica se le corrispondenze non fanno distinzione tra maiuscole e minuscole. Per impostazione predefinita, questo valore è false.

Metodo HTTP e URL: 

POST https://translation.googleapis.com/v3/projects/PROJECT_NUMBER_OR_ID/locations/us-central1:translateText

Corpo JSON della richiesta: 

{
  "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",
    "ignoreCase": BOOLEAN
  }
}

Per inviare la richiesta, espandi una di queste opzioni:

Dovresti ricevere una risposta JSON simile alla seguente:

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

Il campo translations contiene la traduzione automatica standard prima dell'applicazione del glossario; il campo glossaryTranslations contiene la traduzione dopo l'applicazione del glossario.

Go

Prima di provare questo esempio, segui le istruzioni di configurazione di Go nella guida rapida di Cloud Translation utilizzando le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Cloud Translation Go.

Per autenticarti su Cloud Translation, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta la pagina Configurare l'autenticazione per un ambiente di sviluppo locale. 

import (
	"context"
	"fmt"
	"io"

	translate "cloud.google.com/go/translate/apiv3"
	"cloud.google.com/go/translate/apiv3/translatepb"
)

// 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: %w", 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: %w", 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

Prima di provare questo esempio, segui le istruzioni di configurazione di Java nella guida rapida di Cloud Translation utilizzando le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Cloud Translation Java.

Per autenticarti su Cloud Translation, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta la pagina Configurare l'autenticazione per un ambiente di sviluppo locale. 

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

Prima di provare questo esempio, segui le istruzioni di configurazione di Node.js nella guida rapida di Cloud Translation utilizzando le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Cloud Translation Node.js.

Per autenticarti su Cloud Translation, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta la pagina Configurare l'autenticazione per un ambiente di sviluppo locale. 

/**
 * 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,
  };

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

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

translateTextWithGlossary();

Python

Prima di provare questo esempio, segui le istruzioni di configurazione di Python nella guida rapida di Cloud Translation utilizzando le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Cloud Translation Python.

Per autenticarti su Cloud Translation, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta la pagina Configurare l'autenticazione per un ambiente di sviluppo locale. 


from google.cloud import translate

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

    Args:
        text: The text to translate.
        project_id: The ID of the GCP project that owns the glossary.
        glossary_id: The ID of the glossary to use.

    Returns:
        The translated text."""
    client = translate.TranslationServiceClient()
    location = "us-central1"
    parent = f"projects/{project_id}/locations/{location}"

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

    glossary_config = translate.TranslateTextGlossaryConfig(glossary=glossary)

    # Supported language codes: https://cloud.google.com/translate/docs/languages
    response = client.translate_text(
        request={
            "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(f"\t {translation.translated_text}")

    return response

Linguaggi aggiuntivi

C#: segui le istruzioni di configurazione di C# nella pagina delle librerie client e consulta la documentazione di riferimento di Cloud Translation per .NET.

PHP: segui le istruzioni di configurazione dei file PHP nella pagina delle librerie client e consulta la documentazione di riferimento di Cloud Translation per PHP.

Ruby: segui le istruzioni di configurazione di Ruby nella pagina delle librerie client e poi visita la documentazione di riferimento di Cloud Translation per Ruby.

Trovare informazioni su un glossario

REST

Prima di utilizzare qualsiasi dato della richiesta, effettua le seguenti sostituzioni:

  • PROJECT_NUMBER_OR_ID: l'ID numerico o alfanumerico del tuo progetto Google Cloud
  • glossary-id: l'ID del glossario, ad esempio "my-en-to-ru-glossary"

Metodo HTTP e URL: 

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

Per inviare la richiesta, espandi una di queste opzioni:

Dovresti ricevere una risposta JSON simile alla seguente:

{
  "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
}

Go

Prima di provare questo esempio, segui le istruzioni di configurazione di Go nella guida rapida di Cloud Translation utilizzando le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Cloud Translation Go.

Per autenticarti su Cloud Translation, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta la pagina Configurare l'autenticazione per un ambiente di sviluppo locale. 

import (
	"context"
	"fmt"
	"io"

	translate "cloud.google.com/go/translate/apiv3"
	"cloud.google.com/go/translate/apiv3/translatepb"
)

// 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: %w", 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: %w", 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

Prima di provare questo esempio, segui le istruzioni di configurazione di Java nella guida rapida di Cloud Translation utilizzando le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Cloud Translation Java.

Per autenticarti su Cloud Translation, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta la pagina Configurare l'autenticazione per un ambiente di sviluppo locale. 

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

Prima di provare questo esempio, segui le istruzioni di configurazione di Node.js nella guida rapida di Cloud Translation utilizzando le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Cloud Translation Node.js.

Per autenticarti su Cloud Translation, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta la pagina Configurare l'autenticazione per un ambiente di sviluppo locale. 

/**
 * 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}`,
  };

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

  console.log(`Glossary name: ${response.name}`);
  console.log(`Entry count: ${response.entryCount}`);
  console.log(`Input URI: ${response.inputConfig.gcsSource.inputUri}`);
}

getGlossary();

Python

Prima di provare questo esempio, segui le istruzioni di configurazione di Python nella guida rapida di Cloud Translation utilizzando le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Cloud Translation Python.

Per autenticarti su Cloud Translation, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta la pagina Configurare l'autenticazione per un ambiente di sviluppo locale. 

from google.cloud import translate_v3 as translate

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

    Args:
        project_id: The GCP project ID.
        glossary_id: The ID of the glossary to retrieve.

    Returns:
        The glossary.
    """
    client = translate.TranslationServiceClient()

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

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

    return response

Linguaggi aggiuntivi

C#: segui le istruzioni di configurazione di C# nella pagina delle librerie client e consulta la documentazione di riferimento di Cloud Translation per .NET.

PHP: segui le istruzioni di configurazione dei file PHP nella pagina delle librerie client e consulta la documentazione di riferimento di Cloud Translation per PHP.

Ruby: segui le istruzioni di configurazione di Ruby nella pagina delle librerie client e poi visita la documentazione di riferimento di Cloud Translation per Ruby.

Elenco glossari

Un progetto può includere numerosi glossari. Questa sezione descrive come recuperare un elenco dei glossari disponibili per un particolare progetto.

REST

In questo esempio sono elencati tutti i glossari associati al progetto specificato.

Prima di utilizzare qualsiasi dato della richiesta, effettua le seguenti sostituzioni:

  • PROJECT_NUMBER_OR_ID: l'ID numerico o alfanumerico del tuo progetto Google Cloud

Metodo HTTP e URL: 

GET https://translation.googleapis.com/v3/projects/PROJECT_NUMBER_OR_ID/locations/us-central1/glossaries

Per inviare la richiesta, espandi una di queste opzioni:

Dovresti ricevere una risposta JSON simile alla seguente:

{
  "glossaries": [
    {
      "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
    },
    ...
  ]
}

Go

Prima di provare questo esempio, segui le istruzioni di configurazione di Go nella guida rapida di Cloud Translation utilizzando le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Cloud Translation Go.

Per autenticarti su Cloud Translation, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta la pagina Configurare l'autenticazione per un ambiente di sviluppo locale. 

import (
	"context"
	"fmt"
	"io"

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

// 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: %w", 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: %w", 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

Prima di provare questo esempio, segui le istruzioni di configurazione di Java nella guida rapida di Cloud Translation utilizzando le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Cloud Translation Java.

Per autenticarti su Cloud Translation, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta la pagina Configurare l'autenticazione per un ambiente di sviluppo locale. 

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

Prima di provare questo esempio, segui le istruzioni di configurazione di Node.js nella guida rapida di Cloud Translation utilizzando le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Cloud Translation Node.js.

Per autenticarti su Cloud Translation, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta la pagina Configurare l'autenticazione per un ambiente di sviluppo locale. 

/**
 * 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}`,
  };

  // 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}`);
    }
  }
}

listGlossaries();

Python

Prima di provare questo esempio, segui le istruzioni di configurazione di Python nella guida rapida di Cloud Translation utilizzando le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Cloud Translation Python.

Per autenticarti su Cloud Translation, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta la pagina Configurare l'autenticazione per un ambiente di sviluppo locale. 

from google.cloud import translate

def list_glossaries(project_id: str = "YOUR_PROJECT_ID") -> translate.Glossary:
    """List Glossaries.

    Args:
        project_id: The GCP project ID.

    Returns:
        The glossary.
    """
    client = translate.TranslationServiceClient()

    location = "us-central1"

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

    # Iterate over all results
    for glossary in client.list_glossaries(parent=parent):
        print(f"Name: {glossary.name}")
        print(f"Entry count: {glossary.entry_count}")
        print(f"Input uri: {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(f"Language code: {language_code}")

    return glossary

Linguaggi aggiuntivi

C#: segui le istruzioni di configurazione di C# nella pagina delle librerie client e consulta la documentazione di riferimento di Cloud Translation per .NET.

PHP: segui le istruzioni di configurazione dei file PHP nella pagina delle librerie client e consulta la documentazione di riferimento di Cloud Translation per PHP.

Ruby: segui le istruzioni di configurazione di Ruby nella pagina delle librerie client e poi visita la documentazione di riferimento di Cloud Translation per Ruby.

Aggiorna un glossario

Puoi aggiornare un glossario per cambiarne il nome o per sostituire tutte le sue voci con un nuovo file di input del glossario. Se devi eseguire il rollback delle modifiche alle voci del glossario, devi utilizzare il file originale del glossario per sostituire il glossario modificato.

REST

Per aggiornare un glossario, invia una richiesta PATCH con il metodo glossary.patch. L'esempio seguente aggiorna un glossario di un set di termini equivalente. Utilizzare il metodo list per trovare l'ID di un particolare glossario.

Il parametro di query update_mask specifica se stai aggiornando il file di input del glossario, il nome visualizzato del glossario o entrambi. È richiesto almeno un parametro di aggiornamento della maschera.

Prima di utilizzare qualsiasi dato della richiesta, effettua le seguenti sostituzioni:

  • PROJECT_NUMBER_OR_ID: l'ID numerico o alfanumerico del tuo progetto Google Cloud.
  • LOCATION: la regione in cui si trova il glossario da aggiornare, ad esempio us-central1.
  • GLOSSARY_ID: l'ID di un glossario esistente.
  • LANGUAGE_CODE: il codice lingua che specifica i linguaggi per questo glossario del set di termini equivalente.
  • GLOSSARY_FILE_PATH: la posizione e il nome del file di input del glossario.

Metodo HTTP e URL: 

PATCH https://translation.googleapis.com/v3/projects/PROJECT_NUMBER_OR_ID/locations/LOCATION/glossaries/GLOSSARY_ID?update_mask=input_config&update_mask=display_name

Corpo JSON della richiesta: 

{
  "name":"projects/PROJECT_NUMBER_OR_ID/locations/LOCATION/glossaries/GLOSSARY_ID",
  "languageCodesSet": {
    "languageCodes": ["LANGUAGE_CODE", ...]
  },
  "inputConfig": {
    "gcsSource": {
      "inputUri": "gs://GLOSSARY_FILE_PATH"
    }
  }
}

Per inviare la richiesta, espandi una di queste opzioni:

Dovresti ricevere una risposta JSON simile alla seguente:

{
  "name": "projects/PROJECT_NUMBER/locations/LOCATION/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.translation.v3.UpdateGlossaryMetadata",
    "glossary": {
      "name": "projects/PROJECT_NUMBER/locations/LOCATION/glossaries/GLOSSARY_ID",
      "languageCodesSet": {
        "languageCodes": ["LANGUAGE_CODE", ...]
      },
      "inputConfig": {
        "gcsSource": {
        "inputUri": "gs://GLOSSARY_FILE_PATH"
        }
      },
      "entryCount": NUMBER_OF_ENTRIES,
      "submitTime": "2022-04-22T23:16:30.628806944Z",
      "endTime": "2022-04-22T23:41:15.115797Z",
      "displayName": "GLOSSARY_ID"
    },
    "state": "RUNNING",
    "submitTime": "2022-04-22T23:50:24.337964527Z"
  }
}

Linguaggi aggiuntivi

C#: segui le istruzioni di configurazione di C# nella pagina delle librerie client e consulta la documentazione di riferimento di Cloud Translation per .NET.

PHP: segui le istruzioni di configurazione dei file PHP nella pagina delle librerie client e consulta la documentazione di riferimento di Cloud Translation per PHP.

Ruby: segui le istruzioni di configurazione di Ruby nella pagina delle librerie client e poi visita la documentazione di riferimento di Cloud Translation per Ruby.

Eliminare un glossario

L'esempio seguente elimina un glossario.

REST

Prima di utilizzare qualsiasi dato della richiesta, effettua le seguenti sostituzioni:

  • PROJECT_NUMBER_OR_ID: l'ID numerico o alfanumerico del tuo progetto Google Cloud
  • glossary-id: l'ID del glossario

Metodo HTTP e URL: 

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

Per inviare la richiesta, espandi una di queste opzioni:

Dovresti ricevere un codice di stato riuscito (2xx) e una risposta vuota.

Go

Prima di provare questo esempio, segui le istruzioni di configurazione di Go nella guida rapida di Cloud Translation utilizzando le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Cloud Translation Go.

Per autenticarti su Cloud Translation, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta la pagina Configurare l'autenticazione per un ambiente di sviluppo locale. 

import (
	"context"
	"fmt"
	"io"

	translate "cloud.google.com/go/translate/apiv3"
	"cloud.google.com/go/translate/apiv3/translatepb"
)

// 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: %w", 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: %w", err)
	}
	fmt.Fprintf(w, "Processing operation name: %q\n", op.Name())

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

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

	return nil
}

Java

Prima di provare questo esempio, segui le istruzioni di configurazione di Java nella guida rapida di Cloud Translation utilizzando le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Cloud Translation Java.

Per autenticarti su Cloud Translation, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta la pagina Configurare l'autenticazione per un ambiente di sviluppo locale. 

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

Prima di provare questo esempio, segui le istruzioni di configurazione di Node.js nella guida rapida di Cloud Translation utilizzando le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Cloud Translation Node.js.

Per autenticarti su Cloud Translation, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta la pagina Configurare l'autenticazione per un ambiente di sviluppo locale. 

/**
 * 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}`,
  };

  // 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}`);
}

deleteGlossary();

Python

Prima di provare questo esempio, segui le istruzioni di configurazione di Python nella guida rapida di Cloud Translation utilizzando le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Cloud Translation Python.

Per autenticarti su Cloud Translation, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta la pagina Configurare l'autenticazione per un ambiente di sviluppo locale. 

from google.cloud import translate_v3 as translate

def delete_glossary(
    project_id: str = "YOUR_PROJECT_ID",
    glossary_id: str = "YOUR_GLOSSARY_ID",
    timeout: int = 180,
) -> translate.Glossary:
    """Delete a specific glossary based on the glossary ID.

    Args:
        project_id: The ID of the GCP project that owns the glossary.
        glossary_id: The ID of the glossary to delete.
        timeout: The timeout for this request.

    Returns:
        The glossary that was deleted.
    """
    client = translate.TranslationServiceClient()

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

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

    return result

Linguaggi aggiuntivi

C#: segui le istruzioni di configurazione di C# nella pagina delle librerie client e consulta la documentazione di riferimento di Cloud Translation per .NET.

PHP: segui le istruzioni di configurazione dei file PHP nella pagina delle librerie client e consulta la documentazione di riferimento di Cloud Translation per PHP.

Ruby: segui le istruzioni di configurazione di Ruby nella pagina delle librerie client e poi visita la documentazione di riferimento di Cloud Translation per Ruby.

Gestione delle voci di glossario

Una voce di glossario mappa un termine in una lingua a un termine in un'altra lingua. Puoi aggiungere nuove voci a un glossario, elencare tutte le voci di un glossario esistente o modificare quelle esistenti.

Crea nuove voci

Crea nuove voci per aggiungere termini a un glossario esistente. Per i glossari unidirezionali, fornisci una coppia di termini, in cui un termine è nella lingua di origine e l'altro nella lingua di destinazione. Per i glossari di un set di termini equivalenti, fornisci un insieme di termini in cui ogni elemento del set specifica un termine e il relativo codice lingua.

REST

I seguenti esempi creano una voce per un glossario di un set di termini equivalente. Puoi creare una sola voce per richiesta. Per ulteriori informazioni, consulta il metodo glossaryEntries.create.

Prima di utilizzare qualsiasi dato della richiesta, effettua le seguenti sostituzioni:

  • PROJECT_NUMBER_OR_ID: l'ID numerico o alfanumerico del tuo progetto Google Cloud.
  • LOCATION: la regione in cui si trova il glossario da aggiornare, ad esempio us-central1.
  • GLOSSARY_ID: l'ID di un glossario esistente.
  • LANGUAGE_CODE: il codice lingua che specifica la lingua del termine.
  • TERM: il termine da aggiungere al glossario.
  • DESCRIPTION: informazioni sulla voce del glossario.

Metodo HTTP e URL: 

POST https://translation.googleapis.com/v3/projects/PROJECT_NUMBER_OR_ID/locations/LOCATION/glossaries/GLOSSARY_ID/glossaryEntries

Corpo JSON della richiesta: 

{
  termsSet: {
   terms: {
     languageCode: "LANGUAGE_CODE",
     text: "TERM"
    },
    ...
  },
  description: "DESCRIPTION"
}

Per inviare la richiesta, espandi una di queste opzioni:

Dovresti ricevere una risposta JSON simile alla seguente:

{
  "name": "projects/PROJECT_NUMBER/locations/LOCATION/glossaries/GLOSSARY_ID/glossaryEntries/GLOSSARY_ENTRY_ID",
  "termsSet": {
    "terms": [
      {
        "languageCode": "LANGUAGE_CODE",
        "text": "TERM"
      },
      ...
    ]
  },
  "description": "DESCRIPTION"
}

Linguaggi aggiuntivi

C#: segui le istruzioni di configurazione di C# nella pagina delle librerie client e consulta la documentazione di riferimento di Cloud Translation per .NET.

PHP: segui le istruzioni di configurazione dei file PHP nella pagina delle librerie client e consulta la documentazione di riferimento di Cloud Translation per PHP.

Ruby: segui le istruzioni di configurazione di Ruby nella pagina delle librerie client e poi visita la documentazione di riferimento di Cloud Translation per Ruby.

Elenco voci di glossario

Elenca tutte le voci di un glossario esistente. Questa opzione è utile, ad esempio, se vuoi controllare quali termini e quali lingue sono presenti in un determinato glossario.

REST

Per elencare tutte le voci di glossario, invia una richiesta GET con il metodo glossaryEntries.list.

Prima di utilizzare qualsiasi dato della richiesta, effettua le seguenti sostituzioni:

  • PROJECT_NUMBER_OR_ID: l'ID numerico o alfanumerico del tuo progetto Google Cloud.
  • LOCATION: la regione in cui si trova il glossario da aggiornare, ad esempio us-central1.
  • GLOSSARY_ID: l'ID di un glossario esistente.

Metodo HTTP e URL: 

GET https://translation.googleapis.com/v3/projects/PROJECT_NUMBER_OR_ID/locations/LOCATION/glossaries/GLOSSARY_ID/glossaryEntries

Per inviare la richiesta, espandi una di queste opzioni:

Dovresti ricevere una risposta JSON simile alla seguente:

{
  "glossaryEntries": [
    {
      "name": "projects/PROJECT_NUMBER/locations/LOCATION/glossaries/GLOSSARY_ID/glossaryEntries/GLOSSARY_ENTRY_ID",
      "termsSet": {
        "terms": [
          {
            "languageCode": "LANGUAGE_CODE",
            "text": "TERM"
          },
        ...
        ]
      },
      "description": "DESCRIPTION"
    },
    ...
  ]
}

Linguaggi aggiuntivi

C#: segui le istruzioni di configurazione di C# nella pagina delle librerie client e consulta la documentazione di riferimento di Cloud Translation per .NET.

PHP: segui le istruzioni di configurazione dei file PHP nella pagina delle librerie client e consulta la documentazione di riferimento di Cloud Translation per PHP.

Ruby: segui le istruzioni di configurazione di Ruby nella pagina delle librerie client e poi visita la documentazione di riferimento di Cloud Translation per Ruby.

Recupero di una voce del glossario

Ottieni una singola voce per visualizzarne le informazioni.

REST

Per ottenere una singola voce di glossario, invia una richiesta GET con il metodo glossaryEntries.get. Utilizza il metodo list per trovare l'ID di una determinata voce.

Prima di utilizzare qualsiasi dato della richiesta, effettua le seguenti sostituzioni:

  • PROJECT_NUMBER_OR_ID: l'ID numerico o alfanumerico del tuo progetto Google Cloud.
  • LOCATION: la regione in cui si trova il glossario da aggiornare, ad esempio us-central1.
  • GLOSSARY_ID: l'ID di un glossario esistente.
  • GLOSSARY_ENTRY_ID: l'ID di una voce di glossario esistente.

Metodo HTTP e URL: 

GET https://translation.googleapis.com/v3/projects/PROJECT_NUMBER_OR_ID/locations/LOCATION/glossaries/GLOSSARY_ID/glossaryEntries/GLOSSARY_ENTRY_ID

Per inviare la richiesta, espandi una di queste opzioni:

Dovresti ricevere una risposta JSON simile alla seguente:

{
  "name": "projects/PROJECT_NUMBER/locations/LOCATION/glossaries/GLOSSARY_ID/glossaryEntries/GLOSSARY_ENTRY_ID",
  "termsSet": {
    "terms": [
      {
        "languageCode": "LANGUAGE_CODE",
        "text": "TERM"
      },
      ...
    ]
  },
  "description": "DESCRIPTION"
}

Linguaggi aggiuntivi

C#: segui le istruzioni di configurazione di C# nella pagina delle librerie client e consulta la documentazione di riferimento di Cloud Translation per .NET.

PHP: segui le istruzioni di configurazione dei file PHP nella pagina delle librerie client e consulta la documentazione di riferimento di Cloud Translation per PHP.

Ruby: segui le istruzioni di configurazione di Ruby nella pagina delle librerie client e poi visita la documentazione di riferimento di Cloud Translation per Ruby.

Aggiornamento delle voci di glossario

Puoi aggiornare una singola voce o sostituire tutte le voci di un glossario. Per sostituire tutte le voci, consulta Aggiornare un glossario.

Per modificare una voce in un glossario unidirezionale, fornisci una coppia di termini, in cui un termine è nella lingua di origine e l'altro è nella lingua di destinazione. Per i glossari di un set di termini equivalenti, fornisci un set di termini in cui ogni elemento del set specifica un termine e il relativo codice lingua.

REST

Gli esempi riportati di seguito aggiornano una voce di un glossario di un set di termini equivalente. Per ulteriori informazioni, consulta il metodo glossaryEntries.patch.

Prima di utilizzare qualsiasi dato della richiesta, effettua le seguenti sostituzioni:

  • PROJECT_NUMBER_OR_ID: l'ID numerico o alfanumerico del tuo progetto Google Cloud.
  • LOCATION: la regione in cui si trova il glossario da aggiornare, ad esempio us-central1.
  • GLOSSARY_ID: l'ID di un glossario esistente contenente la voce da aggiornare.
  • GLOSSARY_ENTRY_ID: l'ID della voce di glossario da aggiornare.
  • LANGUAGE_CODE: il codice lingua che specifica la lingua del termine.
  • TERM: il termine da aggiornare.
  • DESCRIPTION: informazioni sulla voce del glossario.

Metodo HTTP e URL: 

PATCH https://translation.googleapis.com/v3/projects/PROJECT_NUMBER_OR_ID/locations/LOCATION/glossaries/GLOSSARY_ID/glossaryEntries/GLOSSARY_ENTRY_ID

Corpo JSON della richiesta: 

{
  termsSet: {
   terms: {
     languageCode: "LANGUAGE_CODE",
     text: "TERM"
    },
    ...
  },
  description: "DESCRIPTION"
}

Per inviare la richiesta, espandi una di queste opzioni:

Dovresti ricevere una risposta JSON simile alla seguente:

{
  "name": "projects/PROJECT_NUMBER/locations/LOCATION/glossaries/GLOSSARY_ID/glossaryEntries/GLOSSARY_ENTRY_ID",
  "termsSet": {
    "terms": [
      {
        "languageCode": "LANGUAGE_CODE",
        "text": "TERM"
      },
      ...
    ]
  },
  "description": "DESCRIPTION"
}

Linguaggi aggiuntivi

C#: segui le istruzioni di configurazione di C# nella pagina delle librerie client e consulta la documentazione di riferimento di Cloud Translation per .NET.

PHP: segui le istruzioni di configurazione dei file PHP nella pagina delle librerie client e consulta la documentazione di riferimento di Cloud Translation per PHP.

Ruby: segui le istruzioni di configurazione di Ruby nella pagina delle librerie client e poi visita la documentazione di riferimento di Cloud Translation per Ruby.

Eliminare una voce di glossario

Rimuovere una singola voce di glossario.

REST

Per eliminare una singola voce di glossario, invia una richiesta DELETE con il metodo glossaryEntries.delete. Utilizza il metodo list per trovare l'ID di una determinata voce.

Prima di utilizzare qualsiasi dato della richiesta, effettua le seguenti sostituzioni:

  • PROJECT_NUMBER_OR_ID: l'ID numerico o alfanumerico del tuo progetto Google Cloud.
  • LOCATION: la regione in cui si trova il glossario da aggiornare, ad esempio us-central1.
  • GLOSSARY_ID: l'ID di un glossario esistente contenente la voce da eliminare.
  • GLOSSARY_ENTRY_ID: l'ID della voce di glossario da eliminare.

Metodo HTTP e URL: 

DELETE https://translation.googleapis.com/v3/projects/PROJECT_NUMBER_OR_ID/locations/LOCATION/glossaries/GLOSSARY_ID/glossaryEntries/GLOSSARY_ENTRY_ID

Per inviare la richiesta, espandi una di queste opzioni:

Dovresti ricevere un codice di stato riuscito (2xx) e una risposta vuota.

Linguaggi aggiuntivi

C#: segui le istruzioni di configurazione di C# nella pagina delle librerie client e consulta la documentazione di riferimento di Cloud Translation per .NET.

PHP: segui le istruzioni di configurazione dei file PHP nella pagina delle librerie client e consulta la documentazione di riferimento di Cloud Translation per PHP.

Ruby: segui le istruzioni di configurazione di Ruby nella pagina delle librerie client e poi visita la documentazione di riferimento di Cloud Translation per Ruby.

Risorse aggiuntive