googletransx

package module
v0.3.4 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Nov 23, 2020 License: MIT Imports: 18 Imported by: 0

README

google translate logo

GoogletransX

language Documentation Go Report Card

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

Constants

This section is empty.

Variables

This section is empty.

Functions

func Append

func Append(serviceURLs ...string)

Append appends serviceURLs to defaultTranslator's serviceURLs

func BulkTranslateInterfaces added in v0.3.0

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 added in v0.3.0

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

Directories

Path Synopsis
Package tk generates google translate tk
Package tk generates google translate tk
Package tkk gets google translate tkk
Package tkk gets google translate tkk
Package transcookie just for caching google translation services' cookies
Package transcookie just for caching google translation services' cookies

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL