有道翻译电脑版插件开发入门：创建自定义翻译扩展

mkdir youdao-custom-plugin && cd youdao-custom-plugin
python -m venv venv  # 创建虚拟环境
# Windows: venv\Scripts\activate
# macOS/Linux: source venv/bin/activate
pip install flask requests  # 安装Flask（Web框架）和requests（HTTP库）

# terminology_manager.py
import json
import os

class TerminologyManager:
    def __init__(self, term_file='terminology.json'):
        self.term_file = term_file
        self.terminology = self._load_terminology()

    def _load_terminology(self):
        """从JSON文件加载术语库"""
        if os.path.exists(self.term_file):
            try:
                with open(self.term_file, 'r', encoding='utf-8') as f:
                    return json.load(f)
            except json.JSONDecodeError:
                print(f"术语库文件 {self.term_file} 格式错误，将使用空术语库。")
                return {}
        else:
            # 创建示例术语库
            sample_terms = {
                "AI": {"zh-CN": "人工智能", "note": "技术领域"},
                "Machine Learning": {"zh-CN": "机器学习", "note": "AI子领域"},
                "API": {"zh-CN": "应用程序接口", "note": "编程术语"},
                "neural network": {"zh-CN": "神经网络", "note": "深度学习基础"}
            }
            self._save_terminology(sample_terms)
            return sample_terms

    def _save_terminology(self, data):
        """保存术语库到JSON文件"""
        with open(self.term_file, 'w', encoding='utf-8') as f:
            json.dump(data, f, ensure_ascii=False, indent=2)

    def lookup(self, source_text, from_lang='en', to_lang='zh-CN'):
        """查询术语翻译，支持简单的大小写忽略匹配"""
        # 这里可以实现更复杂的匹配算法，如分词、模糊匹配等
        key = source_text.strip()
        # 尝试精确匹配
        if key in self.terminology:
            return self.terminology[key].get(to_lang) or self.terminology[key].get('zh-CN')
        # 尝试小写匹配
        if key.lower() in [k.lower() for k in self.terminology.keys()]:
            for term_key, trans in self.terminology.items():
                if term_key.lower() == key.lower():
                    return trans.get(to_lang) or trans.get('zh-CN')
        return None

    def add_term(self, source, translation, to_lang='zh-CN', note=''):
        """添加新术语"""
        self.terminology[source] = {to_lang: translation, 'note': note}
        self._save_terminology(self.terminology)
        return True

# 实例化术语管理器
term_manager = TerminologyManager()

# youdao_api.py
import requests
import hashlib
import uuid
import time

# 请替换为你在有道智云申请的实际密钥
APP_KEY = 'YOUR_APP_KEY_HERE'
APP_SECRET = 'YOUR_APP_SECRET_HERE'
YOUDAO_API_URL = 'https://openapi.youdao.com/api'

def translate_with_youdao(text, from_lang='en', to_lang='zh-CHS'):
    """
    调用有道智云文本翻译API
    文档参考：https://ai.youdao.com/DOCSIRMA/html/trans/api/wbfy/index.html
    """
    if not APP_KEY or not APP_SECRET:
        raise ValueError("请先配置有道智云的APP_KEY和APP_SECRET")

    salt = str(uuid.uuid1())
    curtime = str(int(time.time()))
    sign_str = APP_KEY + text + salt + curtime + APP_SECRET
    sign = hashlib.sha256(sign_str.encode('utf-8')).hexdigest()

    data = {
        'q': text,
        'from': from_lang,
        'to': to_lang,
        'appKey': APP_KEY,
        'salt': salt,
        'sign': sign,
        'signType': 'v3',
        'curtime': curtime,
    }

    try:
        response = requests.post(YOUDAO_API_URL, data=data, timeout=10)
        result = response.json()
        if result.get('errorCode') == '0':
            # 成功返回
            return {
                'success': True,
                'translation': result.get('translation', [''])[0],
                'original': text,
                'source_lang': from_lang,
                'target_lang': to_lang,
                'raw': result  # 原始响应，可能包含词典、音标等信息
            }
        else:
            return {
                'success': False,
                'error_code': result.get('errorCode'),
                'error_msg': result.get('errorMsg', '未知错误'),
                'original': text
            }
    except requests.exceptions.RequestException as e:
        return {
            'success': False,
            'error_msg': f'网络请求失败: {str(e)}',
            'original': text
        }

# app.py
from flask import Flask, request, jsonify
from terminology_manager import term_manager
from youdao_api import translate_with_youdao
import re

app = Flask(__name__)

@app.route('/health', methods=['GET'])
def health_check():
    """健康检查端点"""
    return jsonify({'status': 'ok', 'service': 'Youdao Custom Translator Plugin'})

