Creazione e utilizzo dei glossari (Advanced)

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

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

  • Nomi dei prodotti: ad esempio, "Google Home" deve essere tradotto "Google Home".
  • Parole ambigue: ad esempio, la parola "pesca" può indicare un'attività o un frutto. Se sai che stai traducendo parole relative alla frutta, potresti utilizzare un glossario per fornire all'API Cloud Translation la traduzione relativa alla frutta "pesca", non quella relativa all'attività.
  • Prestiti: ad esempio, "bouillabaisse" in francese rimane "bouillabaisse" in italiano. La lingua italiana ha preso in prestito la parola "bouillabaisse" dalla lingua francese nel XIX secolo. Un italofono che non conosce il contesto culturale francese potrebbe non sapere che la bouillabaisse è un piatto a base di stufato di pesce. I glossari possono sostituire una traduzione in modo che "bouillabaisse" in francese venga tradotto come "zuppa di pesce" in italiano.

Prima di iniziare

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

Autorizzazioni obbligatorie

Per lavorare con i glossari, il service account deve avere autorizzazioni specifiche per i glossari. Puoi concedere un ruolo al tuo service account utilizzando uno dei ruoli IAM predefiniti, ad esempio Cloud Translation API Editor (roles/cloudtranslate.editor), oppure puoi creare un ruolo personalizzato che conceda le autorizzazioni necessarie. Per visualizzare tutte le autorizzazioni dell'API Cloud Translation, consulta Riferimento per ruoli e autorizzazioni IAM. Le autorizzazioni Cloud Translation iniziano con cloudtranslate.

Per creare glossari, devi disporre anche delle autorizzazioni necessarie per leggere gli oggetti nel bucket Cloud Storage in cui si trova il file del glossario. Puoi concedere un ruolo al tuo service account utilizzando uno dei ruoli IAM predefiniti, ad esempio Storage Object Viewer (roles/storage.objectViewer), oppure puoi creare un ruolo personalizzato che conceda le autorizzazioni necessarie per leggere gli 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 di un glossario possono essere singoli token (parole) o brevi frasi (in genere meno di cinque parole). Questi sono i passaggi principali da eseguire per utilizzare un glossario:

  1. Crea un file di glossario
  2. Crea la risorsa di glossario con l'API Cloud Translation di Google
  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ù.

Parole non significative

Cloud Translation ignora alcuni termini inclusi in un glossario; questi termini sono noti come parole non significative. Quando traduce le parole non significative, Cloud Translation ignora le voci di glossario corrispondenti. Per un elenco di tutte le parole non significative, consulta Parole non significative del glossario.

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 i glossari unidirezionali, che specificano la traduzione desiderata per una singola coppia di lingue di origine e di destinazione, sia gli insiemi di termini equivalenti, che identificano i termini equivalenti in più lingue.

Il numero totale di termini in un file di input di glossario non può superare i 10,4 milioni (10.485.760) di 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 che superano i 1024 byte vengono ignorati.

Per impostazione predefinita, le corrispondenze del glossario sono sensibili alle maiuscole. Quando applichi un glossario, puoi ignorare la distinzione tra maiuscole e minuscole per tutte le voci. Se hai un mix di termini sensibili alle maiuscole e di termini senza distinzione tra maiuscole e minuscole, utilizza il comportamento predefinito e, per i termini senza distinzione tra maiuscole e minuscole, includi entrambe le forme nel glossario.

Glossari unidirezionali

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

TSV e CSV

