CtrlK
BlogDocsLog inGet started
Tessl Logo

tessl/pypi-google-cloud-translate

Google Cloud Translate API client library for translating text between thousands of language pairs with support for adaptive MT, AutoML, and glossaries

—

Pending
Overview
Eval results
Files

v3-adaptive-mt.mddocs/

V3 Adaptive Machine Translation

Advanced machine translation capabilities using custom datasets and models trained on domain-specific translation pairs. Adaptive MT improves translation accuracy for specialized contexts by learning from user-provided translation examples.

Core Import

from google.cloud import translate_v3

Capabilities

Dataset Management

Create and manage adaptive MT datasets containing translation pairs for model training.

def create_adaptive_mt_dataset(
    self,
    request=None,
    *,
    parent=None,
    adaptive_mt_dataset=None,
    retry=None,
    timeout=None,
    metadata=()
):
    """
    Creates an Adaptive MT dataset.
    
    Args:
        request (CreateAdaptiveMtDatasetRequest): The request object
        parent (str): Project/location resource name
        adaptive_mt_dataset (AdaptiveMtDataset): Dataset configuration
        retry: Retry configuration
        timeout (float): Request timeout in seconds
        metadata: Additional metadata
    
    Returns:
        AdaptiveMtDataset: Created dataset resource
    """

def list_adaptive_mt_datasets(
    self,
    request=None,
    *,
    parent=None,
    page_size=None,
    page_token=None,
    filter=None,
    retry=None,
    timeout=None,
    metadata=()
):
    """
    Lists all Adaptive MT datasets for which the caller has read permission.
    
    Args:
        request (ListAdaptiveMtDatasetsRequest): The request object
        parent (str): Project/location resource name
        page_size (int): Maximum number of datasets to return
        page_token (str): Token for pagination
        filter (str): Filter expression for datasets
        retry: Retry configuration
        timeout (float): Request timeout in seconds
        metadata: Additional metadata
    
    Returns:
        ListAdaptiveMtDatasetsResponse: Paginated list of datasets
    """

def get_adaptive_mt_dataset(
    self,
    request=None,
    *,
    name=None,
    retry=None,
    timeout=None,
    metadata=()
):
    """
    Gets the Adaptive MT dataset.
    
    Args:
        request (GetAdaptiveMtDatasetRequest): The request object
        name (str): Dataset resource name
        retry: Retry configuration
        timeout (float): Request timeout in seconds
        metadata: Additional metadata
    
    Returns:
        AdaptiveMtDataset: Dataset resource
    """

def delete_adaptive_mt_dataset(
    self,
    request=None,
    *,
    name=None,
    retry=None,
    timeout=None,
    metadata=()
):
    """
    Deletes an Adaptive MT dataset, including all its entries and associated metadata.
    
    Args:
        request (DeleteAdaptiveMtDatasetRequest): The request object
        name (str): Dataset resource name
        retry: Retry configuration
        timeout (float): Request timeout in seconds
        metadata: Additional metadata
    
    Returns:
        None
    """

Adaptive Translation

Perform translation using adaptive MT models trained on custom datasets.

def adaptive_mt_translate(
    self,
    request=None,
    *,
    parent=None,
    dataset=None,
    content=None,
    retry=None,
    timeout=None,
    metadata=()
):
    """
    Translate text using Adaptive MT.
    
    Args:
        request (AdaptiveMtTranslateRequest): The request object
        parent (str): Project/location resource name
        dataset (str): Adaptive MT dataset resource name
        content (list): Text content to translate
        retry: Retry configuration
        timeout (float): Request timeout in seconds
        metadata: Additional metadata
    
    Returns:
        AdaptiveMtTranslateResponse: Adaptive translation results
    """

File Management

Import and manage translation files within adaptive MT datasets.

def import_adaptive_mt_file(
    self,
    request=None,
    *,
    parent=None,
    file_input_source=None,
    retry=None,
    timeout=None,
    metadata=()
):
    """
    Imports an AdaptiveMtFile and adds all of its sentences into the dataset.
    
    Args:
        request (ImportAdaptiveMtFileRequest): The request object
        parent (str): Dataset resource name
        file_input_source (FileInputSource): File input configuration
        retry: Retry configuration
        timeout (float): Request timeout in seconds
        metadata: Additional metadata
    
    Returns:
        ImportAdaptiveMtFileResponse: Import operation result
    """

def list_adaptive_mt_files(
    self,
    request=None,
    *,
    parent=None,
    page_size=None,
    page_token=None,
    retry=None,
    timeout=None,
    metadata=()
):
    """
    Lists all AdaptiveMtFiles associated to this dataset.
    
    Args:
        request (ListAdaptiveMtFilesRequest): The request object
        parent (str): Dataset resource name
        page_size (int): Maximum number of files to return
        page_token (str): Token for pagination
        retry: Retry configuration
        timeout (float): Request timeout in seconds
        metadata: Additional metadata
    
    Returns:
        ListAdaptiveMtFilesResponse: Paginated list of files
    """

def get_adaptive_mt_file(
    self,
    request=None,
    *,
    name=None,
    retry=None,
    timeout=None,
    metadata=()
):
    """
    Gets and AdaptiveMtFile.
    
    Args:
        request (GetAdaptiveMtFileRequest): The request object
        name (str): File resource name
        retry: Retry configuration
        timeout (float): Request timeout in seconds
        metadata: Additional metadata
    
    Returns:
        AdaptiveMtFile: File resource
    """

