Dolphin

Dolphin 是一个高性能的文档解析引擎，专为生产环境设计，提供稳定可靠的文档处理能力，支持PDF、Word、Excel等多种格式的高效解析和转换。

🌟 核心特性

✅ 高性能：优化的解析引擎，处理速度快
✅ 生产就绪：稳定可靠，适合企业级部署
✅ 多格式支持：PDF、DOCX、XLSX、PPTX等
✅ 流式处理：支持大文件的流式解析
✅ 分布式架构：支持横向扩展
✅ 监控完善：详细的性能指标和日志
✅ 容器化部署：Docker/K8s友好
✅ API友好：RESTful API和SDK

📦 安装与部署

Docker部署

# 拉取镜像
docker pull dolphin/parser:latest

# 运行容器
docker run -d \
  --name dolphin-parser \
  -p 8080:8080 \
  -v /data:/data \
  dolphin/parser:latest

# 健康检查
curl http://localhost:8080/health

Kubernetes部署

apiVersion: apps/v1
kind: Deployment
metadata:
  name: dolphin-parser
spec:
  replicas: 3
  selector:
    matchLabels:
      app: dolphin
  template:
    metadata:
      labels:
        app: dolphin
    spec:
      containers:
      - name: dolphin
        image: dolphin/parser:latest
        ports:
        - containerPort: 8080
        resources:
          requests:
            memory: "2Gi"
            cpu: "1"
          limits:
            memory: "4Gi"
            cpu: "2"
        livenessProbe:
          httpGet:
            path: /health
            port: 8080
          initialDelaySeconds: 30
          periodSeconds: 10

Python SDK

pip install dolphin-parser

🏗️ 技术架构

graph TB
    A[客户端] --> B[API Gateway]
    B --> C[负载均衡]
    C --> D[Parser Worker 1]
    C --> E[Parser Worker 2]
    C --> F[Parser Worker N]
    
    D --> G[文件存储]
    E --> G
    F --> G
    
    D --> H[Redis缓存]
    E --> H
    F --> H
    
    D --> I[监控系统]
    E --> I
    F --> I

🎯 应用场景

1. RESTful API使用

import requests

# 上传并解析文档
def parse_document(file_path):
    """通过API解析文档"""
    url = "http://localhost:8080/api/v1/parse"
    
    with open(file_path, "rb") as f:
        files = {"file": f}
        response = requests.post(url, files=files)
    
    if response.status_code == 200:
        result = response.json()
        return result
    else:
        raise Exception(f"解析失败: {response.text}")

# 使用示例
result = parse_document("document.pdf")
print(f"文本内容: {result['text']}")
print(f"页数: {result['pages']}")

2. Python SDK使用

from dolphin import DolphinParser

# 初始化客户端
client = DolphinParser(
    api_url="http://localhost:8080",
    api_key="your_api_key"
)

# 解析文档
result = client.parse("document.pdf")

# 获取结果
print(f"文本: {result.text}")
print(f"元数据: {result.metadata}")
print(f"表格数量: {len(result.tables)}")

# 导出为不同格式
markdown = result.to_markdown()
json_data = result.to_json()

3. 批量处理

from dolphin import DolphinParser
from pathlib import Path
import concurrent.futures

def batch_parse_documents(input_dir, output_dir):
    """批量解析文档"""
    client = DolphinParser(api_url="http://localhost:8080")
    
    input_path = Path(input_dir)
    output_path = Path(output_dir)
    output_path.mkdir(exist_ok=True)
    
    # 获取所有文档
    files = list(input_path.glob("*.pdf"))
    
    def process_file(file_path):
        try:
            # 解析文档
            result = client.parse(str(file_path))
            
            # 保存结果
            output_file = output_path / f"{file_path.stem}.md"
            with open(output_file, "w", encoding="utf-8") as f:
                f.write(result.to_markdown())
            
            return {"file": file_path.name, "status": "success"}
        except Exception as e:
            return {"file": file_path.name, "status": "error", "error": str(e)}
    
    # 并发处理
    with concurrent.futures.ThreadPoolExecutor(max_workers=10) as executor:
        results = list(executor.map(process_file, files))
    
    return results

4. 流式处理大文件

from dolphin import DolphinParser

def stream_parse_large_file(file_path):
    """流式处理大文件"""
    client = DolphinParser()
    
    # 流式解析
    for page_result in client.parse_stream(file_path):
        print(f"页码 {page_result.page_num}:")
        print(f"文本: {page_result.text[:100]}...")
        
        # 实时处理每一页
        process_page(page_result)
    
    print("处理完成")

def process_page(page_result):
    """处理单页结果"""
    # 保存到数据库、发送到队列等
    pass

5. 异步处理

import asyncio
from dolphin import AsyncDolphinParser

async def async_parse(file_path):
    """异步解析"""
    client = AsyncDolphinParser(api_url="http://localhost:8080")
    
    # 提交解析任务
    task_id = await client.submit_parse_task(file_path)
    print(f"任务ID: {task_id}")
    
    # 轮询任务状态
    while True:
        status = await client.get_task_status(task_id)
        
        if status.state == "completed":
            result = await client.get_task_result(task_id)
            return result
        elif status.state == "failed":
            raise Exception(f"解析失败: {status.error}")
        
        await asyncio.sleep(1)