@app.route('/translate', methods=['POST'])
def translate():
    """
    核心翻译端点。
    接收JSON: {"text": "要翻译的文本", "from": "en", "to": "zh-CHS"}
    返回增强后的翻译结果。
    """
    data = request.get_json()
    if not data or 'text' not in data:
        return jsonify({'error': '缺少 text 字段'}), 400

    source_text = data['text']
    from_lang = data.get('from', 'en')
    to_lang = data.get('to', 'zh-CHS')

    # 步骤1：查询本地术语库
    term_translation = term_manager.lookup(source_text, from_lang, to_lang)
    if term_translation:
        # 如果术语库命中，直接返回，并标记为术语翻译
        return jsonify({
            'original': source_text,
            'translation': term_translation,
            'source_lang': from_lang,
            'target_lang': to_lang,
            'enhanced': True,
            'type': 'terminology',
            'message': '翻译结果来自本地术语库'
        })

    # 步骤2：术语库未命中，调用有道官方API
    api_result = translate_with_youdao(source_text, from_lang, to_lang)

    if not api_result['success']:
        # API调用失败，直接返回错误
        return jsonify(api_result), 500

    final_translation = api_result['translation']

    # 步骤3：（可选）对API返回结果进行后处理 - 例如，高亮已知术语
    # 这里实现一个简单的示例：检查翻译结果中是否包含我们术语库里的中文术语，并加上标记
    enhanced_translation = final_translation
    for term, info in term_manager.terminology.items():
        chn_trans = info.get('zh-CN')
        if chn_trans and chn_trans in final_translation:
            # 用HTML标记高亮，实际可根据前端需求调整格式
            enhanced_translation = enhanced_translation.replace(chn_trans, f'<span class="term-highlight">{chn_trans}</span>')

    api_result['translation'] = enhanced_translation
    api_result['enhanced'] = True if enhanced_translation != final_translation else False
    api_result['type'] = 'api_with_post_process'

    return jsonify(api_result)

@app.route('/terminology', methods=['GET', 'POST'])
def manage_terminology():
    """管理术语库的端点"""
    if request.method == 'GET':
        # 返回所有术语（可考虑分页）
        return jsonify(term_manager.terminology)
    else: # POST
        data = request.get_json()
        required_fields = ['source', 'translation']
        if not all(field in data for field in required_fields):
            return jsonify({'error': '缺少必要字段 (source, translation)'}), 400
        success = term_manager.add_term(
            data['source'],
            data['translation'],
            data.get('to_lang', 'zh-CN'),
            data.get('note', '')
        )
        return jsonify({'success': success, 'message': '术语已添加'})

if __name__ == '__main__':
    # 在本地5000端口启动服务，调试模式开启
    app.run(host='127.0.0.1', port=5000, debug=True)

<!DOCTYPE html>
<html>
<head>
    <title>有道翻译自定义插件管理</title>
    <style>
        body { font-family: sans-serif; margin: 2em; }
        .term-highlight { background-color: #fff3cd; padding: 2px 4px; border-radius: 3px; }
        .section { margin-bottom: 2em; border: 1px solid #ddd; padding: 1em; border-radius: 5px;}
        input, textarea { width: 300px; margin: 5px; }
        button { padding: 8px 15px; }
    </style>
</head>
<body>
    <h1>学术术语增强翻译插件</h1>
    <div class="section">
        <h2>即时翻译测试</h2>
        <input type="text" id="inputText" placeholder="输入英文文本..." />
        <button onclick="doTranslate()">翻译</button>
        <p>结果：<span id="translationResult"></span></p>
    </div>
    <div class="section">
        <h2>管理术语库</h2>
        <div>
            <input type="text" id="termSource" placeholder="原文 (如: API)" />
            <input type="text" id="termTrans" placeholder="译文 (如: 应用程序接口)" />
            <input type="text" id="termNote" placeholder="备注 (可选)" />
            <button onclick="addTerm()">添加术语</button>
        </div>
        <h3>现有术语列表</h3>
        <ul id="termList"></ul>
    </div>
    <script>
        const API_BASE = 'http://127.0.0.1:5000';
        async function doTranslate() {
            const text = document.getElementById('inputText').value;
            const resp = await fetch(`${API_BASE}/translate`, {
                method: 'POST',
                headers: {'Content-Type': 'application/json'},
                body: JSON.stringify({text: text, from: 'en', to: 'zh-CHS'})
            });
            const data = await resp.json();
            document.getElementById('translationResult').innerHTML = data.translation || data.error_msg;
        }
        async function loadTerms() {
            const resp = await fetch(`${API_BASE}/terminology`);
            const terms = await resp.json();
            const listEl = document.getElementById('termList');
            listEl.innerHTML = '';
            for (const [source, info] of Object.entries(terms)) {
                const li = document.createElement('li');
                li.innerHTML = `<strong>${source}</strong> -> ${info['zh-CN']} <em>(${info.note || ''})</em>`;
                listEl.appendChild(li);
            }
        }
        async function addTerm() {
            const source = document.getElementById('termSource').value;
            const trans = document.getElementById('termTrans').value;
            const note = document.getElementById('termNote').value;
            await fetch(`${API_BASE}/terminology`, {
                method: 'POST',
                headers: {'Content-Type': 'application/json'},
                body: JSON.stringify({source, translation: trans, note})
            });
            loadTerms(); // 重新加载列表
        }
        // 页面加载时获取术语列表
        window.onload = loadTerms;
    </script>
</body>
</html>

@app.route('/')
def index():
    return render_template('index.html')