Glossare erstellen und verwenden (Advanced)

Ein Glossar ist ein benutzerdefiniertes Wörterbuch, mit dem die Cloud Translation API die fachspezifische Terminologie des Kunden konsistent übersetzt. Dazu muss normalerweise angegeben werden, wie eine benannte Entität zu übersetzen ist.

Für folgende Anwendungsfälle können Sie ein Glossar verwenden:

  • Produktnamen: "Google Home" bleibt beispielsweise unverändert "Google Home".
  • Mehrdeutige Wörter: Das Wort englische "bat" kann beispielsweise für ein Sportgerät oder ein Tier stehen. Wenn Sie wissen, dass Sie Wörter zum Thema Gebäck übersetzen, können Sie ein Glossar in der Cloud Translation API verwenden, damit die richtige Übersetzung und nicht die für das Tier verwendet werden.
  • Lehnwörter: Das Wort "bouillabaisse" auf Französisch heißt auch auf Englisch "bouillabaisse". Im 19. Jahrhundert wurde im Englischen das Wort "bouillabaisse" vom Französischen übernommen. Ein Deutscher, dem der kulturelle Kontext Frankreichs fehlt, weiß vielleicht nicht, dass Bouillabaisse ein Fischeintopf ist. Glossare können eine Übersetzung überschreiben, sodass das französische "bouillabaisse" zum englischen "fish stew" (Fischsuppe) übersetzt wird.

Hinweis

Für die Verwendung der Cloud Translation API benötigen Sie ein Projekt, für das die Cloud Translation API aktiviert ist. Außerdem benötigen Sie die entsprechenden Anmeldedaten. Sie können auch Clientbibliotheken für gängige Programmiersprachen installieren, um Aufrufe an die API zu ermöglichen. Weitere Informationen dazu finden Sie auf der Seite Einrichtung.

Erforderliche Berechtigungen

Damit Sie mit Glossaren arbeiten können, benötigt Ihr Dienstkonto glossarspezifische Berechtigungen. Sie können Ihrem Dienstkonto eine Rolle zuweisen, indem Sie eine der vordefinierten IAM-Rollen wie Cloud Translation API-Bearbeiter (roles/cloudtranslate.editor) verwenden oder Erstellen Sie eine benutzerdefinierte Rolle, die die erforderlichen Berechtigungen erteilt. Sie finden alle Cloud Translation API-Berechtigungen in der Referenz für IAM-Berechtigungen. Cloud Translation-Berechtigungen beginnen mit cloudtranslate.

Zum Erstellen von Glossaren benötigen Sie auch Berechtigungen zum Lesen von Objekten im Cloud Storage-Bucket, in dem sich Ihre Glossardatei befindet. Sie können Ihrem Dienstkonto eine Rolle mit einer vordefinierten IAM-Rolle zuweisen, z. B. Storage-Objekt-Betrachter (roles/storage.objectViewer) oder kann eine benutzerdefinierte Rolle erstellen, die Berechtigungen zum Lesen von Objekten gewährt.

Informationen zum Hinzufügen eines Kontos zu einer Rolle finden Sie unter Zugriff auf Ressourcen erteilen, ändern und entziehen.

Glossar erstellen

Bei den Begriffen in einem Glossar kann es sich um einzelne Tokens (Wörter) oder um kurze Phrasen (in der Regel weniger als fünf Wörter) handeln. Wenn Sie ein Glossar einsetzen wollen, müssen Sie die folgenden Schritte ausführen:

  1. Glossardatei erstellen
  2. Glossarressource mit unserer Cloud Translation API erstellen
  3. Glossar angeben, das bei einer Übersetzungsanfrage verwendet werden soll

Für ein Projekt sind mehrere Glossare möglich. Sie können eine Liste der verfügbaren Glossare abrufen und nicht mehr benötigte Glossare löschen.

Stoppwörter

Einige Begriffe, die in einem Glossar enthalten sind, werden von Cloud Translation ignoriert. Diese Begriffe werden als Stoppwörter bezeichnet. Cloud Translation ignoriert beim Übersetzen von Stoppwörtern alle übereinstimmenden Glossareinträge. Eine Liste aller Stoppwörter finden Sie unter Glossar-Stoppwörter.

Glossardatei erstellen

Grundsätzlich ist ein Glossar eine Textdatei, in der die einzelnen Zeilen die entsprechenden Begriffe in mehreren Sprachen enthalten. Die Cloud Translation API unterstützt zwei Arten von Glossaren: Unidirektionale Glossare legen die gewünschte Übersetzung für ein einzelnes Sprachpaar aus Quell- und Zielsprache fest und Glossare mit Sets äquivalenter Begriffe legen Übersetzungen für mehrere Sprachen fest.

