Package cloud.google.com/go/translate (v0.91.1)

Package translate is the v2 client for the Google Translation API.

PLEASE NOTE: We recommend using the new v3 client for new projects: https://cloud.google.com/go/translate/apiv3.

See https://cloud.google.com/translation for details.

Constants

Scope

const Scope = raw.CloudPlatformScope

Scope is the OAuth2 scope required by the Google Cloud Vision API.

Client

type Client struct {
	// contains filtered or unexported fields
}

Client is a client for the translate API.

func NewClient 

func NewClient(ctx context.Context, opts ...option.ClientOption) (*Client, error)

NewClient constructs a new Client that can perform Translation operations.

You can find or create API key for your project from the Credentials page of the Developers Console (console.developers.google.com).

Example

package main

import (
	"context"

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

func main() {
	ctx := context.Background()
	client, err := translate.NewClient(ctx)
	if err != nil {
		// TODO: handle error.
	}
	// Use the client.

	// Close the client when finished.
	if err := client.Close(); err != nil {
		// TODO: handle error.
	}
}

func (*Client) Close 

func (c *Client) Close() error

Close closes any resources held by the client. Close should be called when the client is no longer needed. It need not be called at program exit.

func (*Client) DetectLanguage 

func (c *Client) DetectLanguage(ctx context.Context, inputs []string) ([][]Detection, error)

DetectLanguage attempts to determine the language of the inputs. Each input string may be in a different language.

Each slice of Detections in the return value corresponds with one input string. A slice of Detections holds multiple hypotheses for the language of a single input string.

Example

package main

import (
	"context"
	"fmt"

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

func main() {
	ctx := context.Background()
	client, err := translate.NewClient(ctx)
	if err != nil {
		// TODO: handle error.
	}
	ds, err := client.DetectLanguage(ctx, []string{"Today is Monday"})
	if err != nil {
		// TODO: handle error.
	}
	fmt.Println(ds)
}

func (*Client) SupportedLanguages 

func (c *Client) SupportedLanguages(ctx context.Context, target language.Tag) ([]Language, error)

SupportedLanguages returns a list of supported languages for translation. The target parameter is the language to use to return localized, human readable names of supported languages.

Example

package main

import (
	"context"
	"fmt"

	"cloud.google.com/go/translate"
	"golang.org/x/text/language"
)

func main() {
	ctx := context.Background()
	client, err := translate.NewClient(ctx)
	if err != nil {
		// TODO: handle error.
	}
	langs, err := client.SupportedLanguages(ctx, language.English)
	if err != nil {
		// TODO: handle error.
	}
	fmt.Println(langs)
}

func (*Client) Translate 

func (c *Client) Translate(ctx context.Context, inputs []string, target language.Tag, opts *Options) ([]Translation, error)

Translate one or more strings of text from a source language to a target language. All inputs must be in the same language.

The target parameter supplies the language to translate to. The supported languages are listed at https://cloud.google.com/translation/v2/translate-reference#supported_languages. You can also call the SupportedLanguages method.

The returned Translations appear in the same order as the inputs.

Example

package main

import (
	"context"
	"fmt"

	"cloud.google.com/go/translate"
	"golang.org/x/text/language"
)

func main() {
	ctx := context.Background()
	client, err := translate.NewClient(ctx)
	if err != nil {
		// TODO: handle error.
	}
	translations, err := client.Translate(ctx,
		[]string{"Le singe est sur la branche"}, language.English,
		&translate.Options{
			Source: language.French,
			Format: translate.Text,
		})
	if err != nil {
		// TODO: handle error.
	}
	fmt.Println(translations[0].Text)
}

Detection

type Detection struct {
	// Language is the code of the language detected.
	Language language.Tag

	// Confidence is a number from 0 to 1, with higher numbers indicating more
	// confidence in the detection.
	Confidence float64

	// IsReliable indicates whether the language detection result is reliable.
	IsReliable bool
}

Detection represents information about a language detected in an input.

Format

type Format string

Format is the format of the input text. Used in Options.Format.

HTML, Text

const (
	HTML Format = "html"
	Text Format = "text"
)

Constants for Options.Format.

Language

type Language struct {
	// Name is the human-readable name of the language.
	Name string

	// Tag is a standard code for the language.
	Tag language.Tag
}

A Language describes a language supported for translation.

Options

type Options struct {
	// Source is the language of the input strings. If empty, the service will
	// attempt to identify the source language automatically and return it within
	// the response.
	Source language.Tag

	// Format describes the format of the input texts. The choices are HTML or
	// Text. The default is HTML.
	Format Format

	// The model to use for translation. The choices are "nmt" or "base". The
	// default is "base".
	Model string
}

Options contains options for Translate.

Translation

type Translation struct {
	// Text is the input text translated into the target language.
	Text string

	// Source is the detected language of the input text, if source was
	// not supplied to Client.Translate. If source was supplied, this field
	// will be empty.
	Source language.Tag

	// Model is the model that was used for translation.
	// It may not match the model provided as an option to Client.Translate.
	Model string
}

Translation contains the results of translating a piece of text.