火山引擎机器翻译

https://www.volcengine.com/docs/4640
Admin
火山引擎机器翻译 provides fast, stable, and secure multi-language machine translation services supporting...
Tokens:20,867
Snippets:66
Trust Score:10
Update:1 month ago
Show doc for...
Tokens:
Raw
### Audio Translation with Go SDK

Source: https://www.volcengine.com/docs/4640/78985

This example demonstrates how to initialize the Volcengine client, submit an audio file for translation, and poll the status until completion to retrieve the translated subtitles.

```go
package main

import (
	"encoding/json"
	"fmt"
	"net/http"
	"net/url"
	"time"

	"github.com/volcengine/volc-sdk-golang/base"
)

const (
	kAccessKey      = "密钥管理中的 AccessKey ID" // https://console.volcengine.com/iam/keymanage/
	kSecretKey      = "密钥管理中的 AccessKey Secret"
	kServiceVersion = "2020-06-01"
)

var (
	ServiceInfo = &base.ServiceInfo{
		Timeout: 5 * time.Second,
		Host:    "translate.volcengineapi.com",
		Header: http.Header{
			"Accept": []string{"application/json"},
		},
		Credentials: base.Credentials{Region: base.RegionCnNorth1, Service: "translate"},
	}
	ApiInfoList = map[string]*base.ApiInfo{
		"SubmitAudio": {
			Method: http.MethodPost,
			Path:   "/",
			Query: url.Values{
				"Action":  []string{"SubmitAudio"},
				"Version": []string{kServiceVersion},
			},
		},
		"QueryAudio": {
			Method: http.MethodPost,
			Path:   "/",
			Query: url.Values{
				"Action":  []string{"QueryAudio"},
				"Version": []string{kServiceVersion},
			},
		},
	}
)

func newClient() *base.Client {
	client := base.NewClient(ServiceInfo, ApiInfoList)
	client.SetAccessKey(kAccessKey)
	client.SetSecretKey(kSecretKey)
	return client
}

type SubmitReq struct {
	SourceLanguage string `json:"SourceLanguage"`
	TargetLanguage string `json:"TargetLanguage"`
	Uri            string `json:"Uri"`
}

type SubmitResp struct {
	TaskId           string `json:"TaskId"`
	ResponseMetadata struct {
		RequestId string      `json:"RequestId"`
		Action    string      `json:"Action"`
		Version   string      `json:"Version"`
		Service   string      `json:"Service"`
		Region    string      `json:"Region"`
		Error     interface{} `json:"Error"`
	} `json:"ResponseMetadata"`
}
type QueryReq struct {
	TaskId string `json:"TaskId"`
}

type QueryResp struct {
	Subtitles []struct {
		StartTime   int    `json:"StartTime"`
		EndTime     int    `json:"EndTime"`
		Text        string `json:"Text"`
		Translation string `json:"Translation"`
	} `json:"Subtitles"`
	Status           string `json:"Status"`
	ResponseMetadata struct {
		RequestId string      `json:"RequestId"`
		Action    string      `json:"Action"`
		Version   string      `json:"Version"`
		Service   string      `json:"Service"`
		Region    string      `json:"Region"`
		Error     interface{} `json:"Error"`
	} `json:"ResponseMetadata"`
}

func SubmitAudio(cli *base.Client, uri, sourceLanguage, targetLanguage string) (*SubmitResp, error) {
	req := &SubmitReq{
		SourceLanguage: sourceLanguage,
		TargetLanguage: targetLanguage,
		Uri:            uri,
	}
	reqData, err := json.Marshal(req)
	if err != nil {
		return nil, err
	}
	respData, code, err := cli.Json("SubmitAudio", nil, string(reqData))
	if err != nil {
		return nil, err
	}
	if code != 200 {
		return nil, fmt.Errorf("code:%d,err:%s", code, string(respData))
	}
	resp := &SubmitResp{}
	err = json.Unmarshal(respData, resp)
	if err != nil {
		return nil, err
	}
	return resp, nil
}

func QueryAudio(cli *base.Client, taskId string) (*QueryResp, error) {
	req := &QueryReq{
		TaskId: taskId,
	}
	reqData, err := json.Marshal(req)
	if err != nil {
		return nil, err
	}
	respData, code, err := cli.Json("QueryAudio", nil, string(reqData))
	if err != nil {
		return nil, err
	}
	if code != 200 {
		return nil, fmt.Errorf("code:%d,err:%s", code, string(respData))
	}
	resp := &QueryResp{}
	err = json.Unmarshal(respData, resp)
	if err != nil {
		return nil, err
	}
	return resp, nil
}

func main() {
	cli := newClient()
	submitResp, err := SubmitAudio(cli, "http://xx/xx.mp4", "en", "zh")
	if err != nil {
		panic(err)
	}
	status := "created"
	for status == "created" {
		time.Sleep(time.Minute)
		queryResp, err := QueryAudio(cli, submitResp.TaskId)
		if err != nil {
			panic(err)
		}
		status = queryResp.Status
		if status == "success" {
			for _, subtitle := range queryResp.Subtitles {
				fmt.Printf("%d - %d: %s -> %s", subtitle.StartTime, subtitle.EndTime, subtitle.Text, subtitle.Translation)
			}
		}
	}
}
```

--------------------------------

### Go: WebSocket speech translation client with signing and streaming