Die Gesamtzahl der Begriffe in der Eingabedatei eines Glossars darf 10,4 Millionen (10.485.760) UTF-8-Byte für alle Begriffe in allen Sprachen zusammen nicht überschreiten. Jeder einzelne Glossarbegriff muss kleiner als 1.024 UTF-8-Byte sein. Begriffe, die länger als 1.024 Byte sind, werden ignoriert.

Bei Glossarübereinstimmungen wird standardmäßig zwischen Groß- und Kleinschreibung unterschieden. Wenn Sie ein Glossar anwenden, können Sie die Groß-/Kleinschreibung für alle Einträge ignorieren. Wenn Sie eine Kombination aus Begriffen berücksichtigen, bei denen die Groß- und Kleinschreibung berücksichtigt wird, verwenden Sie das Standardverhalten und fügen Sie für Glossare beide Begriffe in Ihr Glossar ein.

Unidirektionale Glossare

Die Cloud Translation API akzeptiert TSV-, CSV- oder TMX-Dateien.

TSV und CSV

Bei tabulatorgetrennten Werten (TSV) und kommagetrennten Werten (CSV) enthält jede Zeile ein Paar von Begriffen, die durch einen Tabulator (\t) oder ein Komma (,) getrennt sind. Die erste Spalte enthält den Begriff in der Ausgangssprache und die zweite Spalte den Begriff in der Zielsprache, wie im folgenden Beispiel gezeigt:

Unidirektionales Glossar

Translation Memory eXchange (TMX)

Translation Memory eXchange (TMX) ist ein XML-Standardformat zur Bereitstellung des Quell- und des Zieltexts von Übersetzungen. Die Cloud Translation API unterstützt Eingabedateien in einem Format, das auf der TMX-Version 1.4 beruht. Das folgende Beispiel veranschaulicht die erforderliche Struktur:

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

Das <header>-Element einer korrekt formatierten TMX-Datei muss mit dem srclang-Attribut die Ausgangssprache angeben und jedes <tuv>-Element muss mithilfe des Attributs xml:lang die Sprache des enthaltenen Texts angeben. Die Quell- und die Zielsprache wird mit dem jeweiligen ISO-639-Code angegeben.

Alle <tu>-Elemente müssen ein Paar von <tuv>-Elementen mit derselben Quell- und Zielsprache enthalten. Wenn ein <tu>-Element mehr als zwei <tuv>-Elemente enthält, verarbeitet die Cloud Translation API jeweils nur das erste <tuv>-Element, das mit der Ausgangs- und der Zielsprache übereinstimmt, und ignoriert den Rest. Wenn ein <tu>-Element kein übereinstimmendes <tuv>-Elementpaar hat, überspringt die Cloud Translation API das ungültige <tu>-Element.

Die Cloud Translation API entfernt vor der Verarbeitung eines <seg>-Elements die Markup-Tags um das Element. Wenn ein <tuv>-Element mehr als ein <seg>-Element enthält, verkettet die Cloud Translation API den Text zu einem einzelnen Element mit einem Leerzeichen zwischen den Elementen.

Wenn die Datei andere als die oben dargestellten XML-Tags enthält, werden sie von der Cloud Translation API ignoriert.

Wenn die Datei nicht dem richtigen XML- und TMX-Format entspricht, z. B. wenn ein End-Tag oder ein <tmx>-Element fehlt, bricht die Cloud Translation API die Verarbeitung ab. Die Cloud Translation API bricht die Verarbeitung auch ab, wenn mehr als 1.024 ungültige <tu>-Elemente übersprungen werden.

Sets äquivalenter Begriffe (CSV)

Für entsprechende Sets äquivalenter Begriffe akzeptiert die Cloud Translation API nur Dateien im CSV-Format. Zur Definition von Glossaren mit Sets äquivalenter Begriffe erstellen Sie eine mehrspaltige CSV-Datei und geben pro Zeile jeweils einen einzelnen Glossarbegriff in mehreren Sprachen an.

Die erste Zeile der Datei ist eine Kopfzeile, in der die Sprache der jeweiligen Spalte im entsprechenden Sprachcode (ISO-639 oder BCP-47) angegeben ist. Sie können auch optionale Spalten für die Wortart (pos) und eine Beschreibung (description) einfügen. Der Algorithmus verwendet derzeit keine pos-Informationen und bestimmte pos-Werte werden nicht validiert.

In den darauffolgenden Zeilen stehen dann in den einzelnen Spalten die äquivalenten Glossarbegriffe in den Sprachen, die laut Kopfzeile vorgesehen sind. Sie können eine Spalte leer lassen, wenn der Begriff in der betreffenden Sprache nicht verfügbar ist.

Set äquivalenter Begriffe

Glossarressource erstellen

Sobald Sie die entsprechenden Glossarbegriffe gefunden haben, stellen Sie die Glossardatei für die Cloud Translation API zur Verfügung, indem Sie eine Glossarressource erstellen.