Per i valori delimitati da tabulazioni (TSV) e i valori separati da virgola (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 mostrato nell'esempio seguente:

Glossario unidirezionale

Translation Memory eXchange (TMX)

TMX (Translation Memory eXchange) è un formato XML standard per fornire traduzioni di termini con origine e 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 con formato corretto deve identificare la lingua di origine utilizzando l'attributo srclang, mentre ogni elemento <tuv> deve identificare la lingua del testo contenuto utilizzando l'attributo xml:lang. Per identificare le lingue di origine e di destinazione, utilizzi 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 elemento <tuv> che corrisponde alla lingua di origine e il primo che corrisponde alla lingua di destinazione, ignorando 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 estrae i tag di markup da un elemento <seg> prima di elaborarlo. Se un elemento <tuv> contiene più elementi <seg>, l'API Cloud Translation concatena i loro testi in un unico elemento separandoli con uno spazio.

Se il file contiene tag XML diversi da quelli riportati sopra, l'API Cloud Translation li ignora.

Se il file non è conforme al formato XML e TMX corretto, ad esempio se manca di un tag finale o di 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.

Insiemi di termini equivalenti (CSV)

Per gli insiemi di termini equivalenti, l'API Cloud Translation accetta solo file in formato CSV. Per definire insiemi di termini equivalenti, crea un file CSV a più colonne in cui ogni riga contiene 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 codice lingua ISO-639 o BCP-47. Puoi anche includere colonne facoltative per la parte del discorso (pos) e la descrizione (description). Attualmente l'algoritmo non utilizza le informazioni pos e i valori pos specifici non vengono convalidati.

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

Insieme di termini equivalenti

Crea una risorsa di glossario

Una volta identificati 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

Per creare un nuovo glossario, devi fornire un ID glossario (un nome di 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 che hai specificato.

Prima di utilizzare i dati della richiesta, apporta le sostituzioni seguenti:

  • 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: il nome del bucket in cui si trova il file del glossario
  • glossary-filename: il 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 di insiemi di termini equivalenti

Una volta identificati i termini del glossario nell'insieme di termini equivalenti, rendi il file del glossario disponibile per l'API Cloud Translation creando una risorsa di glossario.

REST

Prima di utilizzare i dati della richiesta, apporta le sostituzioni seguenti:

  • PROJECT_NUMBER_OR_ID: l'ID numerico o alfanumerico del tuo progetto Google Cloud
  • glossary-id: l'ID del glossario
  • bucket-name: il nome del bucket in cui si trova il file del glossario
  • glossary-filename: il 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 per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Translation Go.

Per eseguire l'autenticazione in Cloud Translation, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura 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 per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Translation Java.

Per eseguire l'autenticazione in Cloud Translation, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura 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 per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Translation Node.js.

Per eseguire l'autenticazione in Cloud Translation, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura 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 per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Translation Python.

Per eseguire l'autenticazione in Cloud Translation, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura 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, poi consulta la documentazione di riferimento di Cloud Translation per .NET.

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

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

Stato dell'operazione

La creazione di una risorsa di glossario è un'operazione a lunga esecuzione, quindi potrebbe essere necessario un periodo di tempo considerevole per completarla. Puoi eseguire il polling dello stato di questa operazione per vedere se è stata completata oppure puoi annullarla.

Per saperne di più, consulta Operazioni a lunga esecuzione.

Utilizza i glossari

Traduci testo con un glossario

In Cloud Translation - Advanced, devi specificare esplicitamente quale modello di traduzione utilizzare per tradurre il testo. I modelli LLM di traduzione, NMT e personalizzati possono essere chiamati in combinazione con il glossario, ma solo il modello LLM di traduzione supporta il più recente miglioramento della qualità con il glossario contestuale. Per applicare questa funzionalità, imposta BOOLEAN_CONTEXTUAL su TRUE. 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 i dati della richiesta, apporta le sostituzioni seguenti:

  • 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 sono senza distinzione tra maiuscole e minuscole. Per impostazione predefinita, questo valore è false.
  • BOOLEAN_CONTEXTUAL: Indica se il contesto viene preso in considerazione nella traduzione del glossario. 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,
    "contextual_translation_enabled": BOOLEAN_CONTEXTUAL
  }
}

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,
      "contextual_translation_enabled": BOOLEAN_CONTEXTUAL
    }
  },
  "translations": {
    "translatedText": "Доктор Ватсон, пожалуйста, откажитесь от своего мусора. Вы поделились нежелательной электронной почтой со мной. Давайте поговорим о спаме и важности рейтинга в конфиденциальном режиме.",
  }
}