def delete_adaptive_mt_file(
    self,
    request=None,
    *,
    name=None,
    retry=None,
    timeout=None,
    metadata=()
):
    """
    Deletes an AdaptiveMtFile along with its sentences.
    
    Args:
        request (DeleteAdaptiveMtFileRequest): The request object
        name (str): File resource name
        retry: Retry configuration
        timeout (float): Request timeout in seconds
        metadata: Additional metadata
    
    Returns:
        None
    """

Sentence Management

Access and manage individual translation sentence pairs within adaptive MT datasets.

def list_adaptive_mt_sentences(
    self,
    request=None,
    *,
    parent=None,
    page_size=None,
    page_token=None,
    retry=None,
    timeout=None,
    metadata=()
):
    """
    Lists all AdaptiveMtSentences under a given file/dataset.
    
    Args:
        request (ListAdaptiveMtSentencesRequest): The request object
        parent (str): Dataset or file resource name
        page_size (int): Maximum number of sentences to return
        page_token (str): Token for pagination
        retry: Retry configuration
        timeout (float): Request timeout in seconds
        metadata: Additional metadata
    
    Returns:
        ListAdaptiveMtSentencesResponse: Paginated list of sentences
    """

Usage Examples

Creating an Adaptive MT Dataset

from google.cloud import translate_v3

client = translate_v3.TranslationServiceClient()

parent = "projects/my-project/locations/us-central1"

dataset = {
    "name": "my-adaptive-dataset",
    "display_name": "My Adaptive MT Dataset",
    "source_language_code": "en",
    "target_language_code": "es",
}

response = client.create_adaptive_mt_dataset(
    request={
        "parent": parent,
        "adaptive_mt_dataset": dataset,
    }
)

print(f"Created dataset: {response.name}")
print(f"Display name: {response.display_name}")
print(f"Source language: {response.source_language_code}")
print(f"Target language: {response.target_language_code}")

Importing Translation Files

from google.cloud import translate_v3

client = translate_v3.TranslationServiceClient()

dataset_name = "projects/my-project/locations/us-central1/adaptiveMtDatasets/my-dataset"

file_input_source = {
    "gcs_source": {
        "input_uri": "gs://my-bucket/translation-pairs.txt"
    },
    "mime_type": "text/plain"
}

response = client.import_adaptive_mt_file(
    request={
        "parent": dataset_name,
        "file_input_source": file_input_source,
    }
)

print(f"Imported {response.adaptive_mt_file_count} files")
print(f"Processed {response.adaptive_mt_sentence_count} sentences")

Adaptive Translation

from google.cloud import translate_v3

client = translate_v3.TranslationServiceClient()

parent = "projects/my-project/locations/us-central1"
dataset = "projects/my-project/locations/us-central1/adaptiveMtDatasets/my-dataset"

response = client.adaptive_mt_translate(
    request={
        "parent": parent,
        "dataset": dataset,
        "content": ["Hello, world!", "How are you today?"],
    }
)

for translation in response.translations:
    print(f"Original: {translation.translated_text}")
    
# Access language codes from response
print(f"Detected language: {response.language_code}")

Listing Datasets

from google.cloud import translate_v3

client = translate_v3.TranslationServiceClient()

parent = "projects/my-project/locations/us-central1"

response = client.list_adaptive_mt_datasets(
    request={
        "parent": parent,
        "page_size": 10,
    }
)

for dataset in response.adaptive_mt_datasets:
    print(f"Dataset: {dataset.name}")
    print(f"Display name: {dataset.display_name}")
    print(f"Languages: {dataset.source_language_code} -> {dataset.target_language_code}")
    print(f"Example count: {dataset.example_count}")
    print("---")

# Handle pagination
if response.next_page_token:
    next_response = client.list_adaptive_mt_datasets(
        request={
            "parent": parent,
            "page_token": response.next_page_token,
        }
    )

Managing Files and Sentences

from google.cloud import translate_v3

client = translate_v3.TranslationServiceClient()

dataset_name = "projects/my-project/locations/us-central1/adaptiveMtDatasets/my-dataset"

# List files in dataset
files_response = client.list_adaptive_mt_files(
    request={"parent": dataset_name}
)

for file in files_response.adaptive_mt_files:
    print(f"File: {file.name}")
    print(f"Display name: {file.display_name}")
    print(f"Entry count: {file.entry_count}")
    
    # List sentences in this file
    sentences_response = client.list_adaptive_mt_sentences(
        request={
            "parent": file.name,
            "page_size": 5,
        }
    )
    
    for sentence in sentences_response.adaptive_mt_sentences:
        print(f"Source: {sentence.source_sentence}")
        print(f"Target: {sentence.target_sentence}")
    
    print("---")

Install with Tessl CLI

npx tessl i tessl/pypi-google-cloud-translate

docs

index.md

v2-legacy-api.md

v3-adaptive-mt.md

v3-automl-translation.md

v3-data-structures.md

v3-glossary-management.md

v3-request-response-types.md

v3-translation-services.md

tile.json