feat: 添加PDF翻译Web工具完整项目结构

实现PDF翻译Web工具的核心功能，包括：
- FastAPI REST API服务器
- Gradio Web界面
- Python客户端SDK
- Docker部署支持
- 完整文档和测试用例

新增配置文件和环境变量支持，优化项目结构便于维护和扩展

Dockerfile

@@ -0,0 +1,110 @@
+FROM modelscope-registry.us-west-1.cr.aliyuncs.com/modelscope-repo/modelscope:ubuntu22.04-py311-torch2.3.1-1.28.0
+
+ENV DEBIAN_FRONTEND=noninteractive \
+    TZ=Asia/Shanghai
+
+# Remove any third-party apt sources and install basic utilities
+RUN rm -f /etc/apt/sources.list.d/*.list && \
+    apt-get update && apt-get install -y --no-install-recommends \
+    curl \
+    ca-certificates \
+    sudo \
+    git \
+    wget \
+    procps \
+    git-lfs \
+    zip \
+    unzip \
+    htop \
+    vim \
+    nano \
+    bzip2 \
+    libx11-6 \
+    build-essential \
+    libsndfile-dev \
+    software-properties-common \
+ && rm -rf /var/lib/apt/lists/*
+
+# Add cloudflare gpg key
+RUN mkdir -p --mode=0755 /usr/share/keyrings && \
+    curl -fsSL https://pkg.cloudflare.com/cloudflare-main.gpg | tee /usr/share/keyrings/cloudflare-main.gpg >/dev/null
+
+# Add this repo to your apt repositories
+RUN echo 'deb [signed-by=/usr/share/keyrings/cloudflare-main.gpg] https://pkg.cloudflare.com/cloudflared any main' | tee /etc/apt/sources.list.d/cloudflared.list
+
+# install cloudflared
+RUN apt-get update && apt-get install -y cloudflared && rm -rf /var/lib/apt/lists/*
+
+# Install Node.js for Jupyter extensions
+RUN curl -sL https://deb.nodesource.com/setup_21.x | bash - && \
+    apt-get install -y nodejs && \
+    npm install -g configurable-http-proxy
+
+# Define error handling function and install Claude Code CLI
+RUN handle_error() { echo "错误: $1" >&2; exit 1; } && \
+    npm install -g @anthropic-ai/claude-code || handle_error "安装Claude Code CLI失败"
+
+# Create a working directory
+WORKDIR /app
+
+# Create a non-root user and switch to it
+RUN adduser --disabled-password --gecos '' --shell /bin/bash user \
+ && chown -R user:user /app
+RUN echo "user ALL=(ALL) NOPASSWD:ALL" > /etc/sudoers.d/90-user
+USER user
+
+# All users can use /home/user as their home directory
+ENV HOME=/home/user
+RUN mkdir $HOME/.cache $HOME/.config \
+ && chmod -R 777 $HOME
+
+# Set up the Conda environment with Python 3.11
+ENV CONDA_AUTO_UPDATE_CONDA=false \
+    PATH=$HOME/miniconda/bin:$PATH
+RUN curl -sLo ~/miniconda.sh https://repo.continuum.io/miniconda/Miniconda3-py311_23.5.2-0-Linux-x86_64.sh \
+ && chmod +x ~/miniconda.sh \
+ && ~/miniconda.sh -b -p ~/miniconda \
+ && rm ~/miniconda.sh \
+ && conda clean -ya
+
+WORKDIR $HOME/app
+
+#######################################
+# Start root user section
+#######################################
+
+USER root
+
+# Create data directory
+RUN mkdir /data && chown user:user /data
+
+#######################################
+# End root user section
+#######################################
+
+USER user
+
+# Install Python packages using conda and pip
+RUN conda install -c conda-forge python=3.11 && \
+    pip install --no-cache-dir --upgrade pip
+
+# Copy requirements and install Python packages
+COPY --chown=user requirements.txt $HOME/app/
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+# Copy the current directory contents into the container
+COPY --chown=user . $HOME/app
+
+RUN chmod +x start_server.sh
+
+# Set environment variables
+ENV PYTHONUNBUFFERED=1 \
+    GRADIO_ALLOW_FLAGGING=never \
+    GRADIO_NUM_PORTS=1 \
+    GRADIO_SERVER_NAME=0.0.0.0 \
+    GRADIO_THEME=huggingface \
+    SYSTEM=spaces \
+    SHELL=/bin/bash \
+    JUPYTER_TOKEN=huggingface
+
+CMD ["./start_server.sh"]

README.md

@@ -1,11 +1,15 @@
 ---
-title: Pdftranslate Web
-emoji: 🏢
-colorFrom: blue
-colorTo: pink
+title: 20250801test
+emoji: 💻🐳
+colorFrom: gray
+colorTo: green
 sdk: docker
 pinned: false
+tags:
+- jupyterlab
+suggested_storage: small
 license: apache-2.0
 ---
 
+docker build -t jupyterlab_modelscope .
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

login.html

@@ -0,0 +1,68 @@
+{% extends "page.html" %}
+
+
+{% block stylesheet %}
+{% endblock %}
+
+{% block site %}
+
+<div id="jupyter-main-app" class="container">
+    
+    <img src="https://huggingface.co/front/assets/huggingface_logo-noborder.svg" alt="Hugging Face Logo">
+    <h4>Welcome to JupyterLab</h4>
+    
+    <h5>The default token is <span style="color:orange;">huggingface</span></h5>
+  
+    {% if login_available %}
+    {# login_available means password-login is allowed. Show the form. #}
+    <div class="row">
+        <div class="navbar col-sm-8">
+            <div class="navbar-inner">
+                <div class="container">
+                    <div class="center-nav">
+                        <form action="{{base_url}}login?next={{next}}" method="post" class="navbar-form pull-left">
+                            {{ xsrf_form_html() | safe }}
+                            {% if token_available %}
+                            <label for="password_input"><strong>{% trans %}Jupyter token <span title="This is the secret you set up when deploying your JupyterLab space">ⓘ</span> {% endtrans
+                                    %}</strong></label>
+                            {% else %}
+                            <label for="password_input"><strong>{% trans %}Jupyter password:{% endtrans %}</strong></label>
+                            {% endif %}
+                            <input type="password" name="password" id="password_input" class="form-control">
+                            <button type="submit" class="btn btn-default" id="login_submit">{% trans %}Log in{% endtrans
+                                %}</button>
+                        </form>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+    {% else %}
+    <p>{% trans %}No login available, you shouldn't be seeing this page.{% endtrans %}</p>
+    {% endif %}
+
+      <h5>If you don't have the credentials for this Jupyter space, <a target="_blank" href="https://huggingface.co/spaces/SpacesExamples/jupyterlab?duplicate=true">create your own.</a></h5>
+    <br>
+  
+    <p>This template was created by <a href="https://twitter.com/camenduru" target="_blank" >camenduru</a> and <a href="https://huggingface.co/nateraw" target="_blank" >nateraw</a>, with contributions of <a href="https://huggingface.co/osanseviero" target="_blank" >osanseviero</a> and <a href="https://huggingface.co/azzr" target="_blank" >azzr</a> </p>
+    {% if message %}
+    <div class="row">
+        {% for key in message %}
+        <div class="message {{key}}">
+            {{message[key]}}
+        </div>
+        {% endfor %}
+    </div>
+    {% endif %}
+    {% if token_available %}
+    {% block token_message %}
+    
+    {% endblock token_message %}
+    {% endif %}
+</div>
+
+{% endblock %}
+
+
+{% block script %}
+{% endblock %}

on_startup.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+# Write some commands here that will run on root user before startup.
+# For example, to clone transformers and install it in dev mode:
+# git clone https://github.com/huggingface/transformers.git
+# cd transformers && pip install -e ".[dev]"

packages.txt

@@ -0,0 +1 @@
+tree

pdftranslate_web/.dockerignore

@@ -0,0 +1,97 @@
+# 开发相关文件
+.git
+.gitignore
+.env
+*.env
+.env.*
+
+# Python相关
+__pycache__
+*.pyc
+*.pyo
+*.pyd
+.Python
+*.so
+.coverage
+.pytest_cache
+.mypy_cache
+.tox
+venv/
+env/
+.venv/
+
+# 编辑器相关
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# 系统文件
+.DS_Store
+Thumbs.db
+*.log
+
+# 构建相关
+build/
+dist/
+*.egg-info/
+.wheel
+
+# 测试相关
+.coverage
+htmlcov/
+.pytest_cache/
+.tox/
+
+# 文档相关
+docs/_build/
+site/
+
+# 临时文件
+temp/
+tmp/
+*.tmp
+*.temp
+
+# 日志文件
+logs/
+*.log
+
+# 数据库文件
+*.db
+*.sqlite
+
+# 缓存文件
+*.cache
+
+# 备份文件
+*.bak
+*.backup
+
+# 压缩文件
+*.tar.gz
+*.zip
+*.rar
+
+# 媒体文件 (示例，根据需要调整)
+*.pdf
+*.doc
+*.docx
+*.png
+*.jpg
+*.jpeg
+*.gif
+
+# 配置文件 (包含敏感信息)
+config/config.toml
+
+# Docker相关
+.dockerignore
+Dockerfile
+docker-compose*.yml
+
+# CI/CD相关
+.github/
+.gitlab-ci.yml
+Jenkinsfile

pdftranslate_web/Dockerfile

@@ -0,0 +1,47 @@
+# 使用官方Python运行时作为基础镜像
+FROM python:3.11-slim
+
+# 设置工作目录
+WORKDIR /app
+
+# 设置环境变量
+ENV PYTHONPATH=/app/src \
+    PYTHONUNBUFFERED=1 \
+    PIP_NO_CACHE_DIR=1
+
+# 安装系统依赖
+RUN apt-get update && apt-get install -y \
+    curl \
+    git \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender-dev \
+    libgomp1 \
+    && rm -rf /var/lib/apt/lists/*
+
+# 复制项目文件
+COPY pyproject.toml /app/
+COPY src/ /app/src/
+COPY scripts/ /app/scripts/
+COPY simaple/ /app/simaple/
+COPY README.md /app/
+
+# 安装Python依赖
+RUN pip install --upgrade pip && \
+    pip install -e .
+
+# 复制启动脚本
+COPY docker/start.sh /app/start.sh
+RUN chmod +x /app/start.sh
+
+# 暴露端口
+EXPOSE 8000 7860
+
+# 健康检查
+HEALTHCHECK --interval=30s --timeout=10s --start-period=30s --retries=3 \
+    CMD curl -f http://localhost:8000/health || exit 1
+
+# 启动命令
+CMD ["/app/start.sh"]

pdftranslate_web/README.md

@@ -0,0 +1,385 @@
+# PDF翻译Web工具
+
+🌍 基于AI的智能PDF文档翻译工具，支持Web界面和API接口，保持文档结构不变。
+
+## 特性
+
+- 🚀 **智能翻译**: 基于OpenAI/DeepSeek等大语言模型
+- 📄 **保持格式**: 翻译后保持原始PDF文档结构和布局
+- 🌐 **双重接口**: FastAPI REST API + Gradio Web界面
+- ⚙️ **环境配置**: 通过环境变量灵活配置
+- 🔧 **容器部署**: Docker一键部署
+- 📊 **实时监控**: 翻译进度实时跟踪
+
+## 项目结构
+
+```
+pdftranslate_web/
+├── src/pdftranslate_web/       # 核心模块
+│   ├── __init__.py
+│   ├── api_server.py          # FastAPI API服务器
+│   ├── api_client.py          # Python客户端SDK
+│   └── gradio_client.py       # Gradio Web界面
+├── scripts/                   # 启动脚本
+│   ├── run_server.py         # 启动API服务器
+│   └── run_gradio.py         # 启动Web界面
+├── docker/                   # Docker配置
+│   └── start.sh             # 容器启动脚本
+├── docs/                     # 文档
+│   ├── API_USAGE.md         # API使用说明
+│   └── GRADIO_USAGE.md      # Web界面使用说明
+├── tests/                    # 测试文件
+├── .env.example             # 环境变量配置模板
+├── docker-compose.yml       # Docker Compose配置
+├── Dockerfile              # Docker镜像配置
+├── pyproject.toml           # 项目配置和依赖
+└── README.md               # 项目说明
+```
+
+## 快速开始
+
+### 1. 环境准备
+
+> **推荐使用 uv 包管理器**：uv 是一个超快的 Python 包安装器和解析器，比 pip 快 10-100 倍，支持自动依赖解析和虚拟环境管理。
+
+```bash
+# 克隆项目
+git clone https://github.com/wwwzhouhui/pdftranslate_web
+cd pdftranslate_web
+
+# 方式一：使用 uv 包管理器 (推荐)
+# 安装 uv (如果没有安装)
+curl -LsSf https://astral.sh/uv/install.sh | sh
+# 或者使用 pip 安装
+pip install uv
+
+# 使用 uv 安装依赖 (自动创建虚拟环境)
+uv sync
+
+# 方式二：使用传统 pip
+# 安装依赖
+pip install -e .
+```
+
+### 2. 配置设置
+
+复制环境变量模板并编辑：
+
+```bash
+cp .env.example .env
+```
+
+编辑 `.env` 文件，设置API密钥：
+
+```bash
+# OpenAI配置 (必填)
+OPENAI_API_KEY=your-api-key-here
+OPENAI_MODEL=deepseek-ai/DeepSeek-V3
+OPENAI_BASE_URL=https://api.siliconflow.cn/v1
+
+# 翻译配置
+QPS=4
+DEFAULT_LANG_IN=en
+DEFAULT_LANG_OUT=zh
+WATERMARK_OUTPUT_MODE=no_watermark
+```
+
+### 3. 启动服务
+
+#### 方式一：启动API服务器
+
+```bash
+# 使用 uv (推荐)
+uv run python scripts/run_server.py --host 0.0.0.0 --port 8000
+
+# 或使用传统方式
+python scripts/run_server.py --host 0.0.0.0 --port 8000
+```
+
+API服务将在 `http://localhost:8000` 启动，文档地址：`http://localhost:8000/docs`
+
+#### 方式二：启动Web界面
+
+```bash
+# 使用 uv (推荐)
+uv run python scripts/run_gradio.py --server-url http://localhost:8000 --port 7860
+
+# 或使用传统方式
+python scripts/run_gradio.py --server-url http://localhost:8000 --port 7860
+```
+
+Web界面将在 `http://localhost:7860` 启动
+
+## 使用方法
+
+### API使用
+
+```python
+from pdftranslate_web.api_client import BabelDOCClient
+
+# 创建客户端
+client = BabelDOCClient("http://localhost:8000")
+
+# 翻译PDF文件
+downloaded_files = client.translate_and_download(
+    pdf_path="document.pdf",
+    output_dir="./output",
+    lang_in="en",
+    lang_out="zh"
+)
+
+print(f"翻译完成：{downloaded_files}")
+```
+
+### 命令行使用
+
+```bash
+# 使用API客户端
+# uv方式 (推荐)
+uv run python src/pdftranslate_web/api_client.py document.pdf --output-dir ./output --lang-out zh
+
+# 传统方式
+python src/pdftranslate_web/api_client.py document.pdf --output-dir ./output --lang-out zh
+
+# 检查服务器状态
+curl http://localhost:8000/health
+```
+
+### Web界面使用
+
+1. 打开浏览器访问 `http://localhost:7860`
+2. 上传PDF文件
+3. 选择翻译选项（源语言、目标语言、输出类型）
+4. 点击"开始翻译"
+5. 等待翻译完成并下载结果
+
+## API接口
+
+### 核心接口
+
+- `POST /translate` - 提交翻译任务
+- `GET /status/{task_id}` - 查询翻译状态
+- `GET /download/{task_id}/{file_type}` - 下载翻译结果
+- `GET /health` - 健康检查
+
+详细API文档请查看：`docs/API_USAGE.md`
+
+## 配置说明
+
+### 环境变量配置
+
+所有配置通过环境变量进行设置。可以通过 `.env` 文件或直接设置环境变量：
+
+```bash
+# OpenAI配置 (必填)
+OPENAI_API_KEY=your-api-key-here    # API密钥
+OPENAI_MODEL=deepseek-ai/DeepSeek-V3  # 模型名称  
+OPENAI_BASE_URL=https://api.siliconflow.cn/v1  # API基础URL
+
+# 服务器配置
+SERVER_HOST=0.0.0.0     # 绑定地址
+SERVER_PORT=8000        # 端口号
+QPS=4                   # 每秒请求数限制
+
+# 翻译配置
+DEFAULT_LANG_IN=en              # 默���源语言
+DEFAULT_LANG_OUT=zh             # 默认目标语言
+WATERMARK_OUTPUT_MODE=no_watermark  # 水印模式
+NO_DUAL=false                   # 是否生成双语PDF
+NO_MONO=false                   # 是否生成单语PDF
+```
+
+### 支持的环境变量
+
+| 环境变量 | 默认值 | 说明 |
+|---------|--------|------|
+| `OPENAI_API_KEY` | - | OpenAI API密钥 (必填) |
+| `OPENAI_MODEL` | `deepseek-ai/DeepSeek-V3` | 使用的模型 |
+| `OPENAI_BASE_URL` | `https://api.siliconflow.cn/v1` | API端点 |
+| `SERVER_HOST` | `0.0.0.0` | 服务器地址 |
+| `SERVER_PORT` | `8000` | 服务器端口 |
+| `QPS` | `4` | 请求频率限制 |
+| `DEFAULT_LANG_IN` | `en` | 默认源语言 |
+| `DEFAULT_LANG_OUT` | `zh` | 默认目标语言 |
+| `WATERMARK_OUTPUT_MODE` | `no_watermark` | 水印模式 |
+
+## 开发指南
+
+### 开发环境设置
+
+```bash
+# 克隆项目
+git clone https://github.com/wwwzhouhui/pdftranslate_web
+cd pdftranslate_web
+
+# 方式一：使用 uv (推荐)
+# 安装 uv (如果没有安装)
+curl -LsSf https://astral.sh/uv/install.sh | sh
+
+# 安装开发依赖
+uv sync --dev
+
+# 方式二：使用传统 pip + 虚拟环境
+# 创建虚拟环境
+python -m venv venv
+source venv/bin/activate  # Linux/Mac
+# venv\Scripts\activate   # Windows
+
+# 安装开发依赖
+pip install -e ".[dev]"
+```
+
+### 运行测试
+
+```bash
+pytest tests/
+```
+
+### 代码格式化
+
+```bash
+black src/
+isort src/
+```
+
+## Docker部署
+
+### 快速开始
+
+1. **准备环境变量文件**
+
+```bash
+# 复制环境变量模板
+cp .env.example .env
+
+# 编辑环境变量 (必须设置API密钥)
+nano .env
+```
+
+2. **启动服务**
+
+```bash
+# 构建并启动服务
+docker-compose up -d
+
+# 查看服务状态
+docker-compose ps
+
+# 查看日志
+docker-compose logs -f pdftranslate
+```
+
+服务启动后访问：
+- API服务：http://localhost:8000
+- Web界面：http://localhost:7860
+- API文档：http://localhost:8000/docs
+
+### 环境变量配置
+
+在 `.env` 文件中设置必需的配置：
+
+```bash
+# 必需配置
+OPENAI_API_KEY=your-api-key-here
+OPENAI_MODEL=deepseek-ai/DeepSeek-V3
+OPENAI_BASE_URL=https://api.siliconflow.cn/v1
+
+# 可选配置
+QPS=4
+DEFAULT_LANG_IN=en
+DEFAULT_LANG_OUT=zh
+```
+
+### Docker命令
+
+```bash
+# 构建镜像
+docker-compose build
+
+# 启动服务
+docker-compose up -d
+
+# 停止服务
+docker-compose down
+
+# 查看日志
+docker-compose logs pdftranslate
+
+# 重启服务
+docker-compose restart pdftranslate
+```
+
+### 直接使用Docker
+
+```bash
+# 构建镜像
+docker build -t pdftranslate_web .
+
+# 运行容器
+docker run -d \
+  --name pdftranslate \
+  -p 8000:8000 \
+  -p 7860:7860 \
+  -e OPENAI_API_KEY="your-api-key" \
+  pdftranslate_web
+```
+
+## 故障排除
+
+### 常见问题
+
+1. **API密钥错误**
+   - 检查 `.env` 文件中的 `OPENAI_API_KEY` 设置
+   - 确认API密钥有效且有足够配额
+
+2. **模块导入错误**
+   - 确保已正确安装项目依赖
+   - 检查Python路径设置
+
+3. **端口占用**
+   - 修改 `.env` 文件中的端口号
+   - 或使用环境变量指定其他端口
+
+4. **翻译失败**
+   - 检查网络连接
+   - 确认API服务可用性
+   - 查看日志文件获取详细错误信息
+
+### 日志查看
+
+```bash
+# 查看API服务器日志
+python scripts/run_server.py --log-level DEBUG
+
+# 查看特定任务日志
+curl http://localhost:8000/status/{task_id}
+```
+
+## 贡献指南
+
+1. Fork项目
+2. 创建特性分支 (`git checkout -b feature/AmazingFeature`)
+3. 提交更改 (`git commit -m 'Add some AmazingFeature'`)
+4. 推送到分支 (`git push origin feature/AmazingFeature`)
+5. 开启Pull Request
+
+## 许可证
+
+本项目采用 AGPL-3.0 许可证。详见 [LICENSE](LICENSE) 文件。
+
+## 支持
+
+- 📧 Email: 75271002@qq.com
+- 🐛 问题反馈: [GitHub Issues](https://github.com/wwwzhouhui/pdftranslate_web/issues)
+
+## 更新日志
+
+### v0.0.1
+- 重新整理项目目录结构
+- 完善文档和配置文件
+- 添加多种部署方式支持
+- 优化API接口设计
+
+---
+
+⭐ 如果这个项目对您有帮助，请给我们一个star！

pdftranslate_web/docker-compose.yml

@@ -0,0 +1,38 @@
+version: '3.8'
+
+services:
+  pdftranslate:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    container_name: pdftranslate-web
+    restart: unless-stopped
+    ports:
+      - "8000:8000"  # API服务端口
+      - "7860:7860"  # Gradio Web界面端口
+    environment:
+      # OpenAI配置 (必填)
+      - OPENAI_API_KEY=${OPENAI_API_KEY}
+      - OPENAI_MODEL=${OPENAI_MODEL:-deepseek-ai/DeepSeek-V3}
+      - OPENAI_BASE_URL=${OPENAI_BASE_URL:-https://api.siliconflow.cn/v1}
+      
+      # 服务器配置
+      - SERVER_HOST=${SERVER_HOST:-0.0.0.0}
+      - SERVER_PORT=${SERVER_PORT:-8000}
+      - QPS=${QPS:-4}
+      
+      # 翻译配置
+      - DEFAULT_LANG_IN=${DEFAULT_LANG_IN:-en}
+      - DEFAULT_LANG_OUT=${DEFAULT_LANG_OUT:-zh}
+      - WATERMARK_OUTPUT_MODE=${WATERMARK_OUTPUT_MODE:-no_watermark}
+      - NO_DUAL=${NO_DUAL:-false}
+      - NO_MONO=${NO_MONO:-false}
+    volumes:
+      # 日志文件挂载 (可选)
+      - ./logs:/app/logs
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:8000/health"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 30s

pdftranslate_web/docker/.ipynb_checkpoints/start-checkpoint.sh

@@ -0,0 +1,25 @@
+#!/bin/bash
+set -e
+
+# 检查必需的环境变量
+if [ -z "$OPENAI_API_KEY" ]; then
+    echo "错误: 必须设置 OPENAI_API_KEY 环境变量"
+    exit 1
+fi
+
+echo "=== BabelDOC PDF翻译服务 ==="
+echo "OpenAI模型: ${OPENAI_MODEL:-deepseek-ai/DeepSeek-V3}"
+echo "API服务: http://localhost:8000"
+echo "Web界面: http://localhost:7860"
+echo "========================="
+
+# 启动API服务器(后台)
+echo "启动API服务器..."
+python3 /app/scripts/run_server.py &
+
+# 等待API服务器启动
+sleep 10
+
+# 启动Gradio客户端
+echo "启动Web界面..."
+python3 /app/scripts/run_gradio.py --server-url http://localhost:8000 --host 0.0.0.0 --port 7860

pdftranslate_web/docker/start.sh

@@ -0,0 +1,25 @@
+#!/bin/bash
+set -e
+
+# 检查必需的环境变量
+if [ -z "$OPENAI_API_KEY" ]; then
+    echo "错误: 必须设置 OPENAI_API_KEY 环境变量"
+    exit 1
+fi
+
+echo "=== BabelDOC PDF翻译服务 ==="
+echo "OpenAI模型: ${OPENAI_MODEL:-deepseek-ai/DeepSeek-V3}"
+echo "API服务: http://localhost:8000"
+echo "Web界面: http://localhost:7860"
+echo "========================="
+
+# 启动API服务器(后台)
+echo "启动API服务器..."
+python3 /app/scripts/run_server.py &
+
+# 等待API服务器启动
+sleep 10
+
+# 启动Gradio客户端
+echo "启动Web界面..."
+python3 /app/scripts/run_gradio.py --server-url http://localhost:8000 --host 0.0.0.0 --port 7860

pdftranslate_web/docs/API_USAGE.md

@@ -0,0 +1,208 @@
+# BabelDOC API 使用说明
+
+## 配置说明
+
+### 环境变量配置
+
+服务器通过环境变量进行配置。创建 `.env` 文件或直接设置环境变量：
+
+```bash
+# OpenAI配置 (必填)
+OPENAI_API_KEY=your-openai-api-key-here
+OPENAI_MODEL=deepseek-ai/DeepSeek-V3
+OPENAI_BASE_URL=https://api.siliconflow.cn/v1
+
+# 服务器配置
+SERVER_HOST=0.0.0.0
+SERVER_PORT=8000
+QPS=4
+
+# 翻译配置
+DEFAULT_LANG_IN=en
+DEFAULT_LANG_OUT=zh
+WATERMARK_OUTPUT_MODE=no_watermark
+NO_DUAL=false
+NO_MONO=false
+```
+- `OPENAI_API_KEY`: OpenAI API密钥 (必需)
+- `OPENAI_MODEL`: OpenAI模型名称
+- `OPENAI_BASE_URL`: OpenAI API基础URL
+- `SERVER_HOST`: 服务器主机地址
+- `SERVER_PORT`: 服务器端口
+- `QPS`: 每秒请求数限制
+- `DEFAULT_LANG_IN`: 默认源语言
+- `DEFAULT_LANG_OUT`: 默认目标语言
+- `WATERMARK_OUTPUT_MODE`: 水印模式
+- `NO_DUAL`: 不生成双语PDF
+- `NO_MONO`: 不生成单语PDF
+
+## 服务端部署
+
+### 安装依赖
+```bash
+# 安装必要的依赖包
+uv sync
+# 或者 pip install fastapi uvicorn python-multipart toml
+```
+
+### 启动服务器
+```bash
+# 方法1：直接运行启动脚本
+uv run python babeldoc/run_server.py
+
+# 方法2：使用API服务器模块
+uv run python -m babeldoc.api_server
+
+# 方法3：自定义主机和端口
+uv run python babeldoc/run_server.py --host 0.0.0.0 --port 8000
+```
+
+服务器启动后会监听在 `http://0.0.0.0:8000`，可以通过浏览器访问 `http://localhost:8000/docs` 查看API文档。
+
+## API接口说明
+
+### 1. 翻译PDF文档
+- **接口**: `POST /translate`
+- **功能**: 上传PDF文件进行翻译
+- **参数**:
+  - `file`: PDF文件 (必需)
+  - `lang_in`: 源语言代码 (可选，使用服务器默认配置)
+  - `lang_out`: 目标语言代码 (可选，使用服务器默认配置)
+  - `qps`: 每秒请求数限制 (可选，使用服务器默认配置)
+  - `no_dual`: 不生成双语PDF (可选，使用服务器默认配置)
+  - `no_mono`: 不生成单语PDF (可选，使用服务器默认配置)
+  - `watermark_output_mode`: 水印模式 (可选，使用服务器默认配置)
+
+### 2. 查询翻译状态
+- **接口**: `GET /status/{task_id}`
+- **功能**: 查询翻译任务的当前状态和进度
+
+### 3. 下载翻译结果
+- **接口**: `GET /download/{task_id}/{file_type}`
+- **功能**: 下载翻译完成的PDF文件
+- **参数**:
+  - `file_type`: "dual" (双语版本) 或 "mono" (单语版本)
+
+### 4. 健康检查
+- **接口**: `GET /health`
+- **功能**: 检查服务是否正常运行
+
+### 5. 获取服务器配置
+- **接口**: `GET /`
+- **功能**: 获取服务器当前配置信息
+
+## 客户端使用
+
+### Python客户端库
+```python
+from babeldoc.api_client import BabelDOCClient
+
+# 创建客户端
+client = BabelDOCClient("http://localhost:8000")
+
+# 翻译PDF文档 (使用服务器默认配置)
+downloaded_files = client.translate_and_download(
+    pdf_path="example.pdf",
+    output_dir="./output"
+)
+
+# 翻译PDF文档 (自定义参数)
+downloaded_files = client.translate_and_download(
+    pdf_path="example.pdf",
+    output_dir="./output",
+    lang_in="en",
+    lang_out="zh"
+)
+
+print("翻译完成，文件保存至:", downloaded_files)
+```
+
+### 命令行客户端
+```bash
+# 使用服务器默认配置翻译
+uv run python babeldoc/api_client.py example.pdf --output-dir ./output
+
+# 自定义翻译参数
+uv run python babeldoc/api_client.py example.pdf \
+    --output-dir ./output \
+    --lang-in en \
+    --lang-out zh \
+    --server-url http://localhost:8000
+```
+
+### cURL示例
+```bash
+# 1. 提交翻译任务 (使用服务器默认配置)
+curl -X POST "http://localhost:8000/translate" \
+  -F "file=@example.pdf"
+
+# 2. 提交翻译任务 (自定义参数)
+curl -X POST "http://localhost:8000/translate" \
+  -F "file=@example.pdf" \
+  -F "lang_in=en" \
+  -F "lang_out=zh"
+
+# 3. 查询任务状态
+curl "http://localhost:8000/status/{task_id}"
+
+# 4. 下载翻译结果
+curl "http://localhost:8000/download/{task_id}/dual" -o translated.pdf
+
+# 5. 获取服务器配置
+curl "http://localhost:8000/"
+```
+
+## 部署说明
+
+### 生产环境部署
+```bash
+# 使用Gunicorn部署
+pip install gunicorn
+gunicorn babeldoc.api_server:app -w 4 -k uvicorn.workers.UvicornWorker --bind 0.0.0.0:8000
+
+# 使用Docker部署
+# Dockerfile示例:
+FROM python:3.11-slim
+WORKDIR /app
+COPY . .
+RUN pip install -e .
+COPY .env /app/
+EXPOSE 8000
+CMD ["python", "babeldoc/run_server.py"]
+```
+
+## 配置优势
+
+1. **安全性提升**: OpenAI API密钥只需在服务器端配置一次，客户端无需传递敏感信息
+2. **配置集中**: 所有翻译相关配置在服务器端统一管理
+3. **客户端简化**: 客户端只需上传文件，其他参数可选
+4. **灵活性**: 支持配置文件和环境变量两种配置方式
+5. **默认值**: 客户端可以使用服务器默认配置，也可以覆盖特定参数
+
+## 注意事项
+
+1. **环境变量优先**: 所有配置均通过环境变量设置
+2. **API密钥安全**: 确保 `.env` 文件权限设置正确，避免泄露API密钥
+3. **文件存储**: 翻译过程中的临时文件会自动清理
+4. **并发限制**: 服务器会根据配置的QPS参数限制API调用频率
+5. **超时设置**: 大文件翻译可能需要较长时间，建议适当调整客户端超时时间
+
+## 故障排除
+
+### 常见问题
+1. **服务器无法启动**: 
+   - 检查环境变量是否正确设置
+   - 确认 OpenAI API密钥已正确配置
+   - 检查端口是否被占用
+2. **翻译失败**: 
+   - 检查服务器日志中的错误信息
+   - 确认网络连接正常
+   - 验证OpenAI API配置是否正确
+3. **下载失败**: 确认任务已完成且文件类型正确
+
+### 日志查看
+服务器运行时会输出详细日志，包括：
+- 使用的OpenAI模型信息
+- 默认语言配置
+- 任务处理状态
+- 错误详情

pdftranslate_web/docs/GRADIO_USAGE.md

@@ -0,0 +1,205 @@
+# BabelDOC Gradio客户端使用说明
+
+## 概述
+
+BabelDOC Gradio客户端提供了一个直观的Web界面，用于与BabelDOC API服务器进行交互，实现PDF文档的在线翻译。
+
+## 功能特性
+
+### 🎯 核心功能
+- **PDF文件上传**: 支持拖拽或点击上传PDF文件
+- **实时预览**: 左侧显示原始PDF预览，右侧显示翻译结果预览
+- **在线翻译**: 调用API服务器进行文档翻译
+- **进度监控**: 实时显示翻译进度和状态
+- **结果下载**: 翻译完成后可直接下载结果文件
+
+### 📋 界面布局
+- **左侧面板**: 
+  - 文件上传区域
+  - 原始PDF预览（显示前5页）
+  - 翻译选项设置
+  - 翻译按钮
+- **右侧面板**:
+  - 翻译状态显示
+  - 翻译结果PDF预览
+  - 下载按钮
+- **底部区域**:
+  - 任务状态查询功能
+
+## 启动方式
+
+### 前提条件
+确保API服务器已启动：
+```bash
+# 启动API服务器
+uv run python babeldoc/run_server.py
+```
+
+### 启动Gradio客户端
+```bash
+# 方法1：使用启动脚本
+uv run python babeldoc/run_gradio.py
+
+# 方法2：直接运行模块
+uv run python -m babeldoc.gradio_client
+
+# 方法3：自定义参数
+uv run python babeldoc/run_gradio.py \
+    --server-url http://localhost:8000 \
+    --host 0.0.0.0 \
+    --port 7860 \
+    --share
+```
+
+### 命令行参数
+- `--server-url`: API服务器地址 (默认: http://localhost:8000)
+- `--host`: Gradio服务器主机 (默认: 0.0.0.0)
+- `--port`: Gradio服务器端口 (默认: 7860)
+- `--share`: 创建公共分享链接
+
+## 使用流程
+
+### 1. 检查服务器状态
+启动后界面顶部会显示API服务器的连接状态和配置信息：
+- ✅ 服务器在线：显示模型、默认语言等配置
+- ❌ 服务器离线：显示连接错误信息
+
+### 2. 上传PDF文件
+- 点击"选择PDF文件"区域或拖拽PDF文件
+- 上传后左侧会显示PDF预览（前5页）
+- 支持的文件格式：.pdf
+
+### 3. 设置翻译选项
+- **源语言**: 留空使用服务器默认配置，或输入语言代码（如：en）
+- **目标语言**: 留空使用服务器默认配置，或输入语言代码（如：zh）
+- **输出类型**: 
+  - `dual`: 双语对照版本
+  - `mono`: 纯翻译版本
+
+### 4. 开始翻译
+- 点击"🚀 开始翻译"按钮
+- 界面会显示实时翻译进度
+- 翻译过程包括：提交任务 → 处理中 → 完成下载
+
+### 5. 查看结果
+- 翻译完成后右侧显示结果PDF预览
+- 点击"下载翻译结果"按钮下载完整文件
+- 可以查看任务ID和状态信息
+
+### 6. 任务状态查询
+在底部"任务状态查询"区域：
+- 输入任务ID可查询任务状态
+- 显示进度、消息和结果文件信息
+
+## 界面截图说明
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                BabelDOC PDF翻译工具                          │
+│  ✅ 服务器在线 - 模型: deepseek-ai/DeepSeek-V3             │
+├─────────────────────┬───────────────────────────────────────┤
+│    📁 文件上传       │         📊 翻译状态                   │
+│  [选择PDF文件]      │    等待上传文件...                    │
+│                     │                                       │
+│   📄 原始PDF预览     │         📑 翻译结果预览                │
+│  ┌─────────────────┐ │    ┌─────────────────────────────────┐ │
+│  │     页面1       │ │    │       翻译结果页面               │ │
+│  │     页面2       │ │    │      (翻译完成后显示)            │ │
+│  │     ...         │ │    │                                 │ │
+│  └─────────────────┘ │    └─────────────────────────────────┘ │
+│                     │                                       │
+│   ⚙️ 翻译选项        │         [下载翻译结果]                 │
+│  源语言: [  ]       │                                       │
+│  目标语言: [  ]     │    任务信息: task_12345678             │
+│  输出类型: dual     │                                       │
+│                     │                                       │
+│  [🚀 开始翻译]       │                                       │
+├─────────────────────┴───────────────────────────────────────┤
+│         🔍 任务状态查询                                      │
+│  任务ID: [          ]  [查询]                               │
+│  查询结果显示区域                                            │
+└─────────────────────────────────────────────────────────────┘
+```
+
+## 技术特性
+
+### PDF预览功能
+- 使用PyMuPDF将PDF页面转换为图片
+- 显示前5页预览，避免加载时间过长
+- 自动调整图片大小适配界面
+
+### 实时进度监控
+- 通过API客户端轮询任务状态
+- 显示详细的处理阶段和进度百分比
+- 支持任务超时处理（1小时）
+
+### 文件管理
+- 自动创建临时目录存储上传和下载的文件
+- 智能文件命名避免冲突
+- 支持多种文件类型的下载
+
+## 常见问题
+
+### 1. 界面显示"服务器离线"
+- 确认API服务器已启动并运行在正确端口
+- 检查`--server-url`参数是否正确
+- 确认网络连接正常
+
+### 2. PDF预览不显示
+- 确认上传的是有效的PDF文件
+- 检查PDF文件是否已损坏
+- 尝试重新上传文件
+
+### 3. 翻译任务失败
+- 查看右侧状态区域的错误信息
+- 确认API服务器的OpenAI配置正确
+- 检查网络连接和API密钥
+
+### 4. 下载失败
+- 确认翻译任务已完成
+- 检查浏览器的下载设置
+- 尝试刷新页面重新下载
+
+## 部署建议
+
+### 开发环境
+```bash
+# 同时启动API服务器和Gradio客户端
+# 终端1
+uv run python babeldoc/run_server.py
+
+# 终端2  
+uv run python babeldoc/run_gradio.py
+```
+
+### 生产环境
+```bash
+# 使用Docker Compose部署
+# docker-compose.yml 示例:
+version: '3.8'
+services:
+  api-server:
+    build: .
+    command: python babeldoc/run_server.py
+    ports:
+      - "8000:8000"
+    volumes:
+      - ./.env:/app/.env
+  
+  gradio-client:
+    build: .
+    command: python babeldoc/run_gradio.py --server-url http://api-server:8000
+    ports:
+      - "7860:7860"
+    depends_on:
+      - api-server
+```
+
+## 性能优化
+
+1. **预览优化**: 只显示前5页预览，减少加载时间
+2. **异步处理**: 使用Gradio的Progress功能显示实时进度
+3. **缓存机制**: 复用API客户端连接
+4. **文件管理**: 智能清理临时文件
+
+通过这个Gradio客户端，用户可以享受到直观、友好的PDF翻译体验！

pdftranslate_web/pdftranslate-mcp-server/.dockerignore

@@ -0,0 +1,85 @@
+# Git相关
+.git
+.gitignore
+.gitattributes
+
+# Python相关
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# 虚拟环境
+venv/
+env/
+ENV/
+.venv/
+.env/
+
+# IDE相关
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# 测试相关
+.pytest_cache/
+.coverage
+htmlcov/
+.tox/
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+
+# 日志文件
+*.log
+logs/
+
+# 临时文件
+temp/
+tmp/
+*.tmp
+*.temp
+
+# 操作系统相关
+.DS_Store
+Thumbs.db
+
+# Docker相关
+Dockerfile*
+docker-compose*.yml
+.dockerignore
+
+# 文档相关
+docs/
+*.md
+!README.md
+
+# 配置文件（保留示例文件）
+.env
+!.env.example
+
+# 上传和下载目录
+uploads/
+downloads/
+output/

pdftranslate_web/pdftranslate-mcp-server/.env.docker

@@ -0,0 +1,38 @@
+# Docker环境配置文件
+# 复制此文件为 .env 并填入实际的配置值
+
+# ================================
+# OpenAI 配置 (必填)
+# ================================
+OPENAI_API_KEY=your-api-key-here
+OPENAI_MODEL=deepseek-ai/DeepSeek-V3
+OPENAI_BASE_URL=https://api.siliconflow.cn/v1
+
+# ================================
+# MCP服务器配置
+# ================================
+MCP_HOST=0.0.0.0
+MCP_PORT=8006
+
+# ================================
+# 翻译配置
+# ================================
+DEFAULT_LANG_IN=en
+DEFAULT_LANG_OUT=zh
+QPS=4
+WATERMARK_OUTPUT_MODE=no_watermark
+NO_DUAL=false
+NO_MONO=false
+
+# ================================
+# 腾讯云COS配置 (可选，用于文件上传)
+# ================================
+COS_REGION=
+COS_SECRET_ID=
+COS_SECRET_KEY=
+COS_BUCKET=
+
+# ================================
+# 日志配置
+# ================================
+LOG_LEVEL=INFO

pdftranslate_web/pdftranslate-mcp-server/Dockerfile

@@ -0,0 +1,74 @@
+# 使用官方Python运行时作为基础镜像
+FROM python:3.11-slim
+
+# 设置标签信息
+LABEL maintainer="wwwzhouhui <75271002@qq.com>" \
+      version="1.0.0" \
+      description="PDFTranslate MCP Server - 基于BabelDOC的PDF文档翻译服务" \
+      org.opencontainers.image.source="https://github.com/wwwzhouhui/pdftranslate_web"
+
+# 设置工作目录
+WORKDIR /app
+
+# 设置环境变量
+ENV PYTHONPATH=/app \
+    PYTHONUNBUFFERED=1 \
+    PIP_NO_CACHE_DIR=1 \
+    PYTHONDONTWRITEBYTECODE=1 \
+    # MCP服务器配置
+    MCP_HOST=0.0.0.0 \
+    MCP_PORT=8006 \
+    # 翻译默认配置
+    DEFAULT_LANG_IN=en \
+    DEFAULT_LANG_OUT=zh \
+    QPS=4 \
+    WATERMARK_OUTPUT_MODE=no_watermark \
+    NO_DUAL=false \
+    NO_MONO=false \
+    # 日志配置
+    LOG_LEVEL=INFO
+
+# 安装运行时系统依赖
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    curl \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender-dev \
+    libgomp1 \
+    && rm -rf /var/lib/apt/lists/* \
+    && apt-get clean
+
+# 复制MCP服务器项目文件
+COPY pyproject.toml /app/
+COPY main.py /app/
+COPY config.ini /app/
+COPY .env.example /app/
+COPY README.md /app/
+
+# 安装Python依赖
+RUN pip install --upgrade pip && \
+    pip install . && \
+    pip install cos-python-sdk-v5
+
+# 创建非root用户和home目录
+RUN groupadd -r mcpuser && useradd -r -g mcpuser -m mcpuser
+
+# 创建必要的目录并设置权限
+RUN mkdir -p /app/temp /app/uploads /app/downloads /app/logs \
+    /home/mcpuser/.cache/babeldoc/tiktoken \
+    && chown -R mcpuser:mcpuser /app /home/mcpuser
+
+# 切换到非root用户
+USER mcpuser
+
+# 暴露MCP服务器端口
+EXPOSE 8006
+
+# 健康检查
+HEALTHCHECK --interval=30s --timeout=10s --start-period=60s --retries=3 \
+    CMD curl -f http://localhost:${MCP_PORT:-8006}/sse || exit 1
+
+# 启动MCP服务器
+CMD ["python", "main.py"]

pdftranslate_web/pdftranslate-mcp-server/PRD.MD

@@ -0,0 +1,255 @@
+# PDF翻译MCP服务器产品需求文档 (PRD)
+
+## 1. 项目概述
+
+### 1.1 项目名称
+PDFTranslate MCP Server - PDF文档翻译模型上下文协议服务器
+
+### 1.2 项目背景
+基于现有的PDF翻译Web应用(`src/pdftranslate_web/api_server.py`)，开发一个MCP服务器，使AI助手能够通过模型上下文协议直接调用PDF翻译功能，提供标准化的PDF文档翻译服务接口。
+
+### 1.3 项目目标
+- 提供基于MCP协议的PDF翻译服务
+- 支持多种语言间的PDF文档翻译
+- 提供异步翻译任务管理
+- 兼容Cherry Studio、Cursor、Cline、Dify、FastGPT、N8N等MCP客户端
+
+## 2. 功能需求
+
+### 2.1 核心功能
+1. **PDF翻译工具 (translate_pdf)**
+   - 上传PDF文件进行翻译
+   - 支持指定源语言和目标语言
+   - 支持自定义QPS(每秒查询数)
+   - 支持双语对照和单语翻译模式选择
+   - 支持水印输出模式配置
+
+2. **翻译状态查询工具 (get_translation_status)**
+   - 查询翻译任务状态
+   - 获取翻译进度信息
+   - 查看翻译结果文件列表
+
+3. **翻译结果下载工具 (download_translation_result)**
+   - 下载翻译完成的PDF文件
+   - 支持下载双语对照版本
+   - 支持下载单语翻译版本
+
+### 2.2 资源提供
+1. **配置信息资源 (config://)**
+   - 当前服务器配置信息
+   - 支持的语言列表
+   - 默认翻译参数
+
+2. **任务列表资源 (tasks://)**
+   - 所有翻译任务列表
+   - 任务状态概览
+
+## 3. 技术规格
+
+### 3.1 技术栈
+- **MCP SDK**: 基于`mcp[cli]` Python SDK
+- **翻译引擎**: BabelDOC翻译库
+- **AI模型**: OpenAI兼容API (支持DeepSeek等)
+- **异步处理**: 基于Python asyncio
+- **文件处理**: 临时文件管理和清理
+
+### 3.2 传输方式
+- **主要**: SSE (Server-Sent Events) - 适用于云部署
+- **备选**: STDIO - 适用于本地开发
+
+### 3.3 配置管理
+通过环境变量进行配置:
+- `OPENAI_API_KEY`: AI模型API密钥
+- `OPENAI_MODEL`: 使用的AI模型
+- `OPENAI_BASE_URL`: API基础URL
+- `DEFAULT_LANG_IN`: 默认源语言
+- `DEFAULT_LANG_OUT`: 默认目标语言
+- `QPS`: 默认查询每秒数
+- `MCP_HOST`: MCP服务器监听地址
+- `MCP_PORT`: MCP服务器监听端口
+
+## 4. 接口设计
+
+### 4.1 工具接口
+
+#### translate_pdf
+```python
+@mcp.tool()
+def translate_pdf(
+    file_path: str,
+    lang_in: str = "en",
+    lang_out: str = "zh",
+    qps: int = 4,
+    no_dual: bool = False,
+    no_mono: bool = False,
+    watermark_output_mode: str = "no_watermark"
+) -> dict:
+    """
+    翻译PDF文档
+    
+    Args:
+        file_path: PDF文件路径
+        lang_in: 源语言代码
+        lang_out: 目标语言代码
+        qps: 每秒查询数限制
+        no_dual: 是否禁用双语对照版本
+        no_mono: 是否禁用单语翻译版本
+        watermark_output_mode: 水印模式 (no_watermark/watermarked/both)
+    
+    Returns:
+        dict: {"task_id": str, "message": str}
+    """
+```
+
+#### get_translation_status
+```python
+@mcp.tool()
+def get_translation_status(task_id: str) -> dict:
+    """
+    查询翻译任务状态
+    
+    Args:
+        task_id: 翻译任务ID
+    
+    Returns:
+        dict: {
+            "task_id": str,
+            "status": str,  # pending/processing/completed/failed
+            "progress": float,  # 0.0-100.0
+            "message": str,
+            "result_files": dict
+        }
+    """
+```
+
+#### download_translation_result
+```python
+@mcp.tool()
+def download_translation_result(
+    task_id: str,
+    file_type: str = "dual"
+) -> str:
+    """
+    下载翻译结果文件
+    
+    Args:
+        task_id: 翻译任务ID
+        file_type: 文件类型 (dual/mono)
+    
+    Returns:
+        str: 下载链接或文件路径
+    """
+```
+
+### 4.2 资源接口
+
+#### config://
+```python
+@mcp.resource("config://")
+def get_config() -> str:
+    """返回当前配置信息"""
+```
+
+#### tasks://
+```python
+@mcp.resource("tasks://")
+def get_all_tasks() -> str:
+    """返回所有翻译任务状态"""
+```
+
+## 5. 部署要求
+
+### 5.1 环境要求
+- Python 3.12+
+- UV包管理器
+- 足够的磁盘空间存储临时文件
+- 网络访问权限(调用AI API)
+
+### 5.2 部署方式
+1. **本地开发部署**
+   - STDIO传输方式
+   - 直接通过UV运行
+
+2. **云服务器部署**
+   - SSE传输方式
+   - 配置外部访问端口
+   - 建议使用反向代理
+
+### 5.3 安全考虑
+- API密钥安全存储
+- 文件上传大小限制
+- 临时文件定期清理
+- 访问频率限制
+
+## 6. 客户端兼容性
+
+### 6.1 已测试兼容
+- Cherry Studio
+- Dify
+- N8N
+
+### 6.2 理论兼容
+- Cursor
+- Cline
+- FastGPT
+- 其他支持MCP协议的客户端
+
+## 7. 性能指标
+
+### 7.1 翻译性能
+- 支持自定义QPS限制
+- 异步处理避免阻塞
+- 进度实时反馈
+
+### 7.2 系统性能
+- 内存使用: 根据PDF大小动态调整
+- 磁盘使用: 临时文件自动清理
+- 网络使用: 依赖AI API调用频率
+
+## 8. 错误处理
+
+### 8.1 常见错误
+- 文件格式不支持
+- API密钥无效
+- 网络连接失败
+- 磁盘空间不足
+
+### 8.2 错误响应
+所有错误都通过标准MCP错误格式返回，包含错误代码和详细信息。
+
+## 9. 未来扩展
+
+### 9.1 功能扩展
+- 支持更多文档格式
+- 批量翻译功能
+- 翻译记忆库集成
+- 自定义翻译模板
+
+### 9.2 性能优化
+- 缓存机制
+- 分布式处理
+- GPU加速支持
+
+## 10. 验收标准
+
+### 10.1 功能验收
+- [ ] 成功翻译PDF文档
+- [ ] 正确返回任务状态
+- [ ] 文件下载功能正常
+- [ ] 配置信息获取正确
+
+### 10.2 兼容性验收
+- [ ] Cherry Studio客户端调用成功
+- [ ] Dify平台集成正常
+- [ ] N8N工作流调用成功
+
+### 10.3 性能验收
+- [ ] 单个文档翻译时间在合理范围内
+- [ ] 并发处理不影响系统稳定性
+- [ ] 内存和磁盘使用控制在预期范围内
+
+---
+
+**文档版本**: v1.0  
+**创建日期**: 2025-07-28  
+**最后更新**: 2025-07-28

pdftranslate_web/pdftranslate-mcp-server/README.md

@@ -0,0 +1,771 @@
+# PDFTranslate MCP Server
+
+基于BabelDOC的PDF文档翻译模型上下文协议(MCP)服务器，为AI助手提供标准化的PDF翻译功能。
+
+## 功能特性
+
+- 🚀 **多语言PDF翻译**: 支持12+种语言间的PDF文档翻译
+- 🔄 **异步任务处理**: 非阻塞的翻译任务管理
+- 📊 **实时进度反馈**: 翻译进度实时更新
+- 🎯 **双模式输出**: 支持双语对照和单语翻译版本
+- ☁️ **云存储集成**: 自动上传翻译结果到腾讯云COS，返回直接下载链接
+- 🛠️ **MCP协议兼容**: 支持Cherry Studio、Dify、N8N等MCP客户端
+- ⚙️ **灵活配置**: 支持自定义QPS、水印模式、COS配置等参数
+- 🔧 **动态配置**: 支持通过MCP参数动态更新配置，无需重启服务
+
+## 安装要求
+
+- Python 3.12+
+- UV包管理器 (推荐) 或 pip
+- OpenAI兼容的API密钥
+- 腾讯云COS SDK (可选，用于文件上传功能)
+
+## 快速开始
+
+### 方式一：Docker部署 (推荐)
+
+#### 1. 克隆项目
+
+```bash
+git clone <repository-url>
+cd pdftranslate-mcp-server
+```
+
+#### 2. 配置环境变量
+
+```bash
+# 复制环境变量模板
+cp .env.docker .env
+
+# 编辑 .env 文件，填入你的配置
+nano .env
+```
+
+必须配置的环境变量：
+```bash
+OPENAI_API_KEY=your-api-key-here
+```
+
+#### 3. 使用Docker Compose启动 (推荐)
+
+```bash
+# 构建并启动服务
+docker-compose up -d
+
+# 查看日志
+docker-compose logs -f
+
+# 停止服务
+docker-compose down
+```
+
+#### 4. 或者使用Docker命令
+
+```bash
+# 构建镜像
+docker build -t pdftranslate-mcp-server .
+
+# 运行容器
+docker run -d \
+  --name pdftranslate-mcp-server \
+  -p 8006:8006 \
+  -e OPENAI_API_KEY=your-api-key-here \
+  -e OPENAI_MODEL=deepseek-ai/DeepSeek-V3 \
+  -e OPENAI_BASE_URL=https://api.siliconflow.cn/v1 \
+  -v $(pwd)/logs:/app/logs \
+  -v $(pwd)/temp:/app/temp \
+  pdftranslate-mcp-server
+
+# 查看日志
+docker logs -f pdftranslate-mcp-server
+
+# 停止容器
+docker stop pdftranslate-mcp-server
+docker rm pdftranslate-mcp-server
+```
+
+### 方式二：本地安装
+
+#### 1. 克隆项目
+
+```bash
+git clone <repository-url>
+cd pdftranslate-mcp-server
+```
+
+#### 2. 安装依赖
+
+使用UV (推荐):
+```bash
+uv venv
+uv pip install .
+# 安装COS SDK (可选，用于文件上传功能)
+uv pip install cos-python-sdk-v5
+```
+
+或使用pip:
+```bash
+pip install -r requirements.txt
+# 安装COS SDK (可选，用于文件上传功能)
+pip install cos-python-sdk-v5
+```
+
+#### 3. 安装BabelDOC
+
+```bash
+# 使用UV
+uv pip install babeldoc
+
+# 或使用pip
+pip install babeldoc
+```
+
+#### 4. 配置环境变量
+
+复制环境变量模板:
+```bash
+cp .env.example .env
+```
+
+编辑 `.env` 文件，填入你的配置:
+```env
+# OpenAI API配置
+OPENAI_API_KEY=your_api_key_here
+OPENAI_MODEL=deepseek-ai/DeepSeek-V3
+OPENAI_BASE_URL=https://api.siliconflow.cn/v1
+
+# 翻译配置
+DEFAULT_LANG_IN=en
+DEFAULT_LANG_OUT=zh
+QPS=4
+WATERMARK_OUTPUT_MODE=no_watermark
+NO_DUAL=false
+NO_MONO=false
+
+# 服务器配置
+MCP_HOST=0.0.0.0
+MCP_PORT=8003
+
+# 腾讯云COS配置 (可选，用于文件上传功能)
+COS_REGION=ap-nanjing
+COS_SECRET_ID=your_cos_secret_id
+COS_SECRET_KEY=your_cos_secret_key
+COS_BUCKET=your_cos_bucket
+```
+
+### 5. 配置文件设置 (可选)
+
+除了环境变量，您也可以通过 `config.ini` 文件配置COS参数:
+
+```ini
+[common]
+cos_region = ap-nanjing
+cos_secret_id = your_cos_secret_id
+cos_secret_key = your_cos_secret_key
+cos_bucket = your_cos_bucket
+```
+
+> **注意**: 环境变量的优先级高于config.ini配置
+
+### 6. 启动服务器
+
+```bash
+# 使用UV
+uv run main.py
+
+# 或直接运行
+python main.py
+```
+
+服务器将在 `http://0.0.0.0:8006/sse` 启动（SSE模式）。
+
+**注意**: 默认使用SSE传输方式，适合云部署和远程客户端访问。如果需要STDIO模式（适合本地开发），请修改main.py中的`mcp.run(transport="stdio")`。
+
+## Docker镜像构建详解
+
+### 镜像特性
+
+- **多阶段构建**：优化镜像大小，减少最终镜像体积
+- **非root用户**：使用专用的`mcpuser`用户运行服务，提高安全性
+- **环境变量配置**：支持通过环境变量动态配置所有参数
+- **健康检查**：内置健康检查机制，确保服务正常运行
+- **数据持久化**：支持挂载卷保存日志、临时文件等
+
+### 环境变量配置
+
+| 环境变量 | 默认值 | 说明 |
+|---------|--------|------|
+| `OPENAI_API_KEY` | - | OpenAI API密钥 (必填) |
+| `OPENAI_MODEL` | `deepseek-ai/DeepSeek-V3` | 使用的AI模型 |
+| `OPENAI_BASE_URL` | `https://api.siliconflow.cn/v1` | API基础URL |
+| `MCP_HOST` | `0.0.0.0` | MCP服务器监听地址 |
+| `MCP_PORT` | `8006` | MCP服务器端口 |
+| `DEFAULT_LANG_IN` | `en` | 默认源语言 |
+| `DEFAULT_LANG_OUT` | `zh` | 默认目标语言 |
+| `QPS` | `4` | 每秒查询数限制 |
+| `WATERMARK_OUTPUT_MODE` | `no_watermark` | 水印模式 |
+| `NO_DUAL` | `false` | 是否禁用双语版本 |
+| `NO_MONO` | `false` | 是否禁用单语版本 |
+| `COS_REGION` | - | 腾讯云COS地域 |
+| `COS_SECRET_ID` | - | 腾讯云COS密钥ID |
+| `COS_SECRET_KEY` | - | 腾讯云COS密钥Key |
+| `COS_BUCKET` | - | 腾讯云COS存储桶 |
+| `LOG_LEVEL` | `INFO` | 日志级别 |
+
+### 数据卷挂载
+
+推荐挂载以下目录：
+
+```bash
+# 日志目录
+-v ./logs:/app/logs
+
+# 临时文件目录
+-v ./temp:/app/temp
+
+# 上传文件目录
+-v ./uploads:/app/uploads
+
+# 下载文件目录
+-v ./downloads:/app/downloads
+
+# 配置文件 (可选)
+-v ./config.ini:/app/config.ini:ro
+```
+
+### 生产环境部署
+
+#### 使用Docker Compose (推荐)
+
+```yaml
+version: '3.8'
+
+services:
+  pdftranslate-mcp:
+    image: pdftranslate-mcp-server:latest
+    container_name: pdftranslate-mcp-server
+    restart: unless-stopped
+    ports:
+      - "8006:8006"
+    environment:
+      - OPENAI_API_KEY=${OPENAI_API_KEY}
+      - OPENAI_MODEL=${OPENAI_MODEL}
+      - OPENAI_BASE_URL=${OPENAI_BASE_URL}
+    volumes:
+      - ./logs:/app/logs
+      - ./temp:/app/temp
+    networks:
+      - pdftranslate-network
+
+networks:
+  pdftranslate-network:
+    driver: bridge
+```
+
+#### 使用Docker Swarm
+
+```bash
+# 创建Docker Secret存储API密钥
+echo "your-api-key" | docker secret create openai_api_key -
+
+# 部署服务
+docker service create \
+  --name pdftranslate-mcp \
+  --publish 8006:8006 \
+  --secret openai_api_key \
+  --env OPENAI_API_KEY_FILE=/run/secrets/openai_api_key \
+  --mount type=volume,source=pdftranslate-logs,target=/app/logs \
+  --mount type=volume,source=pdftranslate-temp,target=/app/temp \
+  pdftranslate-mcp-server:latest
+```
+
+### 镜像管理
+
+```bash
+# 构建镜像
+docker build -t pdftranslate-mcp-server:latest .
+
+# 构建指定版本
+docker build -t pdftranslate-mcp-server:1.0.0 .
+
+# 推送到镜像仓库
+docker tag pdftranslate-mcp-server:latest your-registry/pdftranslate-mcp-server:latest
+docker push your-registry/pdftranslate-mcp-server:latest
+
+# 清理未使用的镜像
+docker image prune -f
+```
+
+### 容器监控和维护
+
+```bash
+# 查看容器状态
+docker ps
+docker stats pdftranslate-mcp-server
+
+# 查看容器日志
+docker logs -f pdftranslate-mcp-server
+docker logs --tail 100 pdftranslate-mcp-server
+
+# 进入容器调试
+docker exec -it pdftranslate-mcp-server /bin/bash
+
+# 重启容器
+docker restart pdftranslate-mcp-server
+
+# 更新容器
+docker pull pdftranslate-mcp-server:latest
+docker stop pdftranslate-mcp-server
+docker rm pdftranslate-mcp-server
+docker run -d --name pdftranslate-mcp-server ...
+```
+
+## MCP工具说明
+
+### translate_pdf
+翻译PDF文档 - 支持多种文件输入方式
+
+**参数:**
+- `file_input` (str): 文件输入内容
+  - 当`input_type="base64"`时，为base64编码的文件内容
+  - 当`input_type="url"`时，为文件下载URL
+  - 当`input_type="path"`时，为本地文件路径（仅限本地开发）
+- `input_type` (str, 可选): 输入类型，可选值: "base64", "url", "path"，默认为 "base64"
+- `filename` (str, 可选): 文件名称（用于识别和存储），默认为 "document.pdf"
+- `lang_in` (str, 可选): 源语言代码，默认为 "en"
+- `lang_out` (str, 可选): 目标语言代码，默认为 "zh"
+- `qps` (int, 可选): 每秒查询数限制，默认为 4
+- `no_dual` (bool, 可选): 是否禁用双语对照版本，默认为 False
+- `no_mono` (bool, 可选): 是否禁用单语翻译版本，默认为 False
+- `watermark_output_mode` (str, 可选): 水印模式，可选值: "no_watermark", "watermarked", "both"
+
+**使用示例:**
+
+1. **Base64文件上传（推荐用于SSE方式）:**
+```json
+{
+    "file_input": "JVBERi0xLjQKJcOkw7zDtsOfCjIgMCBvYmoKPDwKL...",
+    "input_type": "base64",
+    "filename": "my_document.pdf",
+    "lang_in": "en",
+    "lang_out": "zh"
+}
+```
+
+2. **URL文件下载:**
+```json
+{
+    "file_input": "https://example.com/document.pdf",
+    "input_type": "url",
+    "filename": "remote_document.pdf"
+}
+```
+
+3. **本地文件路径（仅限本地开发）:**
+```json
+{
+    "file_input": "/path/to/local/document.pdf",
+    "input_type": "path"
+}
+```
+
+**返回:**
+```json
+{
+    "task_id": "uuid-string",
+    "message": "翻译任务已创建，正在从en翻译到zh",
+    "status": "pending",
+    "file_name": "document.pdf",
+    "file_size_mb": 2.5,
+    "input_type": "base64",
+    "settings": {
+        "source_language": "en",
+        "target_language": "zh",
+        "qps": 4,
+        "dual_output": true,
+        "mono_output": true,
+        "watermark_mode": "no_watermark"
+    }
+}
+```
+
+### get_translation_status
+查询翻译任务状态
+
+**参数:**
+- `task_id` (str): 翻译任务ID
+
+**返回:**
+```json
+{
+    "task_id": "uuid-string",
+    "status": "processing",
+    "progress": 45.5,
+    "message": "正在翻译文档...",
+    "result_files": {},
+    "cos_urls": {},
+    "created_at": "2025-07-28T10:00:00",
+    "updated_at": "2025-07-28T10:05:00"
+}
+```
+
+### get_translation_result_cos_url
+获取翻译结果文件的COS云存储URL（推荐用于文件分发）
+
+**参数:**
+- `task_id` (str): 翻译任务ID
+- `file_type` (str, 可选): 文件类型，"dual" 或 "mono"，默认为 "dual"
+
+**返回:**
+```json
+{
+    "success": true,
+    "file_type": "dual",
+    "cos_url": "https://your-bucket.cos.ap-nanjing.myqcloud.com/dual_document_20250128_143022.pdf",
+    "download_url": "https://your-bucket.cos.ap-nanjing.myqcloud.com/dual_document_20250128_143022.pdf",
+    "message": "成功获取dual类型的翻译结果文件COS URL"
+}
+```
+
+### get_translation_result_base64
+获取翻译结果文件的base64编码内容（推荐用于SSE方式）
+
+**参数:**
+- `task_id` (str): 翻译任务ID
+- `file_type` (str, 可选): 文件类型，"dual" 或 "mono"，默认为 "dual"
+
+**返回:**
+```json
+{
+    "success": true,
+    "file_name": "translated_document.pdf",
+    "file_size": 1024000,
+    "file_size_mb": 1.0,
+    "file_type": "dual",
+    "base64_content": "JVBERi0xLjQKJcOkw7zDtsOfCjIgMCBvYmoKPDwKL...",
+    "data_url": "data:application/pdf;base64,JVBERi0xLjQK...",
+    "message": "成功获取dual类型的翻译结果文件base64编码"
+}
+```
+
+### download_translation_result
+获取翻译结果文件信息
+
+**参数:**
+- `task_id` (str): 翻译任务ID
+- `file_type` (str, 可选): 文件类型，"dual" 或 "mono"，默认为 "dual"
+
+**返回:**
+```json
+{
+    "file_path": "/path/to/translated.pdf",
+    "file_name": "translated.pdf",
+    "file_size": 1024000,
+    "file_type": "dual"
+}
+```
+
+### list_all_tasks
+列出所有翻译任务
+
+**返回:**
+```json
+{
+    "total_tasks": 5,
+    "tasks": [...]
+}
+```
+
+### get_supported_languages
+获取支持的语言列表
+
+**返回:**
+```json
+{
+    "languages": {
+        "zh": "中文",
+        "en": "English",
+        "ja": "日本語",
+        ...
+    },
+    "default_lang_in": "en",
+    "default_lang_out": "zh"
+}
+```
+
+### update_cos_config
+动态更新COS配置参数（无需重启服务）
+
+**参数:**
+- `cos_region` (str, 可选): COS地域，如 "ap-nanjing"
+- `cos_secret_id` (str, 可选): COS密钥ID
+- `cos_secret_key` (str, 可选): COS密钥Key
+- `cos_bucket` (str, 可选): COS存储桶名称
+
+**返回:**
+```json
+{
+    "success": true,
+    "message": "COS配置已更新: region, bucket",
+    "updated_fields": ["region", "bucket"],
+    "config_complete": true,
+    "cos_upload_ready": true,
+    "current_config": {
+        "region": "ap-nanjing",
+        "secret_id": "已配置",
+        "secret_key": "已配置",
+        "bucket": "my-bucket"
+    }
+}
+```
+
+### check_system_status
+检查系统状态和依赖（已增强COS支持检查）
+
+**返回:**
+```json
+{
+    "service_name": "PDFTranslate MCP Server",
+    "version": "1.0.0",
+    "babeldoc_available": true,
+    "cos_available": true,
+    "api_key_configured": true,
+    "cos_configured": true,
+    "dependencies": {
+        "babeldoc": "✅ 已安装",
+        "openai_api": "✅ 已配置",
+        "cos_sdk": "✅ 已安装",
+        "cos_config": "✅ 已配置"
+    },
+    "configuration": {
+        "model": "deepseek-ai/DeepSeek-V3",
+        "cos_region": "ap-nanjing",
+        "cos_bucket": "my-bucket"
+    },
+    "ready": true,
+    "cos_upload_ready": true
+}
+```
+
+## MCP资源说明
+
+### config://
+获取服务器配置信息
+```json
+{
+    "service_name": "PDFTranslate MCP Server",
+    "version": "1.0.0",
+    "babeldoc_available": true,
+    "openai_model": "deepseek-ai/DeepSeek-V3",
+    ...
+}
+```
+
+### tasks://
+获取任务状态统计
+```json
+{
+    "total_tasks": 10,
+    "tasks_by_status": {
+        "completed": 7,
+        "processing": 2,
+        "failed": 1
+    },
+    "recent_tasks": [...]
+}
+```
+
+## 客户端配置
+
+### Cherry Studio
+
+1. 打开Cherry Studio设置
+2. 添加MCP服务器
+3. 选择 **"SSE"** 传输方式
+4. 输入服务器地址: `http://your-server:8003/sse`
+   - 本地测试: `http://localhost:8003/sse`
+   - 云服务器: `http://your-domain:8003/sse`
+5. 保存配置
+
+### Dify
+
+在Dify工作流中添加MCP节点，配置SSE服务器地址:
+- 本地: `http://localhost:8003/sse`
+- 远程: `http://your-server:8003/sse`
+
+### N8N
+
+使用HTTP Request节点连接到MCP服务器的SSE端点:
+- URL: `http://your-server:8003/sse`
+- Method: POST
+- Content-Type: application/json
+
+**重要提示**: 
+- SSE方式支持base64文件上传，推荐使用`input_type="base64"`
+- 文件大小限制为100MB
+- 支持URL下载方式 (`input_type="url"`)
+- 本地文件路径方式仅在服务器本地可用
+
+## 云存储功能 (COS集成)
+
+### 功能说明
+
+本服务集成了腾讯云对象存储(COS)，提供以下功能：
+
+- ☁️ **自动上传**: 翻译完成后自动上传结果文件到COS
+- 🔗 **直接访问**: 返回可直接下载的COS URL链接
+- 📁 **文件管理**: 自动生成唯一文件名，避免冲突
+- 🔒 **安全配置**: 支持多种配置方式，保护密钥安全
+
+### 配置方式优先级
+
+1. **环境变量** (最高优先级)
+2. **config.ini文件**
+3. **MCP动态配置**
+
+### 使用流程
+
+1. **配置COS参数** - 通过环境变量、config.ini或MCP工具配置
+2. **翻译文件** - 正常使用`translate_pdf()`功能
+3. **自动上传** - 翻译完成后自动上传到COS
+4. **获取URL** - 使用`get_translation_result_cos_url()`获取下载链接
+5. **直接下载** - 用户通过URL直接下载文件
+
+### 文件命名规则
+
+上传到COS的文件会自动添加时间戳前缀：
+- 双语版本: `dual_原文件名_20250128_143022.pdf`
+- 单语版本: `mono_原文件名_20250128_143022.pdf`
+
+### 故障处理
+
+如果COS上传失败，系统会：
+- 记录详细错误日志
+- 保留本地文件供其他方式获取
+- 在任务状态中标明上传失败原因
+
+## 支持的语言
+
+- 中文 (zh)
+- English (en)
+- 日本語 (ja)
+- 한국어 (ko)
+- Français (fr)
+- Deutsch (de)
+- Español (es)
+- Русский (ru)
+- Italiano (it)
+- Português (pt)
+- العربية (ar)
+- हिन्दी (hi)
+
+## 部署
+
+### 本地开发
+
+```bash
+uv run main.py
+```
+
+### 云服务器部署
+
+1. 安装依赖和配置环境变量
+2. 使用systemd或supervisor管理进程
+3. 配置nginx反向代理 (可选)
+
+示例systemd服务文件:
+```ini
+[Unit]
+Description=PDFTranslate MCP Server
+After=network.target
+
+[Service]
+Type=simple
+User=your-user
+WorkingDirectory=/path/to/pdftranslate-mcp-server
+Environment=PATH=/path/to/venv/bin
+ExecStart=/path/to/venv/bin/python main.py
+Restart=always
+
+[Install]
+WantedBy=multi-user.target
+```
+
+### Docker部署
+
+```dockerfile
+FROM python:3.12-slim
+
+WORKDIR /app
+COPY . .
+
+RUN pip install uv
+RUN uv pip install .
+RUN uv pip install babeldoc
+
+EXPOSE 8003
+
+CMD ["python", "main.py"]
+```
+
+## 故障排除
+
+### 常见问题
+
+1. **BabelDOC未安装**
+   ```bash
+   pip install babeldoc
+   # 或
+   uv pip install babeldoc
+   ```
+
+2. **COS SDK未安装**
+   ```bash
+   pip install cos-python-sdk-v5
+   # 或
+   uv pip install cos-python-sdk-v5
+   ```
+
+3. **API密钥错误**
+   检查 `.env` 文件中的 `OPENAI_API_KEY` 配置
+
+4. **COS配置错误**
+   - 检查 `COS_REGION`、`COS_SECRET_ID`、`COS_SECRET_KEY`、`COS_BUCKET` 配置
+   - 使用 `check_system_status()` 工具检查COS配置状态
+   - 使用 `update_cos_config()` 工具动态更新配置
+
+5. **COS上传失败**
+   - 检查网络连接
+   - 验证COS密钥权限
+   - 确认存储桶名称和地域正确
+   - 查看服务器日志获取详细错误信息
+
+6. **端口占用**
+   修改 `.env` 文件中的 `MCP_PORT` 配置
+
+7. **内存不足**
+   处理大型PDF文件时可能需要更多内存
+
+8. **文件无法下载**
+   - 如果COS上传失败，可使用 `get_translation_result_base64()` 获取文件
+   - 检查COS存储桶的访问权限设置
+
+### 日志查看
+
+服务器日志包含详细的错误信息和调试信息，可以帮助定位问题。
+
+## 许可证
+
+MIT License
+
+## 贡献
+
+欢迎贡献代码和报告问题！请创建Issue或提交Pull Request。
+
+## 更新日志
+
+### v1.0.0 (2025-07-28)
+- 初始版本发布
+- 支持PDF翻译功能
+- 支持MCP协议
+- 支持多种客户端

pdftranslate_web/pdftranslate-mcp-server/config.ini

@@ -0,0 +1,5 @@
+[common]
+cos_region  = ap-nanjing
+cos_secret_id  = AKID0036B78yiS5NSM3WyIQKzSI1VjgO9qPl
+cos_secret_key  = IZhavCLI6IH1WlofM6i9NXUFqGTUOFvS
+cos_bucket =tts-1258720957

pdftranslate_web/pdftranslate-mcp-server/docker-compose.yml

@@ -0,0 +1,63 @@
+version: '3.8'
+
+services:
+  pdftranslate-mcp:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    image: pdftranslate-mcp-server:latest
+    container_name: pdftranslate-mcp-server
+    restart: unless-stopped
+    ports:
+      - "8006:8006"
+    environment:
+      # OpenAI API配置 (必填)
+      - OPENAI_API_KEY=${OPENAI_API_KEY}
+      - OPENAI_MODEL=${OPENAI_MODEL:-deepseek-ai/DeepSeek-V3}
+      - OPENAI_BASE_URL=${OPENAI_BASE_URL:-https://api.siliconflow.cn/v1}
+      
+      # MCP服务器配置
+      - MCP_HOST=0.0.0.0
+      - MCP_PORT=8006
+      
+      # 翻译配置
+      - DEFAULT_LANG_IN=${DEFAULT_LANG_IN:-en}
+      - DEFAULT_LANG_OUT=${DEFAULT_LANG_OUT:-zh}
+      - QPS=${QPS:-4}
+      - WATERMARK_OUTPUT_MODE=${WATERMARK_OUTPUT_MODE:-no_watermark}
+      - NO_DUAL=${NO_DUAL:-false}
+      - NO_MONO=${NO_MONO:-false}
+      
+      # 腾讯云COS配置 (可选，用于文件上传)
+      - COS_REGION=${COS_REGION}
+      - COS_SECRET_ID=${COS_SECRET_ID}
+      - COS_SECRET_KEY=${COS_SECRET_KEY}
+      - COS_BUCKET=${COS_BUCKET}
+      
+      # 日志配置
+      - LOG_LEVEL=${LOG_LEVEL:-INFO}
+    
+    volumes:
+      # 挂载配置文件 (可选)
+      - ./config.ini:/app/config.ini:ro
+      # 挂载日志目录
+      - ./logs:/app/logs
+      # 挂载临时文件目录
+      - ./temp:/app/temp
+      # 挂载上传下载目录
+      - ./uploads:/app/uploads
+      - ./downloads:/app/downloads
+    
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:8006/sse"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 60s
+    
+    networks:
+      - pdftranslate-network
+
+networks:
+  pdftranslate-network:
+    driver: bridge

pdftranslate_web/pdftranslate-mcp-server/main.py

@@ -0,0 +1,1100 @@
+import asyncio
+import logging
+import uuid
+import os
+import tempfile
+import shutil
+import json
+import base64
+import aiohttp
+import configparser
+from pathlib import Path
+from typing import Dict, Any, Optional, List, Union
+from concurrent.futures import ThreadPoolExecutor
+from datetime import datetime
+
+from mcp.server.fastmcp import FastMCP
+from dotenv import load_dotenv
+
+# 尝试导入腾讯云COS相关模块
+try:
+    from qcloud_cos import CosConfig, CosS3Client
+    COS_AVAILABLE = True
+    print("✅ 腾讯云COS库已成功加载")
+except ImportError as e:
+    COS_AVAILABLE = False
+    print("❌ 警告: 腾讯云COS库未安装")
+    print("📦 请使用以下命令安装:")
+    print("   pip install cos-python-sdk-v5")
+    print("   或者")
+    print("   uv pip install cos-python-sdk-v5")
+    print(f"详细错误信息: {e}")
+
+# 尝试导入BabelDOC相关模块
+try:
+    import babeldoc.format.pdf.high_level
+    from babeldoc.format.pdf.translation_config import TranslationConfig, WatermarkOutputMode
+    from babeldoc.translator.translator import OpenAITranslator, set_translate_rate_limiter
+    from babeldoc.docvision.doclayout import DocLayoutModel
+    BABELDOC_AVAILABLE = True
+    print("✅ BabelDOC库已成功加载")
+except ImportError as e:
+    BABELDOC_AVAILABLE = False
+    print("❌ 警告: BabelDOC库未安装")
+    print("📦 请使用以下命令安装BabelDOC:")
+    print("   pip install babeldoc")
+    print("   或者")
+    print("   uv pip install babeldoc")
+    print(f"详细错误信息: {e}")
+
+# 配置日志
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# 加载环境变量
+load_dotenv()
+
+def load_cos_config():
+    """从config.ini和环境变量加载COS配置"""
+    cos_config = {}
+    
+    # 优先从环境变量加载
+    cos_config["region"] = os.getenv("COS_REGION")
+    cos_config["secret_id"] = os.getenv("COS_SECRET_ID") 
+    cos_config["secret_key"] = os.getenv("COS_SECRET_KEY")
+    cos_config["bucket"] = os.getenv("COS_BUCKET")
+    
+    # 如果环境变量没有设置，从config.ini加载
+    config_file_path = os.getenv('CONFIG_INI_PATH', 'config.ini')
+    if os.path.exists(config_file_path):
+        config = configparser.ConfigParser()
+        config.read(config_file_path, encoding='utf-8')
+        
+        if not cos_config["region"]:
+            cos_config["region"] = config.get('common', 'cos_region', fallback=None)
+        if not cos_config["secret_id"]:
+            cos_config["secret_id"] = config.get('common', 'cos_secret_id', fallback=None)
+        if not cos_config["secret_key"]:
+            cos_config["secret_key"] = config.get('common', 'cos_secret_key', fallback=None)
+        if not cos_config["bucket"]:
+            cos_config["bucket"] = config.get('common', 'cos_bucket', fallback=None)
+    
+    return cos_config
+
+# 全局配置
+CONFIG = {
+    "openai": {
+        "api_key": os.getenv("OPENAI_API_KEY", ""),
+        "model": os.getenv("OPENAI_MODEL", "deepseek-ai/DeepSeek-V3"),
+        "base_url": os.getenv("OPENAI_BASE_URL", "https://api.siliconflow.cn/v1")
+    },
+    "translation": {
+        "default_lang_in": os.getenv("DEFAULT_LANG_IN", "en"),
+        "default_lang_out": os.getenv("DEFAULT_LANG_OUT", "zh"),
+        "qps": int(os.getenv("QPS", "4")),
+        "watermark_output_mode": os.getenv("WATERMARK_OUTPUT_MODE", "no_watermark"),
+        "no_dual": os.getenv("NO_DUAL", "false").lower() == "true",
+        "no_mono": os.getenv("NO_MONO", "false").lower() == "true"
+    },
+    "server": {
+        "host": os.getenv("MCP_HOST", "0.0.0.0"),
+        "port": int(os.getenv("MCP_PORT", "8003"))
+    },
+    "cos": load_cos_config()
+}
+
+# 验证配置
+if not CONFIG["openai"]["api_key"]:
+    logger.warning("未找到OpenAI API密钥！请通过环境变量OPENAI_API_KEY提供")
+
+# 创建MCP服务器
+mcp = FastMCP("PDFTranslate")
+
+# 全局任务存储
+translation_tasks: Dict[str, Dict[str, Any]] = {}
+task_files: Dict[str, Dict[str, Path]] = {}
+
+async def download_file_from_url(url: str, target_path: Path) -> bool:
+    """
+    从URL下载文件到本地路径
+    
+    Args:
+        url: 文件URL
+        target_path: 目标文件路径
+        
+    Returns:
+        bool: 下载是否成功
+    """
+    try:
+        async with aiohttp.ClientSession() as session:
+            async with session.get(url) as response:
+                if response.status == 200:
+                    with open(target_path, 'wb') as f:
+                        async for chunk in response.content.iter_chunked(8192):
+                            f.write(chunk)
+                    return True
+                else:
+                    logger.error(f"下载失败，HTTP状态码: {response.status}")
+                    return False
+    except Exception as e:
+        logger.error(f"下载文件时出错: {e}")
+        return False
+
+def save_base64_file(base64_content: str, target_path: Path) -> bool:
+    """
+    保存base64编码��文件内容到本地
+    
+    Args:
+        base64_content: base64编码的文件内容
+        target_path: 目标文件路径
+        
+    Returns:
+        bool: 保存是否成功
+    """
+    try:
+        # 如果包含data URL前缀，去掉它
+        if ',' in base64_content and base64_content.startswith('data:'):
+            base64_content = base64_content.split(',', 1)[1]
+        
+        file_data = base64.b64decode(base64_content)
+        with open(target_path, 'wb') as f:
+            f.write(file_data)
+        return True
+    except Exception as e:
+        logger.error(f"保存base64文件时出错: {e}")
+        return False
+
+def validate_pdf_file(file_path: Path) -> bool:
+    """
+    验证文件是否为有效的PDF文件
+    
+    Args:
+        file_path: 文件路径
+        
+    Returns:
+        bool: 是否为有效PDF
+    """
+    try:
+        with open(file_path, 'rb') as f:
+            header = f.read(8)
+            return header.startswith(b'%PDF-')
+    except Exception:
+        return False
+
+def upload_file_to_cos(file_path: Path, file_name: str = None) -> Dict[str, Any]:
+    """
+    上传文件到腾讯云COS
+    
+    Args:
+        file_path: 本地文件路径
+        file_name: COS中的文件名，如果为None则使用原文件名
+        
+    Returns:
+        dict: 上传结果，包含success状态和url或error信息
+    """
+    if not COS_AVAILABLE:
+        return {
+            "success": False,
+            "error": "腾讯云COS库未安装，无法上传文件",
+            "message": "请先安装cos-python-sdk-v5库"
+        }
+    
+    cos_config = CONFIG["cos"]
+    if not all([cos_config.get("region"), cos_config.get("secret_id"), 
+                cos_config.get("secret_key"), cos_config.get("bucket")]):
+        return {
+            "success": False,
+            "error": "COS配置不完整",
+            "message": "请检查config.ini或环境变量中的COS配置",
+            "missing_config": {
+                "region": not cos_config.get("region"),
+                "secret_id": not cos_config.get("secret_id"),
+                "secret_key": not cos_config.get("secret_key"),
+                "bucket": not cos_config.get("bucket")
+            }
+        }
+    
+    try:
+        # 创建COS客户端
+        config = CosConfig(
+            Region=cos_config["region"],
+            SecretId=cos_config["secret_id"],
+            SecretKey=cos_config["secret_key"]
+        )
+        client = CosS3Client(config)
+        
+        # 如果没有指定文件名，使用原文件名
+        if not file_name:
+            file_name = file_path.name
+        
+        # 添加时间戳避免文件名冲突
+        import datetime
+        timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+        name_parts = file_name.rsplit('.', 1)
+        if len(name_parts) == 2:
+            file_name = f"{name_parts[0]}_{timestamp}.{name_parts[1]}"
+        else:
+            file_name = f"{file_name}_{timestamp}"
+        
+        # 上传文件
+        with open(file_path, 'rb') as f:
+            response = client.put_object(
+                Bucket=cos_config["bucket"],
+                Body=f,
+                Key=file_name,
+                EnableMD5=False
+            )
+        
+        if response and response.get('ETag'):
+            # 构造文件URL
+            url = f"https://{cos_config['bucket']}.cos.{cos_config['region']}.myqcloud.com/{file_name}"
+            return {
+                "success": True,
+                "url": url,
+                "file_name": file_name,
+                "etag": response['ETag'],
+                "message": "文件上传成功"
+            }
+        else:
+            return {
+                "success": False,
+                "error": "上传失败",
+                "message": f"COS响应异常: {response}"
+            }
+            
+    except Exception as e:
+        logger.error(f"上传文件到COS时出错: {e}")
+        return {
+            "success": False,
+            "error": f"上传过程出错: {str(e)}",
+            "message": "请检查COS配置和网络连接"
+        }
+
+class TranslationTask:
+    def __init__(self, task_id: str):
+        self.task_id = task_id
+        self.status = "pending"  # pending, processing, completed, failed
+        self.progress = 0.0
+        self.message = "任务已创建，等待处理..."
+        self.result_files = {}
+        self.cos_urls = {}  # 添加COS URL存储
+        self.created_at = datetime.now().isoformat()
+        self.updated_at = datetime.now().isoformat()
+    
+    def to_dict(self):
+        return {
+            "task_id": self.task_id,
+            "status": self.status,
+            "progress": self.progress,
+            "message": self.message,
+            "result_files": self.result_files,
+            "cos_urls": self.cos_urls,  # 包含COS URL信息
+            "created_at": self.created_at,
+            "updated_at": self.updated_at
+        }
+
+async def translate_document_async(
+    task_id: str,
+    pdf_file: Path,
+    lang_in: str,
+    lang_out: str,
+    qps: int,
+    no_dual: bool,
+    no_mono: bool,
+    watermark_output_mode: str,
+    output_dir: Path
+):
+    """异步翻译文档"""
+    if not BABELDOC_AVAILABLE:
+        translation_tasks[task_id].status = "failed"
+        translation_tasks[task_id].message = "BabelDOC库未安装，无法进行翻译"
+        return
+    
+    try:
+        task = translation_tasks[task_id]
+        task.status = "processing"
+        task.message = "正在初始化翻译器..."
+        task.updated_at = datetime.now().isoformat()
+        
+        # 初始化翻译器
+        translator = OpenAITranslator(
+            lang_in=lang_in,
+            lang_out=lang_out,
+            model=CONFIG["openai"]["model"],
+            base_url=CONFIG["openai"]["base_url"],
+            api_key=CONFIG["openai"]["api_key"],
+            ignore_cache=False,
+        )
+        
+        set_translate_rate_limiter(qps)
+        
+        # 加载文档布局模型
+        doc_layout_model = DocLayoutModel.load_onnx()
+        
+        # 配置水印模式
+        watermark_mode = WatermarkOutputMode.NoWatermark
+        if watermark_output_mode == "watermarked":
+            watermark_mode = WatermarkOutputMode.Watermarked
+        elif watermark_output_mode == "both":
+            watermark_mode = WatermarkOutputMode.Both
+        
+        # 创建翻译配置
+        config_obj = TranslationConfig(
+            input_file=str(pdf_file),
+            output_dir=str(output_dir),
+            translator=translator,
+            lang_in=lang_in,
+            lang_out=lang_out,
+            no_dual=no_dual,
+            no_mono=no_mono,
+            qps=qps,
+            doc_layout_model=doc_layout_model,
+            watermark_output_mode=watermark_mode,
+            debug=False,
+            pages=None,
+            font=None,
+            formular_font_pattern=None,
+            formular_char_pattern=None,
+            split_short_lines=False,
+            short_line_split_factor=0.8,
+            skip_clean=False,
+            dual_translate_first=False,
+            disable_rich_text_translate=False,
+            enhance_compatibility=False,
+            use_alternating_pages_dual=False,
+            report_interval=0.1,
+            min_text_length=5,
+            split_strategy=None,
+            table_model=None,
+            show_char_box=False,
+            skip_scanned_detection=False,
+            ocr_workaround=False,
+            custom_system_prompt=None,
+            working_dir=None,
+            add_formula_placehold_hint=False,
+            glossaries=[],
+            pool_max_workers=None,
+            auto_extract_glossary=True,
+            auto_enable_ocr_workaround=False,
+            primary_font_family=None,
+            only_include_translated_page=False,
+            save_auto_extracted_glossary=False,
+        )
+        
+        task.message = "正在翻译文档..."
+        
+        # 执行翻译
+        async for event in babeldoc.format.pdf.high_level.async_translate(config_obj):
+            if event["type"] == "progress_update":
+                task.progress = event.get("overall_progress", 0.0)
+                task.message = f"{event.get('stage', '处理中')} ({event.get('stage_current', 0)}/{event.get('stage_total', 100)})"
+                task.updated_at = datetime.now().isoformat()
+            elif event["type"] == "error":
+                task.status = "failed"
+                task.message = f"翻译失败: {event.get('error', '未知错误')}"
+                task.updated_at = datetime.now().isoformat()
+                logger.error(f"Translation failed for task {task_id}: {event.get('error')}")
+                return
+            elif event["type"] == "finish":
+                result = event["translate_result"]
+                task.status = "completed"
+                task.progress = 100.0
+                task.message = "翻译完成"
+                task.updated_at = datetime.now().isoformat()
+                
+                # 收集结果文件并上传到COS
+                result_files = {}
+                cos_urls = {}
+                
+                if result.dual_pdf_path and Path(result.dual_pdf_path).exists():
+                    dual_path = Path(result.dual_pdf_path)
+                    result_files["dual"] = str(dual_path)
+                    
+                    # 上传双语版本到COS
+                    task.message = "正在上传双语版本到云存储..."
+                    task.updated_at = datetime.now().isoformat()
+                    upload_result = upload_file_to_cos(dual_path, f"dual_{dual_path.name}")
+                    if upload_result.get("success"):
+                        cos_urls["dual"] = upload_result["url"]
+                        logger.info(f"双语版本已上传到COS: {upload_result['url']}")
+                    else:
+                        logger.warning(f"双语版本上传COS失败: {upload_result.get('error')}")
+                
+                if result.mono_pdf_path and Path(result.mono_pdf_path).exists():
+                    mono_path = Path(result.mono_pdf_path)
+                    result_files["mono"] = str(mono_path)
+                    
+                    # 上传单语版本到COS
+                    task.message = "正在上传单语版本到云存储..."
+                    task.updated_at = datetime.now().isoformat()
+                    upload_result = upload_file_to_cos(mono_path, f"mono_{mono_path.name}")
+                    if upload_result.get("success"):
+                        cos_urls["mono"] = upload_result["url"]
+                        logger.info(f"单语版本已上传到COS: {upload_result['url']}")
+                    else:
+                        logger.warning(f"单语版本上传COS失败: {upload_result.get('error')}")
+                
+                task.result_files = result_files
+                task.cos_urls = cos_urls  # 添加COS URL信息
+                task_files[task_id] = {k: Path(v) for k, v in result_files.items()}
+                
+                # 更新最终状态
+                if cos_urls:
+                    task.message = f"翻译完成，文件已上传到云存储。可用版本: {', '.join(cos_urls.keys())}"
+                else:
+                    task.message = "翻译完成，但文件上传到云存储失败，可通过其他方式获取文件"
+                
+                logger.info(f"Translation completed for task {task_id}")
+                break
+                
+    except Exception as e:
+        task = translation_tasks[task_id]
+        task.status = "failed"
+        task.message = f"翻译过程出错: {str(e)}"
+        task.updated_at = datetime.now().isoformat()
+        logger.error(f"Translation error for task {task_id}: {e}", exc_info=True)
+
+@mcp.tool()
+async def translate_pdf(
+    file_input: str,
+    input_type: str = "base64",
+    filename: str = "document.pdf",
+    lang_in: str = None,
+    lang_out: str = None,
+    qps: int = None,
+    no_dual: bool = False,
+    no_mono: bool = False,
+    watermark_output_mode: str = None
+) -> dict:
+    """
+    翻译PDF文档 - 支持多种文件输入方式
+    
+    Args:
+        file_input: 文件输入内容
+            - 当input_type="base64"时，为base64编码的文件内容
+            - 当input_type="url"时，为文件下载URL
+            - 当input_type="path"时，为本地文件路径（仅限本地开发）
+        input_type: 输入类型 ("base64", "url", "path")
+        filename: 文件名称（用于识别和存储）
+        lang_in: 源语言代码 (默认: en)
+        lang_out: 目标语言代码 (默认: zh)
+        qps: 每秒查询数限制 (默认: 4)
+        no_dual: 是否禁用双语对照版本 (默认: False)
+        no_mono: 是否禁用单语翻译版本 (默认: False)
+        watermark_output_mode: 水印模式 (no_watermark/watermarked/both，默认: no_watermark)
+    
+    Returns:
+        dict: {"task_id": str, "message": str, "status": str} 或错误信息
+    """
+    # 检查BabelDOC是否可用
+    if not BABELDOC_AVAILABLE:
+        return {
+            "error": "BabelDOC库未安装，无法进行翻译",
+            "message": "请先安装BabelDOC库",
+            "install_commands": [
+                "pip install babeldoc",
+                "uv pip install babeldoc"
+            ],
+            "status": "failed"
+        }
+    
+    # 检查API密钥
+    if not CONFIG["openai"]["api_key"]:
+        return {
+            "error": "未配置OpenAI API密钥",
+            "message": "请在.env文件中设置OPENAI_API_KEY",
+            "status": "failed"
+        }
+    
+    # 验证输入类型
+    if input_type not in ["base64", "url", "path"]:
+        return {
+            "error": "不支持的输入类型",
+            "message": f"支持的输入类型: base64, url, path。当前: {input_type}",
+            "status": "failed"
+        }
+    
+    try:
+        # 创建临时目录和文件
+        temp_dir = Path(tempfile.mkdtemp())
+        
+        # 确保文件名以.pdf结尾
+        if not filename.lower().endswith('.pdf'):
+            filename += '.pdf'
+        
+        pdf_path = temp_dir / filename
+        
+        # 根据输入类型处理文件
+        if input_type == "base64":
+            logger.info(f"正在处理base64文件: {filename}")
+            if not save_base64_file(file_input, pdf_path):
+                return {
+                    "error": "base64文件解码失败",
+                    "message": "请检查base64编码格式是否正确",
+                    "status": "failed"
+                }
+        
+        elif input_type == "url":
+            logger.info(f"正在从URL下载文件: {file_input}")
+            if not await download_file_from_url(file_input, pdf_path):
+                return {
+                    "error": "文件下载失败",
+                    "message": f"无法从URL下载文件: {file_input}",
+                    "status": "failed"
+                }
+        
+        elif input_type == "path":
+            logger.info(f"正在处理本地文件: {file_input}")
+            source_path = Path(file_input)
+            if not source_path.exists():
+                return {
+                    "error": f"文件不存在: {file_input}",
+                    "message": "请检查文件路径是否正确",
+                    "status": "failed"
+                }
+            # 复制文件到临时目录
+            shutil.copy2(source_path, pdf_path)
+        
+        # 验证是否为有效的PDF文件
+        if not validate_pdf_file(pdf_path):
+            return {
+                "error": "文件格式验证失败",
+                "message": "文件不是有效的PDF格式",
+                "status": "failed"
+            }
+        
+        # 检查文件大小（限制为100MB）
+        file_size = pdf_path.stat().st_size
+        max_size = 100 * 1024 * 1024  # 100MB
+        if file_size > max_size:
+            return {
+                "error": "文件过大",
+                "message": f"文件大小 {file_size/1024/1024:.1f}MB 超过限制 {max_size/1024/1024}MB",
+                "status": "failed"
+            }
+        
+        # 使用默认值
+        lang_in = lang_in or CONFIG["translation"]["default_lang_in"]
+        lang_out = lang_out or CONFIG["translation"]["default_lang_out"]
+        qps = qps or CONFIG["translation"]["qps"]
+        watermark_output_mode = watermark_output_mode or CONFIG["translation"]["watermark_output_mode"]
+        
+        # 创建任务
+        task_id = str(uuid.uuid4())
+        task = TranslationTask(task_id)
+        translation_tasks[task_id] = task
+        
+        # 创建输出目录
+        output_dir = temp_dir / "output"
+        output_dir.mkdir(exist_ok=True)
+        
+        # 启动异步翻译任务
+        asyncio.create_task(translate_document_async(
+            task_id, pdf_path, lang_in, lang_out, qps, 
+            no_dual, no_mono, watermark_output_mode, output_dir
+        ))
+        
+        logger.info(f"翻译任务已创建: {task_id}, 文件: {filename}")
+        
+        return {
+            "task_id": task_id,
+            "message": f"翻译任务已创建，正在从{lang_in}翻译到{lang_out}",
+            "status": "pending",
+            "file_name": filename,
+            "file_size_mb": round(file_size / 1024 / 1024, 2),
+            "input_type": input_type,
+            "settings": {
+                "source_language": lang_in,
+                "target_language": lang_out,
+                "qps": qps,
+                "dual_output": not no_dual,
+                "mono_output": not no_mono,
+                "watermark_mode": watermark_output_mode
+            }
+        }
+        
+    except Exception as e:
+        logger.error(f"创建翻译任务时出错: {e}")
+        return {
+            "error": f"创建翻译任务失败: {str(e)}",
+            "message": "请检查文件内容和参数设置",
+            "status": "failed"
+        }
+
+@mcp.tool()
+def get_translation_status(task_id: str) -> dict:
+    """
+    查询翻译任务状态
+    
+    Args:
+        task_id: 翻译任务ID
+    
+    Returns:
+        dict: 任务状态信息
+    """
+    if task_id not in translation_tasks:
+        return {
+            "error": "任务不存在",
+            "message": f"找不到任务ID: {task_id}",
+            "status": "not_found"
+        }
+    
+    task = translation_tasks[task_id]
+    return task.to_dict()
+
+@mcp.tool()
+def get_translation_result_base64(task_id: str, file_type: str = "dual") -> dict:
+    """
+    获取翻译结果文件的base64编码内容
+    
+    Args:
+        task_id: 翻译任务ID
+        file_type: 文件类型 (dual/mono)
+    
+    Returns:
+        dict: 包含base64编码内容的文件信息
+    """
+    if task_id not in translation_tasks:
+        return {
+            "error": "任务不存在",
+            "message": f"找不到任务ID: {task_id}",
+            "status": "not_found"
+        }
+    
+    task = translation_tasks[task_id]
+    if task.status != "completed":
+        return {
+            "error": "翻译尚未完成",
+            "message": f"当前任务状态: {task.status}，请等待翻译完成",
+            "current_status": task.status,
+            "progress": task.progress
+        }
+    
+    if task_id not in task_files or file_type not in task_files[task_id]:
+        available_types = list(task_files.get(task_id, {}).keys())
+        return {
+            "error": f"文件类型 '{file_type}' 不存在",
+            "message": f"可用的文件类型: {available_types}",
+            "available_types": available_types
+        }
+    
+    file_path = task_files[task_id][file_type]
+    if not file_path.exists():
+        return {
+            "error": "文件不存在",
+            "message": f"翻译结果文件已被删除或移动: {file_path}",
+            "status": "file_missing"
+        }
+    
+    try:
+        # 读取文件并转换为base64
+        with open(file_path, 'rb') as f:
+            file_data = f.read()
+        
+        base64_content = base64.b64encode(file_data).decode('utf-8')
+        
+        return {
+            "success": True,
+            "file_name": file_path.name,
+            "file_size": len(file_data),
+            "file_size_mb": round(len(file_data) / 1024 / 1024, 2),
+            "file_type": file_type,
+            "base64_content": base64_content,
+            "data_url": f"data:application/pdf;base64,{base64_content}",
+            "message": f"成功获取{file_type}类型的翻译结果文件base64编码"
+        }
+        
+    except Exception as e:
+        logger.error(f"读取文件时出错: {e}")
+        return {
+            "error": f"读取文件失败: {str(e)}",
+            "message": "无法读取翻译结果文件",
+            "status": "read_error"
+        }
+
+@mcp.tool()
+def get_translation_result_cos_url(task_id: str, file_type: str = "dual") -> dict:
+    """
+    获取翻译结果文件的COS URL
+    
+    Args:
+        task_id: 翻译任务ID
+        file_type: 文件类型 (dual/mono)
+    
+    Returns:
+        dict: 包含COS URL的文件信息
+    """
+    if task_id not in translation_tasks:
+        return {
+            "error": "任务不存在",
+            "message": f"找不到任务ID: {task_id}",
+            "status": "not_found"
+        }
+    
+    task = translation_tasks[task_id]
+    if task.status != "completed":
+        return {
+            "error": "翻译尚未完成",
+            "message": f"当前任务状态: {task.status}，请等待翻译完成",
+            "current_status": task.status,
+            "progress": task.progress
+        }
+    
+    if not hasattr(task, 'cos_urls') or not task.cos_urls:
+        return {
+            "error": "文件未上传到云存储",
+            "message": "翻译完成但文件未成功上传到COS，请使用其他方式获取文件",
+            "status": "no_cos_upload"
+        }
+    
+    if file_type not in task.cos_urls:
+        available_types = list(task.cos_urls.keys())
+        return {
+            "error": f"文件类型 '{file_type}' 的COS URL不存在",
+            "message": f"可用的文件类型: {available_types}",
+            "available_types": available_types
+        }
+    
+    return {
+        "success": True,
+        "file_type": file_type,
+        "cos_url": task.cos_urls[file_type],
+        "message": f"成功获取{file_type}类型的翻译结果文件COS URL",
+        "download_url": task.cos_urls[file_type]
+    }
+
+@mcp.tool()
+def download_translation_result(task_id: str, file_type: str = "dual") -> dict:
+    """
+    获取翻译结果文件信息
+    
+    Args:
+        task_id: 翻译任务ID
+        file_type: 文件类型 (dual/mono)
+    
+    Returns:
+        dict: 文件信息
+    """
+    if task_id not in translation_tasks:
+        return {
+            "error": "任务不存在",
+            "message": f"找不到任务ID: {task_id}",
+            "status": "not_found"
+        }
+    
+    task = translation_tasks[task_id]
+    if task.status != "completed":
+        return {
+            "error": "翻译尚未完成",
+            "message": f"当前任务状态: {task.status}，请等待翻译完成",
+            "current_status": task.status,
+            "progress": task.progress
+        }
+    
+    if task_id not in task_files or file_type not in task_files[task_id]:
+        available_types = list(task_files.get(task_id, {}).keys())
+        return {
+            "error": f"文件类型 '{file_type}' 不存在",
+            "message": f"可用的文件类型: {available_types}",
+            "available_types": available_types
+        }
+    
+    file_path = task_files[task_id][file_type]
+    if not file_path.exists():
+        return {
+            "error": "文件不存在",
+            "message": f"翻译结果文件已被删除或移动: {file_path}",
+            "status": "file_missing"
+        }
+    
+    return {
+        "success": True,
+        "file_path": str(file_path),
+        "file_name": file_path.name,
+        "file_size": file_path.stat().st_size,
+        "file_type": file_type,
+        "message": f"找到{file_type}类型的翻译结果文件"
+    }
+
+@mcp.tool()
+def check_system_status() -> dict:
+    """
+    检查系统状态和依赖
+    
+    Returns:
+        dict: 系统状态信息
+    """
+    cos_config = CONFIG["cos"]
+    cos_configured = all([cos_config.get("region"), cos_config.get("secret_id"), 
+                         cos_config.get("secret_key"), cos_config.get("bucket")])
+    
+    status = {
+        "service_name": "PDFTranslate MCP Server",
+        "version": "1.0.0",
+        "babeldoc_available": BABELDOC_AVAILABLE,
+        "cos_available": COS_AVAILABLE,
+        "api_key_configured": bool(CONFIG["openai"]["api_key"]),
+        "cos_configured": cos_configured,
+        "dependencies": {
+            "babeldoc": "✅ 已安装" if BABELDOC_AVAILABLE else "❌ 未安装",
+            "openai_api": "✅ 已配置" if CONFIG["openai"]["api_key"] else "❌ 未配置",
+            "cos_sdk": "✅ 已安装" if COS_AVAILABLE else "❌ 未安装",
+            "cos_config": "✅ 已配置" if cos_configured else "❌ 未配置"
+        },
+        "configuration": {
+            "model": CONFIG["openai"]["model"],
+            "base_url": CONFIG["openai"]["base_url"],
+            "default_languages": f"{CONFIG['translation']['default_lang_in']} -> {CONFIG['translation']['default_lang_out']}",
+            "default_qps": CONFIG["translation"]["qps"],
+            "cos_region": cos_config.get("region", "未配置"),
+            "cos_bucket": cos_config.get("bucket", "未配置")
+        },
+        "active_tasks": len(translation_tasks),
+        "ready": BABELDOC_AVAILABLE and bool(CONFIG["openai"]["api_key"]),
+        "cos_upload_ready": COS_AVAILABLE and cos_configured
+    }
+    
+    if not BABELDOC_AVAILABLE:
+        status["install_instructions"] = {
+            "message": "请安装BabelDOC库以启用PDF翻译功能",
+            "commands": [
+                "pip install babeldoc",
+                "uv pip install babeldoc"
+            ]
+        }
+    
+    if not COS_AVAILABLE:
+        status["cos_install_instructions"] = {
+            "message": "请安装腾讯云COS SDK以启用文件上传功能",
+            "commands": [
+                "pip install cos-python-sdk-v5",
+                "uv pip install cos-python-sdk-v5"
+            ]
+        }
+    
+    if not CONFIG["openai"]["api_key"]:
+        status["api_key_instructions"] = {
+            "message": "请配置OpenAI API密钥",
+            "steps": [
+                "1. 复制 .env.example 为 .env",
+                "2. 在 .env 文件中设置 OPENAI_API_KEY=your_api_key",
+                "3. 重启MCP服务器"
+            ]
+        }
+    
+    if not cos_configured:
+        status["cos_config_instructions"] = {
+            "message": "请配置腾讯云COS参数以启用文件上传功能",
+            "config_methods": [
+                {
+                    "method": "环境变量配置",
+                    "steps": [
+                        "设置 COS_REGION=your_region",
+                        "设置 COS_SECRET_ID=your_secret_id", 
+                        "设置 COS_SECRET_KEY=your_secret_key",
+                        "设置 COS_BUCKET=your_bucket"
+                    ]
+                },
+                {
+                    "method": "config.ini配置",
+                    "steps": [
+                        "在config.ini的[common]部分添加:",
+                        "cos_region = your_region",
+                        "cos_secret_id = your_secret_id",
+                        "cos_secret_key = your_secret_key", 
+                        "cos_bucket = your_bucket"
+                    ]
+                }
+            ],
+            "note": "环境变量优先级高于config.ini配置"
+        }
+    
+    return status
+
+@mcp.tool()
+def list_all_tasks() -> dict:
+    """
+    列出所有翻译任务
+    
+    Returns:
+        dict: 所有任务状态
+    """
+    return {
+        "total_tasks": len(translation_tasks),
+        "tasks": [task.to_dict() for task in translation_tasks.values()]
+    }
+
+@mcp.tool()
+def update_cos_config(
+    cos_region: str = None,
+    cos_secret_id: str = None, 
+    cos_secret_key: str = None,
+    cos_bucket: str = None
+) -> dict:
+    """
+    动态更新COS配置参数
+    
+    Args:
+        cos_region: COS地域
+        cos_secret_id: COS密钥ID
+        cos_secret_key: COS密钥Key
+        cos_bucket: COS存储桶名称
+    
+    Returns:
+        dict: 更新结果
+    """
+    try:
+        updated_fields = []
+        
+        if cos_region:
+            CONFIG["cos"]["region"] = cos_region
+            updated_fields.append("region")
+        
+        if cos_secret_id:
+            CONFIG["cos"]["secret_id"] = cos_secret_id
+            updated_fields.append("secret_id")
+            
+        if cos_secret_key:
+            CONFIG["cos"]["secret_key"] = cos_secret_key
+            updated_fields.append("secret_key")
+            
+        if cos_bucket:
+            CONFIG["cos"]["bucket"] = cos_bucket
+            updated_fields.append("bucket")
+        
+        if not updated_fields:
+            return {
+                "success": False,
+                "message": "没有提供任何配置参数",
+                "current_config": {
+                    "region": CONFIG["cos"].get("region", "未配置"),
+                    "secret_id": "已配置" if CONFIG["cos"].get("secret_id") else "未配置",
+                    "secret_key": "已配置" if CONFIG["cos"].get("secret_key") else "未配置", 
+                    "bucket": CONFIG["cos"].get("bucket", "未配置")
+                }
+            }
+        
+        # 检查配置完整性
+        cos_config = CONFIG["cos"]
+        is_complete = all([cos_config.get("region"), cos_config.get("secret_id"), 
+                          cos_config.get("secret_key"), cos_config.get("bucket")])
+        
+        return {
+            "success": True,
+            "message": f"COS配置已更新: {', '.join(updated_fields)}",
+            "updated_fields": updated_fields,
+            "config_complete": is_complete,
+            "cos_upload_ready": COS_AVAILABLE and is_complete,
+            "current_config": {
+                "region": CONFIG["cos"].get("region", "未配置"),
+                "secret_id": "已配置" if CONFIG["cos"].get("secret_id") else "未配置",
+                "secret_key": "已配置" if CONFIG["cos"].get("secret_key") else "未配置",
+                "bucket": CONFIG["cos"].get("bucket", "未配置")
+            }
+        }
+        
+    except Exception as e:
+        logger.error(f"更新COS配置时出错: {e}")
+        return {
+            "success": False,
+            "error": f"更新配置失败: {str(e)}",
+            "message": "请检查提供的配置参数"
+        }
+
+@mcp.tool()
+def get_supported_languages() -> dict:
+    """
+    获取支持的语言列表
+    
+    Returns:
+        dict: 支持的语言代码
+    """
+    return {
+        "languages": {
+            "zh": "中文",
+            "en": "English",
+            "ja": "日本語",
+            "ko": "한국어",
+            "fr": "Français",
+            "de": "Deutsch",
+            "es": "Español",
+            "ru": "Русский",
+            "it": "Italiano",
+            "pt": "Português",
+            "ar": "العربية",
+            "hi": "हिन्दी"
+        },
+        "default_lang_in": CONFIG["translation"]["default_lang_in"],
+        "default_lang_out": CONFIG["translation"]["default_lang_out"]
+    }
+
+@mcp.resource("config://")
+def get_config() -> str:
+    """返回当前配置信息"""
+    config_info = {
+        "service_name": "PDFTranslate MCP Server",
+        "version": "1.0.0",
+        "babeldoc_available": BABELDOC_AVAILABLE,
+        "openai_model": CONFIG["openai"]["model"],
+        "openai_base_url": CONFIG["openai"]["base_url"],
+        "default_languages": {
+            "input": CONFIG["translation"]["default_lang_in"],
+            "output": CONFIG["translation"]["default_lang_out"]
+        },
+        "default_qps": CONFIG["translation"]["qps"],
+        "watermark_mode": CONFIG["translation"]["watermark_output_mode"]
+    }
+    return json.dumps(config_info, indent=2, ensure_ascii=False)
+
+@mcp.resource("tasks://")
+def get_all_tasks() -> str:
+    """返回所有翻译任务状态"""
+    tasks_info = {
+        "total_tasks": len(translation_tasks),
+        "tasks_by_status": {},
+        "recent_tasks": []
+    }
+    
+    # 按状态分组
+    status_counts = {}
+    for task in translation_tasks.values():
+        status = task.status
+        if status not in status_counts:
+            status_counts[status] = 0
+        status_counts[status] += 1
+    
+    tasks_info["tasks_by_status"] = status_counts
+    
+    # 最近的任务
+    recent_tasks = sorted(
+        translation_tasks.values(),
+        key=lambda x: x.updated_at,
+        reverse=True
+    )[:10]
+    
+    tasks_info["recent_tasks"] = [task.to_dict() for task in recent_tasks]
+    
+    return json.dumps(tasks_info, indent=2, ensure_ascii=False)
+
+if __name__ == "__main__":
+    # 初始化BabelDOC（如果可用）
+    if BABELDOC_AVAILABLE:
+        try:
+            babeldoc.format.pdf.high_level.init()
+            logger.info("BabelDOC initialized successfully")
+        except Exception as e:
+            logger.error(f"Failed to initialize BabelDOC: {e}")
+    
+    # 配置MCP服务器
+    mcp.settings.host = CONFIG["server"]["host"]
+    mcp.settings.port = CONFIG["server"]["port"]
+    
+    # 配置信息日志
+    logger.info(f"Starting PDFTranslate MCP Server in SSE mode")
+    logger.info(f"Server URL: http://{CONFIG['server']['host']}:{CONFIG['server']['port']}/sse")
+    logger.info(f"OpenAI Model: {CONFIG['openai']['model']}")
+    logger.info(f"Default Translation: {CONFIG['translation']['default_lang_in']} -> {CONFIG['translation']['default_lang_out']}")
+    logger.info(f"BabelDOC Available: {BABELDOC_AVAILABLE}")
+    
+    # 启动MCP服务器 (SSE模式)
+    mcp.run(transport="sse")

pdftranslate_web/pdftranslate-mcp-server/pyproject.toml

@@ -0,0 +1,141 @@
+[project]
+name = "pdftranslate-mcp-server"
+version = "1.0.0"
+description = "PDF翻译MCP服务器 - 基于BabelDOC的PDF文档翻译模型上下文协议服务器"
+readme = "README.md"
+requires-python = ">=3.11"
+authors = [
+    {name = "wwwzhouhui", email = "75271002@qq.com"}
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Text Processing :: Linguistic",
+]
+keywords = ["mcp", "pdf", "translation", "ai", "babel", "document"]
+
+dependencies = [
+    "mcp[cli]>=1.9.3",
+    "fastapi>=0.104.0",
+    "uvicorn>=0.24.0",
+    "python-dotenv>=1.0.0",
+    "pydantic>=2.5.0",
+    "python-multipart>=0.0.6",
+    "aiofiles>=23.2.0",
+    "aiohttp>=3.9.0",
+    # BabelDOC相关依赖 - 注释掉以避免安装问题，用户需要手动安装
+    "babeldoc>=0.4.16",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.4.0",
+    "pytest-asyncio>=0.21.0",
+    "black>=23.0.0",
+    "isort>=5.12.0",
+    "flake8>=6.0.0",
+    "mypy>=1.7.0",
+]
+
+full = [
+    "babeldoc>=0.4.16",
+]
+
+[project.urls]
+Homepage = "https://github.com/wwwzhouhui/pdftranslate_web"
+Repository = "https://github.com/wwwzhouhui/pdftranslate_web"
+
+[project.scripts]
+pdftranslate-mcp = "main:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["."]
+
+[tool.black]
+line-length = 100
+target-version = ['py312']
+include = '\.pyi?$'
+extend-exclude = '''
+/(
+  # directories
+  \.eggs
+  | \.git
+  | \.hg
+  | \.mypy_cache
+  | \.tox
+  | \.venv
+  | build
+  | dist
+)/
+'''
+
+[tool.isort]
+profile = "black"
+line_length = 100
+multi_line_output = 3
+include_trailing_comma = true
+force_grid_wrap = 0
+use_parentheses = true
+ensure_newline_before_comments = true
+
+[tool.mypy]
+python_version = "3.12"
+warn_return_any = true
+warn_unused_configs = true
+disallow_untyped_defs = true
+disallow_incomplete_defs = true
+check_untyped_defs = true
+disallow_untyped_decorators = true
+no_implicit_optional = true
+warn_redundant_casts = true
+warn_unused_ignores = true
+warn_no_return = true
+warn_unreachable = true
+strict_equality = true
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py", "*_test.py"]
+python_classes = ["Test*"]
+python_functions = ["test_*"]
+addopts = [
+    "-v",
+    "--tb=short",
+    "--strict-config",
+    "--strict-markers",
+]
+asyncio_mode = "auto"
+
+[tool.coverage.run]
+source = ["."]
+omit = [
+    "tests/*",
+    "*/tests/*",
+    "*/test_*",
+    "*/__pycache__/*",
+]
+
+[tool.coverage.report]
+exclude_lines = [
+    "pragma: no cover",
+    "def __repr__",
+    "if self.debug:",
+    "if settings.DEBUG",
+    "raise AssertionError",
+    "raise NotImplementedError",
+    "if 0:",
+    "if __name__ == .__main__.:",
+    "class .*\\bProtocol\\):",
+    "@(abc\\.)?abstractmethod",
+]