Il campo translations contiene la traduzione automatica standard prima dell'applicazione del glossario, mentre il campo glossaryTranslations contiene la traduzione dopo l'applicazione del glossario. Se imposti il campo contextual_translation_enabled su true, la risposta conterrà solo il campo glossaryTranslations e non il campo translations.

Go

Prima di provare questo esempio, segui le istruzioni di configurazione di Go nella guida rapida di Cloud Translation per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Translation Go.

Per eseguire l'autenticazione in Cloud Translation, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura 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 per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Translation Java.

Per eseguire l'autenticazione in Cloud Translation, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura 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 per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Translation Node.js.

Per eseguire l'autenticazione in Cloud Translation, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura 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 per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Translation Python.

Per eseguire l'autenticazione in Cloud Translation, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura 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, poi consulta la documentazione di riferimento di Cloud Translation per .NET.

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

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

Traduzioni adattive con un glossario

Per utilizzare un glossario con una richiesta di traduzione adattiva, includi una configurazione del glossario nella richiesta.

REST

Prima di utilizzare i dati della richiesta, apporta le sostituzioni seguenti:

  • PROJECT_NUMBER_OR_ID: l'ID numerico o alfanumerico del tuo progetto Google Cloud .
  • LOCATION: la regione in cui si trova il set di dati di origine, ad esempio us-central1.
  • DATASET_NAME: il nome del set di dati che Cloud Translation utilizza per personalizzare le traduzioni, formattato come projects/PROJECT_ID/locations/LOCATION/adaptiveMtDatasets/DATASET_ID. Puoi ottenere i nomi dei set di dati elencando tutti i set di dati nel tuo progetto.
  • SOURCE_TEXT: il testo da tradurre.
  • (Facoltativo) MIME_TYPE: il formato del testo di origine, ad esempio text/html o text/plain. Per impostazione predefinita, il tipo MIME è impostato su text/plain.
  • GLOSSARY_ID: l'ID del glossario, ad esempio my-en-ru-glossary.
  • BOOLEAN (facoltativo): indica se le corrispondenze sono senza distinzione tra maiuscole e minuscole. Per impostazione predefinita, questo valore è false.
  • BOOLEAN_CONTEXTUAL (facoltativo): indica se considerare il contesto nella traduzione del glossario. Per impostazione predefinita, questo valore è false.

Metodo HTTP e URL: 

POST https://translation.googleapis.com/v3/projects/PROJECT_ID/locations/LOCATION:adaptiveMtTranslate

Corpo JSON della richiesta: 

{
  "dataset": "DATASET_NAME",
  "content": ["SOURCE_TEXT"],
  "mimeType": "MIME_TYPE",
  "glossaryConfig": {
    "glossary": "projects/project-number/locations/LOCATION/glossaries/GLOSSARY_ID",
    "ignoreCase": BOOLEAN,
    "contextual_translation_enabled": BOOLEAN_CONTEXTUAL
  }
}

Per inviare la richiesta, espandi una di queste opzioni:

Dovresti ricevere una risposta JSON simile alla seguente:

{
  "translations": [
    {
      "translatedText": "TRANSLATED_TEXT"
    }
  ],
  "languageCode": "TARGET_LANGUAGE",
  "glossaryTranslations": {
    "translatedText": "TRANSLATED_TEXT",
    "glossaryConfig": {
      "glossary": "projects/project-number/locations/LOCATION/glossaries/GLOSSARY_ID",
      "ignoreCase": BOOLEAN,
      "contextual_translation_enabled": BOOLEAN_CONTEXTUAL
    }
  },
}

Java

Prima di provare questo esempio, segui le istruzioni di configurazione di Java nella guida rapida di Cloud Translation per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Translation Java.