Unidirektionales Glossar

Beim Erstellen eines unidirektionalen Glossars müssen Sie das Sprachpaar (language_pair) dadurch angeben, dass Sie die Ausgangssprache (source_language_code) und die Zielsprache (target_language_code) festlegen. Im folgenden Beispiel werden die REST API und die Befehlszeile verwendet. Sie können jedoch auch die Clientbibliotheken verwenden, um ein unidirektionales Glossar zu erstellen.

REST

Wenn Sie ein neues Glossar erstellen, geben Sie eine Glossar-ID als Ressourcennamen an. Beispiel:
projects/my-project/locations/us-central1/glossaries/my-en-to-ru-glossary
Dabei ist my-project die "project-number-or-id" und my-en-ru-glossary die "glossary-id", die Sie bereitgestellt haben.

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

  • PROJECT_NUMBER_OR_ID: Die numerische oder alphanumerische ID Ihres Google Cloud-Projekts
  • glossary-id: Ihre Glossar-ID, zum Beispiel., my_en_ru_glossary
  • bucket-name: Name des Buckets, in dem sich die Glossardatei befindet
  • glossary-filename: Dateiname Ihres Glossars

HTTP-Methode und URL:

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

JSON-Text anfordern:

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

Wenn Sie die Anfrage senden möchten, maximieren Sie eine der folgenden Optionen:

Sie sollten eine JSON-Antwort ähnlich wie diese erhalten:

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

Glossare mit Sets äquivalenter Begriffe

Nachdem Sie die äquivalenten Glossarbegriffe festgelegt haben, können Sie die Glossardatei für die Cloud Translation API verfügbar machen. Erstellen Sie dazu eine Glossarressource.

REST

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

  • PROJECT_NUMBER_OR_ID: Die numerische oder alphanumerische ID Ihres Google Cloud-Projekts
  • glossary-id: Ihre Glossar-ID
  • bucket-name: Name des Buckets, in dem sich die Glossardatei befindet
  • glossary-filename: Dateiname Ihres Glossars

HTTP-Methode und URL:

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

JSON-Text anfordern:

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

Wenn Sie die Anfrage senden möchten, maximieren Sie eine der folgenden Optionen:

Sie sollten eine JSON-Antwort ähnlich wie diese erhalten:

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

Folgen Sie der Einrichtungsanleitung für Go in der Cloud Translation-Kurzanleitung zur Verwendung von Clientbibliotheken, bevor Sie dieses Beispiel anwenden. Weitere Informationen finden Sie in der Referenzdokumentation zu Cloud Translation Go API.

Richten Sie zur Authentifizierung bei Cloud Translation Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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

Folgen Sie der Einrichtungsanleitung für Java in der Cloud Translation-Kurzanleitung zur Verwendung von Clientbibliotheken, bevor Sie dieses Beispiel anwenden. Weitere Informationen finden Sie in der Referenzdokumentation zu Cloud Translation Java API.

Richten Sie zur Authentifizierung bei Cloud Translation Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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

Folgen Sie der Einrichtungsanleitung für Node.js in der Cloud Translation-Kurzanleitung zur Verwendung von Clientbibliotheken, bevor Sie dieses Beispiel anwenden. Weitere Informationen finden Sie in der Referenzdokumentation zu Cloud Translation Node.js API.

Richten Sie zur Authentifizierung bei Cloud Translation Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