Source: https://www.volcengine.com/docs/4640/127504

Go example showing how to sign a WebSocket URL using the Volcengine SDK, connect, send audio chunks, and receive translation results. It uses a WaitGroup to manage concurrent read/write goroutines and sends a JSON configuration message with source language 'en' and target 'zh'.

```go
func getWsSignUrl(host string, accessKey string, secretKey string) (string, error) {
        client := newClient(host, accessKey, secretKey)
        signUrl, err := client.GetSignUrl(kSpeechTranslateAction, nil)
        if err != nil {
                return "", err
        }
        clientUrl := url.URL{
                Scheme:   "wss",
                Path:     client.ApiInfoList[kSpeechTranslateAction].Path,
                Host:     client.ServiceInfo.Host,
                RawQuery: signUrl,
        }
        return clientUrl.String(), nil
}

func main() {
        var (
                group  = &sync.WaitGroup{}
                buffer = make([]byte, 200*32)
                dialer = &websocket.Dialer{}
                header = http.Header{}
        )
        r, err := fromLocal("audio.wav")
        if err != nil {
                panic(err)
                return
        }
        signUrl, err := getWsSignUrl(kHost, accessKey, secretKey)
        if err != nil {
                panic(err)
                return
        }
        group.Add(2)
        header.Set("content-type", "application/json")
        conn, resp, err := dialer.Dial(signUrl, header)
        if err != nil {
                println(resp.Status)
                panic(err)
        }

        if err = conn.WriteMessage(websocket.BinaryMessage, []byte(`{"Configuration":{"SourceLanguage":"en","TargetLanguages":["zh"]}}`)); err != nil {
                panic(err)
        }
        go func() {
                defer group.Done()
                for {
                        _, data, err := conn.ReadMessage()
                        if err != nil {
                                println(err.Error())
                                return
                        }
                        println(string(data))
                }
        }()
        go func() {
                defer group.Done()
                for {
                        _, err = r.Read(buffer)
                        if err != nil {
                                println(err.Error())
                                if err == io.EOF {
                                        if err = conn.WriteMessage(websocket.BinaryMessage, []byte(`{"End":true}`)); err != nil {
                                                panic(err)
                                        }
                                }
                                return
                        }
                        err = conn.WriteMessage(websocket.BinaryMessage, newAudioData(buffer))
                        if err != nil {
                                panic(err)
                                return
                        }
                        time.Sleep(200 * time.Millisecond)
                }
        }()
        group.Wait()
}
```

--------------------------------

### Java WebSocket Speech Translation Client

Source: https://www.volcengine.com/docs/4640/127504

This Java example shows how to use the Volcengine TranslateService to create a signed WebSocket URL and stream audio for translation. It sends a configuration message with source and target languages, then sends audio data in chunks, and finally sends an end message. The code assumes the presence of TranslateConfig and Client classes.

```java
//src/main/java/Main.java
import translate.TranslateConfig;
import translate.TranslateService;
import websocket.Client;

import java.io.File;
import java.io.FileInputStream;
import java.net.URI;
import java.util.Base64;

public class Main {

    public static void main(String[] args) throws Exception {
        File input = new File("audio.wav");

        TranslateService translateService = new TranslateService(TranslateConfig.serviceInfo, TranslateConfig.apiInfoList);
        translateService.setAccessKey(TranslateConfig.accessKey);
        translateService.setSecretKey(TranslateConfig.secretKey);

        String signUrl = translateService.getSignUrl(TranslateConfig.api, null);
        URI url = new URI("wss://" + TranslateConfig.host + TranslateConfig.path + "?" + signUrl);
        System.out.println(url);


        // open websocket

        Client client = new Client(url);

        client.connectBlocking();
        client.send("{\n" +
                "    \"Configuration\": {\n" +
                "        \"SourceLanguage\": \"zh\",\n" +
                "        \"TargetLanguages\": [\n" +
                "            \"en\"\n" +
                "        ],\n" +
                "        \"HotWordList\": [\n" +
                "            {\n" +
                "                \"Word\": \"hello\",\n" +
                "                \"Scale\": 1\n" +
                "            }\n" +
                "        ]\n" +
                "    }\n" +
                "}");


        byte[] buffer = new byte[200 * 32];
        int bytesLeft = 100 * 1024 * 1024;
        try (FileInputStream fis = new FileInputStream(input)) {
            while (bytesLeft > 0) {
                int read = fis.read(buffer, 0, Math.min(bytesLeft, buffer.length));
                if (read == -1) {
                    break;
                }
                client.send(bytesToMessage(buffer));
                Thread.sleep(200);
                bytesLeft -= read;
            }
        } finally {
            client.send("{\n" +
                    "    \"End\": true\n" +
                    "}");
        }
    }

    static String bytesToMessage(byte[] data) {
        String base64Data = Base64.getEncoder().encodeToString(data);
        return "{\n" +
                "    \"AudioData\": \"" +
                base64Data +
                "\"\n" +
                "}";
    }
}


java
```

--------------------------------

### 使用 Go 调用文本语种检测API

Source: https://www.volcengine.com/docs/4640/65066

使用 volc-sdk-golang 进行语种检测的示例代码。通过配置 ServiceInfo 和 ApiInfoList 来初始化客户端并发送请求。