Per eseguire l'autenticazione in Cloud Translation, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale. 

  {% dynamic setvar launch_stage %}preview{% dynamic endsetvar %}
{% dynamic setvar launch_type %}feature{% dynamic endsetvar %}
{% include "cloud/_shared/_info_launch_stage_disclaimer.html" %}

/** Translates using AdaptiveMt. */
private static void adaptiveMtTranslate(
    TranslationServiceClient translationServiceClient, String projectId, String datasetId) {
  String adaptiveMtDatasetName =
      String.format(
          "projects/%s/locations/LOCATION/adaptiveMtDatasets/%s", projectId, datasetId);
  String glossaryId = "your-glossary-display-name";
  GlossaryName glossaryName = GlossaryName.of(projectId, location, glossaryId);
  GlossaryConfig glossaryConfig =
      GlossaryConfig.newBuilder().setGlossary(glossaryName.toString()).build();

  AdaptiveMtTranslateRequest request =
      AdaptiveMtTranslateRequest.newBuilder()
          .setParent(LocationName.of(projectId, "us-central1").toString())
          .setDataset(adaptiveMtDatasetName)
          .addContent("Sample translation text")
          .setGlossaryConfig(glossaryConfig)
          .build();
  AdaptiveMtTranslateResponse response = translationServiceClient.adaptiveMtTranslate(request);

  System.out.println("Translating using AdaptiveMt");
  System.out.println(response);
}

Node.js

Prima di provare questo esempio, segui le istruzioni di configurazione di Node.js nella guida rapida di Cloud Translation per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Translation Node.js.

Per eseguire l'autenticazione in Cloud Translation, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale. 

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

  const glossaryConfig = {
    glossary: `projects/${projectId}/locations/${location}/glossaries/${glossaryId}`,
  };
  const request = {
    parent: `projects/${projectId}/locations/${location}`,
    dataset: `projects/${projectId}/locations/${location}/adaptiveMtDatasets/${
        adaptiveMtDatasetName}`,
    content: ['Sample translate query'],
    glossaryConfig: glossaryConfig,
  } const [response] = await translationClient.adaptiveMtTranslate(request)
  console.log('Translating')
  console.log(response)
}

Python

Prima di provare questo esempio, segui le istruzioni di configurazione di Python nella guida rapida di Cloud Translation per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Translation Python.

Per eseguire l'autenticazione in Cloud Translation, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale. 

  def adaptive_mt_translate(
    project_id: str = "YOUR_PROJECT_ID",
    glossary_id: str = "YOUR_GLOSSARY_ID"):
    # Create a client
    client = translate.TranslationServiceClient()
    # Create a glossary
    glossary = client.glossary_path(
        project_id, "us-central1", glossary_id  # The location of the glossary
    )

    glossary_config = translate.GlossaryConfig(glossary=glossary)
    # Initialize the request
    request = translate.AdaptiveMtTranslateRequest(
        parent="projects/PROJECT_ID/locations/LOCATION",
        dataset="projects/PROJECT_ID/locations/LOCATION/adaptiveMtDatasets/DATASET_ID",
        content=["Sample translation request"]
        glossary_config=glossary_config,
    )
    # Make the request
    response = client.adaptive_mt_translate(request)
    # Handle the response
    print(response)

Recupera informazioni su un glossario

REST

Prima di utilizzare i dati della richiesta, apporta le sostituzioni seguenti:

  • 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 per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Translation Go.

Per eseguire l'autenticazione in Cloud Translation, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura 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 per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Translation Java.

Per eseguire l'autenticazione in Cloud Translation, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura 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 per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Translation Node.js.

Per eseguire l'autenticazione in Cloud Translation, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura 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 per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Translation Python.

Per eseguire l'autenticazione in Cloud Translation, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura 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, poi consulta la documentazione di riferimento di Cloud Translation per .NET.

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

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

Recupera un elenco dei glossari

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

REST

Questo esempio elenca tutti i glossari associati al progetto specificato.

