googletransx

README

GoogletransX

Disclaimer: this is not official library and breaks google policies, use it carefully

This is fork of mind1949/googletrans with extended features:

• BulkTranslate with goroutines processing
• HTML translate support
• Built-in API server for integrations
• Dockerized server
• Translate interfaces directly with parameters

Installation

$ go get -u github.com/yuriizinets/googletransx
...

Usage

For usage doc of basic operations, check original repo
Here will be mentioned only extended features

HTML Mime-Type

package main

import (
    "github.com/yuriizinets/googletransx"
)

func main() {
    input := "<div>Test<span>translate</span></div>"
    result, err := googletransx.Translate(googletransx.TranslateParams{
        Text: input,
        Src: "auto",
        Dest: "zh-CN",
        MimeType: "text/html",
    })
    fmt.Println(result) // Translated{} struct with translated html
}

BulkTranslate (HTML is supported too)

package main

import (
    "github.com/yuriizinets/googletransx"
)

func main() {
    inputs := []string{"example", "test"}
    params := []googletransx.TranslateParams{}
    for _, input := range inputs {
        params = append(params, googletransx.TranslateParams{
            Text: input,
            Src: "auto",
            Dest: "zh-CN",
        })
    }
    results, err := googletransx.BulkTranslate(params)
    if err != nil {
        panic(err)
    }
    fmt.Println(results) // Results are []Translated
}

TranslateInterface (example from test)

package main

import (
    "github.com/yuriizinets/googletransx"
)

func main() {
    input := map[string]interface{}{
        "A": map[string]interface{}{
            "B": "I'm a test",
            "D": []string{"Example", "Example"},
        },
        "C": "Example",
    }
    params := TranslateParams{
        Src:  "en",
        Dest: "ru",
    }
    fields := []TranslateField{
        {
            Src:    "A.B",
            Dest:   "A.B_ru",
            Params: params,
        },
        {
            Src:    "A.D",
            Dest:   "A.D_ru",
            Params: params,
        },
    }
    output, err := TranslateInterface(input, fields)
    if err != nil {
        t.Fatal(err)
    }
    fmt.Println(output) // Will be map[A:map[B:I'm a test B_ru:Я тест D:[Example Example] D_ru:[пример пример]] C:Example]
}

API Server (native)
For request examples just check requests.http

$ go run github.com/yuriizinets/googletransx/server.runtime
Starting server at :25021

API Server (docker)

$ docker pull docker.pkg.github.com/yuriizinets/googletransx/googletransx:latest
$ docker run -p 25021:25021 googletransx
Starting server at :25021

Known issues

• socket: too many open files too many connections while making BulkTranslate. Can be temporary fixed with ulimit -Sn 100000
• Pronunciation is not working
• Somethings not working? Just create new issue

Documentation

Index

• func Append(serviceURLs ...string)
• func BulkTranslateInterfaces(i []interface{}, fields []TranslateField) ([]interface{}, error)
• func TranslateInterface(i interface{}, fields []TranslateField) (interface{}, error)
• type Detected
  • func Detect(text string) (Detected, error)
• type TranslateField
• type TranslateParams
• type Translated
  • func BulkTranslate(params []TranslateParams) ([]Translated, error)
  • func Translate(params TranslateParams) (Translated, error)
• type Translator
  • func New(serviceURLs ...string) *Translator
  • func (t *Translator) Append(serviceURLs ...string)
  • func (t *Translator) BulkTranslate(params []TranslateParams) ([]Translated, error)
  • func (t *Translator) BulkTranslateInterfaces(i []interface{}, fields []TranslateField) ([]interface{}, error)
  • func (t *Translator) Detect(text string) (Detected, error)
  • func (t *Translator) Translate(params TranslateParams) (Translated, error)
  • func (t *Translator) TranslateInterface(i interface{}, fields []TranslateField) (interface{}, error)

Functions

func Append

func Append(serviceURLs ...string)

Append appends serviceURLs to defaultTranslator's serviceURLs

func BulkTranslateInterfaces

func BulkTranslateInterfaces(i []interface{}, fields []TranslateField) ([]interface{}, error)

func TranslateInterface

func TranslateInterface(i interface{}, fields []TranslateField) (interface{}, error)

TranslateInterface uses defaultTranslator to translate structure according to provided parameters

Types

type Detected

type Detected struct {
	Lang       string  `json:"lang"`       // detected language
	Confidence float64 `json:"confidence"` // the confidence of detection result (0.00 to 1.00)
}

Detected represents language detection result

func Detect

func Detect(text string) (Detected, error)

Detect uses defaultTranslator to detect language

type TranslateField

type TranslateField struct {
	Src    string          `json:"src"`
	Dest   string          `json:"dest"`
	Params TranslateParams `json:"params"`
}

TranslateField represents interface field translate settings

type TranslateParams

type TranslateParams struct {
	UID      int    `json:"uid"`  // unique params identified (optional)
	Src      string `json:"src"`  // source language (default: auto)
	Dest     string `json:"dest"` // destination language
	Text     string `json:"text"` // text for translating
	MimeType string `json:"mimetype"`
}

TranslateParams represents translate params

type Translated

type Translated struct {
	Params        TranslateParams `json:"params"`
	Text          string          `json:"text"`          // translated text
	Pronunciation string          `json:"pronunciation"` // pronunciation of translated text
}

Translated represents translated result

func BulkTranslate

func BulkTranslate(params []TranslateParams) ([]Translated, error)

BulkTranslate uses defaultTranslator to bulk translate with goroutines

func Translate

func Translate(params TranslateParams) (Translated, error)

Translate uses defaultTranslator to translate params.text

type Translator

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

Translator is responsible for translation

func New

func New(serviceURLs ...string) *Translator

New initializes a Translator

func (*Translator) Append

func (t *Translator) Append(serviceURLs ...string)

Append appends serviceURLS to t's serviceURLs

func (*Translator) BulkTranslate

func (t *Translator) BulkTranslate(params []TranslateParams) ([]Translated, error)

BulkTranslate translates texts to dest language with goroutines

func (*Translator) BulkTranslateInterfaces

func (t *Translator) BulkTranslateInterfaces(i []interface{}, fields []TranslateField) ([]interface{}, error)

func (*Translator) Detect

func (t *Translator) Detect(text string) (Detected, error)

Detect detects text's language

func (*Translator) Translate

func (t *Translator) Translate(params TranslateParams) (Translated, error)

Translate translates text from src language to dest language

func (*Translator) TranslateInterface

func (t *Translator) TranslateInterface(i interface{}, fields []TranslateField) (interface{}, error)

TranslateInterface is a method for translating structure according to provided parameters