```golang
package main

import (
    "fmt"
    "net/http"
    "net/url"
    "time"

    "github.com/volcengine/volc-sdk-golang/base"
)

const (
    kAccessKey      = "密钥管理中的 AccessKey ID" // https://console.volcengine.com/iam/keymanage/
    kSecretKey      = "密钥管理中的 AccessKey Secret"
    kServiceVersion = "2020-06-01"
)

var (
    ServiceInfo = &base.ServiceInfo{
        Timeout: 5 * time.Second,
        Host:    "translate.volcengineapi.com",
        Header: http.Header{
            "Accept": []string{"application/json"},
        },
        Credentials: base.Credentials{Region: base.RegionCnNorth1, Service: "translate"},
    }
    ApiInfoList = map[string]*base.ApiInfo{
        "LangDetect": {
            Method: http.MethodPost,
            Path:   "/",
            Query: url.Values{
                "Action":  []string{"LangDetect"},
                "Version": []string{kServiceVersion},
            },
        },
    }
)

func newClient() *base.Client {
    client := base.NewClient(ServiceInfo, ApiInfoList)
    client.SetAccessKey(kAccessKey)
    client.SetSecretKey(kSecretKey)
    return client
}

func main() {
    client := newClient()
    resp, code, err := client.Json("LangDetect", nil, `{"TextList":["你好世界"]}`)
    if err != nil {
        panic(err)
    }
    fmt.Printf("%d %s\n", code, string(resp))
}
```

--------------------------------

### Speech Translation with Golang SDK

Source: https://www.volcengine.com/docs/4640/127504

Uses vcloud-sdk-golang and gorilla/websocket to interact with the translation service. Includes helper functions for reading local audio files and constructing the service client.

```go
package main

import (
        "bytes"
        "encoding/json"
        "io"
        "io/ioutil"
        "net/http"
        "net/url"
        "os"
        "sync"
        "time"

        "github.com/gorilla/websocket"
        "github.com/volcengine/volc-sdk-golang/base"
)

const (
        accessKey = "accessKey" // https://console.volcengine.com/iam/keymanage/
        secretKey = "secretKey"
)

const (
        kServiceVersion20200601 = "2020-06-01"
        kSpeechTranslateAction  = "SpeechTranslate"
        kHost                   = "translate.volces.com"
)

func fromLocal(path string) (*bytes.Reader, error) {
        f, err := os.Open(path)
        if err != nil {
                return nil, err
        }
        defer f.Close()
        data, err := ioutil.ReadAll(f)
        if err != nil {
                return nil, err
        }
        return bytes.NewReader(data), nil
}

func newServiceInfo(host string) *base.ServiceInfo {
        return &base.ServiceInfo{
                Timeout:     5 * time.Second,
                Host:        host,
                Header:      http.Header{},
                Credentials: base.Credentials{Region: base.RegionCnNorth1, Service: "translate"},
        }
}

func newClient(host string, accessKey string, secretKey string) *base.Client {
        client := base.NewClient(newServiceInfo(host), map[string]*base.ApiInfo{
                kSpeechTranslateAction: {
                        Method: http.MethodGet,
                        Path:   "/api/translate/speech/v1/",
                        Query: url.Values{
                                "Action":  []string{kSpeechTranslateAction},
                                "Version": []string{kServiceVersion20200601},
                        },
                },
        })
        client.SetAccessKey(accessKey)
        client.SetSecretKey(secretKey)
        return client
}

func newAudioData(data []byte) []byte {
        type AudioDataReq struct {
                AudioData []byte `json:"AudioData"`
        }
        audioData := &AudioDataReq{
                AudioData: data,
        }
        b, err := json.Marshal(audioData)
        if err != nil {
                println(err.Error())
                return []byte{0}
        }
        return b
}
```

--------------------------------

### 使用 Python 调用文本语种检测API

Source: https://www.volcengine.com/docs/4640/65066

使用 volc-sdk-python 进行语种检测的示例代码。需配置 AccessKey 和 SecretKey，并设置正确的服务信息。

```python
import json

from volcengine.ApiInfo import ApiInfo
from volcengine.Credentials import Credentials
from volcengine.ServiceInfo import ServiceInfo
from volcengine.base.Service import Service

k_access_key = '密钥管理中的 AccessKey ID' # https://console.volcengine.com/iam/keymanage/
k_secret_key = '密钥管理中的 AccessKey Secret'
k_timeout = 5  # second
k_service_info = \
    ServiceInfo('translate.volcengineapi.com',
                {'Content-Type': 'application/json'},
                Credentials(k_access_key, k_secret_key, 'translate', 'cn-north-1'),
                5,
                5)
k_query = {
    'Action': 'LangDetect',
    'Version': '2020-06-01'
}
k_api_info = {
    'langdetect': ApiInfo('POST', '/', k_query, {}, {})
}
service = Service(k_service_info, k_api_info)
body = {
    'TextList': ['Hello world', 'こんにちは世界'],
}
print(service.json('langdetect', {}, json.dumps(body)))
```

--------------------------------

### Node.js WebSocket语音翻译客户端

Source: https://www.volcengine.com/docs/4640/127504

使用vcloud-sdk-nodejs和ws库，通过WebSocket连接调用SpeechTranslate API。需要配置访问密钥和音频文件audio.wav。发送配置后，以200*32字节块读取音频并发送，最后发送End信号。