# 使用
result = asyncio.run(async_parse("large_document.pdf"))

6. 集成到数据管道

from dolphin import DolphinParser
from airflow import DAG
from airflow.operators.python import PythonOperator

def parse_documents_task(**context):
    """Airflow任务：解析文档"""
    client = DolphinParser()
    
    # 从上游任务获取文件列表
    files = context['task_instance'].xcom_pull(task_ids='get_files')
    
    results = []
    for file_path in files:
        result = client.parse(file_path)
        results.append({
            'file': file_path,
            'text': result.text,
            'metadata': result.metadata
        })
    
    # 传递给下游任务
    return results

# 定义DAG
with DAG('document_processing', schedule_interval='@daily') as dag:
    parse_task = PythonOperator(
        task_id='parse_documents',
        python_callable=parse_documents_task
    )

🔧 高级配置

性能优化

from dolphin import DolphinParser, Config

# 创建配置
config = Config(
    # 并发配置
    max_workers=10,
    queue_size=100,
    
    # 缓存配置
    enable_cache=True,
    cache_ttl=3600,
    
    # 超时配置
    request_timeout=30,
    parse_timeout=300,
    
    # 重试配置
    max_retries=3,
    retry_delay=1
)

# 使用配置
client = DolphinParser(config=config)

监控配置

from dolphin import DolphinParser, MetricsExporter

# 配置监控
metrics = MetricsExporter(
    prometheus_port=9090,
    enable_logging=True,
    log_level="INFO"
)

client = DolphinParser(metrics=metrics)

# 查看指标
stats = client.get_metrics()
print(f"总处理数: {stats.total_processed}")
print(f"成功率: {stats.success_rate}%")
print(f"平均处理时间: {stats.avg_time}s")

分布式配置

from dolphin import DistributedParser

# 配置分布式解析
parser = DistributedParser(
    workers=[
        "http://worker1:8080",
        "http://worker2:8080",
        "http://worker3:8080"
    ],
    load_balancer="round_robin",  # round_robin/least_connections
    health_check_interval=10
)

# 自动负载均衡
result = parser.parse("large_document.pdf")

📊 性能指标

指标	性能
吞吐量	100-500 文档/分钟
延迟	P50: 2s, P99: 10s
CPU使用率	60-80%
内存占用	2-4GB
可用性	99.9%

💡 最佳实践

合理配置资源

# 根据文档大小调整资源
小文档(< 10MB): 1CPU, 2GB内存
中等文档(10-50MB): 2CPU, 4GB内存
大文档(> 50MB): 4CPU, 8GB内存

使用缓存

# 启用缓存避免重复解析
client = DolphinParser(enable_cache=True)

监控告警

# 配置告警规则
- 解析失败率 > 5%
- 平均延迟 > 30s
- CPU使用率 > 90%

优雅降级

try:
    result = client.parse(file_path)
except Exception:
    # 降级到基础解析
    result = basic_parse(file_path)

📚 资源链接

官方网站: https://dolphin-parser.io
文档: https://docs.dolphin-parser.io
GitHub: https://github.com/dolphin/parser
Docker Hub: https://hub.docker.com/r/dolphin/parser

⚠️ 注意事项

生产环境建议部署3个以上节点
定期清理缓存避免磁盘占满
监控内存使用，避免OOM
大文件建议使用流式处理
配置合理的超时时间

🆚 适用场景

选择 Dolphin 当：

生产环境部署
需要高可用性
大规模文档处理
需要监控和告警
分布式架构

选择其他工具当：

开发测试环境 → 轻量级工具
单机使用 → 本地工具
特殊格式 → 专用工具

🔄 更新日志

2024.06: v2.1 - 性能优化
2024.03: v2.0 - 分布式支持
2023.12: v1.5 - 流式处理
2023.09: v1.0 - 首次发布

🌟 核心特性​

📦 安装与部署​

Docker部署​

Kubernetes部署​

Python SDK​

🏗️ 技术架构​

🎯 应用场景​

1. RESTful API使用​

2. Python SDK使用​

3. 批量处理​

4. 流式处理大文件​

5. 异步处理​

6. 集成到数据管道​

🔧 高级配置​

性能优化​

监控配置​

分布式配置​

📊 性能指标​

💡 最佳实践​

📚 资源链接​

⚠️ 注意事项​

🆚 适用场景​

🔄 更新日志​

🌟 核心特性

📦 安装与部署

Docker部署

Kubernetes部署

Python SDK

🏗️ 技术架构

🎯 应用场景

1. RESTful API使用

2. Python SDK使用

3. 批量处理

4. 流式处理大文件

5. 异步处理

6. 集成到数据管道

🔧 高级配置

性能优化

监控配置

分布式配置

📊 性能指标

💡 最佳实践

📚 资源链接

⚠️ 注意事项

🆚 适用场景

🔄 更新日志