Prima di utilizzare i dati della richiesta, apporta le sostituzioni seguenti:

  • 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 per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Translation Go.

Per eseguire l'autenticazione in Cloud Translation, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura 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 per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Translation Java.

Per eseguire l'autenticazione in Cloud Translation, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura 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 per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Translation Node.js.

Per eseguire l'autenticazione in Cloud Translation, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura 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 per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Translation Python.

Per eseguire l'autenticazione in Cloud Translation, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura 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, poi consulta la documentazione di riferimento di Cloud Translation per .NET.

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

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

Aggiorna un glossario

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

REST

Per aggiornare un glossario, invia una richiesta PATCH con il metodo glossary.patch. L'esempio seguente aggiorna un glossario di insiemi di termini equivalenti. Utilizza il metodo list per trovare l'ID di un glossario specifico.

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

Prima di utilizzare i dati della richiesta, apporta le sostituzioni seguenti:

  • 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 le lingue di questo glossario di insiemi di termini equivalenti.
  • GLOSSARY_FILE_PATH: il percorso e il nome file 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, poi consulta la documentazione di riferimento di Cloud Translation per .NET.

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

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

Elimina un glossario

L'esempio seguente elimina un glossario.

REST

Prima di utilizzare i dati della richiesta, apporta le sostituzioni seguenti:

  • 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 per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Translation Go.

Per eseguire l'autenticazione in Cloud Translation, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura 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 per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Translation Java.

Per eseguire l'autenticazione in Cloud Translation, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura 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 per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Translation Node.js.

Per eseguire l'autenticazione in Cloud Translation, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura 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 per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Translation Python.

Per eseguire l'autenticazione in Cloud Translation, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura 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, poi consulta la documentazione di riferimento di Cloud Translation per .NET.

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

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

Gestisci le 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 voci esistenti.

Crea nuove voci

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

REST

Gli esempi seguenti creano una voce per un glossario di insiemi di termini equivalenti. Puoi creare una sola voce per richiesta. Per saperne di più, consulta il metodo glossaryEntries.create.

Prima di utilizzare i dati della richiesta, apporta le sostituzioni seguenti:

  • 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 di 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, poi consulta la documentazione di riferimento di Cloud Translation per .NET.

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

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

Elenca le voci di glossario

Puoi elencare tutte le voci di un glossario esistente. Questa operazione è utile, ad esempio, se vuoi controllare quali termini e quali lingue sono presenti in un glossario specifico.

REST

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

Prima di utilizzare i dati della richiesta, apporta le sostituzioni seguenti:

  • 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, poi consulta la documentazione di riferimento di Cloud Translation per .NET.

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

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

Recupera una voce di glossario

Puoi recuperare una singola voce per visualizzarne le informazioni.

REST

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

Prima di utilizzare i dati della richiesta, apporta le sostituzioni seguenti:

  • 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, poi consulta la documentazione di riferimento di Cloud Translation per .NET.

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

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

Aggiorna le voci di glossario

Puoi aggiornare una singola voce o sostituire tutte le voci di un glossario. Per sostituire tutte le voci, consulta Aggiorna 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 insiemi di termini equivalenti, fornisci un insieme di termini, in cui ogni elemento dell'insieme specifica un termine e il relativo codice lingua.

REST

Gli esempi seguenti aggiornano una voce per un glossario di insiemi di termini equivalenti. Per saperne di più, consulta il metodo glossaryEntries.patch.

Prima di utilizzare i dati della richiesta, apporta le sostituzioni seguenti:

  • 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 che contiene 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 di 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, poi consulta la documentazione di riferimento di Cloud Translation per .NET.

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

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

Elimina una voce di glossario

Puoi 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 voce specifica.

Prima di utilizzare i dati della richiesta, apporta le sostituzioni seguenti:

  • 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 che contiene 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, poi consulta la documentazione di riferimento di Cloud Translation per .NET.

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

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

Risorse aggiuntive