```typescript
import {Signer} from "@volcengine/openapi";
import {Credentials, RequestObj} from "@volcengine/openapi/lib/base/types";
import WebSocket from 'ws';
import * as fs from 'fs';
import {open} from 'node:fs/promises';
import {sleep} from "@volcengine/openapi/lib/services/rocketmq/utils/common";

const host = "translate.volces.com"
const path = "/api/translate/speech/v1/"

function getWebsocketUrl(): string {
    const openApiRequestData: RequestObj = {
        method: "GET",
        region: "cn-north-1",
        params: {
            Action: "SpeechTranslate",
            Version: "2020-06-01",
        },
        pathname: "/api/translate/speech/v1/"
    };

    const credentials: Credentials = {
        accessKeyId: "your access key",
        secretKey: "your secret key",
    };

    const signer = new Signer(openApiRequestData, "translate");
    return 'wss://' + host + path + '?' + signer.getSignUrl(credentials);
}

console.log(getWebsocketUrl());
const ws = new WebSocket(getWebsocketUrl());
ws.on('open', async () => {
    console.log("onopen")
    let configuration = {
        "Configuration": {
            "SourceLanguage": "en",
            "TargetLanguages": [
                "zh"
            ],
            "HotWordList": [
                {
                    "Word": "hello",
                    "Scale": 1
                }
            ],
            "Extra": {}
        }
    };
    ws.send(JSON.stringify(configuration));
    let readStream = fs.createReadStream('audio.wav');
    readStream.on('readable', async () => {
        let chunk = readStream.read(200 * 32);
        while (chunk !== null) {
            await sleep(200).catch(e => {
                console.error(e);
            })
            let audio = {
                "AudioData": Buffer.from(chunk).toString("base64")
            };
            ws.send(JSON.stringify(audio));
            chunk = readStream.read(200 * 32);
        }
        ws.send(JSON.stringify({
            "End": true
        }));
    })
});

ws.on('message', (data) => {
    console.log("%s", data);
});

ws.on("close", () => {
    console.log("onclose")
});

ws.on("error", (err) => {
    console.error(err)
});

ws.on("ping", () => {
    console.log("headers")
});
ws.on("pong", () => {
});



typescript

```

--------------------------------

### WEBSOCKET wss://translate.volces.com/api/translate/speech/v1/

Source: https://www.volcengine.com/docs/4640/127504

实时语音翻译API集成语音识别、智能断句、文本翻译等技术能力，可以将实时语音流、音频文件识别成文字并翻译成目标语言，达到“边说边译”的效果。

```APIDOC
## WEBSOCKET wss://translate.volces.com/api/translate/speech/v1/

### Description
实时语音翻译API集成语音识别、智能断句、文本翻译等技术能力，可以将实时语音流、音频文件识别成文字并翻译成目标语言，达到“边说边译”的效果。

### Method
WEBSOCKET

### Endpoint
wss://translate.volces.com/api/translate/speech/v1/

### Authentication
使用火山引擎鉴权sdk，详情参照公共参数。

| 参数名 | 值 |
|---|---|
| Version | 2020-06-01 |
| Action | SpeechTranslate |
| Path | /api/translate/speech/v1/ |

### Request Body
服务使用websocket协议。

#### Configuration
建立websocket之后第一包发送配置包如下：

| 字段 | 类型 | 是否为必须项 | 说明 | 备注 |
|---|---|---|---|---|
| SourceLanguage | String | 是 | 源语言 | 仅支持zh ja en |
| TargetLanguages | [String] | 是 | 目标语言 | 对齐文本翻译支持列表：语言支持 |
| HotWordList | [Object] | 否 | 热词 | 在语音识别时，接口更倾向于识别成热词的内容 |

```json
{
    "Configuration": {
        "SourceLanguage": "zh",
        "TargetLanguages": [
            "en"
        ],
        "HotWordList": [
            {
                "Word": "hello",
                "Scale": 1
            }
        ]
    }
}
```

#### AudioData
发送Configuratoin之后可以发送二进制数组的音频数据包，采样率为16000hz，单声道，使用base64编码，推荐每100-200ms发送一包。

| 字段 | 类型 | 是否为必须项 | 说明 | 备注 |
|---|---|---|---|---|
| AudioData | String | 是 | 音频包的base64编码 | 无 |

```json
{
    "AudioData": "YQ=="
}
```

#### End
bool值，只要发送了就表示音频发送结束。

| 字段 | 类型 | 是否为必须项 | 说明 | 备注 |
|---|---|---|---|---|
| End | Bool | 是 | 音频包发送完成时发 | 不论true，false，server接收到包后会处理完剩余的音频包以及相关的翻译，全部结束后会断开websocket |

```json
{
    "End": true
}
```

### Response

#### Success Response

| 字段 | 类型 | 说明 | 备注 |
|---|---|---|---|
| ResponseMetadata | ResponseMetadata | 通用字段 | 无 |
| Subtitle | Object | 包含翻译结果、时间、语言等信息的结果 | 无 |

Subtitle字段：

| 字段 | 类型 | 说明 | 备注 |
|---|---|---|---|
| Text | String | 返回的结果 | 当某两个结果的Sequence和Definite一致时，结果中的Text分别代表原文及其译文 |
| BeginTime | Int | 该文本识别的开始时间 | 无 |
| EndTime | Int | 该文本识别的结束时间 | 无 |
| Definite | Bool | 文本是否确定 | true：语音已结束；false：语音进行中 |
| Language | String | 语言 | 无 |
| Sequence | Int | 序列号 | 文本片段的序号 |

```json
{
    "Subtitle": {
        "Text": "i'm elise hugh this is ted talk daily",
        "BeginTime": 4070,
        "EndTime": 6955,
        "Definite": false,
        "Language": "en",
        "Sequence": 8
    },
    "ResponseMetaData": {
        "RequestId": "7088303501725501476",
        "Action": "SpeechTranslate",
        "Version": "2020-06-01",
        "Service": "translate",
        "Region": "cn-north-1"
    }
}
```

#### Error Response
在接口错误时，错误信息会在ResponseMetadata.Error中，包含了错误类型Code:: String和错误信息Message:: String两个字段。

| 错误码 | 说明 |
|---|---|
| -301 | 音频间隔过长 |
| -400 | 请求参数错误，具体错误可参考Message信息 |
| -401 | 未授权用户 |
| -403 | 无权限 |
| -429 | 请求过于频繁 |
| -5xx | 翻译引擎内部错误 |
| 100001-100021 | 通用错误 |

### Audio Requirements
- 采样率：16000hz
- 采样位：16
- 单声道
- 格式：wav或pcm（格式错误会导致识别效果差，返回时间戳错误等一系列问题，所以一定要确保自己发送的格式正确。）
- 音频内容需使用base64编码
```

