Deepseek 字幕翻译脚本

from openai import OpenAI
import srt
import os
import tkinter as tk
from tkinter import filedialog
import time
import string

# ===================== 【配置区自行修改】 =====================
DEEPSEEK_API_KEY = "sk-替换成你的密钥"
BATCH_SIZE = 5       # 调小，降低丢句概率
MODEL_NAME = "deepseek-v4-flash"
REQUEST_INTERVAL = 0.8  # 每批请求间隔，防API限流
MAX_RETRY = 2        # 接口失败重试次数
SKIP_MAX_CHAR = 4    # 少于等于该字符直接跳过翻译
SUFFIX_TAG = ".chn"  # 翻译文件后缀标识
# ==========================================================

client = OpenAI(
    api_key=DEEPSEEK_API_KEY,
    base_url="https://api.deepseek.com"
)

def select_folder_dialog():
    root = tk.Tk()
    root.withdraw()
    folder_path = filedialog.askdirectory(title="请选择存放SRT字幕的源文件夹")
    return folder_path

def is_skip_text(text: str) -> bool:
    """判断是否为短句/语气词/纯符号，需要跳过翻译"""
    txt = text.strip()
    if len(txt) <= SKIP_MAX_CHAR:
        return True
    # 全是标点符号
    all_punc = all(c in string.punctuation + " " for c in txt)
    if all_punc:
        return True
    # 纯数字
    if txt.isdigit():
        return True
    return False

def batch_translate(sub_batch):
    # 拆分：需要翻译的条目 / 直接保留原文的条目
    need_trans = []
    keep_origin = []
    for idx, sub in enumerate(sub_batch):
        if is_skip_text(sub.content):
            keep_origin.append((idx, sub))
        else:
            need_trans.append((idx, sub))

    # 没有需要翻译的，直接返回原批次
    if not need_trans:
        time.sleep(REQUEST_INTERVAL)
        return sub_batch

    # 组装待翻译文本
    send_text = ""
    map_idx = {}  # 记录内部序号对应原始下标
    for inner_id, (ori_idx, sub) in enumerate(need_trans):
        map_idx[inner_id + 1] = ori_idx
        send_text += f"{inner_id+1}\n{sub.content.strip()}\n\n"

    retry = 0
    raw_result = ""
    while retry <= MAX_RETRY:
        try:
            resp = client.chat.completions.create(
                model=MODEL_NAME,
                messages=[
                    {
                        "role": "system",
                        "content": """你是专业影视字幕翻译。
输入是带数字序号的台词，严格按顺序逐条翻译为通顺简体中文。
输出格式：每条译文前带上对应数字，一条序号对应一句译文，不要合并、不要漏译。
只输出译文内容，不加任何解释、注释、多余文字。"""
                    },
                    {"role": "user", "content": f"翻译以下台词：\n{send_text}"}
                ],
                temperature=0.2,
                timeout=15
            )
            raw_result = resp.choices[0].message.content.strip()
            break
        except Exception as e:
            retry += 1
            print(f"批次请求失败，重试{retry}/{MAX_RETRY}，错误：{str(e)}")
            time.sleep(1.2)
            if retry > MAX_RETRY:
                # 多次失败保留原文
                time.sleep(REQUEST_INTERVAL)
                return sub_batch

    # 解析译文
    trans_map = {}
    current_num = None
    current_text = []
    for line in raw_result.splitlines():
        line = line.strip()
        if not line:
            continue
        if line.isdigit():
            if current_num is not None and current_text:
                trans_map[current_num] = " ".join(current_text)
            current_num = int(line)
            current_text = []
        else:
            current_text.append(line)
    if current_num is not None and current_text:
        trans_map[current_num] = " ".join(current_text)

    # 回填翻译
    for inner_seq, ori_idx in map_idx.items():
        if inner_seq in trans_map and trans_map[inner_seq].strip():
            sub_batch[ori_idx].content = trans_map[inner_seq]
            # 双语开启替换上面这行为：
            # sub_batch[ori_idx].content = sub_batch[ori_idx].content + "\n【译】" + trans_map[inner_seq]

    time.sleep(REQUEST_INTERVAL)
    return sub_batch

def process_single_srt(src_dir, filename):
    src_path = os.path.join(src_dir, filename)
    # 构造输出文件名：test.srt → test.chn.srt
    name_no_ext, ext = os.path.splitext(filename)
    out_filename = f"{name_no_ext}{SUFFIX_TAG}{ext}"
    out_path = os.path.join(src_dir, out_filename)

    print(f"\n==== 正在处理：{filename} → {out_filename} ====")
    try:
        with open(src_path, "r", encoding="utf-8") as f:
            subs = list(srt.parse(f.read()))
    except Exception as e:
        print(f"读取字幕失败：{e}")
        return

    total = len(subs)
    for start in range(0, total, BATCH_SIZE):
        end = start + BATCH_SIZE
        chunk = subs[start:end]
        chunk = batch_translate(chunk)
        subs[start:end] = chunk
        print(f"进度：{min(end, total)}/{total}")

    # 保存翻译后字幕到源文件夹
    with open(out_path, "w", encoding="utf-8") as f:
        f.write(srt.compose(subs))
    print(f"文件完成输出：{out_path}")

def main():
    input_dir = select_folder_dialog()
    if not input_dir:
        print("未选择文件夹，程序退出")
        return

    print(f"源目录：{input_dir}")
    print(f"过滤规则：≤{SKIP_MAX_CHAR}字符、纯标点、纯数字自动跳过翻译")
    print(f"输出规则：同目录生成 *.chn.srt 翻译字幕\n")

    all_files = os.listdir(input_dir)
    srt_files = [f for f in all_files if f.lower().endswith(".srt") and SUFFIX_TAG not in f]
    if not srt_files:
        print("文件夹内未找到未翻译的SRT字幕")
        return

    print(f"共检测到 {len(srt_files)} 个字幕文件，开始翻译")
    for filename in srt_files:
        process_single_srt(input_dir, filename)

    print("\n==================== 全部任务结束 ====================")
    print(f"翻译完成的 .chn.srt 文件保存在原字幕同一目录")

if __name__ == "__main__":
    main()