pdftranslate_web/pdftranslate-mcp-server/pyproject_scnet.toml

@@ -0,0 +1,141 @@
+[project]
+name = "pdftranslate-mcp-server"
+version = "1.0.0"
+description = "PDF翻译MCP服务器 - 基于BabelDOC的PDF文档翻译模型上下文协议服务器"
+readme = "README.md"
+requires-python = ">=3.11"
+authors = [
+    {name = "wwwzhouhui", email = "75271002@qq.com"}
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Text Processing :: Linguistic",
+]
+keywords = ["mcp", "pdf", "translation", "ai", "babel", "document"]
+
+dependencies = [
+    "mcp[cli]>=1.9.3",
+    "fastapi>=0.104.0",
+    "uvicorn>=0.24.0",
+    "python-dotenv>=1.0.0",
+    "pydantic>=2.5.0",
+    "python-multipart>=0.0.6",
+    "aiofiles>=23.2.0",
+    "aiohttp>=3.9.0",
+    # BabelDOC相关依赖 - 注释掉以避免安装问题，用户需要手动安装
+    "babeldoc>=0.4.16",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.4.0",
+    "pytest-asyncio>=0.21.0",
+    "black>=23.0.0",
+    "isort>=5.12.0",
+    "flake8>=6.0.0",
+    "mypy>=1.7.0",
+]
+
+full = [
+    "babeldoc>=0.4.16",
+]
+
+[project.urls]
+Homepage = "https://github.com/wwwzhouhui/pdftranslate_web"
+Repository = "https://github.com/wwwzhouhui/pdftranslate_web"
+
+[project.scripts]
+pdftranslate-mcp = "main:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["."]
+
+[tool.black]
+line-length = 100
+target-version = ['py312']
+include = '\.pyi?$'
+extend-exclude = '''
+/(
+  # directories
+  \.eggs
+  | \.git
+  | \.hg
+  | \.mypy_cache
+  | \.tox
+  | \.venv
+  | build
+  | dist
+)/
+'''
+
+[tool.isort]
+profile = "black"
+line_length = 100
+multi_line_output = 3
+include_trailing_comma = true
+force_grid_wrap = 0
+use_parentheses = true
+ensure_newline_before_comments = true
+
+[tool.mypy]
+python_version = "3.12"
+warn_return_any = true
+warn_unused_configs = true
+disallow_untyped_defs = true
+disallow_incomplete_defs = true
+check_untyped_defs = true
+disallow_untyped_decorators = true
+no_implicit_optional = true
+warn_redundant_casts = true
+warn_unused_ignores = true
+warn_no_return = true
+warn_unreachable = true
+strict_equality = true
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py", "*_test.py"]
+python_classes = ["Test*"]
+python_functions = ["test_*"]
+addopts = [
+    "-v",
+    "--tb=short",
+    "--strict-config",
+    "--strict-markers",
+]
+asyncio_mode = "auto"
+
+[tool.coverage.run]
+source = ["."]
+omit = [
+    "tests/*",
+    "*/tests/*",
+    "*/test_*",
+    "*/__pycache__/*",
+]
+
+[tool.coverage.report]
+exclude_lines = [
+    "pragma: no cover",
+    "def __repr__",
+    "if self.debug:",
+    "if settings.DEBUG",
+    "raise AssertionError",
+    "raise NotImplementedError",
+    "if 0:",
+    "if __name__ == .__main__.:",
+    "class .*\\bProtocol\\):",
+    "@(abc\\.)?abstractmethod",
+]