--------------------------------

### TranslateImage API with Python

Source: https://www.volcengine.com/docs/4640/65105

Uses the volc-sdk-python to translate an image. Requires setting your AccessKey ID and Secret Key from the Volcengine console.

```python
import json
import requests
import base64
import time

from volcengine.ApiInfo import ApiInfo
from volcengine.Credentials import Credentials
from volcengine.ServiceInfo import ServiceInfo
from volcengine.base.Service import Service

# 示例图片url
img_url = 'https://s1.ax1x.com/2020/07/07/UAtqnf.png'

k_access_key = '密钥管理中的 AccessKey ID' # https://console.volcengine.com/iam/keymanage/
k_secret_key = '密钥管理中的 AccessKey Secret'
k_timeout = 5  # second
k_service_info = \
    ServiceInfo('translate.volcengineapi.com',
                {'Content-Type': 'application/json'},
                Credentials(k_access_key, k_secret_key, 'translate', 'cn-north-1'),
                5,
                5)
k_query = {
    'Action': 'TranslateImage',
    'Version': '2020-07-01'
}
k_api_info = {
    'translate': ApiInfo('POST', '/', k_query, {}, {})
}
service = Service(k_service_info, k_api_info)

img_data = requests.get(img_url).content
img_base64 = str(base64.b64encode(img_data), encoding='utf8')
body = {
    'Image': img_base64,
    'TargetLanguage': "zh"}
res_data = service.json('translate', {}, json.dumps(body))
print(res_data)
```

--------------------------------

### Submit and query audio translation task with volc-sdk-python

Source: https://www.volcengine.com/docs/4640/78985

Uses the volc-sdk-python dependency to submit an audio translation task and poll for its result. Requires valid AccessKey ID and Secret from the Volcengine IAM console. The script prints the task ID, then polls every 60 seconds until the status becomes 'success', printing each subtitle's timing, text, and translation.

```python
import json
import time

from volcengine.ApiInfo import ApiInfo
from volcengine.Credentials import Credentials
from volcengine.ServiceInfo import ServiceInfo
from volcengine.base.Service import Service

k_access_key = '密钥管理中的 AccessKey ID' # https://console.volcengine.com/iam/keymanage/
k_secret_key = '密钥管理中的 AccessKey Secret'
k_timeout = 5  # second
k_service_info = \
    ServiceInfo('translate.volcengineapi.com',
                {'Content-Type': 'application/json'},
                Credentials(k_access_key, k_secret_key, 'translate', 'cn-north-1'),
                5,
                5)
k_api_info = {
    'submit_audio': ApiInfo('POST', '/', {
        'Action': 'SubmitAudio',
        'Version': '2020-06-01'
    }, {}, {}),
    'query_audio': ApiInfo('POST', '/', {
        'Action': 'QueryAudio',
        'Version': '2020-06-01'
    }, {}, {}),

}
service = Service(k_service_info, k_api_info)

# 提交任务
submit_body = {
    'SourceLanguage': 'en',
    'TargetLanguage': 'zh',
    'Uri': "http://xx/xx.mp4",
}
submit_result = json.loads(service.json('submit_audio', {}, json.dumps(submit_body)))
task_id = submit_result["TaskId"]
print(task_id)

# 查询任务
status = "created"
while status == "created":
    time.sleep(60)
    query_body = {
        'TaskId': task_id,
    }
    query_result = json.loads(service.json('query_audio', {}, json.dumps(query_body)))
    status = query_result["Status"]
    print(status)
    if status == "success":
        for subtitle in query_result["Subtitles"]:
            print("{} - {}: {} -> {}".format(subtitle["StartTime"],
                                             subtitle["EndTime"],
                                             subtitle["Text"],
                                             subtitle["Translation"]))

```

--------------------------------

### TranslateImage API with Go