/**
 * 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

Folgen Sie der Einrichtungsanleitung für Python in der Cloud Translation-Kurzanleitung zur Verwendung von Clientbibliotheken, bevor Sie dieses Beispiel anwenden. Weitere Informationen finden Sie in der Referenzdokumentation zu Cloud Translation Python API.

Richten Sie zur Authentifizierung bei Cloud Translation Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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

Weitere Sprachen

C#: Folgen Sie der Anleitung zur Einrichtung von C# auf der Seite der Clientbibliotheken und rufen Sie dann die Cloud Translation-Referenzdokumentation für .NET auf.

PHP: Folgen Sie der Anleitung zur Einrichtung von PHP auf der Seite der Clientbibliotheken und rufen Sie dann die Cloud Translation-Referenzdokumentation für PHP auf.

Ruby: Folgen Sie der Anleitung zur Einrichtung von Ruby auf der Seite der Clientbibliotheken und rufen Sie dann die Cloud Translation-Referenzdokumentation für Ruby auf.

Vorgangsstatus

Das Erstellen einer Glossarressource ist ein langwieriger Vorgang, der viel Zeit in Anspruch nehmen kann. Sie können den Status dieses Vorgangs abrufen, um festzustellen, ob er abgeschlossen wurde. Sie haben aber auch die Möglichkeit, ihn abzubrechen.

Weitere Informationen finden Sie unter Vorgänge mit langer Laufzeit.

Glossare verwenden

Text mit einem Glossar übersetzen

In Cloud Translation – Advanced legen Sie explizit fest, welches Übersetzungsmodell für die Übersetzung des Texts verwendet werden soll. Sie können außerdem ein Glossar angeben, das für die fachspezifische Terminologie verwendet werden soll.

REST

In diesem Beispiel wird Text mit dem NMÜ-Standardmodell und einem Glossar übersetzt.

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

  • PROJECT_NUMBER_OR_ID: Die numerische oder alphanumerische ID Ihres Google Cloud-Projekts.
  • glossary-id: Ihre Glossar-ID, z. B. my-en-ru-glossary.
  • BOOLEAN: Gibt an, ob bei Übereinstimmungen zwischen Groß- und Kleinschreibung unterschieden wird. Standardmäßig ist dieser Wert false.

HTTP-Methode und URL:

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

JSON-Text anfordern:

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

Wenn Sie die Anfrage senden möchten, maximieren Sie eine der folgenden Optionen:

Sie sollten eine JSON-Antwort ähnlich wie diese erhalten:

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

Das Feld translations enthält die reguläre maschinelle Übersetzung ohne angewendetes Glossar. Das Feld glossaryTranslations enthält die Übersetzung, nachdem das Glossar angewendet wurde.

Go

Folgen Sie der Einrichtungsanleitung für Go in der Cloud Translation-Kurzanleitung zur Verwendung von Clientbibliotheken, bevor Sie dieses Beispiel anwenden. Weitere Informationen finden Sie in der Referenzdokumentation zu Cloud Translation Go API.

Richten Sie zur Authentifizierung bei Cloud Translation Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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

Folgen Sie der Einrichtungsanleitung für Java in der Cloud Translation-Kurzanleitung zur Verwendung von Clientbibliotheken, bevor Sie dieses Beispiel anwenden. Weitere Informationen finden Sie in der Referenzdokumentation zu Cloud Translation Java API.

Richten Sie zur Authentifizierung bei Cloud Translation Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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

Folgen Sie der Einrichtungsanleitung für Node.js in der Cloud Translation-Kurzanleitung zur Verwendung von Clientbibliotheken, bevor Sie dieses Beispiel anwenden. Weitere Informationen finden Sie in der Referenzdokumentation zu Cloud Translation Node.js API.

Richten Sie zur Authentifizierung bei Cloud Translation Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

/**
 * 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

Folgen Sie der Einrichtungsanleitung für Python in der Cloud Translation-Kurzanleitung zur Verwendung von Clientbibliotheken, bevor Sie dieses Beispiel anwenden. Weitere Informationen finden Sie in der Referenzdokumentation zu Cloud Translation Python API.

Richten Sie zur Authentifizierung bei Cloud Translation Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.


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

Weitere Sprachen

C#: Folgen Sie der Anleitung zur Einrichtung von C# auf der Seite der Clientbibliotheken und rufen Sie dann die Cloud Translation-Referenzdokumentation für .NET auf.

PHP: Folgen Sie der Anleitung zur Einrichtung von PHP auf der Seite der Clientbibliotheken und rufen Sie dann die Cloud Translation-Referenzdokumentation für PHP auf.

Ruby: Folgen Sie der Anleitung zur Einrichtung von Ruby auf der Seite der Clientbibliotheken und rufen Sie dann die Cloud Translation-Referenzdokumentation für Ruby auf.

Informationen zu einem Glossar abrufen

REST

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

  • PROJECT_NUMBER_OR_ID: Die numerische oder alphanumerische ID Ihres Google Cloud-Projekts
  • glossary-id: Ihre Glossar-ID, z. B. "my-en-to-ru-glossary"

HTTP-Methode und URL:

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

Wenn Sie die Anfrage senden möchten, maximieren Sie eine der folgenden Optionen:

Sie sollten eine JSON-Antwort ähnlich wie diese erhalten:

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

Folgen Sie der Einrichtungsanleitung für Go in der Cloud Translation-Kurzanleitung zur Verwendung von Clientbibliotheken, bevor Sie dieses Beispiel anwenden. Weitere Informationen finden Sie in der Referenzdokumentation zu Cloud Translation Go API.

Richten Sie zur Authentifizierung bei Cloud Translation Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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

Folgen Sie der Einrichtungsanleitung für Java in der Cloud Translation-Kurzanleitung zur Verwendung von Clientbibliotheken, bevor Sie dieses Beispiel anwenden. Weitere Informationen finden Sie in der Referenzdokumentation zu Cloud Translation Java API.

Richten Sie zur Authentifizierung bei Cloud Translation Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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

Folgen Sie der Einrichtungsanleitung für Node.js in der Cloud Translation-Kurzanleitung zur Verwendung von Clientbibliotheken, bevor Sie dieses Beispiel anwenden. Weitere Informationen finden Sie in der Referenzdokumentation zu Cloud Translation Node.js API.

Richten Sie zur Authentifizierung bei Cloud Translation Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

/**
 * 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

Folgen Sie der Einrichtungsanleitung für Python in der Cloud Translation-Kurzanleitung zur Verwendung von Clientbibliotheken, bevor Sie dieses Beispiel anwenden. Weitere Informationen finden Sie in der Referenzdokumentation zu Cloud Translation Python API.

Richten Sie zur Authentifizierung bei Cloud Translation Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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

Weitere Sprachen

C#: Folgen Sie der Anleitung zur Einrichtung von C# auf der Seite der Clientbibliotheken und rufen Sie dann die Cloud Translation-Referenzdokumentation für .NET auf.

PHP: Folgen Sie der Anleitung zur Einrichtung von PHP auf der Seite der Clientbibliotheken und rufen Sie dann die Cloud Translation-Referenzdokumentation für PHP auf.

Ruby: Folgen Sie der Anleitung zur Einrichtung von Ruby auf der Seite der Clientbibliotheken und rufen Sie dann die Cloud Translation-Referenzdokumentation für Ruby auf.

Glossare auflisten

Ein Projekt kann mehrere Glossare enthalten. In diesem Abschnitt wird beschrieben, wie Sie eine Liste der verfügbaren Glossare für ein bestimmtes Projekt abrufen.

REST

In diesem Beispiel werden alle Glossare aufgelistet, die dem angegebenen Projekt zugeordnet sind.

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

  • PROJECT_NUMBER_OR_ID: Die numerische oder alphanumerische ID Ihres Google Cloud-Projekts

HTTP-Methode und URL:

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

Wenn Sie die Anfrage senden möchten, maximieren Sie eine der folgenden Optionen:

Sie sollten eine JSON-Antwort ähnlich wie diese erhalten:

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

Folgen Sie der Einrichtungsanleitung für Go in der Cloud Translation-Kurzanleitung zur Verwendung von Clientbibliotheken, bevor Sie dieses Beispiel anwenden. Weitere Informationen finden Sie in der Referenzdokumentation zu Cloud Translation Go API.

Richten Sie zur Authentifizierung bei Cloud Translation Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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

Folgen Sie der Einrichtungsanleitung für Java in der Cloud Translation-Kurzanleitung zur Verwendung von Clientbibliotheken, bevor Sie dieses Beispiel anwenden. Weitere Informationen finden Sie in der Referenzdokumentation zu Cloud Translation Java API.

Richten Sie zur Authentifizierung bei Cloud Translation Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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

Folgen Sie der Einrichtungsanleitung für Node.js in der Cloud Translation-Kurzanleitung zur Verwendung von Clientbibliotheken, bevor Sie dieses Beispiel anwenden. Weitere Informationen finden Sie in der Referenzdokumentation zu Cloud Translation Node.js API.

Richten Sie zur Authentifizierung bei Cloud Translation Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

/**
 * 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

Folgen Sie der Einrichtungsanleitung für Python in der Cloud Translation-Kurzanleitung zur Verwendung von Clientbibliotheken, bevor Sie dieses Beispiel anwenden. Weitere Informationen finden Sie in der Referenzdokumentation zu Cloud Translation Python API.

Richten Sie zur Authentifizierung bei Cloud Translation Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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

Weitere Sprachen

C#: Folgen Sie der Anleitung zur Einrichtung von C# auf der Seite der Clientbibliotheken und rufen Sie dann die Cloud Translation-Referenzdokumentation für .NET auf.

PHP: Folgen Sie der Anleitung zur Einrichtung von PHP auf der Seite der Clientbibliotheken und rufen Sie dann die Cloud Translation-Referenzdokumentation für PHP auf.

Ruby: Folgen Sie der Anleitung zur Einrichtung von Ruby auf der Seite der Clientbibliotheken und rufen Sie dann die Cloud Translation-Referenzdokumentation für Ruby auf.

Glossar aktualisieren

Sie können ein Glossar aktualisieren, um seinen Namen zu ändern, oder alle Einträge durch eine neue Glossar-Eingabedatei ersetzen. Wenn Sie ein Rollback der Änderungen an den Glossareinträgen durchführen müssen, müssen Sie das ursprüngliche Glossar durch die ursprüngliche Glossardatei ersetzen.

REST

Senden Sie zum Aktualisieren eines Glossars eine PATCH-Anfrage mit der Methode glossary.patch. Im folgenden Beispiel wird ein Glossar mit Sets äquivalenter Begriffe aktualisiert. Verwenden Sie die Auflistungsmethode, um die ID eines bestimmten Glossars zu ermitteln.

Der Abfrageparameter update_mask gibt an, ob Sie die Glossareingabedatei, den Anzeigenamen des Glossars oder beides aktualisieren müssen. Es ist mindestens ein Parameter für die Aktualisierungsmaske erforderlich.

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

  • PROJECT_NUMBER_OR_ID: Die numerische oder alphanumerische ID Ihres Google Cloud-Projekts.
  • LOCATION: Die Region, in der sich das zu aktualisierende Glossar befindet, z. B. us-central1.
  • GLOSSARY_ID: Die ID eines vorhandenen Glossars.
  • LANGUAGE_CODE: Der Sprachcode, der die Sprachen für dieses Glossar mit Sets äquivalenter Begriffe angibt.
  • GLOSSARY_FILE_PATH: Der Speicherort und der Dateiname Ihrer Glossar-Eingabedatei.

HTTP-Methode und 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

JSON-Text anfordern:

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

Wenn Sie die Anfrage senden möchten, maximieren Sie eine der folgenden Optionen:

Sie sollten eine JSON-Antwort ähnlich wie diese erhalten:

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

Weitere Sprachen

C#: Folgen Sie der Anleitung zur Einrichtung von C# auf der Seite der Clientbibliotheken und rufen Sie dann die Cloud Translation-Referenzdokumentation für .NET auf.

PHP: Folgen Sie der Anleitung zur Einrichtung von PHP auf der Seite der Clientbibliotheken und rufen Sie dann die Cloud Translation-Referenzdokumentation für PHP auf.

Ruby: Folgen Sie der Anleitung zur Einrichtung von Ruby auf der Seite der Clientbibliotheken und rufen Sie dann die Cloud Translation-Referenzdokumentation für Ruby auf.

Glossar löschen

In diesem Beispiel wird ein Glossar gelöscht.

REST

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

  • PROJECT_NUMBER_OR_ID: Die numerische oder alphanumerische ID Ihres Google Cloud-Projekts
  • glossary-id: Ihre Glossar-ID

HTTP-Methode und URL:

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

Wenn Sie die Anfrage senden möchten, maximieren Sie eine der folgenden Optionen:

Sie sollten einen erfolgreichen Statuscode (2xx) und eine leere Antwort als Ausgabe erhalten.

Go

Folgen Sie der Einrichtungsanleitung für Go in der Cloud Translation-Kurzanleitung zur Verwendung von Clientbibliotheken, bevor Sie dieses Beispiel anwenden. Weitere Informationen finden Sie in der Referenzdokumentation zu Cloud Translation Go API.

Richten Sie zur Authentifizierung bei Cloud Translation Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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

Folgen Sie der Einrichtungsanleitung für Java in der Cloud Translation-Kurzanleitung zur Verwendung von Clientbibliotheken, bevor Sie dieses Beispiel anwenden. Weitere Informationen finden Sie in der Referenzdokumentation zu Cloud Translation Java API.

Richten Sie zur Authentifizierung bei Cloud Translation Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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

Folgen Sie der Einrichtungsanleitung für Node.js in der Cloud Translation-Kurzanleitung zur Verwendung von Clientbibliotheken, bevor Sie dieses Beispiel anwenden. Weitere Informationen finden Sie in der Referenzdokumentation zu Cloud Translation Node.js API.

Richten Sie zur Authentifizierung bei Cloud Translation Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

/**
 * 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

Folgen Sie der Einrichtungsanleitung für Python in der Cloud Translation-Kurzanleitung zur Verwendung von Clientbibliotheken, bevor Sie dieses Beispiel anwenden. Weitere Informationen finden Sie in der Referenzdokumentation zu Cloud Translation Python API.

Richten Sie zur Authentifizierung bei Cloud Translation Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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

Weitere Sprachen

C#: Folgen Sie der Anleitung zur Einrichtung von C# auf der Seite der Clientbibliotheken und rufen Sie dann die Cloud Translation-Referenzdokumentation für .NET auf.

PHP: Folgen Sie der Anleitung zur Einrichtung von PHP auf der Seite der Clientbibliotheken und rufen Sie dann die Cloud Translation-Referenzdokumentation für PHP auf.

Ruby: Folgen Sie der Anleitung zur Einrichtung von Ruby auf der Seite der Clientbibliotheken und rufen Sie dann die Cloud Translation-Referenzdokumentation für Ruby auf.

Glossareinträge verwalten

In einem Glossareintrag wird ein Begriff in einer Sprache einem Begriff in einer anderen Sprache zugeordnet. Sie können einem Glossar neue Einträge hinzufügen, alle Einträge für ein vorhandenes Glossar auflisten oder vorhandene Einträge ändern.

Neue Einträge erstellen

Erstellen Sie neue Einträge, um Begriffe zu einem vorhandenen Glossar hinzuzufügen. Geben Sie für unidirektionale Glossare ein Begriffspaar an, wobei ein Begriff in der Ausgangssprache und der andere in der Zielsprache vorliegt. Stellen Sie für Glossare mit Sets äquivalenter Begriffe ein Seit mit Begriffen bereit, wobei jedes Element im Set einen Begriff und seinen Sprachcode angibt.

REST

In den folgenden Beispielen wird ein Eintrag für ein Glossar mit Sets äquivalenter Begriffe erstellt. Sie können nur einen Eintrag pro Anfrage erstellen. Weitere Informationen finden Sie unter der Methode glossaryEntries.create.

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

  • PROJECT_NUMBER_OR_ID: Die numerische oder alphanumerische ID Ihres Google Cloud-Projekts.
  • LOCATION: Die Region, in der sich das zu aktualisierende Glossar befindet, z. B. us-central1.
  • GLOSSARY_ID: Die ID eines vorhandenen Glossars.
  • LANGUAGE_CODE: Der Sprachcode, der die Sprache des Begriffs angibt.
  • TERM: Der Begriff, der dem Glossar hinzugefügt werden soll.
  • DESCRIPTION: Informationen zum Glossareintrag.

HTTP-Methode und URL:

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

JSON-Text anfordern:

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

Wenn Sie die Anfrage senden möchten, maximieren Sie eine der folgenden Optionen:

Sie sollten eine JSON-Antwort ähnlich wie diese erhalten:

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

Weitere Sprachen

C#: Folgen Sie der Anleitung zur Einrichtung von C# auf der Seite der Clientbibliotheken und rufen Sie dann die Cloud Translation-Referenzdokumentation für .NET auf.

PHP: Folgen Sie der Anleitung zur Einrichtung von PHP auf der Seite der Clientbibliotheken und rufen Sie dann die Cloud Translation-Referenzdokumentation für PHP auf.

Ruby: Folgen Sie der Anleitung zur Einrichtung von Ruby auf der Seite der Clientbibliotheken und rufen Sie dann die Cloud Translation-Referenzdokumentation für Ruby auf.

Glossareinträge auflisten

Listen Sie alle Einträge für ein vorhandenes Glossar auf. Dies ist beispielsweise hilfreich, wenn Sie prüfen möchten, welche Begriffe und Sprachen in einem bestimmten Glossar enthalten sind.

REST

Senden Sie eine GET-Anfrage mit der Methode glossaryEntries.list, um alle Glossareinträge aufzulisten.

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

  • PROJECT_NUMBER_OR_ID: Die numerische oder alphanumerische ID Ihres Google Cloud-Projekts.
  • LOCATION: Die Region, in der sich das zu aktualisierende Glossar befindet, z. B. us-central1.
  • GLOSSARY_ID: Die ID eines vorhandenen Glossars.

HTTP-Methode und URL:

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

Wenn Sie die Anfrage senden möchten, maximieren Sie eine der folgenden Optionen:

Sie sollten eine JSON-Antwort ähnlich wie diese erhalten:

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

Weitere Sprachen

C#: Folgen Sie der Anleitung zur Einrichtung von C# auf der Seite der Clientbibliotheken und rufen Sie dann die Cloud Translation-Referenzdokumentation für .NET auf.

PHP: Folgen Sie der Anleitung zur Einrichtung von PHP auf der Seite der Clientbibliotheken und rufen Sie dann die Cloud Translation-Referenzdokumentation für PHP auf.

Ruby: Folgen Sie der Anleitung zur Einrichtung von Ruby auf der Seite der Clientbibliotheken und rufen Sie dann die Cloud Translation-Referenzdokumentation für Ruby auf.

Glossareintrag abrufen

Rufen Sie einen einzelnen Eintrag ab, um seine Informationen zu sehen.

REST

Senden Sie eine GET-Anfrage mit der Methode glossaryEntries.get, um einen einzelnen Glossareintrag abzurufen. Verwenden Sie die Auflistungsmethode, um die ID eines bestimmten Eintrags zu ermitteln.

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

  • PROJECT_NUMBER_OR_ID: Die numerische oder alphanumerische ID Ihres Google Cloud-Projekts.
  • LOCATION: Die Region, in der sich das zu aktualisierende Glossar befindet, z. B. us-central1.
  • GLOSSARY_ID: Die ID eines vorhandenen Glossars.
  • GLOSSARY_ENTRY_ID: Die ID eines vorhandenen Glossareintrags.

HTTP-Methode und URL:

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

Wenn Sie die Anfrage senden möchten, maximieren Sie eine der folgenden Optionen:

Sie sollten eine JSON-Antwort ähnlich wie diese erhalten:

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

Weitere Sprachen

C#: Folgen Sie der Anleitung zur Einrichtung von C# auf der Seite der Clientbibliotheken und rufen Sie dann die Cloud Translation-Referenzdokumentation für .NET auf.

PHP: Folgen Sie der Anleitung zur Einrichtung von PHP auf der Seite der Clientbibliotheken und rufen Sie dann die Cloud Translation-Referenzdokumentation für PHP auf.

Ruby: Folgen Sie der Anleitung zur Einrichtung von Ruby auf der Seite der Clientbibliotheken und rufen Sie dann die Cloud Translation-Referenzdokumentation für Ruby auf.

Glossareinträge aktualisieren

Sie können einen einzelnen Eintrag aktualisieren oder alle Einträge in einem Glossar ersetzen. Informationen zum Ersetzen aller Einträge finden Sie unter Glossar aktualisieren.

Wenn Sie einen Eintrag in einem unidirektionalen Glossar ändern möchten, geben Sie ein Begriffspaar an, wobei sich ein Begriff in der Ausgangssprache und der andere in der Zielsprache befindet. Geben Sie für Glossare mit Sets äquivalenter Begriffe ein Set mit Begriffen an, wobei jedes Element im Set einen Begriff und seinen Sprachcode angibt.

REST

In den folgenden Beispielen wird ein Eintrag für ein Glossar mit Sets äquivalenter Begriffe aktualisiert. Weitere Informationen finden Sie unter der Methode glossaryEntries.patch.

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

  • PROJECT_NUMBER_OR_ID: Die numerische oder alphanumerische ID Ihres Google Cloud-Projekts.
  • LOCATION: Die Region, in der sich das zu aktualisierende Glossar befindet, z. B. us-central1.
  • GLOSSARY_ID: Die ID eines vorhandenen Glossars, das den zu aktualisierenden Eintrag enthält.
  • GLOSSARY_ENTRY_ID: Die ID des zu aktualisierenden Glossareintrags.
  • LANGUAGE_CODE: Der Sprachcode, der die Sprache des Begriffs angibt.
  • TERM: Der zu aktualisierende Begriff.
  • DESCRIPTION: Informationen zum Glossareintrag.

HTTP-Methode und URL:

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

JSON-Text anfordern:

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

Wenn Sie die Anfrage senden möchten, maximieren Sie eine der folgenden Optionen:

Sie sollten eine JSON-Antwort ähnlich wie diese erhalten:

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

Weitere Sprachen

C#: Folgen Sie der Anleitung zur Einrichtung von C# auf der Seite der Clientbibliotheken und rufen Sie dann die Cloud Translation-Referenzdokumentation für .NET auf.

PHP: Folgen Sie der Anleitung zur Einrichtung von PHP auf der Seite der Clientbibliotheken und rufen Sie dann die Cloud Translation-Referenzdokumentation für PHP auf.

Ruby: Folgen Sie der Anleitung zur Einrichtung von Ruby auf der Seite der Clientbibliotheken und rufen Sie dann die Cloud Translation-Referenzdokumentation für Ruby auf.

Glossareintrag löschen

Entfernen Sie einen einzelnen Glossareintrag.

REST

Senden Sie eine DELETE-Anfrage mit der Methode glossaryEntries.delete, um einen einzelnen Glossareintrag zu löschen. Verwenden Sie die Auflistungsmethode, um die ID eines bestimmten Eintrags zu ermitteln.

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

  • PROJECT_NUMBER_OR_ID: Die numerische oder alphanumerische ID Ihres Google Cloud-Projekts.
  • LOCATION: Die Region, in der sich das zu aktualisierende Glossar befindet, z. B. us-central1.
  • GLOSSARY_ID: Die ID eines vorhandenen Glossars, das den zu löschenden Eintrag enthält.
  • GLOSSARY_ENTRY_ID: Die ID des zu löschenden Glossareintrags.

HTTP-Methode und URL:

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

Wenn Sie die Anfrage senden möchten, maximieren Sie eine der folgenden Optionen:

Sie sollten einen erfolgreichen Statuscode (2xx) und eine leere Antwort als Ausgabe erhalten.

Weitere Sprachen

C#: Folgen Sie der Anleitung zur Einrichtung von C# auf der Seite der Clientbibliotheken und rufen Sie dann die Cloud Translation-Referenzdokumentation für .NET auf.

PHP: Folgen Sie der Anleitung zur Einrichtung von PHP auf der Seite der Clientbibliotheken und rufen Sie dann die Cloud Translation-Referenzdokumentation für PHP auf.

Ruby: Folgen Sie der Anleitung zur Einrichtung von Ruby auf der Seite der Clientbibliotheken und rufen Sie dann die Cloud Translation-Referenzdokumentation für Ruby auf.

Weitere Ressourcen

  • Unterstützung zur Behebung häufiger Probleme oder Fehler erhalten Sie auf der Seite Fehlerbehebung.