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 AutoML Translation

Name: tessl/pypi-google-cloud-translate
Author: tessl

Custom machine learning model training and management for specialized translation needs. AutoML Translation allows you to create custom translation models trained on your domain-specific data for improved accuracy in specialized contexts.

Core Import

from google.cloud import translate_v3

Capabilities

Dataset Management

Create and manage datasets for training custom translation models.

def create_dataset(
    self,
    request=None,
    *,
    parent=None,
    dataset=None,
    retry=None,
    timeout=None,
    metadata=()
):
    """
    Creates a Dataset.
    
    Args:
        request (CreateDatasetRequest): The request object
        parent (str): Project/location resource name
        dataset (Dataset): Dataset configuration
        retry: Retry configuration
        timeout (float): Request timeout in seconds
        metadata: Additional metadata
    
    Returns:
        Operation: Long-running operation for dataset creation
    """

def list_datasets(
    self,
    request=None,
    *,
    parent=None,
    page_size=None,
    page_token=None,
    retry=None,
    timeout=None,
    metadata=()
):
    """
    Lists datasets.
    
    Args:
        request (ListDatasetsRequest): The request object
        parent (str): Project/location resource name
        page_size (int): Maximum number of datasets to return
        page_token (str): Token for pagination
        retry: Retry configuration
        timeout (float): Request timeout in seconds
        metadata: Additional metadata
    
    Returns:
        ListDatasetsResponse: Paginated list of datasets
    """

def get_dataset(
    self,
    request=None,
    *,
    name=None,
    retry=None,
    timeout=None,
    metadata=()
):
    """
    Gets a Dataset.
    
    Args:
        request (GetDatasetRequest): The request object
        name (str): Dataset resource name
        retry: Retry configuration
        timeout (float): Request timeout in seconds
        metadata: Additional metadata
    
    Returns:
        Dataset: Dataset resource
    """

def delete_dataset(
    self,
    request=None,
    *,
    name=None,
    retry=None,
    timeout=None,
    metadata=()
):
    """
    Deletes a dataset and all of its contents.
    
    Args:
        request (DeleteDatasetRequest): The request object
        name (str): Dataset resource name
        retry: Retry configuration
        timeout (float): Request timeout in seconds
        metadata: Additional metadata
    
    Returns:
        Operation: Long-running operation for dataset deletion
    """

Data Import and Export

Manage training data within datasets through import and export operations.

def import_data(
    self,
    request=None,
    *,
    dataset=None,
    input_config=None,
    retry=None,
    timeout=None,
    metadata=()
):
    """
    Imports data into a dataset.
    
    Args:
        request (ImportDataRequest): The request object
        dataset (str): Dataset resource name
        input_config (DatasetInputConfig): Input configuration
        retry: Retry configuration
        timeout (float): Request timeout in seconds
        metadata: Additional metadata
    
    Returns:
        Operation: Long-running operation for data import
    """

def export_data(
    self,
    request=None,
    *,
    dataset=None,
    output_config=None,
    retry=None,
    timeout=None,
    metadata=()
):
    """
    Exports dataset's data to the provided output location.
    
    Args:
        request (ExportDataRequest): The request object
        dataset (str): Dataset resource name
        output_config (DatasetOutputConfig): Output configuration
        retry: Retry configuration
        timeout (float): Request timeout in seconds
        metadata: Additional metadata
    
    Returns:
        Operation: Long-running operation for data export
    """

def list_examples(
    self,
    request=None,
    *,
    parent=None,
    filter=None,
    page_size=None,
    page_token=None,
    retry=None,
    timeout=None,
    metadata=()
):
    """
    Lists sentence pairs in the dataset.
    
    Args:
        request (ListExamplesRequest): The request object
        parent (str): Dataset resource name
        filter (str): Filter expression for examples
        page_size (int): Maximum number of examples to return
        page_token (str): Token for pagination
        retry: Retry configuration
        timeout (float): Request timeout in seconds
        metadata: Additional metadata
    
    Returns:
        ListExamplesResponse: Paginated list of training examples
    """

Model Management

Train and manage custom translation models using your datasets.

def create_model(
    self,
    request=None,
    *,
    parent=None,
    model=None,
    retry=None,
    timeout=None,
    metadata=()
):
    """
    Creates a Model.
    
    Args:
        request (CreateModelRequest): The request object
        parent (str): Project/location resource name
        model (Model): Model configuration
        retry: Retry configuration
        timeout (float): Request timeout in seconds
        metadata: Additional metadata
    
    Returns:
        Operation: Long-running operation for model creation
    """

def list_models(
    self,
    request=None,
    *,
    parent=None,
    filter=None,
    page_size=None,
    page_token=None,
    retry=None,
    timeout=None,
    metadata=()
):
    """
    Lists models.
    
    Args:
        request (ListModelsRequest): The request object
        parent (str): Project/location resource name
        filter (str): Filter expression for models
        page_size (int): Maximum number of models to return
        page_token (str): Token for pagination
        retry: Retry configuration
        timeout (float): Request timeout in seconds
        metadata: Additional metadata
    
    Returns:
        ListModelsResponse: Paginated list of models
    """

def get_model(
    self,
    request=None,
    *,
    name=None,
    retry=None,
    timeout=None,
    metadata=()
):
    """
    Gets a model.
    
    Args:
        request (GetModelRequest): The request object
        name (str): Model resource name
        retry: Retry configuration
        timeout (float): Request timeout in seconds
        metadata: Additional metadata
    
    Returns:
        Model: Model resource
    """