Source: https://www.volcengine.com/docs/4640/65105

Uses the volc-sdk-golang to translate an image. Requires configuring the ServiceInfo and ApiInfoList with your credentials.

```golang
package main

import (
    "encoding/base64"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
    "net/url"
    "time"

    "github.com/volcengine/volc-sdk-golang/base"
)

const (
    kAccessKey      = "密钥管理中的 AccessKey ID" // https://console.volcengine.com/iam/keymanage/
    kSecretKey      = "密钥管理中的 AccessKey Secret"
    kServiceVersion = "2020-07-01"

    // 示例图片url
    imgUrl = "https://s1.ax1x.com/2020/07/07/UAtqnf.png"
)

var (
    ServiceInfo = &base.ServiceInfo{
        Timeout: 5 * time.Second,
        Host:    "translate.volcengineapi.com",
        Header: http.Header{
            "Accept": []string{"application/json"},
        },
        Credentials: base.Credentials{Region: base.RegionCnNorth1, Service: "translate"},
    }
    ApiInfoList = map[string]*base.ApiInfo{
        "TranslateImage": {
            Method: http.MethodPost,
            Path:   "/",
            Query: url.Values{
                "Action":  []string{"TranslateImage"},
                "Version": []string{kServiceVersion},
            },
        },
    }
)

func newClient() *base.Client {
    client := base.NewClient(ServiceInfo, ApiInfoList)
    client.SetAccessKey(kAccessKey)
    client.SetSecretKey(kSecretKey)
    return client
}

func main() {
    imgRes, _ := http.Get(imgUrl)
    defer imgRes.Body.Close()
    imgData, _ := ioutil.ReadAll(imgRes.Body)
    imgBase64 := base64.StdEncoding.EncodeToString(imgData)
    jsonBody := map[string]string{
        "Image": imgBase64,
        "TargetLanguage": "zh"}
    body, _ := json.Marshal(jsonBody)

    client := newClient()
    res, code, err := client.Json("TranslateImage", nil, string(body))
    if err != nil {
        panic(err)
    }
    fmt.Printf("%d %s\n", code, string(res))
}
```

--------------------------------

### Java: Maven dependencies for WebSocket speech translation

Source: https://www.volcengine.com/docs/4640/127504

Maven pom.xml snippet listing required dependencies for using Java WebSocket client, SLF4J logging, and the Volcengine Java SDK. Placeholders like {version} must be replaced with actual versions.

```xml
<dependencies>
        <dependency>
            <groupId>javax.websocket</groupId>
            <artifactId>javax.websocket-client-api</artifactId>
            <version>{version}</version>
        </dependency>

        <dependency>
            <groupId>org.java-websocket</groupId>
            <artifactId>Java-WebSocket</artifactId>
            <version>1{version}</version>
        </dependency>

        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-simple</artifactId>
            <version>{version}</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>{version}</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/com.volcengine/volc-sdk-java -->
        <dependency>
            <groupId>com.volcengine</groupId>
            <artifactId>volc-sdk-java</artifactId>
            <version>{version}</version>
        </dependency>

</dependencies>
```

--------------------------------

### TranslateConfig.java - Configure Speech Translate API

Source: https://www.volcengine.com/docs/4640/127504

Defines access keys, API name, path, host, and service info for the Volcengine Speech Translate API. Sets connection and socket timeouts, headers, credentials, and API method/path/query parameters.

```java
//src/main/java/translate/TranslateConfig.java
package translate;

import com.volcengine.helper.Const;
import com.volcengine.model.ApiInfo;
import com.volcengine.model.Credentials;
import com.volcengine.model.ServiceInfo;
import org.apache.http.Header;
import org.apache.http.NameValuePair;
import org.apache.http.message.BasicHeader;
import org.apache.http.message.BasicNameValuePair;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;

public class TranslateConfig {
    public static String accessKey = "your access key";
    public static String secretKey = "your secret key";
    public static String api = "SpeechTranslate";
    public static String path = "/api/translate/speech/v1/";
    public static String host = "translate.volces.com";

    public static ServiceInfo serviceInfo = new ServiceInfo(
            new HashMap<>() {
                {
                    put(Const.CONNECTION_TIMEOUT, 5000);
                    put(Const.SOCKET_TIMEOUT, 5000);
                    put(Const.Host, host);
                    put(Const.Header, new ArrayList<Header>() {
                        {
                            add(new BasicHeader("Accept", "application/json"));
                        }
                    });
                    put(Const.Credentials, new Credentials(Const.REGION_CN_NORTH_1, "translate"));
                }
            }
    );
    public static Map<String, ApiInfo> apiInfoList = new HashMap<>() {
        {
            put(api, new ApiInfo(
                    new HashMap<>() {
                        {
                            put(Const.Method, "GET");
                            put(Const.Path, path);
                            put(Const.Query, new ArrayList<NameValuePair>() {
                                {
                                    add(new BasicNameValuePair("Action", api));
                                    add(new BasicNameValuePair("Version", "2020-06-01"));
                                }
                            });
                        }
                    }
            ));
        }
    };
}
```

--------------------------------

### TranslateImage API with Java

Source: https://www.volcengine.com/docs/4640/65105

Snippet for using the volc-sdk-java to perform image translation. Assumes an existing translateService instance.