pdftranslate_web/pyproject.toml

@@ -0,0 +1,174 @@
+[project]
+name = "pdftranslate_web"
+version = "0.0.1"
+description = "用户上传PDF，系统会把它翻译成其他国家语言，保持文档结构不变"
+license = "AGPL-3.0"
+readme = "README.md"
+requires-python = ">=3.10,<3.14"
+authors = [
+    { name = "wwwzhouhui", email = "75271002@qq.com" }
+]
+maintainers = [
+    { name = "wwwzhouhui", email = "75271002@qq.com" }
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+keywords = ["PDF"]
+dependencies = [
+    # Core BabelDOC translation engine
+    "babeldoc @ git+https://github.com/funstory-ai/BabelDOC.git",
+    
+    # Additional dependencies for web interface
+    "httpx[socks]>=0.27.0",        # HTTP client for API calls
+    "fastapi>=0.116.1",            # Web framework
+    "uvicorn[standard]>=0.35.0",   # ASGI server
+    "python-multipart>=0.0.20",    # File upload support
+    "gradio>=5.34.1",               # Web interface
+    "requests>=2.32.4",            # HTTP client for gradio
+    "Pillow>=11.3.0",               # Image processing for previews
+]
+
+[project.optional-dependencies]
+directml = ["onnxruntime-directml>=1.16.1"]
+cuda = ["onnxruntime-gpu>=1.16.1"]
+memray = ["memray>=1.17.1"]
+
+[project.urls]
+Homepage = "https://github.com/wwwzhouhui/pdftranslate_web"
+Issues = "https://github.com/wwwzhouhui/pdftranslate_web/issues"
+
+[project.scripts]
+pdftranslate = "pdftranslate_web.api_server:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.metadata]
+allow-direct-references = true
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/pdftranslate_web"]
+
+[tool.flake8]
+ignore = ["E203", "E261", "E501", "W503", "E741", "E501"]
+max-line-length = 88
+
+[tool.ruff]
+src = ["babeldoc"]
+target-version = "py310"
+show-fixes = true
+
+[tool.ruff.format]
+# Enable reformatting of code snippets in docstrings.
+docstring-code-format = true
+
+[tool.ruff.lint]
+ignore = [
+    "E203",   # 冒号前的空格
+    "E261",   # 注释前至少两个空格
+    "E501",   # 行太长
+    "E741",   # 变量名歧义
+    "F841",   # 未使用的变量
+    "C901",   # 太复杂的函数
+    "S101",   # use assert
+    "SIM",    # flake8-simplify
+    "ARG002", # unused argument
+    "S110",   # `try`-`except`-`pass` detected, consider logging the exception
+    "B024",   # abstract class without abstract methods
+    "S112",   # `try`-`except`-`continue` detected, consider logging the exception
+    "COM812", # missing-trailing-comma
+
+]
+select = [
+    "E",   # pycodestyle 错误
+    "F",   # Pyflakes
+    "N",   # PEP8 命名
+    "B",   # flake8-bugbear
+    "I",   # isort
+    "C",   # mccabe
+    "UP",  # pyupgrade
+    "S",   # flake8-bandit
+    "A",   # flake8-builtins
+    "COM", # flake8-commas
+    "ARG", # flake8-unused-arguments
+    "PTH", # 使用 pathlib
+]
+
+[tool.ruff.lint.flake8-quotes]
+docstring-quotes = "double"
+
+[tool.ruff.lint.flake8-annotations]
+suppress-none-returning = true
+
+[tool.ruff.lint.isort]
+force-single-line = true
+
+[tool.ruff.lint.pydocstyle]
+convention = "google"
+
+# 设置一些规则的特定配置
+[tool.ruff.lint.mccabe]
+max-complexity = 10 # 函数圈复杂度阈值
+
+[tool.ruff.lint.per-file-ignores]
+"babeldoc/babeldoc_exception/BabelDOCException.py" = ["N999"]
+"babeldoc/format/pdf/pdfinterp.py" = ["N"] # 忽略命名规范
+"tests/*" = ["S101"]            # 在测试文件中允许 assert
+"**/__init__.py" = ["F401"]     # 允许未使用的导入
+# 忽略 S311 警告，因为这是有意的
+"babeldoc/format/pdf/document_il/midend/paragraph_finder.py" = ["S311"]
+"docs/*" = ["A001"]
+"babeldoc/pdfminer/*" =["A","F", "I", "N", "S", "B", "C", "COM", "ARG", "PTH", "UP"]
+[dependency-groups]
+dev = [
+    "bumpver>=2024.1130",
+    "markdown-callouts>=0.4.0",
+    "markdown-include>=0.8.1",
+    "mkdocs-git-authors-plugin>=0.9.2",
+    "mkdocs-git-committers-plugin-2>=2.5.0",
+    "mkdocs-git-revision-date-localized-plugin>=1.3.0",
+    "mkdocs-material[recommended]>=9.6.4",
+    "pre-commit>=4.1.0",
+    "pygments>=2.19.1",
+    "ruff>=0.9.2",
+    "pytest>=8.3.4",
+    "pylance>=0.29.0",
+    "py-spy>=0.4.0",
+]
+
+[tool.pytest.ini_options]
+pythonpath = [".", "src"]
+testpaths = ["tests"]
+
+[bumpver]
+current_version = "0.0.1"
+version_pattern = "MAJOR.MINOR.PATCH[.PYTAGNUM]"
+
+[bumpver.file_patterns]
+"pyproject.toml" = [
+    'current_version = "{version}"',
+    'version = "{version}"'
+]
+"babeldoc/__init__.py" = [
+    '__version__ = "{version}"'
+]
+"babeldoc/main.py" = [
+    '__version__ = "{version}"'
+]
+"babeldoc/const.py" = [
+    '__version__ = "{version}"'
+]
+
+[tool.uv.sources]
+yadt = { path = ".", editable = true }
+
+[tool.pyright]
+pythonVersion = "3.10"
+# typeCheckingMode = "off"
+reportGeneralTypeIssues = false
+reportUnknownVariableType = false
+reportMissingParameterType = false
+reportUnknownParameterType = false

pdftranslate_web/pyproject_scnet.toml

@@ -0,0 +1,176 @@
+[project]
+name = "pdftranslate_web"
+version = "0.0.1"
+description = "用户上传PDF，系统会把它翻译成其他国家语言，保持文档结构不变"
+license = "AGPL-3.0"
+readme = "README.md"
+requires-python = ">=3.10,<3.14"
+authors = [
+    { name = "wwwzhouhui", email = "75271002@qq.com" }
+]
+maintainers = [
+    { name = "wwwzhouhui", email = "75271002@qq.com" }
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+keywords = ["PDF"]
+dependencies = [
+    # Core BabelDOC translation engine
+    "babeldoc @ git+https://ghfast.top//https://github.com/funstory-ai/BabelDOC.git",
+    
+    "onnxruntime<1.17.0",
+    # Additional dependencies for web interface
+    "httpx[socks]>=0.27.0",        # HTTP client for API calls
+    "fastapi>=0.116.1",            # Web framework
+    "uvicorn[standard]>=0.35.0",   # ASGI server
+    "python-multipart>=0.0.20",    # File upload support
+    "gradio>=5.34.1",               # Web interface
+    "requests>=2.32.4",            # HTTP client for gradio
+    "Pillow>=11.3.0",               # Image processing for previews
+]
+
+[project.optional-dependencies]
+directml = ["onnxruntime-directml==1.15.1"]
+cuda = ["onnxruntime-gpu==1.15.1"]
+memray = ["memray>=1.17.1"]
+
+[project.urls]
+Homepage = "https://github.com/wwwzhouhui/pdftranslate_web"
+Issues = "https://github.com/wwwzhouhui/pdftranslate_web/issues"
+
+[project.scripts]
+pdftranslate = "pdftranslate_web.api_server:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.metadata]
+allow-direct-references = true
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/pdftranslate_web"]
+
+[tool.flake8]
+ignore = ["E203", "E261", "E501", "W503", "E741", "E501"]
+max-line-length = 88
+
+[tool.ruff]
+src = ["babeldoc"]
+target-version = "py310"
+show-fixes = true
+
+[tool.ruff.format]
+# Enable reformatting of code snippets in docstrings.
+docstring-code-format = true
+
+[tool.ruff.lint]
+ignore = [
+    "E203",   # 冒号前的空格
+    "E261",   # 注释前至少两个空格
+    "E501",   # 行太长
+    "E741",   # 变量名歧义
+    "F841",   # 未使用的变量
+    "C901",   # 太复杂的函数
+    "S101",   # use assert
+    "SIM",    # flake8-simplify
+    "ARG002", # unused argument
+    "S110",   # `try`-`except`-`pass` detected, consider logging the exception
+    "B024",   # abstract class without abstract methods
+    "S112",   # `try`-`except`-`continue` detected, consider logging the exception
+    "COM812", # missing-trailing-comma
+
+]
+select = [
+    "E",   # pycodestyle 错误
+    "F",   # Pyflakes
+    "N",   # PEP8 命名
+    "B",   # flake8-bugbear
+    "I",   # isort
+    "C",   # mccabe
+    "UP",  # pyupgrade
+    "S",   # flake8-bandit
+    "A",   # flake8-builtins
+    "COM", # flake8-commas
+    "ARG", # flake8-unused-arguments
+    "PTH", # 使用 pathlib
+]
+
+[tool.ruff.lint.flake8-quotes]
+docstring-quotes = "double"
+
+[tool.ruff.lint.flake8-annotations]
+suppress-none-returning = true
+
+[tool.ruff.lint.isort]
+force-single-line = true
+
+[tool.ruff.lint.pydocstyle]
+convention = "google"
+
+# 设置一些规则的特定配置
+[tool.ruff.lint.mccabe]
+max-complexity = 10 # 函数圈复杂度阈值
+
+[tool.ruff.lint.per-file-ignores]
+"babeldoc/babeldoc_exception/BabelDOCException.py" = ["N999"]
+"babeldoc/format/pdf/pdfinterp.py" = ["N"] # 忽略命名规范
+"tests/*" = ["S101"]            # 在测试文件中允许 assert
+"**/__init__.py" = ["F401"]     # 允许未使用的导入
+# 忽略 S311 警告，因为这是有意的
+"babeldoc/format/pdf/document_il/midend/paragraph_finder.py" = ["S311"]
+"docs/*" = ["A001"]
+"babeldoc/pdfminer/*" =["A","F", "I", "N", "S", "B", "C", "COM", "ARG", "PTH", "UP"]
+[dependency-groups]
+dev = [
+    "bumpver>=2024.1130",
+    "markdown-callouts>=0.4.0",
+    "markdown-include>=0.8.1",
+    "mkdocs-git-authors-plugin>=0.9.2",
+    "mkdocs-git-committers-plugin-2>=2.5.0",
+    "mkdocs-git-revision-date-localized-plugin>=1.3.0",
+    "mkdocs-material[recommended]>=9.6.4",
+    "pre-commit>=4.1.0",
+    "pygments>=2.19.1",
+    "ruff>=0.9.2",
+    "pytest>=8.3.4",
+    "pylance>=0.29.0",
+    "py-spy>=0.4.0",
+]
+
+[tool.pytest.ini_options]
+pythonpath = [".", "src"]
+testpaths = ["tests"]
+
+[bumpver]
+current_version = "0.0.1"
+version_pattern = "MAJOR.MINOR.PATCH[.PYTAGNUM]"
+
+[bumpver.file_patterns]
+"pyproject.toml" = [
+    'current_version = "{version}"',
+    'version = "{version}"'
+]
+"babeldoc/__init__.py" = [
+    '__version__ = "{version}"'
+]
+"babeldoc/main.py" = [
+    '__version__ = "{version}"'
+]
+"babeldoc/const.py" = [
+    '__version__ = "{version}"'
+]
+
+[tool.uv.sources]
+yadt = { path = ".", editable = true }
+
+
+[tool.pyright]
+pythonVersion = "3.10"
+# typeCheckingMode = "off"
+reportGeneralTypeIssues = false
+reportUnknownVariableType = false
+reportMissingParameterType = false
+reportUnknownParameterType = false

pdftranslate_web/scripts/run_gradio.py

@@ -0,0 +1,17 @@
+#!/usr/bin/env python3
+"""
+BabelDOC Gradio Client Launcher
+
+启动BabelDOC Gradio客户端界面
+"""
+
+import sys
+from pathlib import Path
+
+# 添加src目录到Python路径
+sys.path.insert(0, str(Path(__file__).parent.parent / "src"))
+
+from pdftranslate_web.gradio_client import main
+
+if __name__ == "__main__":
+    main()

pdftranslate_web/scripts/run_server.py

@@ -0,0 +1,29 @@
+#!/usr/bin/env python3
+"""
+BabelDOC API Server Launcher
+
+启动BabelDOC翻译API服务器
+"""
+
+import sys
+from pathlib import Path
+
+# 添加src目录到Python路径
+sys.path.insert(0, str(Path(__file__).parent.parent / "src"))
+
+from pdftranslate_web.api_server import start_server
+
+if __name__ == "__main__":
+    import argparse
+    
+    parser = argparse.ArgumentParser(description="启动BabelDOC翻译API服务器")
+    parser.add_argument("--host", default="0.0.0.0", help="服务器主机地址 (默认: 0.0.0.0)")
+    parser.add_argument("--port", type=int, default=8000, help="服务器端口 (默认: 8000)")
+    
+    args = parser.parse_args()
+    
+    print(f"正在启动BabelDOC翻译API服务器...")
+    print(f"服务器地址: http://{args.host}:{args.port}")
+    print(f"API文档: http://{args.host}:{args.port}/docs")
+    
+    start_server(host=args.host, port=args.port)

pdftranslate_web/src/pdftranslate_web/__init__.py

@@ -0,0 +1,23 @@
+"""
+BabelDOC PDF Translation Package
+
+一个基于AI的PDF文档翻译工具包，支持：
+- FastAPI REST API服务
+- Gradio Web界面
+- Python客户端SDK
+"""
+
+__version__ = "0.0.1"
+__author__ = "wwwzhouhui"
+
+from .api_server import app, start_server
+from .api_client import BabelDOCClient
+from .gradio_client import create_gradio_interface, GradioClient
+
+__all__ = [
+    "app",
+    "start_server", 
+    "BabelDOCClient",
+    "create_gradio_interface",
+    "GradioClient"
+]

pdftranslate_web/src/pdftranslate_web/api_client.py

@@ -0,0 +1,273 @@
+import requests
+import time
+from pathlib import Path
+from typing import Optional, Dict, Any
+import json
+
+class BabelDOCClient:
+    def __init__(self, base_url: str = "http://localhost:8000"):
+        self.base_url = base_url.rstrip('/')
+        self.session = requests.Session()
+    
+    def translate_pdf(
+        self,
+        pdf_path: str,
+        lang_in: Optional[str] = None,
+        lang_out: Optional[str] = None,
+        qps: Optional[int] = None,
+        no_dual: Optional[bool] = None,
+        no_mono: Optional[bool] = None,
+        watermark_output_mode: Optional[str] = None
+    ) -> str:
+        """
+        提交PDF翻译任务
+        
+        Args:
+            pdf_path: PDF文件路径
+            lang_in: 源语言代码 (可选，使用服务器默认配置)
+            lang_out: 目标语言代码 (可选，使用服务器默认配置)
+            qps: 每秒请求数限制 (可选，使用服务器默认配置)
+            no_dual: 不生成双语PDF (可选，使用服务器默认配置)
+            no_mono: 不生成单语PDF (可选，使用服务器默认配置)
+            watermark_output_mode: 水印模式 (可选，使用服务器默认配置)
+        
+        Returns:
+            任务ID
+        """
+        if not Path(pdf_path).exists():
+            raise FileNotFoundError(f"PDF文件不存在: {pdf_path}")
+        
+        files = {
+            'file': ('document.pdf', open(pdf_path, 'rb'), 'application/pdf')
+        }
+        
+        data = {}
+        if lang_in is not None:
+            data['lang_in'] = lang_in
+        if lang_out is not None:
+            data['lang_out'] = lang_out
+        if qps is not None:
+            data['qps'] = qps
+        if no_dual is not None:
+            data['no_dual'] = no_dual
+        if no_mono is not None:
+            data['no_mono'] = no_mono
+        if watermark_output_mode is not None:
+            data['watermark_output_mode'] = watermark_output_mode
+        
+        try:
+            response = self.session.post(
+                f"{self.base_url}/translate",
+                files=files,
+                data=data
+            )
+            response.raise_for_status()
+            result = response.json()
+            return result['task_id']
+        finally:
+            files['file'][1].close()
+    
+    def get_status(self, task_id: str) -> Dict[str, Any]:
+        """
+        获取翻译任务状态
+        
+        Args:
+            task_id: 任务ID
+        
+        Returns:
+            任务状态信息
+        """
+        response = self.session.get(f"{self.base_url}/status/{task_id}")
+        response.raise_for_status()
+        return response.json()
+    
+    def wait_for_completion(self, task_id: str, check_interval: int = 5, timeout: int = 3600) -> Dict[str, Any]:
+        """
+        等待翻译任务完成
+        
+        Args:
+            task_id: 任务ID
+            check_interval: 检查间隔秒数 (默认: 5)
+            timeout: 超时时间秒数 (默认: 3600)
+        
+        Returns:
+            最终任务状态
+        """
+        start_time = time.time()
+        
+        while time.time() - start_time < timeout:
+            status = self.get_status(task_id)
+            
+            if status['status'] in ['completed', 'failed']:
+                return status
+            
+            print(f"任务状态: {status['status']} | 进度: {status['progress']:.1f}% | {status['message']}")
+            time.sleep(check_interval)
+        
+        raise TimeoutError(f"任务 {task_id} 在 {timeout} 秒内未完成")
+    
+    def download_result(self, task_id: str, file_type: str, output_path: str) -> bool:
+        """
+        下载翻译结果文件
+        
+        Args:
+            task_id: 任务ID
+            file_type: 文件类型 ("dual" 或 "mono")
+            output_path: 输出文件路径
+        
+        Returns:
+            下载是否成功
+        """
+        response = self.session.get(f"{self.base_url}/download/{task_id}/{file_type}")
+        
+        if response.status_code == 404:
+            return False
+        
+        response.raise_for_status()
+        
+        with open(output_path, 'wb') as f:
+            f.write(response.content)
+        
+        return True
+    
+    def translate_and_download(
+        self,
+        pdf_path: str,
+        output_dir: str,
+        lang_in: Optional[str] = None,
+        lang_out: Optional[str] = None,
+        qps: Optional[int] = None,
+        no_dual: Optional[bool] = None,
+        no_mono: Optional[bool] = None,
+        watermark_output_mode: Optional[str] = None,
+        check_interval: int = 5,
+        timeout: int = 3600
+    ) -> Dict[str, str]:
+        """
+        完整的翻译流程：提交任务 -> 等待完成 -> 下载结果
+        
+        Args:
+            pdf_path: PDF文件路径
+            output_dir: 输出目录
+            其他参数同 translate_pdf 方法
+        
+        Returns:
+            下载的文件路径字典 {"dual": "path", "mono": "path"}
+        """
+        print(f"正在提交翻译任务: {pdf_path}")
+        task_id = self.translate_pdf(
+            pdf_path=pdf_path,
+            lang_in=lang_in,
+            lang_out=lang_out,
+            qps=qps,
+            no_dual=no_dual,
+            no_mono=no_mono,
+            watermark_output_mode=watermark_output_mode
+        )
+        
+        print(f"任务已创建，ID: {task_id}")
+        
+        print("等待翻译完成...")
+        final_status = self.wait_for_completion(task_id, check_interval, timeout)
+        
+        if final_status['status'] != 'completed':
+            raise Exception(f"翻译失败: {final_status['message']}")
+        
+        print("翻译完成，正在下载结果...")
+        
+        output_path = Path(output_dir)
+        output_path.mkdir(parents=True, exist_ok=True)
+        
+        downloaded_files = {}
+        
+        for file_type in ['dual', 'mono']:
+            if file_type in final_status['result_files']:
+                filename = f"{Path(pdf_path).stem}.{file_type}.pdf"
+                output_file = output_path / filename
+                
+                if self.download_result(task_id, file_type, str(output_file)):
+                    downloaded_files[file_type] = str(output_file)
+                    print(f"已下载 {file_type} 文件: {output_file}")
+        
+        return downloaded_files
+    
+    def health_check(self) -> bool:
+        """
+        检查服务健康状态
+        
+        Returns:
+            服务是否健康
+        """
+        try:
+            response = self.session.get(f"{self.base_url}/health")
+            return response.status_code == 200
+        except requests.RequestException:
+            return False
+    
+    def get_server_config(self) -> Dict[str, Any]:
+        """
+        获取服务器配置信息
+        
+        Returns:
+            服务器配置信息
+        """
+        response = self.session.get(f"{self.base_url}/")
+        response.raise_for_status()
+        return response.json()
+
+def main():
+    """命令行客户端示例"""
+    import argparse
+    
+    parser = argparse.ArgumentParser(description="BabelDOC Translation Client")
+    parser.add_argument("pdf_path", help="PDF文件路径")
+    parser.add_argument("--output-dir", "-o", default="./output", help="输出目录")
+    parser.add_argument("--server-url", default="http://localhost:8000", help="服务器URL")
+    parser.add_argument("--lang-in", help="源语言 (可选，使用服务器默认)")
+    parser.add_argument("--lang-out", help="目标语言 (可选，使用服务器默认)")
+    parser.add_argument("--qps", type=int, help="每秒请求数 (可选，使用服务器默认)")
+    parser.add_argument("--no-dual", action="store_true", help="不生成双语PDF")
+    parser.add_argument("--no-mono", action="store_true", help="不生成单语PDF")
+    parser.add_argument("--watermark-mode", choices=["watermarked", "no_watermark", "both"], 
+                       help="水印模式 (可选，使用服务器默认)")
+    
+    args = parser.parse_args()
+    
+    client = BabelDOCClient(args.server_url)
+    
+    if not client.health_check():
+        print(f"错误: 无法连接到服务器 {args.server_url}")
+        return
+    
+    # 显示服务器配置
+    try:
+        server_config = client.get_server_config()
+        print("服务器配置:")
+        print(f"  模型: {server_config['config']['openai_model']}")
+        print(f"  默认语言: {server_config['config']['default_lang_in']} -> {server_config['config']['default_lang_out']}")
+        print(f"  QPS: {server_config['config']['qps']}")
+        print()
+    except Exception as e:
+        print(f"获取服务器配置失败: {e}")
+    
+    try:
+        downloaded_files = client.translate_and_download(
+            pdf_path=args.pdf_path,
+            output_dir=args.output_dir,
+            lang_in=args.lang_in,
+            lang_out=args.lang_out,
+            qps=args.qps,
+            no_dual=args.no_dual,
+            no_mono=args.no_mono,
+            watermark_output_mode=args.watermark_mode
+        )
+        
+        print(f"\n翻译完成! 下载的文件:")
+        for file_type, path in downloaded_files.items():
+            print(f"  {file_type}: {path}")
+            
+    except Exception as e:
+        print(f"错误: {e}")
+
+if __name__ == "__main__":
+    main()

pdftranslate_web/src/pdftranslate_web/api_server.py

@@ -0,0 +1,298 @@
+import asyncio
+import logging
+import uuid
+from pathlib import Path
+from typing import Dict, Any, Optional
+import tempfile
+import shutil
+from concurrent.futures import ThreadPoolExecutor
+import os
+
+from fastapi import FastAPI, File, UploadFile, HTTPException, BackgroundTasks, Form
+from fastapi.responses import FileResponse
+from pydantic import BaseModel
+import uvicorn
+from dotenv import load_dotenv
+
+import babeldoc.format.pdf.high_level
+from babeldoc.format.pdf.translation_config import TranslationConfig, WatermarkOutputMode
+from babeldoc.translator.translator import OpenAITranslator, set_translate_rate_limiter
+
+logger = logging.getLogger(__name__)
+load_dotenv()  # 自动加载同目录下的 .env 文件
+# 从环境变量加载配置
+def load_config():
+    """从环境变量加载配置"""
+    return {
+        "openai": {
+            "api_key": os.getenv("OPENAI_API_KEY", ""),
+            "model": os.getenv("OPENAI_MODEL", "deepseek-ai/DeepSeek-V3"),
+            "base_url": os.getenv("OPENAI_BASE_URL", "https://api.siliconflow.cn/v1")
+        },
+        "server": {
+            "host": os.getenv("SERVER_HOST", "0.0.0.0"),
+            "port": int(os.getenv("SERVER_PORT", "8000")),
+            "qps": int(os.getenv("QPS", "4"))
+        },
+        "translation": {
+            "default_lang_in": os.getenv("DEFAULT_LANG_IN", "en"),
+            "default_lang_out": os.getenv("DEFAULT_LANG_OUT", "zh"),
+            "watermark_output_mode": os.getenv("WATERMARK_OUTPUT_MODE", "no_watermark"),
+            "no_dual": os.getenv("NO_DUAL", "false").lower() == "true",
+            "no_mono": os.getenv("NO_MONO", "false").lower() == "true"
+        }
+    }
+
+config = load_config()
+
+# 验证OpenAI配置
+if not config["openai"]["api_key"]:
+    logger.error("未找到OpenAI API密钥！请通过环境变量OPENAI_API_KEY提供")
+    raise ValueError("Missing OpenAI API key")
+
+app = FastAPI(title="BabelDOC Translation API", version="0.4.16")
+
+class TranslationRequest(BaseModel):
+    lang_in: Optional[str] = None
+    lang_out: Optional[str] = None
+    qps: Optional[int] = None
+    no_dual: Optional[bool] = None
+    no_mono: Optional[bool] = None
+    watermark_output_mode: Optional[str] = None
+
+class TranslationStatus(BaseModel):
+    task_id: str
+    status: str  # pending, processing, completed, failed
+    progress: float = 0.0
+    message: str = ""
+    result_files: Dict[str, str] = {}
+
+translation_tasks: Dict[str, TranslationStatus] = {}
+task_files: Dict[str, Dict[str, Path]] = {}
+
+async def translate_document(
+    task_id: str,
+    pdf_file: Path,
+    request: TranslationRequest,
+    output_dir: Path
+):
+    try:
+        translation_tasks[task_id].status = "processing"
+        translation_tasks[task_id].message = "正在初始化翻译器..."
+        
+        # 使用配置文件中的OpenAI设置
+        translator = OpenAITranslator(
+            lang_in=request.lang_in or config["translation"]["default_lang_in"],
+            lang_out=request.lang_out or config["translation"]["default_lang_out"],
+            model=config["openai"]["model"],
+            base_url=config["openai"]["base_url"],
+            api_key=config["openai"]["api_key"],
+            ignore_cache=False,
+        )
+        
+        set_translate_rate_limiter(request.qps or config["server"]["qps"])
+        
+        from babeldoc.docvision.doclayout import DocLayoutModel
+        doc_layout_model = DocLayoutModel.load_onnx()
+        
+        watermark_output_mode = request.watermark_output_mode or config["translation"]["watermark_output_mode"]
+        watermark_mode = WatermarkOutputMode.Watermarked
+        if watermark_output_mode == "no_watermark":
+            watermark_mode = WatermarkOutputMode.NoWatermark
+        elif watermark_output_mode == "both":
+            watermark_mode = WatermarkOutputMode.Both
+        
+        config_obj = TranslationConfig(
+            input_file=str(pdf_file),
+            font=None,
+            pages=None,
+            output_dir=str(output_dir),
+            translator=translator,
+            debug=False,
+            lang_in=request.lang_in or config["translation"]["default_lang_in"],
+            lang_out=request.lang_out or config["translation"]["default_lang_out"],
+            no_dual=request.no_dual if request.no_dual is not None else config["translation"]["no_dual"],
+            no_mono=request.no_mono if request.no_mono is not None else config["translation"]["no_mono"],
+            qps=request.qps or config["server"]["qps"],
+            formular_font_pattern=None,
+            formular_char_pattern=None,
+            split_short_lines=False,
+            short_line_split_factor=0.8,
+            doc_layout_model=doc_layout_model,
+            skip_clean=False,
+            dual_translate_first=False,
+            disable_rich_text_translate=False,
+            enhance_compatibility=False,
+            use_alternating_pages_dual=False,
+            report_interval=0.1,
+            min_text_length=5,
+            watermark_output_mode=watermark_mode,
+            split_strategy=None,
+            table_model=None,
+            show_char_box=False,
+            skip_scanned_detection=False,
+            ocr_workaround=False,
+            custom_system_prompt=None,
+            working_dir=None,
+            add_formula_placehold_hint=False,
+            glossaries=[],
+            pool_max_workers=None,
+            auto_extract_glossary=True,
+            auto_enable_ocr_workaround=False,
+            primary_font_family=None,
+            only_include_translated_page=False,
+            save_auto_extracted_glossary=False,
+        )
+        
+        translation_tasks[task_id].message = "正在翻译文档..."
+        
+        async for event in babeldoc.format.pdf.high_level.async_translate(config_obj):
+            if event["type"] == "progress_update":
+                translation_tasks[task_id].progress = event.get("overall_progress", 0.0)
+                translation_tasks[task_id].message = f"{event.get('stage', '处理中')} ({event.get('stage_current', 0)}/{event.get('stage_total', 100)})"
+            elif event["type"] == "error":
+                translation_tasks[task_id].status = "failed"
+                translation_tasks[task_id].message = f"翻译失败: {event.get('error', '未知错误')}"
+                logger.error(f"Translation failed for task {task_id}: {event.get('error')}")
+                return
+            elif event["type"] == "finish":
+                result = event["translate_result"]
+                translation_tasks[task_id].status = "completed"
+                translation_tasks[task_id].progress = 100.0
+                translation_tasks[task_id].message = "翻译完成"
+                
+                result_files = {}
+                if result.dual_pdf_path and Path(result.dual_pdf_path).exists():
+                    result_files["dual"] = str(result.dual_pdf_path)
+                if result.mono_pdf_path and Path(result.mono_pdf_path).exists():
+                    result_files["mono"] = str(result.mono_pdf_path)
+                
+                translation_tasks[task_id].result_files = result_files
+                task_files[task_id] = {k: Path(v) for k, v in result_files.items()}
+                
+                logger.info(f"Translation completed for task {task_id}")
+                break
+                
+    except Exception as e:
+        translation_tasks[task_id].status = "failed"
+        translation_tasks[task_id].message = f"翻译过程出错: {str(e)}"
+        logger.error(f"Translation error for task {task_id}: {e}", exc_info=True)
+
+@app.post("/translate", response_model=dict)
+async def translate_pdf(
+    background_tasks: BackgroundTasks,
+    file: UploadFile = File(...),
+    lang_in: Optional[str] = Form(None),
+    lang_out: Optional[str] = Form(None),
+    qps: Optional[int] = Form(None),
+    no_dual: Optional[bool] = Form(None),
+    no_mono: Optional[bool] = Form(None),
+    watermark_output_mode: Optional[str] = Form(None)
+):
+    if not file.filename.lower().endswith('.pdf'):
+        raise HTTPException(status_code=400, detail="只支持PDF文件")
+    
+    task_id = str(uuid.uuid4())
+    
+    temp_dir = Path(tempfile.mkdtemp())
+    pdf_path = temp_dir / file.filename
+    output_dir = temp_dir / "output"
+    output_dir.mkdir(exist_ok=True)
+    
+    with open(pdf_path, "wb") as buffer:
+        shutil.copyfileobj(file.file, buffer)
+    
+    request = TranslationRequest(
+        lang_in=lang_in,
+        lang_out=lang_out,
+        qps=qps,
+        no_dual=no_dual,
+        no_mono=no_mono,
+        watermark_output_mode=watermark_output_mode
+    )
+    
+    translation_tasks[task_id] = TranslationStatus(
+        task_id=task_id,
+        status="pending",
+        message="任务已创建，等待处理..."
+    )
+    
+    background_tasks.add_task(
+        translate_document,
+        task_id,
+        pdf_path,
+        request,
+        output_dir
+    )
+    
+    return {"task_id": task_id, "message": "翻译任务已创建"}
+
+@app.get("/status/{task_id}", response_model=TranslationStatus)
+async def get_translation_status(task_id: str):
+    if task_id not in translation_tasks:
+        raise HTTPException(status_code=404, detail="任务不存在")
+    
+    return translation_tasks[task_id]
+
+@app.get("/download/{task_id}/{file_type}")
+async def download_result(task_id: str, file_type: str):
+    if task_id not in translation_tasks:
+        raise HTTPException(status_code=404, detail="任务不存在")
+    
+    if translation_tasks[task_id].status != "completed":
+        raise HTTPException(status_code=400, detail="翻译尚未完成")
+    
+    if task_id not in task_files or file_type not in task_files[task_id]:
+        raise HTTPException(status_code=404, detail="文件不存在")
+    
+    file_path = task_files[task_id][file_type]
+    
+    if not file_path.exists():
+        raise HTTPException(status_code=404, detail="文件不存在")
+    
+    return FileResponse(
+        path=file_path,
+        filename=file_path.name,
+        media_type='application/pdf'
+    )
+
+@app.get("/health")
+async def health_check():
+    return {"status": "healthy", "service": "BabelDOC Translation API"}
+
+@app.get("/")
+async def root():
+    return {
+        "message": "BabelDOC Translation API",
+        "version": "0.4.16",
+        "config": {
+            "openai_model": config["openai"]["model"],
+            "default_lang_in": config["translation"]["default_lang_in"],
+            "default_lang_out": config["translation"]["default_lang_out"],
+            "qps": config["server"]["qps"]
+        },
+        "endpoints": {
+            "translate": "POST /translate - 上传PDF文件进行翻译",
+            "status": "GET /status/{task_id} - 查询翻译状态",
+            "download": "GET /download/{task_id}/{file_type} - 下载翻译结果",
+            "health": "GET /health - 健康检查"
+        }
+    }
+
+def start_server(host: Optional[str] = None, port: Optional[int] = None):
+    babeldoc.format.pdf.high_level.init()
+    
+    logging.basicConfig(level=logging.INFO)
+    logging.getLogger("httpx").setLevel("WARNING")
+    logging.getLogger("openai").setLevel("WARNING")
+    
+    server_host = host or config["server"]["host"]
+    server_port = port or config["server"]["port"]
+    
+    logger.info(f"Using OpenAI model: {config['openai']['model']}")
+    logger.info(f"Default languages: {config['translation']['default_lang_in']} -> {config['translation']['default_lang_out']}")
+    
+    uvicorn.run(app, host=server_host, port=server_port)
+
+if __name__ == "__main__":
+    start_server()

pdftranslate_web/src/pdftranslate_web/gradio_client.py

@@ -0,0 +1,749 @@
+import gradio as gr
+import os
+import tempfile
+import time
+from pathlib import Path
+from typing import Optional, Tuple, Dict, Any
+import fitz  # PyMuPDF
+import base64
+from io import BytesIO
+from PIL import Image
+
+from pdftranslate_web.api_client import BabelDOCClient
+import json
+
+# 管理员密码配置
+ADMIN_PASSWORD = os.getenv("ADMIN_PASSWORD", "zhouqingYu666")
+
+class GradioClient:
+    def __init__(self, server_url: str = "http://localhost:8000"):
+        self.client = BabelDOCClient(server_url)
+        self.temp_dir = Path(tempfile.mkdtemp())
+        self.current_task_id = None
+        # 获取项目根目录路径
+        self.project_root = Path(__file__).parent.parent.parent
+        self.sample_file_path = self.project_root / "simaple" / "11.pdf"
+        # 配置缓存
+        self.config_cache = {
+            "openai_api_key": "",
+            "openai_model": "",
+            "openai_base_url": ""
+        }
+        
+    def update_config(self, api_key: str = None, model: str = None, base_url: str = None) -> str:
+        """更新配置缓存"""
+        if api_key is not None:
+            self.config_cache["openai_api_key"] = api_key
+        if model is not None:
+            self.config_cache["openai_model"] = model
+        if base_url is not None:
+            self.config_cache["openai_base_url"] = base_url
+        return "✅ 配置已更新（下次翻译时生效）"
+    
+    def get_masked_api_key(self, api_key: str) -> str:
+        """获取遮蔽的API密钥"""
+        if not api_key or len(api_key) < 8:
+            return api_key
+        return api_key[:4] + "*" * (len(api_key) - 8) + api_key[-4:]
+        
+    def check_server_status(self) -> Tuple[str, Dict]:
+        """检查服务器状态和配置"""
+        try:
+            if not self.client.health_check():
+                return "❌ 服务器离线", {}
+            
+            config = self.client.get_server_config()
+            
+            # 更新配置缓存为服务器当前值
+            if not self.config_cache["openai_api_key"]:
+                self.config_cache["openai_api_key"] = "sk-****"  # 默认占位符
+            if not self.config_cache["openai_model"]:
+                self.config_cache["openai_model"] = config['config']['openai_model']
+            if not self.config_cache["openai_base_url"]:
+                self.config_cache["openai_base_url"] = ""  # 服务器不返回base_url
+            
+            status_text = f"""✅ 服务器在线
+            
+**服务器配置:**
+- 模型: {config['config']['openai_model']}
+- 默认语言: {config['config']['default_lang_in']} → {config['config']['default_lang_out']}
+- QPS限制: {config['config']['qps']}
+"""
+            return status_text, config['config']
+        except Exception as e:
+            return f"❌ 连接失败: {str(e)}", {}
+    
+    def pdf_to_images(self, pdf_path: str, max_pages: int = 5) -> list:
+        """将PDF转换为图片预览"""
+        if not pdf_path or not os.path.exists(pdf_path):
+            return []
+        
+        try:
+            doc = fitz.open(pdf_path)
+            images = []
+            
+            for page_num in range(min(len(doc), max_pages)):
+                page = doc[page_num]
+                # 设置缩放比例以获得合适的预览大小
+                mat = fitz.Matrix(1.5, 1.5)
+                pix = page.get_pixmap(matrix=mat)
+                img_data = pix.tobytes("png")
+                
+                # 转换为PIL Image
+                img = Image.open(BytesIO(img_data))
+                images.append(img)
+            
+            doc.close()
+            return images
+        except Exception as e:
+            print(f"PDF预览失败: {e}")
+            return []
+    
+    def translate_pdf(
+        self, 
+        pdf_file, 
+        lang_in: Optional[str] = None,
+        lang_out: Optional[str] = None,
+        file_type: str = "dual",
+        progress=gr.Progress()
+    ) -> Tuple[str, str, list, str, str]:
+        """翻译PDF文件"""
+        if pdf_file is None:
+            return "❌ 请先上传PDF文件", "", [], "", ""
+        
+        try:
+            # 记录开始时间
+            start_time = time.time()
+            start_time_str = time.strftime("%H:%M:%S", time.localtime(start_time))
+            
+            progress(0, desc="正在提交翻译任务...")
+            
+            # 保存上传的文件
+            pdf_path = self.temp_dir / f"input_{int(time.time())}.pdf"
+            with open(pdf_path, "wb") as f:
+                f.write(pdf_file)
+            
+            # 提交翻译任务
+            task_id = self.client.translate_pdf(
+                pdf_path=str(pdf_path),
+                lang_in=lang_in if lang_in else None,
+                lang_out=lang_out if lang_out else None
+            )
+            self.current_task_id = task_id
+            
+            progress(0.1, desc=f"任务已创建: {task_id[:8]}...")
+            
+            # 监控翻译进度
+            while time.time() - start_time < 3600:  # 1小时超时
+                status = self.client.get_status(task_id)
+                
+                if status['status'] == 'completed':
+                    progress(1.0, desc="翻译完成，正在下载结果...")
+                    
+                    # 记录结束时间
+                    end_time = time.time()
+                    end_time_str = time.strftime("%H:%M:%S", time.localtime(end_time))
+                    duration = end_time - start_time
+                    duration_str = f"{int(duration//60)}分{int(duration%60)}秒"
+                    
+                    timing_info = f"开始时间: {start_time_str} | 完成时间: {end_time_str} | 总耗时: {duration_str}"
+                    
+                    # 下载结果文件
+                    output_dir = self.temp_dir / f"output_{task_id[:8]}"
+                    output_dir.mkdir(exist_ok=True)
+                    
+                    downloaded_files = {}
+                    for ftype in ['dual', 'mono']:
+                        if ftype in status['result_files']:
+                            output_file = output_dir / f"translated_{ftype}.pdf"
+                            if self.client.download_result(task_id, ftype, str(output_file)):
+                                downloaded_files[ftype] = str(output_file)
+                    
+                    # 返回指定类型的文件
+                    if file_type in downloaded_files:
+                        result_path = downloaded_files[file_type]
+                        result_images = self.pdf_to_images(result_path)
+                        
+                        return (
+                            f"✅ 翻译完成！共生成 {len(result_images)} 页内容",
+                            result_path,
+                            result_images,
+                            f"任务ID: {task_id}",
+                            timing_info
+                        )
+                    else:
+                        return (
+                            f"⚠️ 翻译完成但未找到 {file_type} 文件类型",
+                            "",
+                            [],
+                            f"任务ID: {task_id}",
+                            timing_info
+                        )
+                
+                elif status['status'] == 'failed':
+                    end_time = time.time()
+                    end_time_str = time.strftime("%H:%M:%S", time.localtime(end_time))
+                    duration = end_time - start_time
+                    duration_str = f"{int(duration//60)}分{int(duration%60)}秒"
+                    timing_info = f"开始时间: {start_time_str} | 失败时间: {end_time_str} | 耗时: {duration_str}"
+                    
+                    return (
+                        f"❌ 翻译失败: {status['message']}",
+                        "",
+                        [],
+                        f"任务ID: {task_id}",
+                        timing_info
+                    )
+                
+                # 更新进度
+                progress_val = status['progress'] / 100.0
+                progress(progress_val, desc=f"{status['message']}")
+                time.sleep(2)
+            
+            # 超时情况
+            end_time = time.time()
+            end_time_str = time.strftime("%H:%M:%S", time.localtime(end_time))
+            duration = end_time - start_time
+            duration_str = f"{int(duration//60)}分{int(duration%60)}秒"
+            timing_info = f"开始时间: {start_time_str} | 超时时间: {end_time_str} | 耗时: {duration_str}"
+            
+            return "❌ 翻译超时", "", [], f"任务ID: {task_id}", timing_info
+            
+        except Exception as e:
+            return f"❌ 翻译出错: {str(e)}", "", [], "", ""
+    
+    def get_task_status(self, task_id: str) -> str:
+        """获取任务状态"""
+        if not task_id:
+            return "请输入任务ID"
+        
+        try:
+            status = self.client.get_status(task_id)
+            return f"""
+**任务状态:** {status['status']}
+**进度:** {status['progress']:.1f}%
+**消息:** {status['message']}
+**结果文件:** {', '.join(status['result_files'].keys()) if status['result_files'] else '无'}
+"""
+        except Exception as e:
+            return f"查询失败: {str(e)}"
+    
+    def load_sample_file(self) -> Tuple[bytes, list, str]:
+        """加载示例PDF文件"""
+        try:
+            if not self.sample_file_path.exists():
+                return None, [], "❌ 示例文件不存在"
+            
+            # 读取示例文件
+            with open(self.sample_file_path, "rb") as f:
+                file_data = f.read()
+            
+            # 生成预览图片
+            images = self.pdf_to_images(str(self.sample_file_path))
+            status = f"✅ 已加载示例文件，共 {len(images)} 页（显示前5页预览）"
+            
+            return file_data, images, status
+        except Exception as e:
+            return None, [], f"❌ 加载示例文件失败: {str(e)}"
+
+def create_gradio_interface(server_url: str = "http://localhost:8000"):
+    """创建Gradio界面"""
+    gradio_client = GradioClient(server_url)
+    
+    with gr.Blocks(
+        title="pdftranslate PDF翻译工具",
+        theme=gr.themes.Soft(),
+        css="""
+        .main-container { max-width: 1400px; margin: 0 auto; }
+        .preview-container { height: 600px; overflow-y: auto; }
+        .status-box { background-color: #f8f9fa; padding: 15px; border-radius: 8px; }
+        
+        /* 表格样式配置 */
+        .config-table {
+            border: 1px solid #e5e7eb;
+            border-radius: 8px;
+            overflow: hidden;
+            margin: 16px 0;
+        }
+        .config-header-row {
+            background-color: #6366f1 !important;
+            margin: 0 !important;
+        }
+        .config-header { 
+            background-color: #6366f1; 
+            color: white; 
+            padding: 12px 16px; 
+            margin: 0; 
+            text-align: center;
+            font-weight: bold;
+            border-right: 1px solid #5b63d4;
+        }
+        .config-row { 
+            border-bottom: 1px solid #e5e7eb; 
+            padding: 12px 16px; 
+            margin: 0 !important;
+            background-color: white;
+        }
+        .config-row:hover { 
+            background-color: #f8fafc; 
+        }
+        .config-row:last-child {
+            border-bottom: none;
+        }
+        .config-actions {
+            background-color: #f9fafb;
+            padding: 16px;
+            border-top: 1px solid #e5e7eb;
+            margin: 0 !important;
+        }
+        .config-status {
+            background-color: #f0f9ff;
+            padding: 12px 16px;
+            border-radius: 6px;
+            border-left: 4px solid #3b82f6;
+            margin: 16px 0;
+        }
+        """
+    ) as demo:
+        
+        gr.Markdown("""
+        # 🌍 pdftranslate PDF翻译工具
+        
+        上传PDF文件，选择翻译选项，即可获得翻译后的PDF文件。支持双语对照和纯翻译两种模式。
+        """)
+        
+        # 顶部状态和选项栏
+        with gr.Row():
+            with gr.Column(scale=1):
+                server_status = gr.Markdown("检查服务器状态中...")
+        
+        # 主要界面区域，包含配置选项卡
+        with gr.Tabs():
+            with gr.TabItem("📄 PDF翻译"):
+                # 翻译选项区域
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        gr.Markdown("**⚙️ 翻译选项**")
+                        with gr.Row():
+                            lang_in = gr.Textbox(
+                                label="源语言",
+                                placeholder="留空使用服务器默认 (en)",
+                                scale=1,
+                                container=False
+                            )
+                            lang_out = gr.Textbox(
+                                label="目标语言", 
+                                placeholder="留空使用服务器默认 (zh)",
+                                scale=1,
+                                container=False
+                            )
+                        
+                        with gr.Row():
+                            file_type = gr.Radio(
+                                choices=["dual", "mono"],
+                                value="dual",
+                                label="输出类型",
+                                info="dual: 双语对照, mono: 纯翻译",
+                                container=False,
+                                scale=1
+                            )
+                            
+                            translate_btn = gr.Button(
+                                "🚀 开始翻译",
+                                variant="primary",
+                                size="sm",
+                                scale=1
+                            )
+                
+                with gr.Row():
+                    # 左侧：上传和控制面板
+                    with gr.Column(scale=1):
+                        gr.Markdown("### 📁 文件上传")
+                        
+                        # 示例文件加载
+                        with gr.Row():
+                            sample_btn = gr.Button(
+                                "📋 加载示例文件 (11.pdf)",
+                                variant="secondary",
+                                size="sm",
+                                scale=3
+                            )
+                            with gr.Column(scale=1, min_width=50):
+                                gr.Markdown("*或*")
+                        
+                        pdf_input = gr.File(
+                            label="拖放PDF文件至此或点击选择",
+                            file_types=[".pdf"],
+                            type="binary"
+                        )
+                        
+                        # 原始PDF预览
+                        gr.Markdown("### 📄 原始PDF预览")
+                        original_preview = gr.Gallery(
+                            label="原始PDF页面",
+                            show_label=False,
+                            elem_classes=["preview-container"],
+                            columns=1,
+                            rows=2,
+                            height="400px",
+                            show_download_button=False,
+                            interactive=False
+                        )
+                        
+                    # 右侧：结果展示
+                    with gr.Column(scale=1):
+                        gr.Markdown("### 📊 翻译状态")
+                        translation_status = gr.Markdown(
+                            "等待上传文件...",
+                            elem_classes=["status-box"]
+                        )
+                        
+                        gr.Markdown("### 📑 翻译结果预览")
+                        result_preview = gr.Gallery(
+                            label="翻译后PDF页面",
+                            show_label=False,
+                            elem_classes=["preview-container"],
+                            columns=1,
+                            rows=2,
+                            height="400px",
+                            show_download_button=False,
+                            interactive=False
+                        )
+                        
+                        # 下载按钮
+                        download_btn = gr.File(
+                            label="下载翻译结果",
+                            visible=False
+                        )
+                        
+                        # 任务信息
+                        task_info = gr.Textbox(
+                            label="任务信息",
+                            interactive=False,
+                            visible=False
+                        )
+                
+                # 底部：任务状态查询
+                with gr.Accordion("🔍 任务状态查询", open=False):
+                    with gr.Row():
+                        task_id_input = gr.Textbox(
+                            label="任务ID",
+                            placeholder="输入任务ID查询状态"
+                        )
+                        query_btn = gr.Button("查询", size="sm")
+                    
+                    task_status_output = gr.Markdown("输入任务ID进行查询")
+                
+                # 底部时间统计显示
+                with gr.Row():
+                    timing_display = gr.Markdown(
+                        "⏱️ **处理时间统计**：等待开始翻译...",
+                        elem_classes=["status-box"]
+                    )
+
+            with gr.TabItem("⚙️ 参数设置"):
+                gr.Markdown("### 🔧 核心API配置")
+                gr.Markdown("在此修改OpenAI API配置，修改后立即生效于下次翻译任务。")
+                
+                # 用于跟踪当前会话是否已认证的内部状态
+                session_authenticated = gr.State(False)
+                
+                # 管理员认证模块
+                with gr.Group() as auth_group:
+                    gr.Markdown("#### **管理员认证**")
+                    admin_password_input = gr.Textbox(
+                        label="请输入管理员密码以查看或修改敏感配置",
+                        type="password",
+                        placeholder=f"默认密码是 'admin123'，或通过环境变量 ADMIN_PASSWORD 进行设置"
+                    )
+                    unlock_button = gr.Button("🔓 解锁", variant="primary")
+                
+                # 将所有需要被锁定的组件收集到一个列表中
+                interactive_settings_components = []
+                
+                # 表格样式的配置界面
+                with gr.Group(elem_classes=["config-table"]):
+                    # 表格头部
+                    with gr.Row(elem_classes=["config-header-row"]):
+                        with gr.Column(scale=1):
+                            gr.HTML("<div class='config-header'>配置项</div>")
+                        with gr.Column(scale=2):
+                            gr.HTML("<div class='config-header'>当前值</div>")
+                        with gr.Column(scale=1):
+                            gr.HTML("<div class='config-header'>操作</div>")
+                    
+                    # API Key 行
+                    with gr.Row(elem_classes=["config-row"]):
+                        with gr.Column(scale=1):
+                            gr.Markdown("**OpenAI API Key**")
+                        with gr.Column(scale=2):
+                            api_key_input = gr.Textbox(
+                                placeholder="输入你的API��钥",
+                                type="password",
+                                container=False,
+                                show_label=False,
+                                interactive=False
+                            )
+                            interactive_settings_components.append(api_key_input)
+                        with gr.Column(scale=1):
+                            show_api_key_btn = gr.Button("👁 显示", size="sm", interactive=False)
+                            interactive_settings_components.append(show_api_key_btn)
+                    
+                    # 模型名称行
+                    with gr.Row(elem_classes=["config-row"]):
+                        with gr.Column(scale=1):
+                            gr.Markdown("**模型名称**")
+                        with gr.Column(scale=2):
+                            model_input = gr.Textbox(
+                                placeholder="如: deepseek-ai/DeepSeek-V3",
+                                container=False,
+                                show_label=False,
+                                interactive=False
+                            )
+                            interactive_settings_components.append(model_input)
+                        with gr.Column(scale=1):
+                            gr.HTML("<span></span>")  # 空占位符
+                    
+                    # Base URL 行
+                    with gr.Row(elem_classes=["config-row"]):
+                        with gr.Column(scale=1):
+                            gr.Markdown("**Base URL**")
+                        with gr.Column(scale=2):
+                            base_url_input = gr.Textbox(
+                                placeholder="如: https://api.siliconflow.cn/v1",
+                                container=False,
+                                show_label=False,
+                                interactive=False
+                            )
+                            interactive_settings_components.append(base_url_input)
+                        with gr.Column(scale=1):
+                            gr.HTML("<span></span>")  # 空占位符
+                    
+                    # 操作按钮行
+                    with gr.Row(elem_classes=["config-actions"]):
+                        save_config_btn = gr.Button(
+                            "💾 保存配置",
+                            variant="primary",
+                            size="sm",
+                            interactive=False
+                        )
+                        interactive_settings_components.append(save_config_btn)
+                        
+                # 配置状态显示
+                config_status = gr.Markdown("等待配置...", elem_classes=["config-status"])
+                
+                # 创建一个 State 来传递需要解锁的组件数量
+                num_components = gr.State(len(interactive_settings_components))
+        
+        def update_server_status():
+            status_text, config = gradio_client.check_server_status()
+            return status_text
+        
+        def unlock_settings(password_attempt, num_components_to_unlock):
+            """
+            检查管理员密码。如果正确，解锁设置UI并隐藏认证模块。
+            """
+            if password_attempt == ADMIN_PASSWORD:
+                gr.Info("认证成功！设置已解锁。")
+                # 为每一个需要解锁的组件创建一个更新指令
+                unlock_updates = [gr.update(interactive=True) for _ in range(num_components_to_unlock)]
+                # 返回所有更新指令，以及对认证组和会话状态的更新
+                # The * operator unpacks the list into individual arguments for the tuple
+                return *unlock_updates, gr.update(visible=False), True
+            else:
+                # 密码错误时，通过 gr.Error 弹出提示，UI不会有任何变化
+                raise gr.Error("管理员密码错误！")
+        
+        def toggle_api_key_visibility(api_key_value):
+            """切换API密钥的显示/隐藏状态"""
+            # 根据当前值判断是否为隐藏状态
+            # 如果包含*号，则当前是遮蔽状态，需要显示原文
+            if api_key_value and "*" in api_key_value:
+                # 从缓存中获取原始值
+                original_key = gradio_client.config_cache.get('openai_api_key', '')
+                return gr.update(value=original_key, type="text")
+            else:
+                # 当前显示原文，需要遮蔽
+                if api_key_value:
+                    # 保存到缓存
+                    gradio_client.config_cache['openai_api_key'] = api_key_value
+                    masked_key = gradio_client.get_masked_api_key(api_key_value)
+                    return gr.update(value=masked_key, type="password")
+                else:
+                    return gr.update(type="password")
+        
+        def save_config(api_key, model, base_url):
+            """保存配���"""
+            status = gradio_client.update_config(api_key=api_key, model=model, base_url=base_url)
+            
+            # 从配置缓存生成当前配置显示
+            config_info = f"""**当前配置:**
+- API Key: {gradio_client.get_masked_api_key(gradio_client.config_cache['openai_api_key'])}
+- 模型: {gradio_client.config_cache['openai_model'] or '未设置'}
+- Base URL: {gradio_client.config_cache['openai_base_url'] or '未设置'}
+"""
+            return status + "\n\n" + config_info
+        
+        def load_config_from_server():
+            """从环境变量和服务器加载配置到输入框"""
+            import os
+            from dotenv import load_dotenv
+            
+            # 加载.env文件
+            load_dotenv()
+            
+            # 从环境变量读取配置
+            api_key = os.getenv("OPENAI_API_KEY", "")
+            model = os.getenv("OPENAI_MODEL", "")
+            base_url = os.getenv("OPENAI_BASE_URL", "")
+            
+            # 更新配置缓存
+            gradio_client.config_cache.update({
+                "openai_api_key": api_key,
+                "openai_model": model,
+                "openai_base_url": base_url
+            })
+            
+            # 返回遮蔽后的API Key和其他配置
+            masked_api_key = gradio_client.get_masked_api_key(api_key) if api_key else ""
+            
+            return masked_api_key, model, base_url
+        
+        # 定期更新服务器状态
+        demo.load(update_server_status, outputs=[server_status])
+        
+        # 事件处理
+        def on_pdf_upload(pdf_file):
+            """PDF文件上传时的预览"""
+            if pdf_file is None:
+                return [], "等待上传文件..."
+            
+            # 保存临时文件用于预览
+            temp_path = gradio_client.temp_dir / f"preview_{int(time.time())}.pdf"
+            with open(temp_path, "wb") as f:
+                f.write(pdf_file)
+            
+            # 生成预览图片
+            images = gradio_client.pdf_to_images(str(temp_path))
+            status = f"✅ 已上传PDF文件，共 {len(images)} 页（显示前5页预览）"
+            
+            return images, status
+        
+        def on_load_sample():
+            """加载示例文件"""
+            file_data, images, status = gradio_client.load_sample_file()
+            if file_data:
+                # 创建临时文件并返回其路径给gr.File组件
+                temp_sample_path = gradio_client.temp_dir / f"sample_{int(time.time())}.pdf"
+                with open(temp_sample_path, "wb") as f:
+                    f.write(file_data)
+                return str(temp_sample_path), images, status
+            else:
+                return None, [], status
+        
+        def on_translate(pdf_file, lang_in, lang_out, file_type, progress=gr.Progress()):
+            """执行翻译"""
+            status, result_path, result_images, task_id, timing_info = gradio_client.translate_pdf(
+                pdf_file, lang_in, lang_out, file_type, progress
+            )
+            
+            # 返回结果
+            download_visible = bool(result_path and os.path.exists(result_path))
+            task_visible = bool(task_id)
+            
+            # 格式化时间信息显示
+            timing_display_text = f"⏱️ **处理时间统计**：{timing_info}" if timing_info else "⏱️ **处理时间统计**：处理异常"
+            
+            return (
+                status,  # translation_status
+                result_images,  # result_preview
+                gr.File(value=result_path if result_path else None, visible=download_visible),  # download_btn
+                gr.Textbox(value=task_id, visible=task_visible),  # task_info
+                timing_display_text  # timing_display
+            )
+        
+        # 绑定事件
+        # 管理员认证事件
+        unlock_button.click(
+            fn=unlock_settings,
+            inputs=[admin_password_input, num_components],
+            # outputs 列表现在包含所有被控制的组件、认证组和会话状态
+            outputs=interactive_settings_components + [auth_group, session_authenticated]
+        )
+        
+        # 配置相关事件
+        show_api_key_btn.click(
+            toggle_api_key_visibility,
+            inputs=[api_key_input],
+            outputs=[api_key_input]
+        )
+        
+        save_config_btn.click(
+            save_config,
+            inputs=[api_key_input, model_input, base_url_input],
+            outputs=[config_status]
+        )
+        
+        # 页面加载时从服务器加载配置
+        demo.load(
+            load_config_from_server,
+            outputs=[api_key_input, model_input, base_url_input]
+        )
+        
+        # 示例文件加载
+        sample_btn.click(
+            on_load_sample,
+            outputs=[pdf_input, original_preview, translation_status]
+        )
+        
+        pdf_input.change(
+            on_pdf_upload,
+            inputs=[pdf_input],
+            outputs=[original_preview, translation_status]
+        )
+        
+        translate_btn.click(
+            on_translate,
+            inputs=[pdf_input, lang_in, lang_out, file_type],
+            outputs=[translation_status, result_preview, download_btn, task_info, timing_display]
+        )
+        
+        query_btn.click(
+            gradio_client.get_task_status,
+            inputs=[task_id_input],
+            outputs=[task_status_output]
+        )
+    
+    return demo
+
+def main():
+    """启动Gradio客户端"""
+    import argparse
+    
+    # 显示管理员密码信息
+    print("---" * 10)
+    print(f"INFO: 管理员密码已设置。请使用 '{ADMIN_PASSWORD}' 在参数设置页面解锁敏感信息。")
+    print("---" * 10)
+    
+    parser = argparse.ArgumentParser(description="BabelDOC Gradio客户端")
+    parser.add_argument("--server-url", default="http://localhost:8000", help="API服务器地址")
+    parser.add_argument("--host", default="0.0.0.0", help="Gradio服务器主机")
+    parser.add_argument("--port", type=int, default=7860, help="Gradio服务器端口")
+    parser.add_argument("--share", action="store_true", help="创建公共链接")
+    
+    args = parser.parse_args()
+    
+    print(f"正在启动Gradio客户端...")
+    print(f"API服务器: {args.server_url}")
+    print(f"Gradio地址: http://{args.host}:{args.port}")
+    
+    demo = create_gradio_interface(args.server_url)
+    demo.launch(
+        server_name=args.host,
+        server_port=args.port,
+        share=args.share,
+        show_error=True
+    )
+
+if __name__ == "__main__":
+    main()

pdftranslate_web/tests/test2.py

@@ -0,0 +1,4 @@
+from dotenv import load_dotenv
+load_dotenv()  # 自动加载同目录下的 .env 文件
+import os
+print(os.getenv("OPENAI_API_KEY"))  # 验证是否加载成功

pdftranslate_web/tests/test_structure.py

@@ -0,0 +1,30 @@
+# 基础测试文件
+from pathlib import Path
+
+def test_project_structure():
+    """测试项目结构是否正确"""
+    project_root = Path(__file__).parent.parent
+    
+    # 检查核心目录
+    assert (project_root / "src" / "pdftranslate_web").exists()
+    assert (project_root / "scripts").exists()
+    assert (project_root / "docs").exists()
+    
+    # 检查核心文件
+    assert (project_root / "src" / "pdftranslate_web" / "__init__.py").exists()
+    assert (project_root / "src" / "pdftranslate_web" / "api_server.py").exists()
+    assert (project_root / "src" / "pdftranslate_web" / "api_client.py").exists()
+    assert (project_root / "src" / "pdftranslate_web" / "gradio_client.py").exists()
+    
+    # 检查配置文件
+    assert (project_root / ".env.example").exists()
+    assert (project_root / "pyproject.toml").exists()
+    assert (project_root / "README.md").exists()
+    
+    # 检查Docker文件
+    assert (project_root / "Dockerfile").exists()
+    assert (project_root / "docker-compose.yml").exists()
+
+if __name__ == "__main__":
+    test_project_structure()
+    print("✅ 项目结构测试通过")

requirements.txt

@@ -0,0 +1,4 @@
+jupyterlab==4.4.5
+tornado==6.2
+ipywidgets
+uv==0.8.4

start_server.sh

@@ -0,0 +1,19 @@
+#!/bin/bash
+JUPYTER_TOKEN="${JUPYTER_TOKEN:=huggingface}"
+
+NOTEBOOK_DIR="/data"
+
+jupyter labextension disable "@jupyterlab/apputils-extension:announcements"
+
+jupyter-lab \
+    --ip 0.0.0.0 \
+    --port 7860 \
+    --no-browser \
+    --allow-root \
+    --ServerApp.token="$JUPYTER_TOKEN" \
+    --ServerApp.tornado_settings="{'headers': {'Content-Security-Policy': 'frame-ancestors *'}}" \
+    --ServerApp.cookie_options="{'SameSite': 'None', 'Secure': True}" \
+    --ServerApp.disable_check_xsrf=True \
+    --LabApp.news_url=None \
+    --LabApp.check_for_updates_class="jupyterlab.NeverCheckForUpdate" \
+    --notebook-dir=$NOTEBOOK_DIR