def delete_model(
    self,
    request=None,
    *,
    name=None,
    retry=None,
    timeout=None,
    metadata=()
):
    """
    Deletes a model.
    
    Args:
        request (DeleteModelRequest): The request object
        name (str): Model resource name
        retry: Retry configuration
        timeout (float): Request timeout in seconds
        metadata: Additional metadata
    
    Returns:
        Operation: Long-running operation for model deletion
    """

Usage Examples

Creating a Dataset

from google.cloud import translate_v3

client = translate_v3.TranslationServiceClient()

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

dataset = {
    "display_name": "My Translation Dataset",
    "source_language_code": "en",
    "target_language_code": "es",
    "train_example_count": 1000,
    "validate_example_count": 100,
}

operation = client.create_dataset(
    request={
        "parent": parent,
        "dataset": dataset,
    }
)

print(f"Operation name: {operation.name}")

# Wait for operation to complete
result = operation.result(timeout=300)
print(f"Created dataset: {result.name}")
print(f"Display name: {result.display_name}")
print(f"Source language: {result.source_language_code}")
print(f"Target language: {result.target_language_code}")

Importing Training Data

from google.cloud import translate_v3

client = translate_v3.TranslationServiceClient()

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

input_config = {
    "gcs_source": {
        "input_uri": "gs://my-bucket/training-data.csv"
    },
    "mime_type": "text/csv"
}

operation = client.import_data(
    request={
        "dataset": dataset_name,
        "input_config": input_config,
    }
)

print(f"Import operation: {operation.name}")

# Wait for import to complete
result = operation.result(timeout=1800)  # 30 minutes timeout
print(f"Import completed")
print(f"Imported example count: {result.example_count}")

Training a Model

from google.cloud import translate_v3

client = translate_v3.TranslationServiceClient()

parent = "projects/my-project/locations/us-central1"
dataset_name = f"{parent}/datasets/my-dataset"

model = {
    "display_name": "My Custom Translation Model",
    "dataset": dataset_name,
}

operation = client.create_model(
    request={
        "parent": parent,
        "model": model,
    }
)

print(f"Training operation: {operation.name}")

# Model training can take several hours
result = operation.result(timeout=7200)  # 2 hours timeout
print(f"Model training completed: {result.name}")
print(f"Model state: {result.state}")

Using Custom Model for Translation

from google.cloud import translate_v3

client = translate_v3.TranslationServiceClient()

parent = "projects/my-project/locations/us-central1"
model_name = f"{parent}/models/my-model"

response = client.translate_text(
    request={
        "parent": parent,
        "contents": ["Hello, world!", "How are you?"],
        "mime_type": "text/plain",
        "source_language_code": "en",
        "target_language_code": "es",
        "model": model_name,
    }
)

for translation in response.translations:
    print(f"Custom model translation: {translation.translated_text}")

Managing Datasets and Models

from google.cloud import translate_v3

client = translate_v3.TranslationServiceClient()

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

# List all datasets
datasets_response = client.list_datasets(
    request={
        "parent": parent,
        "page_size": 10,
    }
)

print("Datasets:")
for dataset in datasets_response.datasets:
    print(f"  {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(f"  State: {dataset.state}")
    print("  ---")

# List all models
models_response = client.list_models(
    request={
        "parent": parent,
        "page_size": 10,
    }
)

print("Models:")
for model in models_response.models:
    print(f"  {model.name}")
    print(f"  Display name: {model.display_name}")
    print(f"  Dataset: {model.dataset}")
    print(f"  State: {model.state}")
    print(f"  Create time: {model.create_time}")
    print("  ---")

Listing Training Examples

from google.cloud import translate_v3

client = translate_v3.TranslationServiceClient()

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

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

print("Training examples:")
for example in response.examples:
    print(f"Source: {example.source_text}")
    print(f"Target: {example.target_text}")
    print(f"Usage: {example.usage}")  # TRAIN, VALIDATION, or TEST
    print("---")

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

Exporting Dataset

from google.cloud import translate_v3

client = translate_v3.TranslationServiceClient()

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

output_config = {
    "gcs_destination": {
        "output_uri_prefix": "gs://my-bucket/exported-data/"
    }
}

operation = client.export_data(
    request={
        "dataset": dataset_name,
        "output_config": output_config,
    }
)

print(f"Export operation: {operation.name}")

# Wait for export to complete
result = operation.result(timeout=600)  # 10 minutes timeout
print(f"Export completed")
print(f"Exported example count: {result.example_count}")

Model Evaluation and Metrics

from google.cloud import translate_v3

client = translate_v3.TranslationServiceClient()

model_name = "projects/my-project/locations/us-central1/models/my-model"

# Get model details including evaluation metrics
model = client.get_model(
    request={"name": model_name}
)

print(f"Model: {model.display_name}")
print(f"State: {model.state}")
print(f"Create time: {model.create_time}")
print(f"Update time: {model.update_time}")

# Check if model has evaluation results
if hasattr(model, 'evaluation_results') and model.evaluation_results:
    for result in model.evaluation_results:
        print(f"Evaluation metric: {result.metric}")
        print(f"Score: {result.score}")

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

tessl/pypi-google-cloud-translate