```java
//            byte[] input = new byte[10]; // read file
            String base64Image = Base64.getEncoder().encodeToString(input);

            TranslateImageRequest translateImageRequest = new TranslateImageRequest();
            translateImageRequest.setTargetLanguage("zh");
            translateImageRequest.setImage(base64Image);

            TranslateImageResponse translateImageResponse = translateService.translateImage(translateImageRequest);
            System.out.println(JSON.toJSONString(translateImageResponse.getResponseMetadata()));
            System.out.println(JSON.toJSONString(translateImageResponse.getResult()));
            byte[] output = Base64.getDecoder().decode(translateImageResponse.getImage());
            // write file
```

--------------------------------

### POST /submit-audio-translation-task

Source: https://www.volcengine.com/docs/4640/78985

Submits an audio/video file translation task. This is the first step of the audio/video file translation API, which integrates speech recognition, intelligent sentence segmentation, and machine translation to process audio/video files.

```APIDOC
## POST /submit-audio-translation-task

### Description
Submits an audio/video file translation task. This is the first step of the audio/video file translation API, which integrates speech recognition, intelligent sentence segmentation, and machine translation to process audio/video files.

### Method
POST

### Endpoint
Not specified in the source. The API is invoked via a POST request with the request body described below.

### Parameters
#### Request Body
- **SourceLanguage** (String) - Required - Source language. Supported values: en, zh, ko.
- **TargetLanguage** (String) - Required - Target language. Supported values: en, zh, ko, ja, pt, fr, de, es.
- **Uri** (String) - Required - URL of the video/audio file to be translated. It is recommended to use with video-on-demand service to avoid server-side download failures.

### Request Example
{
    "SourceLanguage": "en",
    "TargetLanguage": "zh",
    "Uri": "http://xx/xx.mp4"
}

### Response
#### Success Response (200)
- **ResponseMetadata** (ResponseMetadata) - Common metadata.
- **TaskId** (String) - Task ID for querying the result later.

#### Response Example
{
    "TaskId": "asdasda",
    "ResponseMetadata": {
        "RequestId": "202004092306480100140440781F5D7119",
        "Action": "SubmitAudio",
        "Version": "2020-06-01",
        "Service": "translate",
        "Region": "cn-north-1",
        "Error": null
    }
}
```

--------------------------------

### Speech Translation with Python SDK

Source: https://www.volcengine.com/docs/4640/127504

Uses volc-sdk-python and websocket-client to stream audio data to the translation service. Requires valid access and secret keys from the Volcengine console.

```python
# 需要引入https://github.com/volcengine/volc-sdk-python
import base64
import json
import threading
import time

import websocket
from volcengine.ApiInfo import ApiInfo
from volcengine.Credentials import Credentials
from volcengine.ServiceInfo import ServiceInfo
from volcengine.base.Service import Service

k_access_key = "k_access_key" # https://console.volcengine.com/iam/keymanage/
k_secret_key = "k_secret_key"
k_host = 'translate.volces.com'
k_path = '/api/translate/speech/v1/'
k_timeout = 5  # second
k_service_info = \
    ServiceInfo(k_host,
                {'Content-Type': 'application/json'},
                Credentials(k_access_key, k_secret_key, 'translate', 'cn-north-1'),
                5,
                5)
k_query = {
    'Action': 'SpeechTranslate',
    'Version': '2020-06-01'
}
k_api_info = {
    'SpeechTranslate': ApiInfo('GET', k_path, k_query, {}, {})
}

file_path = './audio.wav'  # 音频的文件


def get_websocket_url():
    service = Service(k_service_info, k_api_info)
    url = 'wss://' + k_host + k_path + '?' + service.get_sign_url("SpeechTranslate", {})
    return url


def send_audio(ws):
    file = open(file_path, 'rb')
    while True:
        chunk = file.read(200 * 32)
        if not chunk:
            break
        audio = {
            "AudioData": base64.b64encode(chunk).decode('utf-8')
        }
        ws.send(json.dumps(audio))
        time.sleep(0.2)
    end = {
        "End": True
    }
    ws.send(json.dumps(end))


def recv(ws):
    while True:
        print(ws.recv().decode("utf-8"))


if __name__ == '__main__':
    websocket.enableTrace(False)
    ws = websocket.WebSocket()
    ws.connect(get_websocket_url(),
               header=["Content-Type: application/json"])
    configuration = {
        "Configuration": {
            "SourceLanguage": "zh",
            "TargetLanguages": [
                "en"
            ],
            "HotWordList": [
                {
                    "Word": "hello",
                    "Scale": 1
                }
            ]
        }
    }
    ws.send(json.dumps(configuration))
    t2 = threading.Thread(target=recv, args=(ws,))
    t1 = threading.Thread(target=send_audio, args=(ws,))
    t2.start()
    t1.start()
```

--------------------------------

### 提交音视频翻译任务请求与响应

Source: https://www.volcengine.com/docs/4640/78985

提交翻译任务的请求体包含源语言、目标语言和文件链接，响应返回任务ID。

```json
{
    "SourceLanguage": "en",
    "TargetLanguage": "zh",
    "Uri": "http://xx/xx.mp4"
}
```

```json
{
    "TaskId": "asdasda",
    "ResponseMetadata": {
        "RequestId": "202004092306480100140440781F5D7119",
        "Action": "SubmitAudio",
        "Version": "2020-06-01",
        "Service": "translate",
        "Region": "cn-north-1",
        "Error": null
    }
}
```

--------------------------------

### 文本语种检测API 请求与返回样例

Source: https://www.volcengine.com/docs/4640/65066

展示了调用文本语种检测接口的JSON请求体格式以及对应的返回体结构，包含语言代码和置信度信息。

```json
{
    "TextList": [
        "Hello world"
    ]
}
```

```json
{
    "DetectedLanguageList": [
        {
            "Language": "en",
            "Confidence": 1
        }
    ],
    "ResponseMetadata": {
        "RequestId": "202004092241580100140440770840151B",
        "Action": "LangDetect",
        "Version": "2020-06-01",
        "Service": "translate",
        "Region": "cn-north-1",
        "Error": null
    }
}
```

--------------------------------

### Client.java - WebSocket Client for Speech Translate

Source: https://www.volcengine.com/docs/4640/127504

Implements a WebSocket client that prints connection events and received messages. Handles both text and binary messages, and prints errors.

```java
// src/main/java/websocket/Client.java
package websocket;

import org.java_websocket.client.WebSocketClient;
import org.java_websocket.handshake.ServerHandshake;

import java.net.URI;
import java.nio.ByteBuffer;
import java.nio.charset.StandardCharsets;

public class Client extends WebSocketClient {
    public Client(URI serverUri) {
        super(serverUri);
    }

    @Override
    public void onOpen(ServerHandshake serverHandshake) {
        System.out.println("onopen");
    }

    @Override
    public void onMessage(String s) {
        System.out.println("onmessage");
        System.out.println(s);
    }
    @Override
    public void onMessage(ByteBuffer message) {
        System.out.println("onmessage");
        System.out.println(new String(message.array(), StandardCharsets.UTF_8));
    }

    @Override
    public void onClose(int i, String s, boolean b) {

        System.out.println("onclose");
    }

    @Override
    public void onError(Exception e) {
        e.printStackTrace();
    }
}
```

--------------------------------

### TranslateService.java - Extend BaseServiceImpl

Source: https://www.volcengine.com/docs/4640/127504

Defines a service class that extends BaseServiceImpl, taking ServiceInfo and API info map as constructor arguments. Used to interact with the Volcengine Speech Translate API.

```java
// src/main/java/translate/TranslateService.java
package translate;

import com.volcengine.model.ApiInfo;
import com.volcengine.model.ServiceInfo;
import com.volcengine.service.BaseServiceImpl;

import java.util.Map;

public class TranslateService extends BaseServiceImpl {

    public TranslateService(ServiceInfo info, Map<String, ApiInfo> apiInfoList) {
        super(info, apiInfoList);
    }
}
```

--------------------------------

### POST /

Source: https://www.volcengine.com/docs/4640/65066

Detects the language of the provided text list. Supports 140 languages and returns the most reliable result.

```APIDOC
## POST /

### Description
Detects the language of the provided text list. Supports 140 languages and returns the most reliable result.

### Method
POST

### Endpoint
/

### Parameters
#### Request Body
- **TextList** ([String]) - Required - The list of texts to detect. List length must not exceed 16.

### Request Example
{
    "TextList": [
        "Hello world"
    ]
}

### Response
#### Success Response (200)
- **ResponseMetadata** (ResponseMetadata) - Common fields.
- **DetectedLanguageList** ([DetectedLanguage]) - List of detected languages.
  - **Language** (String) - Detection result.
  - **Confidence** (Double) - Confidence score, range 0-1; higher means more reliable.

#### Response Example
{
    "DetectedLanguageList": [
        {
            "Language": "en",
            "Confidence": 1
        }
    ],
    "ResponseMetadata": {
        "RequestId": "202004092241580100140440770840151B",
        "Action": "LangDetect",
        "Version": "2020-06-01",
        "Service": "translate",
        "Region": "cn-north-1",
        "Error": null
    }
}
```

--------------------------------

### Java 音频翻译任务提交与查询

Source: https://www.volcengine.com/docs/4640/78985

该示例演示了创建翻译任务、等待处理以及根据任务 ID 查询翻译结果的完整调用流程。

```java
// 提交任务，获取任务ID
            TranslateAudioSubmitRequest translateAudioSubmitRequest = new TranslateAudioSubmitRequest();
            translateAudioSubmitRequest.setSourceLanguage("en");
            translateAudioSubmitRequest.setTargetLanguage("zh");
            translateAudioSubmitRequest.setUri("http://xx/xx.mp4");
            TranslateAudioSubmitResponse translateAudioSubmitResponse = translateService.translateAudioSubmit(translateAudioSubmitRequest);
            System.out.println(JSON.toJSONString(translateAudioSubmitResponse));
            // 等待任务完成
            Thread.sleep(5000); // 视频时长*0.3
            // 查询结果
            TranslateAudioQueryRequest translateAudioQueryRequest = new TranslateAudioQueryRequest();
            translateAudioQueryRequest.setTaskId(translateAudioSubmitResponse.getTaskId());
            TranslateAudioQueryResponse translateAudioQueryResponse = translateService.translateAudioQuery(translateAudioQueryRequest);
            System.out.println(JSON.toJSONString(translateAudioQueryResponse));
```
Tokens:
Raw
火山引擎 机器翻译

火山引擎机器翻译
