init

.gitignore

@@ -0,0 +1,131 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# celery beat schedule file
+celerybeat-schedule
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# uv
+.uv/
+
+# Output files
+output/
+logs/
+
+# Large models
+*.bin
+*.pth
+*.pt
+*.onnx 
+
+examples/input/
+examples/output/
+
+# temp files
+_temp_*

.vscode/launch.json

@@ -0,0 +1,19 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Python Debugger: Current File",
+            "type": "debugpy",
+            "request": "launch",
+            "program": "${file}",
+            "console": "integratedTerminal",
+            "env": {
+                // "HTTPS_PROXY": "http://127.0.0.1:12334",
+                // "HF_ENDPOINT": "https://hf-mirror.com"
+            }
+        }
+    ]
+}

app.py

@@ -1,7 +1,46 @@
-import gradio as gr
+#!/usr/bin/env python3
+"""
+播客转录工具 - 主启动文件
+这个文件用于启动 Gradio WebUI 应用
+"""
 
-def greet(name):
-    return "Hello " + name + "!!"
+import sys
+import os
 
-demo = gr.Interface(fn=greet, inputs="text", outputs="text")
-demo.launch()
+# 将 src 目录添加到 Python 路径中
+current_dir = os.path.dirname(os.path.abspath(__file__))
+src_path = os.path.join(current_dir, "src")
+if src_path not in sys.path:
+    sys.path.insert(0, src_path)
+
+def main():
+    """主函数：启动 WebUI 应用"""
+    try:
+        # 导入并启动 webui 应用
+        from podcast_transcribe.webui.app import demo
+        
+        print("🎙️ 启动播客转录工具...")
+        print("📍 WebUI 将在浏览器中打开")
+        print("🔗 默认地址: http://localhost:7860")
+        print("⏹️  按 Ctrl+C 停止服务")
+        
+        # 启动 Gradio 应用
+        demo.launch(
+            debug=True,
+            server_name="0.0.0.0",  # 允许外部访问
+            server_port=7860,       # 指定端口
+            share=False,            # 不生成公开链接
+            inbrowser=True          # 自动在浏览器中打开
+        )
+        
+    except ImportError as e:
+        print(f"❌ 导入错误: {e}")
+        print("请确保已安装所有依赖包:")
+        print("pip install -r requirements.txt")
+        sys.exit(1)
+    except Exception as e:
+        print(f"❌ 启动失败: {e}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

examples/combined_podcast_transcription.py

@@ -0,0 +1,102 @@
+# 添加项目根目录到Python路径
+import json
+import sys
+from pathlib import Path
+import os
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from src.podcast_transcribe.transcriber import transcribe_podcast_audio
+from src.podcast_transcribe.audio import load_audio
+from src.podcast_transcribe.rss.podcast_rss_parser import parse_rss_xml_content
+from podcast_transcribe.llm.llm_gemma_mlx import GemmaMLXChatCompletion
+from src.podcast_transcribe.schemas import EnhancedSegment, CombinedTranscriptionResult
+from src.podcast_transcribe.summary.speaker_identify import recognize_speaker_names
+
+def main():
+    """主函数"""
+    podcast_rss_xml_file = Path.joinpath(Path(__file__).parent, "input", "lexfridman.com.rss.xml")
+    audio_file = Path.joinpath(Path(__file__).parent, "input", "lex_ai_john_carmack_1.wav")  # 播客音频文件路径
+    # audio_file = Path("/Users/konie/Desktop/voices/lex_ai_john_carmack_30.wav")
+    
+    # 模型配置
+    asr_model_name = "mlx-community/parakeet-tdt-0.6b-v2"  # ASR模型名称
+    diarization_model_name = "pyannote/speaker-diarization-3.1"  # 说话人分离模型名称
+    llm_model_path = "mlx-community/gemma-3-12b-it-4bit-DWQ"
+    hf_token = ""  # Hugging Face API 令牌
+    device = "mps"  # 设备类型
+    segmentation_batch_size = 64
+    parallel = True
+
+    # 检查文件是否存在
+    if not os.path.exists(audio_file):
+        print(f"错误：文件 '{audio_file}' 不存在")
+        return 1
+    
+    # 检查HF令牌
+    if not hf_token:
+        print("警告：未设置HF_TOKEN环境变量，必须设置此环境变量才能使用pyannote说话人分离模型")
+        print("请执行：export HF_TOKEN='你的HuggingFace令牌'")
+        return 1
+    
+    try:
+        print(f"正在加载音频文件: {audio_file}")
+        # 加载音频文件
+        audio, _ = load_audio(audio_file)
+        
+        print(f"音频信息: 时长={audio.duration_seconds:.2f}秒, 通道数={audio.channels}, 采样率={audio.frame_rate}Hz")
+
+
+    except Exception as e:
+        print(f"错误: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        return 1
+
+    # Load the podcast RSS XML file
+    with open(podcast_rss_xml_file, "r") as f:
+        podcast_rss_xml = f.read()
+        mock_podcast_info = parse_rss_xml_content(podcast_rss_xml)
+
+    
+    # 查找标题已 "#309" 开头的剧集
+    mock_episode_info = next((episode for episode in mock_podcast_info.episodes if episode.title.startswith("#309")), None)
+    if not mock_episode_info:
+        raise ValueError("Could not find episode with title starting with '#309'")
+
+    result = transcribe_podcast_audio(audio,
+                             podcast_info=mock_podcast_info,
+                             episode_info=mock_episode_info,
+                             hf_token=hf_token,
+                             asr_model_name=asr_model_name,
+                             diarization_model_name=diarization_model_name,
+                             llm_model_name=llm_model_path,
+                             device=device,
+                             segmentation_batch_size=segmentation_batch_size,
+                             parallel=parallel,
+                             llm_model_name=llm_model_path)
+    
+    # 输出结果
+    print("\n转录结果:")
+    print("-" * 50)
+    print(f"检测到的语言: {result.language}")
+    print(f"检测到的说话人数量: {result.num_speakers}")
+    print(f"总文本长度: {len(result.text)} 字符")
+    
+    # 输出每个说话人的部分
+    speakers = set(segment.speaker for segment in result.segments)
+    for speaker in sorted(speakers):
+        speaker_segments = [seg for seg in result.segments if seg.speaker == speaker]
+        total_duration = sum(seg.end - seg.start for seg in speaker_segments)
+        print(f"\n说话人 {speaker}: 共 {len(speaker_segments)} 个片段, 总时长 {total_duration:.2f} 秒")
+    
+    # 输出详细分段信息
+    print("\n详细分段信息:")
+    for i, segment in enumerate(result.segments, 1):
+        if i <= 20 or i > len(result.segments) - 20:  # 仅显示前20个和后20个分段
+            print(f"段落 {i}/{len(result.segments)}: [{segment.start:.2f}s - {segment.end:.2f}s] 说话人: {segment.speaker_name if segment.speaker_name else segment.speaker} 文本: {segment.text}")
+        elif i == 21:
+            print("... 省略中间部分 ...")
+
+if __name__ == '__main__':
+    main()

examples/combined_transcription.py

@@ -0,0 +1,104 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+整合ASR和说话人分离的示例程序
+从本地文件读取音频，同时进行转录和说话人分离
+"""
+
+import json
+import os
+import sys
+from pathlib import Path
+from dataclasses import asdict
+
+# 添加项目根目录到Python路径
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+# 导入必要的模块，使用正确的导入路径
+from src.podcast_transcribe.audio import load_audio
+from src.podcast_transcribe.transcriber import transcribe_audio
+
+
+def main():
+    """主函数"""
+    audio_file = Path.joinpath(Path(__file__).parent, "input", "lex_ai_john_carmack_1.wav")  # 播客音频文件路径
+    # audio_file = Path("/Users/konie/Desktop/voices/lex_ai_john_carmack_30.wav")
+    
+    # 模型配置
+    asr_model_name = "distil-whisper/distil-large-v3.5"  # ASR模型名称
+    diarization_model_name = "pyannote/speaker-diarization-3.1"  # 说话人分离模型名称
+    hf_token = ""  # Hugging Face API 令牌
+    device = "mps"  # 设备类型
+    segmentation_batch_size = 64
+    parallel = True
+
+    # 检查文件是否存在
+    if not os.path.exists(audio_file):
+        print(f"错误：文件 '{audio_file}' 不存在")
+        return 1
+    
+    # 检查HF令牌
+    if not hf_token:
+        print("警告：未设置HF_TOKEN环境变量，必须设置此环境变量才能使用pyannote说话人分离模型")
+        print("请执行：export HF_TOKEN='你的HuggingFace令牌'")
+        return 1
+    
+    try:
+        print(f"正在加载音频文件: {audio_file}")
+        # 加载音频文件
+        audio, _ = load_audio(audio_file)
+        
+        print(f"音频信息: 时长={audio.duration_seconds:.2f}秒, 通道数={audio.channels}, 采样率={audio.frame_rate}Hz")
+      
+        result = transcribe_audio(
+            audio, 
+            asr_model_name=asr_model_name,
+            diarization_model_name=diarization_model_name,
+            hf_token=hf_token,
+            device=device,
+            segmentation_batch_size=segmentation_batch_size,
+            parallel=parallel,
+        )
+        
+        # 输出结果
+        print("\n转录结果:")
+        print("-" * 50)
+        print(f"检测到的语言: {result.language}")
+        print(f"检测到的说话人数量: {result.num_speakers}")
+        print(f"总文本长度: {len(result.text)} 字符")
+        
+        # 输出每个说话人的部分
+        speakers = set(segment.speaker for segment in result.segments)
+        for speaker in sorted(speakers):
+            speaker_segments = [seg for seg in result.segments if seg.speaker == speaker]
+            total_duration = sum(seg.end - seg.start for seg in speaker_segments)
+            print(f"\n说话人 {speaker}: 共 {len(speaker_segments)} 个片段, 总时长 {total_duration:.2f} 秒")
+        
+        # 输出详细分段信息
+        print("\n详细分段信息:")
+        for i, segment in enumerate(result.segments, 1):
+            if i <= 20 or i > len(result.segments) - 20:  # 仅显示前20个和后20个分段
+                print(f"段落 {i}/{len(result.segments)}: [{segment.start:.2f}s - {segment.end:.2f}s] 说话人: {segment.speaker} 文本: {segment.text}")
+            elif i == 21:
+                print("... 省略中间部分 ...")
+
+        # 将转录结果保存为json文件，文件名取自音频文件名
+        output_file = Path.joinpath(Path(__file__).parent, "output", f"{audio_file.stem}.transcription.json")
+        # 创建上层文件夹
+        output_dir = Path.joinpath(Path(__file__).parent, "output")
+        output_dir.mkdir(parents=True, exist_ok=True)
+        with open(output_file, "w") as f:
+            json.dump(asdict(result), f)
+            print(f"转录结果已保存到 {output_file}")
+        
+        return 0
+        
+    except Exception as e:
+        print(f"错误: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main()) 

examples/simple_asr.py

@@ -0,0 +1,80 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+简单的语音识别示例程序
+从本地文件读取音频并进行转录
+"""
+
+import logging
+import os
+import sys
+from pathlib import Path
+
+# 添加项目根目录到Python路径
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from src.podcast_transcribe.audio import load_audio
+
+logger = logging.getLogger("asr_example")
+
+
+def main():
+    """主函数"""
+    # audio_file = Path.joinpath(Path(__file__).parent, "input", "lex_ai_john_carmack_1.wav")  # 播客音频文件路径
+    # audio_file = "/Users/konie/Desktop/voices/lex_ai_john_carmack_30.wav"  # 播客音频文件路径
+    audio_file = "/Users/konie/Desktop/voices/podcast1_1.wav"
+    # model = "distil-whisper"
+    model = "distil-whisper-transformers"
+
+    device = "mlx"
+    
+    # 检查文件是否存在
+    if not os.path.exists(audio_file):
+        print(f"错误：文件 '{audio_file}' 不存在")
+        return 1
+    
+    if model == "parakeet":
+        from src.podcast_transcribe.asr.asr_parakeet_mlx import transcribe_audio
+        model_name = "mlx-community/parakeet-tdt-0.6b-v2"
+        logger.info(f"使用Parakeet模型: {model_name}")
+    elif model == "distil-whisper":  # distil-whisper
+        from src.podcast_transcribe.asr.asr_distil_whisper_mlx import transcribe_audio
+        model_name = "mlx-community/distil-whisper-large-v3"
+        logger.info(f"使用Distil Whisper模型: {model_name}")
+    elif model == "distil-whisper-transformers":  # distil-whisper
+        from src.podcast_transcribe.asr.asr_distil_whisper_transformers import transcribe_audio
+        model_name = "distil-whisper/distil-large-v3.5"
+        logger.info(f"使用Distil Whisper模型: {model_name}")
+    else:
+        logger.error(f"错误：未指定模型类型")
+        return 1
+    
+    try:
+        print(f"正在加载音频文件: {audio_file}")
+        # 加载音频文件
+        audio, _ = load_audio(audio_file)
+        
+        print(f"音频信息: 时长={audio.duration_seconds:.2f}秒, 通道数={audio.channels}, 采样率={audio.frame_rate}Hz")
+        
+        # 进行转录
+        print("开始转录...")
+        result = transcribe_audio(audio, model_name=model_name, device=device)
+        
+        # 输出结果
+        print("\n转录结果:")
+        print("-" * 50)
+        print(f"检测到的语言: {result.language}")
+        print(f"完整文本: {result.text}")
+        print("\n分段信息:")
+        for i, segment in enumerate(result.segments, 1):
+            print(f"分段 {i}: [{segment['start']:.2f}s - {segment['end']:.2f}s] {segment['text']}")
+        
+        return 0
+        
+    except Exception as e:
+        print(f"错误: {str(e)}")
+        return 1
+
+
+if __name__ == "__main__":
+    main()

examples/simple_diarization.py

@@ -0,0 +1,79 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+简单的说话人标注示例程序
+从本地文件读取音频并进行说话人分离
+"""
+
+import os
+import sys
+from pathlib import Path
+
+# 添加项目根目录到Python路径
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from src.podcast_transcribe.audio import load_audio
+from src.podcast_transcribe.diarization.diarization_pyannote_mlx import diarize_audio as diarize_audio_mlx
+from src.podcast_transcribe.diarization.diarization_pyannote_transformers import diarize_audio as diarize_audio_transformers
+
+
+def main():
+    """主函数"""
+    audio_file = Path.joinpath(Path(__file__).parent, "input", "lex_ai_john_carmack_1.wav")  # 播客音频文件路径
+    # audio_file = "/Users/konie/Desktop/voices/history_in_the_baking.mp3"  # 播客音频文件路径
+    model_name = "pyannote/speaker-diarization-3.1"  # 说话人分离模型名称
+    hf_token = ""  # Hugging Face API 令牌
+    device = "mps"  # 设备类型
+    
+    # 检查文件是否存在
+    if not os.path.exists(audio_file):
+        print(f"错误：文件 '{audio_file}' 不存在")
+        return 1
+    
+    # 检查令牌是否设置
+    if not hf_token:
+        print("错误：未设置HF_TOKEN环境变量，请设置后再运行")
+        return 1
+    
+    try:
+        print(f"正在加载音频文件: {audio_file}")
+        # 加载音频文件
+        audio, _ = load_audio(audio_file)
+        
+        print(f"音频信息: 时长={audio.duration_seconds:.2f}秒, 通道数={audio.channels}, 采样率={audio.frame_rate}Hz")
+        
+        # 根据model_name选择合适的实现
+        if "pyannote/speaker-diarization" in model_name:
+            # 使用transformers版本进行说话人分离
+            print(f"使用transformers版本处理模型: {model_name}")
+            result = diarize_audio_transformers(audio, model_name=model_name, token=hf_token, device=device, segmentation_batch_size=128)
+            version_name = "Transformers"
+        else:
+            # 使用MLX版本进行说话人分离
+            print(f"使用MLX版本处理模型: {model_name}")
+            result = diarize_audio_mlx(audio, model_name=model_name, token=hf_token, device=device, segmentation_batch_size=128)
+            version_name = "MLX"
+        
+        # 输出结果
+        print(f"\n{version_name}版本说话人分离结果:")
+        print("-" * 50)
+        print(f"检测到的说话人数量: {result.num_speakers}")
+        print(f"分段总数: {len(result.segments)}")
+        
+        print("\n分段详情:")
+        for i, segment in enumerate(result.segments, 1):
+            start = segment["start"]
+            end = segment["end"]
+            speaker = segment["speaker"]
+            duration = end - start
+            print(f"分段 {i}: [{start:.2f}s - {end:.2f}s] (时长: {duration:.2f}s) 说话人: {speaker}")
+        
+        return 0
+        
+    except Exception as e:
+        print(f"错误: {str(e)}")
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

examples/simple_llm.py

@@ -0,0 +1,74 @@
+
+# 添加项目根目录到Python路径
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from src.podcast_transcribe.llm.llm_phi4_transfomers import Phi4TransformersChatCompletion
+from src.podcast_transcribe.llm.llm_gemma_mlx import GemmaMLXChatCompletion
+from src.podcast_transcribe.llm.llm_gemma_transfomers import GemmaTransformersChatCompletion
+
+
+if __name__ == "__main__":
+    # 示例用法：
+    print("正在初始化 LLM 聊天补全...")
+    try:
+        model_name = "google/gemma-3-4b-it"
+        use_4bit_quantization = False
+
+        # gemma_chat = GemmaMLXChatCompletion(model_name="mlx-community/gemma-3-12b-it-4bit-DWQ")
+        # 或者，如果您有更小、更快的模型，可以尝试使用，例如："mlx-community/gemma-2b-it-8bit"
+        if model_name.startswith("mlx-community"):
+            gemma_chat = GemmaMLXChatCompletion(model_name=model_name)
+        elif model_name.startswith("microsoft"):
+            gemma_chat = Phi4TransformersChatCompletion(model_name=model_name, use_4bit_quantization=use_4bit_quantization)
+        else:
+            gemma_chat = GemmaTransformersChatCompletion(model_name=model_name, use_4bit_quantization=use_4bit_quantization)
+
+        print("\n--- 示例 1: 简单用户查询 ---")
+        messages_example1 = [
+            {"role": "user", "content": "你好，你是谁？"}
+        ]
+        response1 = gemma_chat.create(messages=messages_example1, max_tokens=50)
+        print("响应 1:")
+        print(f"  助手: {response1['choices'][0]['message']['content']}")
+        print(f"  用量: {response1['usage']}")
+
+        print("\n--- 示例 2: 带历史记录的对话 ---")
+        messages_example2 = [
+            {"role": "user", "content": "法国的首都是哪里？"},
+            {"role": "assistant", "content": "法国的首都是巴黎。"},
+            {"role": "user", "content": "你能告诉我一个关于它的有趣事实吗？"}
+        ]
+        response2 = gemma_chat.create(messages=messages_example2, max_tokens=100, temperature=0.8)
+        print("响应 2:")
+        print(f"  助手: {response2['choices'][0]['message']['content']}")
+        print(f"  用量: {response2['usage']}")
+        
+        print("\n--- 示例 3: 系统提示 (实验性，效果取决于模型微调) ---")
+        messages_example3 = [
+            {"role": "system", "content": "你是一位富有诗意的助手，擅长用富有创意的方式解释复杂的编程概念。"},
+            {"role": "user", "content": "解释一下编程中递归的概念。"}
+        ]
+        response3 = gemma_chat.create(messages=messages_example3, max_tokens=150)
+        print("响应 3:")
+        print(f"  助手: {response3['choices'][0]['message']['content']}")
+        print(f"  用量: {response3['usage']}")
+
+        print("\n--- 示例 4: 使用 max_tokens 强制缩短响应 ---")
+        messages_example4 = [
+            {"role": "user", "content": "给我讲一个关于勇敢骑士的很长的故事。"}
+        ]
+        response4 = gemma_chat.create(messages=messages_example4, max_tokens=20) # 非常短
+        print("响应 4:")
+        print(f"  助手: {response4['choices'][0]['message']['content']}")
+        print(f"  用量: {response4['usage']}")
+        if response4['usage']['completion_tokens'] >= 20:
+             print("  注意：由于 max_tokens，补全可能已被截断。")
+
+
+    except Exception as e:
+        print(f"示例用法期间发生错误: {e}")
+        import traceback
+        traceback.print_exc()

examples/simple_rss_parser.py

@@ -0,0 +1,40 @@
+
+# 添加项目根目录到Python路径
+import sys
+from pathlib import Path
+
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from src.podcast_transcribe.rss.podcast_rss_parser import parse_podcast_rss
+
+if __name__ == '__main__':
+    # 使用示例:
+    lex_fridman_rss = "https://feeds.buzzsprout.com/2460059.rss"
+    print(f"正在解析 Lex Fridman Podcast RSS: {lex_fridman_rss}")
+    podcast_data = parse_podcast_rss(lex_fridman_rss)
+
+    if podcast_data:
+        print(f"Podcast Title: {podcast_data.title}")
+        print(f"Podcast Link: {podcast_data.link}")
+        print(f"Podcast Description: {podcast_data.description[:200] if podcast_data.description else 'N/A'}...")
+        print(f"Podcast Author: {podcast_data.author}")
+        print(f"Podcast Image URL: {podcast_data.image_url}")
+        print(f"Total episodes found: {len(podcast_data.episodes)}")
+
+        if podcast_data.episodes:
+            print("\n--- Sample Episode ---")
+            sample_episode = podcast_data.episodes[0]
+            print(f"  标题: {sample_episode.title}")
+            print(f"  发布日期: {sample_episode.published_date}")
+            print(f"  链接: {sample_episode.link}")
+            print(f"  音频 URL: {sample_episode.audio_url}")
+            print(f"  GUID: {sample_episode.guid}")
+            print(f"  时长: {sample_episode.duration}")
+            print(f"  季: {sample_episode.season}")
+            print(f"  集数: {sample_episode.episode_number}")
+            print(f"  剧集类型: {sample_episode.episode_type}")
+            print(f"  摘要: {sample_episode.summary[:200] if sample_episode.summary else 'N/A'}...")
+            print(f"  Shownotes (前 300 字符): {sample_episode.shownotes[:300] if sample_episode.shownotes else 'N/A'}...")
+    else:
+        print("解析播客 RSS feed 失败。")

examples/simple_speaker_identify.py

@@ -0,0 +1,68 @@
+# 添加项目根目录到Python路径
+import json
+import sys
+from pathlib import Path
+import os
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from src.podcast_transcribe.rss.podcast_rss_parser import parse_rss_xml_content
+from src.podcast_transcribe.schemas import EnhancedSegment, CombinedTranscriptionResult
+from src.podcast_transcribe.summary.speaker_identify import SpeakerIdentifier
+
+if __name__ == '__main__':
+    transcribe_result_dump_file = Path.joinpath(Path(__file__).parent, "output", "lex_ai_john_carmack_1.transcription.json")
+    podcast_rss_xml_file = Path.joinpath(Path(__file__).parent, "input", "lexfridman.com.rss.xml")
+
+    # Load the transcription result
+    if not os.path.exists(transcribe_result_dump_file):
+        print(f"错误：转录结果文件 '{transcribe_result_dump_file}' 不存在。请先运行 combined_transcription.py 生成结果。")
+        sys.exit(1)
+
+    with open(transcribe_result_dump_file, "r", encoding="utf-8") as f:
+        # transcription_result = json.load(f) # 旧代码
+        data = json.load(f)
+        segments_data = data.get("segments", [])
+        # 确保 segments_data 中的每个元素都是字典，以避免在 EnhancedSegment(**seg) 时出错
+        # 假设 EnhancedSegment 的字段与 JSON 中 segment 字典的键完全对应
+        enhanced_segments = []
+        for seg_dict in segments_data:
+            if isinstance(seg_dict, dict):
+                enhanced_segments.append(EnhancedSegment(**seg_dict))
+            else:
+                # 处理非字典类型 segment 的情况，例如记录日志或抛出错误
+                print(f"警告: 在JSON中发现非字典类型的segment: {seg_dict}")
+        
+        transcription_result = CombinedTranscriptionResult(
+            segments=enhanced_segments,
+            text=data.get("text", ""),
+            language=data.get("language", ""),
+            num_speakers=data.get("num_speakers", 0)
+        )
+
+    # 打印加载的 CombinedTranscriptionResult 对象的一些信息以供验证
+    print(f"\\n成功从JSON加载 CombinedTranscriptionResult 对象:")
+    print(f"类型: {type(transcription_result)}")
+
+    # Load the podcast RSS XML file
+    with open(podcast_rss_xml_file, "r") as f:
+        podcast_rss_xml = f.read()
+        mock_podcast_info = parse_rss_xml_content(podcast_rss_xml)
+
+    
+    # 查找标题已 "#309" 开头的剧集
+    mock_episode_info = next((episode for episode in mock_podcast_info.episodes if episode.title.startswith("#309")), None)
+    if not mock_episode_info:
+        raise ValueError("Could not find episode with title starting with '#309'")
+    
+
+    speaker_identifier = SpeakerIdentifier(
+        llm_model_name="mlx-community/gemma-3-12b-it-4bit-DWQ",
+        llm_provider="gemma-mlx"
+    )
+
+    # 3. Call the function
+    print("\\n--- Test Case 1: Normal execution ---")
+    speaker_names = speaker_identifier.recognize_speaker_names(transcription_result.segments, mock_podcast_info, mock_episode_info)
+    print("\\nRecognized Speaker Names (Test Case 1):")
+    print(json.dumps(speaker_names, ensure_ascii=False, indent=2))

requirements.txt

@@ -0,0 +1,21 @@
+pydub>=0.25.1
+numpy>=2.2.5
+pyannote.audio>=3.3.2
+transformers>=4.51.3
+torch>=2.7.0
+torchaudio>=2.7.0
+soundfile>=0.13.1
+feedparser>=6.0.11
+requests>=2.32.3
+gradio>=5.30.0
+
+# 可选依赖 - whisper.cpp 绑定
+pywhispercpp>=1.3.0
+bitsandbytes>=0.42.0
+accelerate>=1.6.0
+
+# MLX特定依赖 - 仅适用于Apple Silicon Mac
+# mlx>=0.25.2
+# mlx-lm>=0.24.0
+# parakeet-mlx=0.2.6
+# mlx-whisper=0.4.2

src/podcast_transcribe/__init__.py

@@ -0,0 +1,8 @@
+import logging
+
+# 设置根日志级别为INFO，这样第三方包默认使用INFO级别
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+
+# 单独设置podcast_transcribe包的日志级别
+package_logger = logging.getLogger("podcast_transcribe")
+package_logger.setLevel(logging.INFO)

src/podcast_transcribe/asr/asr_base.py

@@ -0,0 +1,277 @@
+"""
+语音识别模块基类
+"""
+
+import os
+import numpy as np
+from pydub import AudioSegment
+from typing import Dict, List, Union, Optional, Tuple
+# from dataclasses import dataclass # dataclass is now imported from schemas if needed or already there
+import logging
+
+from ..schemas import TranscriptionResult # Added import
+
+# 配置日志
+logger = logging.getLogger("asr")
+
+
+class BaseTranscriber:
+    """统一的语音识别基类，支持MLX和Transformers等多种框架"""
+    
+    def __init__(
+        self, 
+        model_name: str,
+        device: str = None,
+    ):
+        """
+        初始化转录器
+        
+        参数:
+            model_name: 模型名称
+            device: 推理设备，'cpu'或'cuda'，对于MLX框架此参数可忽略
+        """
+        self.model_name = model_name
+        self.device = device
+        self.pipeline = None  # 用于Transformers
+        self.model = None     # 用于MLX等其他框架
+                
+        logger.info(f"初始化转录器，模型: {model_name}" + (f"，设备: {device}" if device else ""))
+        
+        # 子类需要实现_load_model方法
+        self._load_model()
+        
+    def _load_model(self):
+        """
+        加载模型（需要在子类中实现）
+        """
+        raise NotImplementedError("子类必须实现_load_model方法")
+    
+    def _prepare_audio(self, audio: AudioSegment) -> AudioSegment:
+        """
+        准备音频数据
+        
+        参数:
+            audio: 输入的AudioSegment对象
+            
+        返回:
+            处理后的AudioSegment对象
+        """
+        logger.debug(f"准备音频数据: 时长={len(audio)/1000:.2f}秒, 采样率={audio.frame_rate}Hz, 声道数={audio.channels}")
+        
+        # 确保采样率为16kHz
+        if audio.frame_rate != 16000:
+            logger.debug(f"重采样音频从 {audio.frame_rate}Hz 到 16000Hz")
+            audio = audio.set_frame_rate(16000)
+            
+        # 确保是单声道
+        if audio.channels > 1:
+            logger.debug(f"将{audio.channels}声道音频转换为单声道")
+            audio = audio.set_channels(1)
+            
+        logger.debug(f"音频处理完成")
+        
+        return audio
+    
+    def _detect_language(self, text: str) -> str:
+        """
+        简单的语言检测（基于经验规则）
+        
+        参数:
+            text: 识别出的文本
+            
+        返回:
+            检测到的语言代码
+        """
+        # 简单的规则检测，实际应用中应使用更准确的语言检测
+        chinese_chars = len([c for c in text if '\u4e00' <= c <= '\u9fff'])
+        chinese_ratio = chinese_chars / len(text) if text else 0
+        logger.debug(f"语言检测: 中文字符比例 = {chinese_ratio:.2f}")
+        
+        if chinese_chars > len(text) * 0.3:
+            return "zh"
+        return "en"
+    
+    def _convert_segments(self, model_result) -> List[Dict[str, Union[float, str]]]:
+        """
+        将模型的分段结果转换为所需格式（需要在子类中实现）
+        
+        参数:
+            model_result: 模型返回的结果
+            
+        返回:
+            转换后的分段列表
+        """
+        raise NotImplementedError("子类必须实现_convert_segments方法")
+    
+    def transcribe(self, audio: AudioSegment, chunk_duration_s: int = 30, overlap_s: int = 5) -> TranscriptionResult:
+        """
+        转录音频，支持长音频分块处理。
+        
+        参数:
+            audio: 要转录的AudioSegment对象
+            chunk_duration_s: 分块处理的块时长（秒）。如果音频短于此，则不分块。
+            overlap_s: 分块间的重叠时长（秒）。
+            
+        返回:
+            TranscriptionResult对象，包含转录结果
+        """
+        logger.info(f"开始转录 {len(audio)/1000:.2f} 秒的音频。分块设置: 块时长={chunk_duration_s}s, 重叠={overlap_s}s")
+
+        if overlap_s >= chunk_duration_s and len(audio)/1000.0 > chunk_duration_s :
+            logger.error("重叠时长必须小于块时长。")
+            raise ValueError("overlap_s 必须小于 chunk_duration_s。")
+
+        total_duration_ms = len(audio)
+        chunk_duration_ms = chunk_duration_s * 1000
+        overlap_ms = overlap_s * 1000
+
+        if total_duration_ms <= chunk_duration_ms:
+            logger.debug("音频时长不大于设定块时长，直接进行完整转录。")
+            processed_audio = self._prepare_audio(audio)
+            samples = np.array(processed_audio.get_array_of_samples(), dtype=np.float32) / 32768.0
+            
+            try:
+                model_result = self._perform_transcription(samples)
+                text = self._get_text_from_result(model_result)
+                segments = self._convert_segments(model_result)
+                language = self._detect_language(text)
+                
+                logger.info(f"单块转录完成，语言: {language}，文本长度: {len(text)}，分段数: {len(segments)}")
+                return TranscriptionResult(text=text, segments=segments, language=language)
+            except Exception as e:
+                logger.error(f"单块转录失败: {str(e)}", exc_info=True)
+                raise RuntimeError(f"单块转录失败: {str(e)}")
+
+        # 长音频分块处理
+        final_segments = []
+        # current_pos_ms 指的是当前块要处理的"新内容"的起始点在原始音频中的位置
+        current_pos_ms = 0 
+
+        while current_pos_ms < total_duration_ms:
+            # 计算当前块实际送入模型处理的音频的起始和结束时间点
+            # 对于第一个块，start_process_ms = 0
+            # 对于后续块，start_process_ms 会向左回退 overlap_ms 以包含重叠区域
+            start_process_ms = max(0, current_pos_ms - overlap_ms)
+            end_process_ms = min(start_process_ms + chunk_duration_ms, total_duration_ms)
+
+            # 如果计算出的块起始点已经等于或超过总时长，说明处理完毕
+            if start_process_ms >= total_duration_ms:
+                break
+            
+            chunk_audio = audio[start_process_ms:end_process_ms]
+            
+            logger.info(f"处理音频块: {start_process_ms/1000.0:.2f}s - {end_process_ms/1000.0:.2f}s (新内容起始于: {current_pos_ms/1000.0:.2f}s)")
+
+            if len(chunk_audio) == 0:
+                logger.warning(f"生成了一个空的音频块，跳过。起始: {start_process_ms/1000.0:.2f}s, 结束: {end_process_ms/1000.0:.2f}s")
+                # 必须推进 current_pos_ms 以避免死循环
+                advance_ms = chunk_duration_ms - overlap_ms
+                if advance_ms <= 0: # 应该在函数开始时已检查 overlap_s < chunk_duration_s
+                    raise RuntimeError("块推进时长配置错误，可能导致死循环。")
+                current_pos_ms += advance_ms
+                continue
+
+            processed_chunk_audio = self._prepare_audio(chunk_audio)
+            samples = np.array(processed_chunk_audio.get_array_of_samples(), dtype=np.float32) / 32768.0
+            
+            try:
+                model_result = self._perform_transcription(samples)
+                segments_chunk = self._convert_segments(model_result)
+
+                for seg in segments_chunk:
+                    # seg["start"] 和 seg["end"] 是相对于当前块 (chunk_audio) 的起始点（即0）
+                    # 计算 segment 在原始完整音频中的绝对起止时间
+                    global_seg_start_s = start_process_ms / 1000.0 + seg["start"]
+                    global_seg_end_s = start_process_ms / 1000.0 + seg["end"]
+                    
+                    # 核心去重逻辑：
+                    # 我们只接受那些真实开始于 current_pos_ms / 1000.0 之后的 segment。
+                    # current_pos_ms 是当前块应该贡献的"新"内容的开始时间。
+                    # 对于第一个块 (current_pos_ms == 0)，所有 segment 都被接受（只要它们的 start >= 0）。
+                    # 对于后续块，只有当 segment 的全局开始时间 >= 当前块新内容的开始时间时，才添加。
+                    if global_seg_start_s >= current_pos_ms / 1000.0:
+                        final_segments.append({
+                            "start": global_seg_start_s,
+                            "end": global_seg_end_s,
+                            "text": seg["text"]
+                        })
+                    # 特殊处理第一个块，因为 current_pos_ms 为 0，上面的条件 global_seg_start_s >= 0 总是满足。
+                    # 但为了更清晰，如果不是第一个块，但 segment 跨越了 current_pos_ms,
+                    # 它的起始部分在重叠区，结束部分在非重叠区。
+                    # 当前逻辑是，如果它的 global_seg_start_s < current_pos_ms / 1000.0，它就被丢弃。
+                    # 这是为了确保不重复记录重叠区域的开头部分。
+                    # 如果一个 segment 完全在重叠区内且在前一个块已被记录，此逻辑可避免重复。
+
+            except Exception as e:
+                logger.error(f"处理音频块 {start_process_ms/1000.0:.2f}s - {end_process_ms/1000.0:.2f}s 失败: {str(e)}", exc_info=True)
+            
+            # 更新下一个"新内容"块的起始位置
+            advance_ms = chunk_duration_ms - overlap_ms
+            current_pos_ms += advance_ms
+        
+        # 对收集到的所有 segments 按开始时间排序
+        final_segments.sort(key=lambda s: s["start"])
+
+        # 可选：进一步清理 segments，例如合并非常接近且文本连续的，或移除完全重复的
+        cleaned_segments = []
+        if final_segments:
+            cleaned_segments.append(final_segments[0])
+            for i in range(1, len(final_segments)):
+                prev_s = cleaned_segments[-1]
+                curr_s = final_segments[i]
+                # 简单的去重：如果时间戳和文本都几乎一样，则认为是重复
+                if abs(curr_s["start"] - prev_s["start"]) < 0.01 and \
+                   abs(curr_s["end"] - prev_s["end"]) < 0.01 and \
+                   curr_s["text"] == prev_s["text"]:
+                    continue
+                
+                # 如果当前 segment 的开始时间在前一个 segment 的结束时间之前，
+                # 并且文本有明显重叠，可能需要更智能的合并。
+                # 目前的逻辑通过 global_seg_start_s >= current_pos_ms / 1000.0 过滤，
+                # 已经大大减少了直接的 segment 重复。
+                # 此处的清理更多是处理模型在边界可能产生的一些微小偏差。
+                # 如果上一个segment的结束时间比当前segment的开始时间还要晚，说明有重叠，
+                # 且上一个segment包含了当前segment的开始部分。
+                # 这种情况下，可以考虑调整上一个的结束，或当前segment的开始和文本。
+                # 为简单起见，暂时直接添加，相信之前的过滤已处理主要重叠。
+                if curr_s["start"] < prev_s["end"] and prev_s["text"].endswith(curr_s["text"][:len(prev_s["text"]) - int((prev_s["end"] - curr_s["start"])*10) ]): # 粗略检查
+                     # 如果curr_s的开始部分被prev_s覆盖，并且文本也对应，则调整curr_s
+                     # pass # 暂时不处理这种细微重叠，依赖模型切分
+                     cleaned_segments.append(curr_s) # 仍添加，依赖后续文本拼接
+                else:
+                    cleaned_segments.append(curr_s)
+        
+        final_text = " ".join([s["text"] for s in cleaned_segments]).strip()
+        language = self._detect_language(final_text)
+        
+        logger.info(f"分块转录完成。最终文本长度: {len(final_text)}, 分段数: {len(cleaned_segments)}")
+        
+        return TranscriptionResult(
+            text=final_text,
+            segments=cleaned_segments,
+            language=language
+        )
+            
+    def _perform_transcription(self, audio_data):
+        """
+        执行转录（需要在子类中实现）
+        
+        参数:
+            audio_data: 音频数据（numpy数组）
+            
+        返回:
+            模型的转录结果
+        """
+        raise NotImplementedError("子类必须实现_perform_transcription方法")
+    
+    def _get_text_from_result(self, result):
+        """
+        从结果中获取文本（需要在子类中实现）
+        
+        参数:
+            result: 模型的转录结果
+            
+        返回:
+            转录的文本
+        """
+        raise NotImplementedError("子类必须实现_get_text_from_result方法") 

src/podcast_transcribe/asr/asr_distil_whisper_mlx.py

@@ -0,0 +1,112 @@
+"""
+基于MLX实现的语音识别模块，使用distil-whisper-large-v3模型
+"""
+
+import os
+from pydub import AudioSegment
+from typing import Dict, List, Union
+import logging
+import numpy as np
+import mlx_whisper
+
+# 导入基类
+from .asr_base import BaseTranscriber, TranscriptionResult
+
+# 配置日志
+logger = logging.getLogger("asr")
+
+
+class MLXDistilWhisperTranscriber(BaseTranscriber):
+    """使用MLX加载和运行distil-whisper-large-v3模型的转录器"""
+    
+    def __init__(
+        self, 
+        model_name: str = "mlx-community/distil-whisper-large-v3",
+    ):
+        """
+        初始化转录器
+        
+        参数:
+            model_name: 模型名称
+        """
+        super().__init__(model_name=model_name)
+        
+    def _load_model(self):
+        """加载Distil Whisper模型"""
+        try:
+            # 懒加载mlx-whisper
+            try:
+                import mlx_whisper
+            except ImportError:
+                raise ImportError("请先安装mlx-whisper库: pip install mlx-whisper")
+                
+            logger.info(f"开始加载模型 {self.model_name}")
+            self.model = mlx_whisper.load_models.load_model(self.model_name)
+            logger.info(f"模型加载成功")
+        except Exception as e:
+            logger.error(f"加载模型失败: {str(e)}", exc_info=True)
+            raise RuntimeError(f"加载模型失败: {str(e)}")
+    
+    def _convert_segments(self, result) -> List[Dict[str, Union[float, str]]]:
+        """
+        将模型的分段结果转换为所需格式
+        
+        参数:
+            result: 模型返回的结果
+            
+        返回:
+            转换后的分段列表
+        """
+        segments = []
+        
+        for segment in result.get("segments", []):
+            segments.append({
+                "start": segment.get("start", 0.0),
+                "end": segment.get("end", 0.0),
+                "text": segment.get("text", "").strip()
+            })
+        
+        return segments
+    
+    def _perform_transcription(self, audio_data):
+        """
+        执行转录
+        
+        参数:
+            audio_data: 音频数据（numpy数组）
+            
+        返回:
+            模型的转录结果
+        """
+        return mlx_whisper.transcribe(audio_data, path_or_hf_repo=self.model_name)
+    
+    def _get_text_from_result(self, result):
+        """
+        从结果中获取文本
+        
+        参数:
+            result: 模型的转录结果
+            
+        返回:
+            转录的文本
+        """
+        return result.get("text", "")
+
+
+def transcribe_audio(
+    audio_segment: AudioSegment,
+    model_name: str = "mlx-community/distil-whisper-large-v3",
+) -> TranscriptionResult:
+    """
+    使用MLX和distil-whisper-large-v3模型转录音频
+    
+    参数:
+        audio_segment: 输入的AudioSegment对象
+        model_name: 使用的模型名称
+        
+    返回:
+        TranscriptionResult对象，包含转录的文本、分段和语言
+    """
+    logger.info(f"调用transcribe_audio函数，音频长度: {len(audio_segment)/1000:.2f}秒")
+    transcriber = MLXDistilWhisperTranscriber(model_name=model_name)
+    return transcriber.transcribe(audio_segment)

src/podcast_transcribe/asr/asr_distil_whisper_transformers.py

@@ -0,0 +1,133 @@
+"""
+基于Transformers实现的语音识别模块，使用distil-whisper-large-v3.5模型
+"""
+
+import os
+from pydub import AudioSegment
+from typing import Dict, List, Union
+import logging
+import numpy as np
+
+# 导入基类
+from .asr_base import BaseTranscriber, TranscriptionResult
+
+# 配置日志
+logger = logging.getLogger("asr")
+
+
+class TransformersDistilWhisperTranscriber(BaseTranscriber):
+    """使用Transformers加载和运行distil-whisper-large-v3.5模型的转录器"""
+    
+    def __init__(
+        self, 
+        model_name: str = "distil-whisper/distil-large-v3.5",
+        device: str = "cpu",
+    ):
+        """
+        初始化转录器
+        
+        参数:
+            model_name: 模型名称
+            device: 推理设备，'cpu'或'cuda'
+        """
+        super().__init__(model_name=model_name, device=device)
+        
+    def _load_model(self):
+        """加载Distil Whisper模型"""
+        try:
+            # 懒加载transformers
+            try:
+                from transformers import pipeline
+            except ImportError:
+                raise ImportError("请先安装transformers库: pip install transformers")
+                
+            logger.info(f"开始加载模型 {self.model_name}")
+            self.pipeline = pipeline(
+                "automatic-speech-recognition",
+                model=self.model_name,
+                device=0 if self.device == "cuda" else -1,
+                return_timestamps=True,
+                chunk_length_s=30,
+                batch_size=16,
+            )
+            logger.info(f"模型加载成功")
+        except Exception as e:
+            logger.error(f"加载模型失败: {str(e)}", exc_info=True)
+            raise RuntimeError(f"加载模型失败: {str(e)}")
+    
+    def _convert_segments(self, result) -> List[Dict[str, Union[float, str]]]:
+        """
+        将模型的分段结果转换为所需格式
+        
+        参数:
+            result: 模型返回的结果
+            
+        返回:
+            转换后的分段列表
+        """
+        segments = []
+        
+        # transformers pipeline 的结果格式
+        if "chunks" in result:
+            for chunk in result["chunks"]:
+                segments.append({
+                    "start": chunk["timestamp"][0] if chunk["timestamp"][0] is not None else 0.0,
+                    "end": chunk["timestamp"][1] if chunk["timestamp"][1] is not None else 0.0,
+                    "text": chunk["text"].strip()
+                })
+        else:
+            # 如果没有分段信息，创建一个单一分段
+            segments.append({
+                "start": 0.0,
+                "end": 0.0,  # 无法确定结束时间
+                "text": result.get("text", "").strip()
+            })
+        
+        return segments
+    
+    def _perform_transcription(self, audio_data):
+        """
+        执行转录
+        
+        参数:
+            audio_data: 音频数据（numpy数组）
+            
+        返回:
+            模型的转录结果
+        """
+        # transformers pipeline 接受numpy数组作为输入
+        # 音频数据已经在_prepare_audio中确保是16kHz采样率
+        return self.pipeline(audio_data)
+    
+    def _get_text_from_result(self, result):
+        """
+        从结果中获取文本
+        
+        参数:
+            result: 模型的转录结果
+            
+        返回:
+            转录的文本
+        """
+        return result.get("text", "")
+
+
+def transcribe_audio(
+    audio_segment: AudioSegment,
+    model_name: str = "distil-whisper/distil-large-v3.5",
+    device: str = "cpu",
+) -> TranscriptionResult:
+    """
+    使用Transformers和distil-whisper-large-v3.5模型转录音频
+    
+    参数:
+        audio_segment: 输入的AudioSegment对象
+        model_name: 使用的模型名称
+        device: 推理设备，'cpu'或'cuda'
+        
+    返回:
+        TranscriptionResult对象，包含转录的文本、分段和语言
+    """
+    logger.info(f"调用transcribe_audio函数，音频长度: {len(audio_segment)/1000:.2f}秒")
+    transcriber = TransformersDistilWhisperTranscriber(model_name=model_name, device=device)
+    return transcriber.transcribe(audio_segment)

src/podcast_transcribe/asr/asr_parakeet_mlx.py

@@ -0,0 +1,126 @@
+"""
+基于MLX实现的语音识别模块，使用parakeet-tdt模型
+"""
+
+import os
+from pydub import AudioSegment
+from typing import Dict, List, Union
+import logging
+import tempfile
+import numpy as np
+import soundfile as sf
+
+# 导入基类
+from .asr_base import BaseTranscriber, TranscriptionResult
+
+# 配置日志
+logger = logging.getLogger("asr")
+
+
+class MLXParakeetTranscriber(BaseTranscriber):
+    """使用MLX加载和运行parakeet-tdt-0.6b-v2模型的转录器"""
+    
+    def __init__(
+        self, 
+        model_name: str = "mlx-community/parakeet-tdt-0.6b-v2",
+    ):
+        """
+        初始化转录器
+        
+        参数:
+            model_name: 模型名称
+        """
+        super().__init__(model_name=model_name)
+    
+    def _load_model(self):
+        """加载Parakeet模型"""
+        try:
+            # 懒加载parakeet_mlx
+            try:
+                from parakeet_mlx import from_pretrained
+            except ImportError:
+                raise ImportError("请先安装parakeet-mlx库: pip install parakeet-mlx")
+                
+            logger.info(f"开始加载模型 {self.model_name}")
+            self.model = from_pretrained(self.model_name)
+            logger.info(f"模型加载成功")
+        except Exception as e:
+            logger.error(f"加载模型失败: {str(e)}", exc_info=True)
+            raise RuntimeError(f"加载模型失败: {str(e)}")
+    
+    def _convert_segments(self, aligned_result) -> List[Dict[str, Union[float, str]]]:
+        """
+        将模型的分段结果转换为所需格式
+        
+        参数:
+            aligned_result: 模型返回的分段结果
+            
+        返回:
+            转换后的分段列表
+        """
+        segments = []
+        
+        for sentence in aligned_result.sentences:
+            segments.append({
+                "start": sentence.start,
+                "end": sentence.end,
+                "text": sentence.text
+            })
+        
+        return segments
+    
+    def _perform_transcription(self, audio_data):
+        """
+        执行转录
+        
+        参数:
+            audio_data: 音频数据（numpy数组）
+            
+        返回:
+            模型的转录结果
+        """
+        # 由于parakeet-mlx可能不直接支持numpy数组输入
+        # 创建临时文件并写入音频数据
+        with tempfile.NamedTemporaryFile(suffix='.wav', delete=True) as temp_file:
+            # 确保数据在[-1, 1]范围内
+            if audio_data.max() > 1.0 or audio_data.min() < -1.0:
+                audio_data = np.clip(audio_data, -1.0, 1.0)
+            
+            # 写入临时文件
+            sf.write(temp_file.name, audio_data, 16000, 'PCM_16')
+            
+            # 使用临时文件进行转录
+            result = self.model.transcribe(temp_file.name)
+        
+        return result
+    
+    def _get_text_from_result(self, result):
+        """
+        从结果中获取文本
+        
+        参数:
+            result: 模型的转录结果
+            
+        返回:
+            转录的文本
+        """
+        return result.text
+
+
+def transcribe_audio(
+    audio_segment: AudioSegment,
+    model_name: str = "mlx-community/parakeet-tdt-0.6b-v2",
+) -> TranscriptionResult:
+    """
+    使用MLX和parakeet-tdt模型转录音频
+    
+    参数:
+        audio_segment: 输入的AudioSegment对象
+        model_name: 使用的模型名称
+        
+    返回:
+        TranscriptionResult对象，包含转录的文本、分段和语言
+    """
+    logger.info(f"调用transcribe_audio函数，音频长度: {len(audio_segment)/1000:.2f}秒")
+    transcriber = MLXParakeetTranscriber(model_name=model_name)
+    return transcriber.transcribe(audio_segment)

src/podcast_transcribe/asr/asr_router.py

@@ -0,0 +1,273 @@
+"""
+ASR模型调用路由器
+根据传递的provider参数调用不同的ASR实现，支持延迟加载
+"""
+
+import logging
+from typing import Dict, Any, Optional, Callable
+from pydub import AudioSegment
+from .asr_base import TranscriptionResult
+from . import asr_parakeet_mlx
+from . import asr_distil_whisper_mlx
+from . import asr_distil_whisper_transformers
+
+# 配置日志
+logger = logging.getLogger("asr")
+
+
+class ASRRouter:
+    """ASR模型调用路由器，支持多种ASR实现的统一调用"""
+    
+    def __init__(self):
+        """初始化路由器"""
+        self._loaded_modules = {}  # 用于缓存已加载的模块
+        self._transcribers = {}    # 用于缓存已实例化的转录器
+        
+        # 定义支持的provider配置
+        self._provider_configs = {
+            "parakeet_mlx": {
+                "module_path": "asr_parakeet_mlx",
+                "function_name": "transcribe_audio",
+                "default_model": "mlx-community/parakeet-tdt-0.6b-v2",
+                "supported_params": ["model_name"],
+                "description": "基于MLX的Parakeet模型"
+            },
+            "distil_whisper_mlx": {
+                "module_path": "asr_distil_whisper_mlx", 
+                "function_name": "transcribe_audio",
+                "default_model": "mlx-community/distil-whisper-large-v3",
+                "supported_params": ["model_name"],
+                "description": "基于MLX的Distil Whisper模型"
+            },
+            "distil_whisper_transformers": {
+                "module_path": "asr_distil_whisper_transformers",
+                "function_name": "transcribe_audio", 
+                "default_model": "distil-whisper/distil-large-v3.5",
+                "supported_params": ["model_name", "device"],
+                "description": "基于Transformers的Distil Whisper模型"
+            }
+        }
+    
+    def _lazy_load_module(self, provider: str):
+        """
+        获取指定provider的模块
+        
+        参数:
+            provider: provider名称
+            
+        返回:
+            对应的模块
+        """
+        if provider not in self._provider_configs:
+            raise ValueError(f"不支持的provider: {provider}")
+            
+        if provider not in self._loaded_modules:
+            module_path = self._provider_configs[provider]["module_path"]
+            logger.info(f"获取模块: {module_path}")
+            
+            # 根据module_path返回对应的模块
+            if module_path == "asr_parakeet_mlx":
+                module = asr_parakeet_mlx
+            elif module_path == "asr_distil_whisper_mlx":
+                module = asr_distil_whisper_mlx
+            elif module_path == "asr_distil_whisper_transformers":
+                module = asr_distil_whisper_transformers
+            else:
+                raise ImportError(f"未找到模块: {module_path}")
+            
+            self._loaded_modules[provider] = module
+            logger.info(f"模块 {module_path} 获取成功")
+        
+        return self._loaded_modules[provider]
+    
+    def _get_transcribe_function(self, provider: str) -> Callable:
+        """
+        获取指定provider的转录函数
+        
+        参数:
+            provider: provider名称
+            
+        返回:
+            转录函数
+        """
+        module = self._lazy_load_module(provider)
+        function_name = self._provider_configs[provider]["function_name"]
+        
+        if not hasattr(module, function_name):
+            raise AttributeError(f"模块中未找到函数: {function_name}")
+            
+        return getattr(module, function_name)
+    
+    def _filter_params(self, provider: str, params: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        过滤参数，只保留指定provider支持的参数
+        
+        参数:
+            provider: provider名称
+            params: 原始参数字典
+            
+        返回:
+            过滤后的参数字典
+        """
+        supported_params = self._provider_configs[provider]["supported_params"]
+        filtered_params = {}
+        
+        for param in supported_params:
+            if param in params:
+                filtered_params[param] = params[param]
+        
+        # 如果没有指定model_name，使用默认模型
+        if "model_name" not in filtered_params and "model_name" in supported_params:
+            filtered_params["model_name"] = self._provider_configs[provider]["default_model"]
+        
+        return filtered_params
+    
+    def transcribe(
+        self,
+        audio_segment: AudioSegment,
+        provider: str,
+        **kwargs
+    ) -> TranscriptionResult:
+        """
+        统一的音频转录接口
+        
+        参数:
+            audio_segment: 输入的AudioSegment对象
+            provider: ASR提供者名称
+            **kwargs: 其他参数，如model_name, device等
+            
+        返回:
+            TranscriptionResult��象
+        """
+        logger.info(f"使用provider '{provider}' 进行音频转录，音频长度: {len(audio_segment)/1000:.2f}秒")
+        
+        if provider not in self._provider_configs:
+            available_providers = list(self._provider_configs.keys())
+            raise ValueError(f"不支持的provider: {provider}。支持的provider: {available_providers}")
+        
+        try:
+            # 获取转录函数
+            transcribe_func = self._get_transcribe_function(provider)
+            
+            # 过滤并准备参数
+            filtered_kwargs = self._filter_params(provider, kwargs)
+            
+            logger.debug(f"调用 {provider} 转录函数，参数: {filtered_kwargs}")
+            
+            # 执行转录
+            result = transcribe_func(audio_segment, **filtered_kwargs)
+            
+            logger.info(f"转录完成，文本长度: {len(result.text)}字符")
+            return result
+            
+        except Exception as e:
+            logger.error(f"使用provider '{provider}' 转录音频失败: {str(e)}", exc_info=True)
+            raise RuntimeError(f"转录失败: {str(e)}")
+    
+    def get_available_providers(self) -> Dict[str, str]:
+        """
+        获取所有可用的provider及其描述
+        
+        返回:
+            provider名称到描述的映射
+        """
+        return {
+            provider: config["description"] 
+            for provider, config in self._provider_configs.items()
+        }
+    
+    def get_provider_info(self, provider: str) -> Dict[str, Any]:
+        """
+        获取指定provider的详细信息
+        
+        参数:
+            provider: provider名称
+            
+        返回:
+            provider的配置信息
+        """
+        if provider not in self._provider_configs:
+            raise ValueError(f"不支持的provider: {provider}")
+            
+        return self._provider_configs[provider].copy()
+
+
+# 创建全局路由器实例
+_router = ASRRouter()
+
+
+def transcribe_audio(
+    audio_segment: AudioSegment,
+    provider: str = "distil_whisper_transformers",
+    model_name: Optional[str] = None,
+    device: str = "cpu",
+    **kwargs
+) -> TranscriptionResult:
+    """
+    统一的音频转录接口函数
+    
+    参数:
+        audio_segment: 输入的AudioSegment对象
+        provider: ASR提供者，可选值：
+            - "parakeet_mlx": 基于MLX的Parakeet模型
+            - "distil_whisper_mlx": 基于MLX的Distil Whisper模型  
+            - "distil_whisper_transformers": 基于Transformers的Distil Whisper模型
+        model_name: 模型名称，如果不指定则使用默认模型
+        device: 推理设备，仅对transformers provider有效
+        **kwargs: 其他参数
+        
+    返回:
+        TranscriptionResult对象，包含转录的文本、分段和语言
+        
+    示例:
+        # 使用默认MLX Distil Whisper模型
+        result = transcribe_audio(audio_segment, provider="distil_whisper_mlx")
+        
+        # 使用Parakeet模型
+        result = transcribe_audio(audio_segment, provider="parakeet_mlx")
+        
+        # 使用Transformers模型并指定设备
+        result = transcribe_audio(
+            audio_segment, 
+            provider="distil_whisper_transformers",
+            device="cuda"
+        )
+        
+        # 使用自定义模型
+        result = transcribe_audio(
+            audio_segment,
+            provider="distil_whisper_mlx", 
+            model_name="mlx-community/whisper-large-v3"
+        )
+    """
+    # 准备参数
+    params = kwargs.copy()
+    if model_name is not None:
+        params["model_name"] = model_name
+    if device != "cpu":
+        params["device"] = device
+    
+    return _router.transcribe(audio_segment, provider, **params)
+
+
+def get_available_providers() -> Dict[str, str]:
+    """
+    获取所有可用的ASR提供者
+    
+    返回:
+        provider名称到描述的映射
+    """
+    return _router.get_available_providers()
+
+
+def get_provider_info(provider: str) -> Dict[str, Any]:
+    """
+    获取指定provider的详细信息
+    
+    参数:
+        provider: provider名称
+        
+    返回:
+        provider的配置信息
+    """
+    return _router.get_provider_info(provider)

src/podcast_transcribe/audio.py

@@ -0,0 +1,62 @@
+"""
+音频处理工具模块
+"""
+
+import numpy as np
+from io import BytesIO
+from pydub import AudioSegment
+from typing import Tuple, Dict, Any
+
+
+def load_audio(audio_file: str, target_sample_rate: int = 16000, mono: bool = True) -> Tuple[AudioSegment, np.ndarray]:
+    """
+    加载音频文件并转换为目标采样率和通道数
+
+    参数:
+        audio_file: 音频文件路径
+        target_sample_rate: 目标采样率，默认16kHz
+        mono: 是否转换为单声道，默认True
+
+    返回:
+        AudioSegment对象和对应的numpy数组
+    """
+    try:
+        audio = AudioSegment.from_file(audio_file)
+        
+        # 转换为单声道（如果需要）
+        if mono and audio.channels > 1:
+            audio = audio.set_channels(1)
+            
+        # 转换采样率
+        if audio.frame_rate != target_sample_rate:
+            audio = audio.set_frame_rate(target_sample_rate)
+            
+        # 获取音频波形（用于pyannote）
+        waveform = np.array(audio.get_array_of_samples()).astype(np.float32) / 32768.0
+        
+        return audio, waveform
+        
+    except Exception as e:
+        raise RuntimeError(f"无法加载音频文件: {str(e)}")
+
+
+def extract_audio_segment(audio: AudioSegment, start_ms: int, end_ms: int) -> BytesIO:
+    """
+    从音频中提取指定时间段
+
+    参数:
+        audio: AudioSegment对象
+        start_ms: 开始时间（毫秒）
+        end_ms: 结束时间（毫秒）
+        
+    返回:
+        包含音频段的BytesIO对象
+    """
+    try:
+        sub_audio = audio[start_ms:end_ms]
+        fp = BytesIO()
+        sub_audio.export(fp, format="wav")
+        fp.seek(0)
+        return fp
+    except Exception as e:
+        raise RuntimeError(f"无法提取音频段: {str(e)}") 

src/podcast_transcribe/diarization/diarization_pyannote_mlx.py

@@ -0,0 +1,154 @@
+"""
+基于pyannote/speaker-diarization-3.1模型实现的说话人分离模块
+"""
+
+import os
+import numpy as np
+from pydub import AudioSegment
+from typing import Any, Dict, List, Mapping, Text, Union, Optional, Tuple
+import logging
+import torch
+
+from .diarizer_base import BaseDiarizer
+from ..schemas import DiarizationResult
+
+# 配置日志
+logger = logging.getLogger("diarization")
+
+class PyannoteTranscriber(BaseDiarizer):
+    """使用pyannote/speaker-diarization-3.1模型进行说话人分离"""
+    
+    def __init__(
+        self, 
+        model_name: str = "pyannote/speaker-diarization-3.1",
+        token: Optional[str] = None,
+        device: str = "cpu",
+        segmentation_batch_size: int = 32,
+    ):
+        """
+        初始化说话人分离器
+        
+        参数:
+            model_name: 模型名称
+            token: Hugging Face令牌，用于访问模型
+            device: 推理设备，'cpu'或'cuda'
+            segmentation_batch_size: 分割批处理大小，默认为32
+        """
+        super().__init__(model_name, token, device, segmentation_batch_size)
+        
+        # 加载模型
+        self._load_model()
+        
+    def _load_model(self):
+        """加载pyannote模型"""
+        try:
+            # 懒加载pyannote.audio
+            try:
+                from pyannote.audio import Pipeline
+            except ImportError:
+                raise ImportError("请先安装pyannote.audio库: pip install pyannote.audio")
+                
+            if not self.token:
+                raise ValueError("需要提供Hugging Face令牌才能使用pyannote模型。请通过参数传入或设置HF_TOKEN环境变量。")
+                
+            logger.info(f"开始加载模型 {self.model_name}")
+            self.pipeline = Pipeline.from_pretrained(
+                self.model_name,
+                use_auth_token=self.token
+            )
+            
+            # 设置设备
+            self.pipeline.to(torch.device(self.device))
+            
+            # 设置分割批处理大小
+            if hasattr(self.pipeline, "segmentation_batch_size"):
+                logger.info(f"设置分割批处理大小: {self.segmentation_batch_size}")
+                self.pipeline.segmentation_batch_size = self.segmentation_batch_size
+            
+            logger.info(f"模型加载成功")
+        except Exception as e:
+            logger.error(f"加载模型失败: {str(e)}", exc_info=True)
+            raise RuntimeError(f"加载模型失败: {str(e)}")
+    
+
+    
+    def diarize(self, audio: AudioSegment) -> DiarizationResult:
+        """
+        对音频进行说话人分离
+        
+        参数:
+            audio: 要处理的AudioSegment对象
+            
+        返回:
+            DiarizationResult对象，包含分段结果和说话人数量
+        """
+        logger.info(f"开始处理 {len(audio)/1000:.2f} 秒的音频进行说话人分离")
+        
+        # 准备音频输入
+        temp_audio_path = self._prepare_audio(audio)
+        
+        try:
+            # 执行说话人分离
+            logger.debug("开始执行说话人分离")
+            from pyannote.audio.pipelines.utils.hook import ProgressHook
+
+            # 自定义 ProgressHook 类
+            class CustomProgressHook(ProgressHook):
+                def __call__(
+                    self,
+                    step_name: Text,
+                    step_artifact: Any,
+                    file: Optional[Mapping] = None,
+                    total: Optional[int] = None,
+                    completed: Optional[int] = None,
+                ):
+                    if completed is not None:
+                        logger.info(f"处理中 {step_name}: ({completed/total*100:.1f}%)")
+                    else:
+                        logger.info(f"已完成 {step_name}")
+
+            with CustomProgressHook() as hook:
+                diarization = self.pipeline(temp_audio_path, hook=hook)
+
+            # 转换分段结果
+            segments, num_speakers = self._convert_segments(diarization)
+            
+            logger.info(f"说话人分离完成，检测到 {num_speakers} 个说话人，生成 {len(segments)} 个分段")
+            
+            return DiarizationResult(
+                segments=segments,
+                num_speakers=num_speakers
+            )
+            
+        except Exception as e:
+            logger.error(f"说话人分离失败: {str(e)}", exc_info=True)
+            raise RuntimeError(f"说话人分离失败: {str(e)}")
+        finally:
+            # 删除临时文件
+            if os.path.exists(temp_audio_path):
+                os.remove(temp_audio_path)
+
+
+def diarize_audio(
+    audio_segment: AudioSegment,
+    model_name: str = "pyannote/speaker-diarization-3.1",
+    token: Optional[str] = None,
+    device: str = "cpu",
+    segmentation_batch_size: int = 32,
+) -> DiarizationResult:
+    """
+    使用pyannote模型对音频进行说话人��离
+    
+    参数:
+        audio_segment: 输入的AudioSegment对象
+        model_name: 使用的模型名称
+        token: Hugging Face令牌
+        device: 推理设备，'cpu'、'cuda'、'mps'
+        segmentation_batch_size: 分割批处理大小，默认为32
+        
+    返回:
+        DiarizationResult对象，包含分段和说话人数量
+    """
+    logger.info(f"调用diarize_audio函数，音频长度: {len(audio_segment)/1000:.2f}秒")
+    transcriber = PyannoteTranscriber(model_name=model_name, token=token, device=device, segmentation_batch_size=segmentation_batch_size)
+    return transcriber.diarize(audio_segment)

src/podcast_transcribe/diarization/diarization_pyannote_transformers.py

@@ -0,0 +1,170 @@
+"""
+基于pyannote.audio库调用pyannote/speaker-diarization-3.1模型实现的说话人分离模块
+"""
+
+import os
+import numpy as np
+from pydub import AudioSegment
+from typing import Any, Dict, List, Mapping, Text, Union, Optional, Tuple
+import logging
+import torch
+
+from .diarizer_base import BaseDiarizer
+from ..schemas import DiarizationResult
+
+# 配置日志
+logger = logging.getLogger("diarization")
+
+
+class PyannoteTransformersTranscriber(BaseDiarizer):
+    """使用pyannote.audio库调用pyannote/speaker-diarization-3.1模型进行说话人分离"""
+    
+    def __init__(
+        self, 
+        model_name: str = "pyannote/speaker-diarization-3.1",
+        token: Optional[str] = None,
+        device: str = "cpu",
+        segmentation_batch_size: int = 32,
+    ):
+        """
+        初始化说话人分离器
+        
+        参数:
+            model_name: 模型名称
+            token: Hugging Face令牌，用于访问模型
+            device: 推理设备，'cpu'或'cuda'
+            segmentation_batch_size: 分割批处理大小，默认为32
+        """
+        super().__init__(model_name, token, device, segmentation_batch_size)
+        
+        # 加载模型
+        self._load_model()
+        
+    def _load_model(self):
+        """使用pyannote.audio加载模型"""
+        try:
+            # 检查依赖库
+            try:
+                from pyannote.audio import Pipeline
+            except ImportError:
+                raise ImportError("请先安装pyannote.audio库: pip install pyannote.audio")
+                
+            if not self.token:
+                raise ValueError("需要提供Hugging Face令牌才能使用pyannote模型。请通过参数传入或设置HF_TOKEN环境变量。")
+                
+            logger.info(f"开始使用pyannote.audio加载模型 {self.model_name}")
+            
+            # 使用pyannote.audio Pipeline加载说话人分离模型
+            self.pipeline = Pipeline.from_pretrained(
+                self.model_name,
+                use_auth_token=self.token
+            )
+            
+            # 设置设备
+            logger.info(f"将模型移动到设备: {self.device}")
+            self.pipeline.to(torch.device(self.device))
+            
+            # 设置分割批处理大小
+            if hasattr(self.pipeline, "segmentation_batch_size"):
+                logger.info(f"设置分割批处理大小: {self.segmentation_batch_size}")
+                self.pipeline.segmentation_batch_size = self.segmentation_batch_size
+            
+            logger.info(f"pyannote.audio模型加载成功")
+            
+        except Exception as e:
+            logger.error(f"加载模型失败: {str(e)}", exc_info=True)
+            raise RuntimeError(f"模型加载失败: {str(e)}")
+    
+    def diarize(self, audio: AudioSegment) -> DiarizationResult:
+        """
+        对音频进行说话人分离
+        
+        参数:
+            audio: 要处理的AudioSegment对象
+            
+        返回:
+            DiarizationResult对象，包含分段结果和说话人数量
+        """
+        logger.info(f"开始使用pyannote.audio处理 {len(audio)/1000:.2f} 秒的音频进行说话人分离")
+        
+        # 准备音频输入
+        temp_audio_path = self._prepare_audio(audio)
+        
+        try:
+            # 执行说话人分离
+            logger.debug("开始执行说话人分离")
+            
+            # 使用自定义 ProgressHook 来显示进度
+            try:
+                from pyannote.audio.pipelines.utils.hook import ProgressHook
+
+                class CustomProgressHook(ProgressHook):
+                    def __call__(
+                        self,
+                        step_name: Text,
+                        step_artifact: Any,
+                        file: Optional[Mapping] = None,
+                        total: Optional[int] = None,
+                        completed: Optional[int] = None,
+                    ):
+                        if completed is not None and total is not None:
+                            percentage = completed / total * 100
+                            logger.info(f"处理中 {step_name}: ({percentage:.1f}%)")
+                        else:
+                            logger.info(f"已完成 {step_name}")
+
+                with CustomProgressHook() as hook:
+                    diarization = self.pipeline(temp_audio_path, hook=hook)
+                    
+            except ImportError:
+                # 如果ProgressHook不可用，直接执行
+                logger.info("ProgressHook不可用，直接执行说话人分离")
+                diarization = self.pipeline(temp_audio_path)
+
+            # 转换分段结果
+            segments, num_speakers = self._convert_segments(diarization)
+            
+            logger.info(f"说话人分离完成，检测到 {num_speakers} 个说话人，生成 {len(segments)} 个分段")
+            
+            return DiarizationResult(
+                segments=segments,
+                num_speakers=num_speakers
+            )
+            
+        except Exception as e:
+            logger.error(f"说话人分离失败: {str(e)}", exc_info=True)
+            raise RuntimeError(f"说话人分离失败: {str(e)}")
+        finally:
+            # 删除临时文件
+            if os.path.exists(temp_audio_path):
+                os.remove(temp_audio_path)
+
+
+def diarize_audio(
+    audio_segment: AudioSegment,
+    model_name: str = "pyannote/speaker-diarization-3.1",
+    token: Optional[str] = None,
+    device: str = "cpu",
+    segmentation_batch_size: int = 32,
+) -> DiarizationResult:
+    """
+    使用pyannote.audio调用pyannote模型对音频进行说话人分离
+    
+    参数:
+        audio_segment: 输入的AudioSegment对象
+        model_name: 使用的模型名称
+        token: Hugging Face令牌
+        device: 推理设备，'cpu'、'cuda'、'mps'
+        segmentation_batch_size: 分割批处理大小，默认为32
+        
+    返回:
+        DiarizationResult对象，包含分段和说话人数量
+    """
+    logger.info(f"调用pyannote.audio版本diarize_audio函数，音频长度: {len(audio_segment)/1000:.2f}秒")
+    transcriber = PyannoteTransformersTranscriber(
+        model_name=model_name, 
+        token=token, 
+        device=device, 
+        segmentation_batch_size=segmentation_batch_size
+    )
+    return transcriber.diarize(audio_segment)

src/podcast_transcribe/diarization/diarizer_base.py

@@ -0,0 +1,118 @@
+"""
+说话人分离器基础类，包含可复用的方法
+"""
+
+import os
+import logging
+from abc import ABC, abstractmethod
+from pydub import AudioSegment
+from typing import Any, Dict, List, Union, Optional, Tuple
+
+from ..schemas import DiarizationResult
+
+# 配置日志
+logger = logging.getLogger("diarization")
+
+
+class BaseDiarizer(ABC):
+    """说话人分离器基础类"""
+    
+    def __init__(
+        self, 
+        model_name: str,
+        token: Optional[str] = None,
+        device: str = "cpu",
+        segmentation_batch_size: int = 32,
+    ):
+        """
+        初始化说话人分离器基础参数
+        
+        参数:
+            model_name: 模型名称
+            token: Hugging Face令牌，用于访问模型
+            device: 推理设备，'cpu'或'cuda'
+            segmentation_batch_size: 分割批处理大小，默认为32
+        """
+        self.model_name = model_name
+        self.token = token or os.environ.get("HF_TOKEN")
+        self.device = device
+        self.segmentation_batch_size = segmentation_batch_size
+        
+        logger.info(f"初始化说话人分离器，模型: {model_name}，设备: {device}，分割批处理大小: {segmentation_batch_size}")
+    
+    @abstractmethod
+    def _load_model(self):
+        """加载模型，子类需要实现"""
+        pass
+    
+    def _prepare_audio(self, audio: AudioSegment) -> str:
+        """
+        准备音频数据，保存为临时文件
+        
+        参数:
+            audio: 输入的AudioSegment对象
+            
+        返回:
+            临时音频文件的路径
+        """
+        logger.debug(f"准备音频数据: 时长={len(audio)/1000:.2f}秒, 采样率={audio.frame_rate}Hz, 声道数={audio.channels}")
+        
+        # 确保采样率为16kHz (pyannote模型要求)
+        if audio.frame_rate != 16000:
+            logger.debug(f"重采样音频从 {audio.frame_rate}Hz 到 16000Hz")
+            audio = audio.set_frame_rate(16000)
+            
+        # 确保是单声道
+        if audio.channels > 1:
+            logger.debug(f"将{audio.channels}声道音频转换为单声道")
+            audio = audio.set_channels(1)
+            
+        # 保存为临时文件
+        temp_audio_path = "_temp_audio_for_diarization.wav"
+        audio.export(temp_audio_path, format="wav")
+        
+        logger.debug(f"音频处理完成，保存至: {temp_audio_path}")
+        
+        return temp_audio_path
+    
+    def _convert_segments(self, diarization) -> Tuple[List[Dict[str, Union[float, str, int]]], int]:
+        """
+        将pyannote的分段结果转换为所需格式
+        
+        参数:
+            diarization: pyannote模型返回的分段结果
+            
+        返回:
+            转换后的分段列表和说话人数量
+        """
+        segments = []
+        speakers = set()
+        
+        # 遍历说话人分离结果
+        for turn, _, speaker in diarization.itertracks(yield_label=True):
+            segments.append({
+                "start": turn.start,
+                "end": turn.end,
+                "speaker": speaker
+            })
+            speakers.add(speaker)
+        
+        # 按开始时间排序
+        segments.sort(key=lambda x: x["start"])
+        
+        logger.debug(f"转换了 {len(segments)} 个分段，检测到 {len(speakers)} 个说话人")
+        
+        return segments, len(speakers)
+    
+    @abstractmethod
+    def diarize(self, audio: AudioSegment) -> DiarizationResult:
+        """
+        对音频进行说话人分离，子类需要实现
+        
+        参数:
+            audio: 要处理的AudioSegment对象
+            
+        返回:
+            DiarizationResult对象，包含分段结果和说话人数量
+        """
+        pass 

src/podcast_transcribe/diarization/diarizer_router.py

@@ -0,0 +1,276 @@
+"""
+说话人分离模型调用路由器
+根据传递的provider参数调用不同的说话人分离实现，支持延迟加载
+"""
+
+import logging
+from typing import Dict, Any, Optional, Callable
+from pydub import AudioSegment
+from ..schemas import DiarizationResult
+from . import diarization_pyannote_mlx
+from . import diarization_pyannote_transformers
+
+# 配置日志
+logger = logging.getLogger("diarization")
+
+
+class DiarizerRouter:
+    """说话人分离模型调用路由器，支持多种实现的统一调用"""
+    
+    def __init__(self):
+        """初始化路由器"""
+        self._loaded_modules = {}  # 用于缓存已加载的模块
+        self._diarizers = {}       # 用于缓存已实例化的分离器
+        
+        # 定义支持的provider配置
+        self._provider_configs = {
+            "pyannote_mlx": {
+                "module_path": "diarization_pyannote_mlx",
+                "function_name": "diarize_audio",
+                "default_model": "pyannote/speaker-diarization-3.1",
+                "supported_params": ["model_name", "token", "device", "segmentation_batch_size"],
+                "description": "基于pyannote.audio的原生MLX实现"
+            },
+            "pyannote_transformers": {
+                "module_path": "diarization_pyannote_transformers",
+                "function_name": "diarize_audio",
+                "default_model": "pyannote/speaker-diarization-3.1",
+                "supported_params": ["model_name", "token", "device", "segmentation_batch_size"],
+                "description": "基于transformers库调用pyannote模型"
+            }
+        }
+    
+    def _lazy_load_module(self, provider: str):
+        """
+        获取指定provider的模块
+        
+        参数:
+            provider: provider名称
+            
+        返回:
+            对应的模块
+        """
+        if provider not in self._provider_configs:
+            raise ValueError(f"不支持的provider: {provider}")
+            
+        if provider not in self._loaded_modules:
+            module_path = self._provider_configs[provider]["module_path"]
+            logger.info(f"获取模块: {module_path}")
+            
+            # 根据module_path返回对应的模块
+            if module_path == "diarization_pyannote_mlx":
+                module = diarization_pyannote_mlx
+            elif module_path == "diarization_pyannote_transformers":
+                module = diarization_pyannote_transformers
+            else:
+                raise ImportError(f"未找到模块: {module_path}")
+            
+            self._loaded_modules[provider] = module
+            logger.info(f"模块 {module_path} 获取成功")
+        
+        return self._loaded_modules[provider]
+    
+    def _get_diarize_function(self, provider: str) -> Callable:
+        """
+        获取指定provider的说话人分离函数
+        
+        参数:
+            provider: provider名称
+            
+        返回:
+            说话人分离函数
+        """
+        module = self._lazy_load_module(provider)
+        function_name = self._provider_configs[provider]["function_name"]
+        
+        if not hasattr(module, function_name):
+            raise AttributeError(f"模块中未找到函数: {function_name}")
+            
+        return getattr(module, function_name)
+    
+    def _filter_params(self, provider: str, params: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        过滤参数，只保留指定provider支持的参数
+        
+        参数:
+            provider: provider名称
+            params: 原始参数字典
+            
+        返回:
+            过滤后的参数字典
+        """
+        supported_params = self._provider_configs[provider]["supported_params"]
+        filtered_params = {}
+        
+        for param in supported_params:
+            if param in params:
+                filtered_params[param] = params[param]
+        
+        # 如果没有指定model_name，使用默认模型
+        if "model_name" not in filtered_params and "model_name" in supported_params:
+            filtered_params["model_name"] = self._provider_configs[provider]["default_model"]
+        
+        return filtered_params
+    
+    def diarize(
+        self,
+        audio_segment: AudioSegment,
+        provider: str,
+        **kwargs
+    ) -> DiarizationResult:
+        """
+        统一的说话人分离接口
+        
+        参数:
+            audio_segment: 输入的AudioSegment对象
+            provider: 说话人分离提供者名称
+            **kwargs: 其他参数，如model_name, token, device, segmentation_batch_size等
+            
+        返回:
+            DiarizationResult对象
+        """
+        logger.info(f"使用provider '{provider}' 进行说话人分离，音频长度: {len(audio_segment)/1000:.2f}秒")
+        
+        if provider not in self._provider_configs:
+            available_providers = list(self._provider_configs.keys())
+            raise ValueError(f"不支持的provider: {provider}。支持的provider: {available_providers}")
+        
+        try:
+            # 获取说话人分离函数
+            diarize_func = self._get_diarize_function(provider)
+            
+            # 过滤并准备参数
+            filtered_kwargs = self._filter_params(provider, kwargs)
+            
+            logger.debug(f"调用 {provider} 说话人分离函数，参数: {filtered_kwargs}")
+            
+            # 执行说话人分离
+            result = diarize_func(audio_segment, **filtered_kwargs)
+            
+            logger.info(f"说话人分离完成，检测到 {result.num_speakers} 个说话人，生成 {len(result.segments)} 个分段")
+            return result
+            
+        except Exception as e:
+            logger.error(f"使用provider '{provider}' 进行说话人分离失败: {str(e)}", exc_info=True)
+            raise RuntimeError(f"说话人分离失败: {str(e)}")
+    
+    def get_available_providers(self) -> Dict[str, str]:
+        """
+        获取所有可用的provider及其描述
+        
+        返回:
+            provider名称到描述的映射
+        """
+        return {
+            provider: config["description"] 
+            for provider, config in self._provider_configs.items()
+        }
+    
+    def get_provider_info(self, provider: str) -> Dict[str, Any]:
+        """
+        获取指定provider的详细信息
+        
+        参数:
+            provider: provider名称
+            
+        返回:
+            provider的配置信息
+        """
+        if provider not in self._provider_configs:
+            raise ValueError(f"不支持的provider: {provider}")
+            
+        return self._provider_configs[provider].copy()
+
+
+# 创建全局路由器实例
+_router = DiarizerRouter()
+
+
+def diarize_audio(
+    audio_segment: AudioSegment,
+    provider: str = "pyannote_mlx",
+    model_name: Optional[str] = None,
+    token: Optional[str] = None,
+    device: str = "cpu",
+    segmentation_batch_size: int = 32,
+    **kwargs
+) -> DiarizationResult:
+    """
+    统一的音频说话人分离接口函数
+    
+    参数:
+        audio_segment: 输入的AudioSegment对象
+        provider: 说话人分离提供者，可选值：
+            - "pyannote_mlx": 基于pyannote.audio的原生MLX实现
+            - "pyannote_transformers": 基于transformers库调用pyannote模型
+        model_name: 模型名称，如果不指定则使用默认模型
+        token: Hugging Face令牌，用于访问模型
+        device: 推理设备，'cpu'、'cuda'、'mps'
+        segmentation_batch_size: 分割批处理大小，默认为32
+        **kwargs: 其他参数
+        
+    返回:
+        DiarizationResult对象，包含分段结果和说话人数量
+        
+    示例:
+        # 使用默认pyannote MLX实现
+        result = diarize_audio(audio_segment, provider="pyannote_mlx", token="your_hf_token")
+        
+        # 使用transformers实现
+        result = diarize_audio(
+            audio_segment, 
+            provider="pyannote_transformers",
+            token="your_hf_token"
+        )
+        
+        # 使用GPU设备
+        result = diarize_audio(
+            audio_segment,
+            provider="pyannote_mlx",
+            token="your_hf_token",
+            device="cuda"
+        )
+        
+        # 自定义批处理大小
+        result = diarize_audio(
+            audio_segment,
+            provider="pyannote_mlx", 
+            token="your_hf_token",
+            segmentation_batch_size=64
+        )
+    """
+    # 准备参数
+    params = kwargs.copy()
+    if model_name is not None:
+        params["model_name"] = model_name
+    if token is not None:
+        params["token"] = token
+    if device != "cpu":
+        params["device"] = device
+    if segmentation_batch_size != 32:
+        params["segmentation_batch_size"] = segmentation_batch_size
+    
+    return _router.diarize(audio_segment, provider, **params)
+
+
+def get_available_providers() -> Dict[str, str]:
+    """
+    获取所有可用的说话人分离提供者
+    
+    返回:
+        provider名称到描述的映射
+    """
+    return _router.get_available_providers()
+
+
+def get_provider_info(provider: str) -> Dict[str, Any]:
+    """
+    获取指定provider的详细信息
+    
+    参数:
+        provider: provider名称
+        
+    返回:
+        provider的配置信息
+    """
+    return _router.get_provider_info(provider)

src/podcast_transcribe/llm/llm_base.py

@@ -0,0 +1,391 @@
+import time
+import uuid
+import torch
+from typing import List, Dict, Optional, Union, Literal
+from abc import ABC, abstractmethod
+
+
+class BaseChatCompletion(ABC):
+    """Gemma 聊天完成的基类，包含公共功能"""
+    
+    def __init__(self, model_name: str):
+        self.model_name = model_name
+    
+    @abstractmethod
+    def _load_model_and_tokenizer(self):
+        """加载模型和分词器的抽象方法，由子类实现"""
+        pass
+    
+    @abstractmethod
+    def _generate_response(self, prompt_str: str, temperature: float, max_tokens: int, top_p: float, **kwargs) -> str:
+        """生成响应的抽象方法，由子类实现"""
+        pass
+
+    def _format_messages_for_gemma(self, messages: List[Dict[str, str]]) -> str:
+        """
+        为Gemma格式化消息。
+        Gemma期望特定的格式，通常类似于：
+        <start_of_turn>user
+        {user_message}<end_of_turn>
+        <start_of_turn>model
+        {assistant_message}<end_of_turn>
+        ...
+        <start_of_turn>user
+        {current_user_message}<end_of_turn>
+        <start_of_turn>model
+        """
+        # 尝试使用分词器的聊天模板（如果可用）
+        try:
+            # Hugging Face分词器中的apply_chat_template方法
+            # 通常需要一个字典列表，每个字典包含'role'和'content'。
+            # 我们需要确保我们的`messages`格式兼容。
+            # add_generation_prompt=True 至关重要，以确保模型知道轮到它发言了。
+            return self.tokenizer.apply_chat_template(
+                messages, tokenize=False, add_generation_prompt=True
+            )
+        except Exception:
+            # 如果apply_chat_template失败或不可用，则回退到手动格式化
+            prompt_parts = []
+            for message in messages:
+                role = message.get("role")
+                content = message.get("content")
+                if role == "user":
+                    prompt_parts.append(f"<start_of_turn>user\n{content}<end_of_turn>")
+                elif role == "assistant":
+                    prompt_parts.append(f"<start_of_turn>model\n{content}<end_of_turn>")
+                elif role == "system": # Gemma可能不会以相同的方式显式使用'system'，通常是前置的
+                    # 对于Gemma，系统提示通常只是前置到第一个用户消息或隐式处理。
+                    # 我们会在这里前置它，尽管其有效性取决于特定的Gemma微调。
+                    # 一种常见的模式是在开头放置系统指令，不使用特殊标记。
+                    # 然而，为了保持结构化，我们将尝试一种通用方法。
+                    # 如果分词器在其模板中有特定的方式来处理系统提示，
+                    # 那么`apply_chat_template`将是首选。
+                    # 由于我们处于回退状态，这是一个最佳猜测。
+                    # 一些模型期望系统提示在轮次结构之外，或者在最开始。
+                    # 为了在回退中简化，我们只做前置处理。
+                    # 如果`apply_chat_template`不可用，更健壮的解决方案是检查模型的特定聊天模板。
+                    prompt_parts.insert(0, f"<start_of_turn>system\n{content}<end_of_turn>")
+
+            # 添加提示，让模型开始生成
+            prompt_parts.append("<start_of_turn>model")
+            return "\n".join(prompt_parts)
+
+    def _post_process_response(self, response_text: str, prompt_str: str) -> str:
+        """
+        后处理生成的响应文本，清理提示和特殊标记
+        """
+        # 后处理：Gemma的输出可能包含输入提示或特殊标记。
+        # 我们需要清理这些，以仅返回助手的最新消息。
+        # 一种常见的模式是，模型输出将以我们给它的提示开始，
+        # 或者它可能包含 <start_of_turn>model 标记，然后是其响应。
+
+        # 如果模型输出包含提示，然后是新的响应：
+        if response_text.startswith(prompt_str):
+            assistant_message_content = response_text[len(prompt_str):].strip()
+        else:
+            # 如果模型不回显提示，则可能需要更复杂的清理。
+            # 对于Gemma，响应通常跟随提示的最后一部分 "<start_of_turn>model\n"。
+            # 让我们尝试找到最后一个 "<start_of_turn>model" 并获取其后的文本。
+            # 这是一种启发式方法，可能需要根据实际模型输出进行调整。
+            parts = response_text.split("<start_of_turn>model")
+            if len(parts) > 1:
+                assistant_message_content = parts[-1].strip()
+                # 进一步清理 <end_of_turn> 或其他特殊标记
+                assistant_message_content = assistant_message_content.split("<end_of_turn>")[0].strip()
+            else: # 如果上述方法不起作用，则回退
+                assistant_message_content = response_text.strip()
+        
+        return assistant_message_content
+
+    def _calculate_tokens(self, prompt_str: str, assistant_message_content: str) -> Dict[str, int]:
+        """
+        计算token数量（近似值，因为确切的OpenAI分词可能不同）
+        """
+        # 对于提示token，我们对输入到模型的字符串进行分词。
+        # 对于完成token，我们对生成的助手消息进行分词。
+        prompt_tokens = len(self.tokenizer.encode(prompt_str))
+        completion_tokens = len(self.tokenizer.encode(assistant_message_content))
+        total_tokens = prompt_tokens + completion_tokens
+        
+        return {
+            "prompt_tokens": prompt_tokens,
+            "completion_tokens": completion_tokens,
+            "total_tokens": total_tokens
+        }
+
+    def _build_chat_completion_response(self, assistant_message_content: str, token_usage: Dict[str, int]) -> Dict:
+        """
+        构建模仿OpenAI结构的响应对象
+        基于: https://platform.openai.com/docs/api-reference/chat/object
+        """
+        # 获取完成的当前时间戳
+        created_timestamp = int(time.time())
+        completion_id = f"chatcmpl-{uuid.uuid4().hex}" # 创建一个唯一的ID
+
+        return {
+            "id": completion_id,
+            "object": "chat.completion",
+            "created": created_timestamp,
+            "model": self.model_name, # 报告我们使用的模型名称
+            "choices": [
+                {
+                    "index": 0,
+                    "message": {
+                        "role": "assistant",
+                        "content": assistant_message_content,
+                    },
+                    "finish_reason": "stop", # 假定为 "stop"
+                }
+            ],
+            "usage": token_usage,
+        }
+
+    def create(
+        self,
+        messages: List[Dict[str, str]],
+        temperature: float = 0.7,
+        max_tokens: int = 2048,
+        top_p: float = 1.0,
+        model: Optional[str] = None,
+        **kwargs,
+    ):
+        """
+        创建聊天完成响应。
+        模仿OpenAI的ChatCompletion.create方法。
+        """
+        if model and model != self.model_name:
+            # 这是一个简化的处理。在实际场景中，您可能希望加载新模型。
+            # 目前，我们将只打印一个警告并使用初始化的模型。
+            print(f"警告: 'model' 参数 ({model}) 与初始化的模型 ({self.model_name}) 不同。"
+                  f"正在使用初始化的模型。要使用不同的模型，请重新初始化该类。")
+
+        # 为Gemma格式化消息
+        prompt_str = self._format_messages_for_gemma(messages)
+
+        # 生成响应（由子类实现）
+        response_text = self._generate_response(prompt_str, temperature, max_tokens, top_p, **kwargs)
+        
+        # 后处理响应
+        assistant_message_content = self._post_process_response(response_text, prompt_str)
+        
+        # 计算token使用量
+        token_usage = self._calculate_tokens(prompt_str, assistant_message_content)
+        
+        # 构建响应对象
+        return self._build_chat_completion_response(assistant_message_content, token_usage)
+
+
+class TransformersBaseChatCompletion(BaseChatCompletion):
+    """基于Transformers库的聊天完成基类，提供通用的设备管理和量化功能"""
+    
+    def __init__(
+        self,
+        model_name: str,
+        use_4bit_quantization: bool = False,
+        device_map: Optional[str] = "auto",
+        device: Optional[str] = None,
+        trust_remote_code: bool = True,
+        torch_dtype: Optional[torch.dtype] = None
+    ):
+        super().__init__(model_name)
+        self.use_4bit_quantization = use_4bit_quantization
+        self.device_map = device_map
+        self.trust_remote_code = trust_remote_code
+        self.torch_dtype = torch_dtype or torch.float16
+        self.device = device
+        
+        # 加载模型和分词器
+        self._load_model_and_tokenizer()
+    
+    def _get_quantization_config(self):
+        """获取量化配置"""
+        if not self.use_4bit_quantization:
+            return None
+            
+        if self.device and self.device.type == "mps":
+            print("警告: MPS 设备不支持 4bit 量化，将禁用量化")
+            self.use_4bit_quantization = False
+            return None
+        
+        # 导入量化配置
+        try:
+            from transformers import BitsAndBytesConfig
+        except ImportError:
+            raise ImportError("请先安装 bitsandbytes 库: pip install bitsandbytes")
+        
+        return BitsAndBytesConfig(
+            load_in_4bit=True,
+            bnb_4bit_compute_dtype=self.torch_dtype,
+            bnb_4bit_quant_type="nf4",
+            bnb_4bit_use_double_quant=True,
+        )
+    
+    def _load_tokenizer(self):
+        """加载分词器"""
+        try:
+            from transformers import AutoTokenizer
+        except ImportError:
+            raise ImportError("请先安装 transformers 库: pip install transformers")
+        
+        self.tokenizer = AutoTokenizer.from_pretrained(
+            self.model_name,
+            trust_remote_code=self.trust_remote_code
+        )
+        
+        # 设置 pad_token 如果不存在
+        if self.tokenizer.pad_token is None:
+            self.tokenizer.pad_token = self.tokenizer.eos_token
+    
+    def _load_model(self):
+        """加载模型"""
+        try:
+            from transformers import AutoModelForCausalLM
+        except ImportError:
+            raise ImportError("请先安装 transformers 库: pip install transformers")
+        
+        print(f"正在加载模型: {self.model_name}")
+        print(f"4bit量化: {'启用' if self.use_4bit_quantization else '禁用'}")
+        print(f"目标设备: {self.device}")
+        print(f"设备映射: {self.device_map}")
+        
+        # 配置模型加载参数
+        model_kwargs = {
+            "trust_remote_code": self.trust_remote_code,
+            "torch_dtype": self.torch_dtype,
+        }
+        
+        # 处理量化配置
+        quantization_config = self._get_quantization_config()
+        if quantization_config:
+            model_kwargs["quantization_config"] = quantization_config
+            print(f"使用 4bit 量化配置")
+        
+        # 处理设备映射
+        if self.device_map is not None:
+            if self.device and self.device.type == "mps":
+                print("警告: MPS 设备不支持 device_map，将手动管理设备")
+            else:
+                model_kwargs["device_map"] = self.device_map
+        
+        # 加载模型
+        self.model = AutoModelForCausalLM.from_pretrained(
+            self.model_name,
+            **model_kwargs
+        )
+        
+        # MPS 或手动设备管理
+        if self.device_map is None or (self.device and self.device.type == "mps"):
+            if not self.use_4bit_quantization:
+                print(f"手动移动模型到设备: {self.device}")
+                self.model = self.model.to(self.device)
+        
+        print(f"模型 {self.model_name} 加载成功")
+    
+    def _load_model_and_tokenizer(self):
+        """加载模型和分词器"""
+        try:
+            self._load_tokenizer()
+            self._load_model()
+        except Exception as e:
+            print(f"加载模型 {self.model_name} 时出错: {e}")
+            self._print_error_hints()
+            raise
+    
+    def _print_error_hints(self):
+        """打印错误提示信息"""
+        print("请确保模型名称正确且可访问。")
+        if self.use_4bit_quantization:
+            print("如果使用量化，请确保已安装 bitsandbytes 库: pip install bitsandbytes")
+        if self.device and self.device.type == "mps":
+            print("MPS 设备注意事项:")
+            print("- 不支持 4bit 量化")
+            print("- 不支持 device_map")
+            print("- 确保 PyTorch 版本支持 MPS")
+    
+    def _generate_response(
+        self,
+        prompt_str: str,
+        temperature: float,
+        max_tokens: int,
+        top_p: float,
+        **kwargs
+    ) -> str:
+        """使用 transformers 生成响应"""
+        
+        # 对提示进行编码
+        inputs = self.tokenizer.encode(prompt_str, return_tensors="pt")
+        
+        # 移动输入到正确的设备
+        if self.device_map is None or (self.device and self.device.type == "mps"):
+            inputs = inputs.to(self.device)
+        
+        # 生成参数
+        generation_config = {
+            "max_new_tokens": max_tokens,
+            "temperature": temperature,
+            "top_p": top_p,
+            "do_sample": True if temperature > 0 else False,
+            "pad_token_id": self.tokenizer.pad_token_id,
+            "eos_token_id": self.tokenizer.eos_token_id,
+            "repetition_penalty": kwargs.get("repetition_penalty", 1.1),
+            "no_repeat_ngram_size": kwargs.get("no_repeat_ngram_size", 3),
+        }
+        
+        # 如果温度为0，使用贪婪解码
+        if temperature == 0:
+            generation_config["do_sample"] = False
+            generation_config.pop("temperature", None)
+            generation_config.pop("top_p", None)
+        
+        try:
+            # 生成响应
+            with torch.no_grad():
+                outputs = self.model.generate(
+                    inputs,
+                    **generation_config
+                )
+            
+            # 解码生成的文本，跳过输入部分
+            generated_tokens = outputs[0][len(inputs[0]):]
+            generated_text = self.tokenizer.decode(generated_tokens, skip_special_tokens=True)
+            
+            return generated_text
+            
+        except Exception as e:
+            print(f"生成响应时出错: {e}")
+            raise
+    
+    def get_model_info(self) -> Dict[str, Union[str, bool, int]]:
+        """获取模型信息"""
+        model_info = {
+            "model_name": self.model_name,
+            "use_4bit_quantization": self.use_4bit_quantization,
+            "device": str(self.device),
+            "device_type": self.device.type,
+            "device_map": self.device_map,
+            "model_type": "transformers",
+            "torch_dtype": str(self.torch_dtype),
+            "mps_available": torch.backends.mps.is_available() if hasattr(torch.backends, 'mps') else False,
+            "cuda_available": torch.cuda.is_available(),
+        }
+        
+        # 添加模型配置信息（如果可用）
+        try:
+            if hasattr(self.model, "config"):
+                config = self.model.config
+                model_info.update({
+                    "vocab_size": getattr(config, "vocab_size", "未知"),
+                    "hidden_size": getattr(config, "hidden_size", "未知"),
+                    "num_layers": getattr(config, "num_hidden_layers", "未知"),
+                    "num_attention_heads": getattr(config, "num_attention_heads", "未知"),
+                })
+        except Exception:
+            pass
+        
+        return model_info
+    
+    def clear_cache(self):
+        """清理 GPU 缓存"""
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+            print("GPU 缓存已清理") 

src/podcast_transcribe/llm/llm_gemma_mlx.py

@@ -0,0 +1,62 @@
+from mlx_lm import load, generate
+from mlx_lm.sample_utils import make_sampler
+from typing import Dict, Union
+from .llm_base import BaseChatCompletion
+
+
+class GemmaMLXChatCompletion(BaseChatCompletion):
+    """基于 MLX 库的 Gemma 聊天完成实现"""
+    
+    def __init__(self, model_name: str = "mlx-community/gemma-3-12b-it-4bit-DWQ"):
+        super().__init__(model_name)
+        self._load_model_and_tokenizer()
+
+    def _load_model_and_tokenizer(self):
+        """加载 MLX 模型和分词器"""
+        try:
+            print(f"正在加载 MLX 模型: {self.model_name}")
+            self.model, self.tokenizer = load(self.model_name)
+            print(f"MLX 模型 {self.model_name} 加载成功")
+        except Exception as e:
+            print(f"加载模型 {self.model_name} 时出错: {e}")
+            print("请确保模型名称正确且可访问。")
+            print("您可以尝试使用 'mlx_lm.utils.get_model_path(model_name)' 搜索可用的模型。")
+            raise
+
+    def _generate_response(
+        self,
+        prompt_str: str,
+        temperature: float,
+        max_tokens: int,
+        top_p: float,
+        **kwargs
+    ) -> str:
+        """使用 MLX 生成响应"""
+        
+        # 为temperature和top_p创建一个采样器
+        sampler = make_sampler(temp=temperature, top_p=top_p)
+
+        # 生成响应
+        # mlx_lm中的`generate`函数接受模型、分词器、提示和其他生成参数。
+        # 我们需要将我们的参数映射到`generate`期望的参数。
+        # `mlx_lm.generate` 的 verbose 参数可用于调试。
+        # `temperature` 是 `mlx_lm.generate` 中温度的参数名称。
+        response_text = generate(
+            self.model,
+            self.tokenizer,
+            prompt=prompt_str,
+            max_tokens=max_tokens,
+            sampler=sampler,
+            # verbose=True # 取消注释以调试生成过程
+        )
+        
+        return response_text
+
+    def get_model_info(self) -> Dict[str, Union[str, bool, int]]:
+        """获取模型信息"""
+        return {
+            "model_name": self.model_name,
+            "model_type": "mlx",
+            "library": "mlx_lm"
+        }
+

src/podcast_transcribe/llm/llm_gemma_transfomers.py

@@ -0,0 +1,61 @@
+import torch
+from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
+from typing import List, Dict, Optional, Union, Literal
+from .llm_base import TransformersBaseChatCompletion
+
+
+class GemmaTransformersChatCompletion(TransformersBaseChatCompletion):
+    """基于 Transformers 库的 Gemma 聊天完成实现"""
+    
+    def __init__(
+        self,
+        model_name: str = "google/gemma-3-12b-it",
+        use_4bit_quantization: bool = False,
+        device_map: Optional[str] = "auto",
+        device: Optional[str] = None,
+        trust_remote_code: bool = True
+    ):
+        # Gemma 使用 float16 作为默认数据类型
+        super().__init__(
+            model_name=model_name,
+            use_4bit_quantization=use_4bit_quantization,
+            device_map=device_map,
+            device=device,
+            trust_remote_code=trust_remote_code,
+            torch_dtype=torch.float16
+        )
+    
+    def _print_error_hints(self):
+        """打印Gemma特定的错误提示信息"""
+        super()._print_error_hints()
+        print("Gemma 特殊要求:")
+        print("- 建议使用 Transformers >= 4.21.0")
+        print("- 推荐使用 float16 数据类型")
+        print("- 确保有足够的GPU内存")
+
+
+# 为了保持向后兼容性，也可以提供一个简化的工厂函数
+def create_gemma_transformers_client(
+    model_name: str = "google/gemma-3-12b-it",
+    use_4bit_quantization: bool = False,
+    device: Optional[str] = None,
+    **kwargs
+) -> GemmaTransformersChatCompletion:
+    """
+    创建 Gemma Transformers 客户端的工厂函数
+    
+    Args:
+        model_name: 模型名称
+        use_4bit_quantization: 是否使用4bit量化
+        device: 指定设备 ("cpu", "cuda", "mps", 等)
+        **kwargs: 其他传递给构造函数的参数
+    
+    Returns:
+        GemmaTransformersChatCompletion 实例
+    """
+    return GemmaTransformersChatCompletion(
+        model_name=model_name,
+        use_4bit_quantization=use_4bit_quantization,
+        device=device,
+        **kwargs
+    )

src/podcast_transcribe/llm/llm_phi4_transfomers.py

@@ -0,0 +1,369 @@
+import torch
+from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
+from typing import List, Dict, Optional, Union, Literal
+from .llm_base import TransformersBaseChatCompletion
+
+
+class Phi4TransformersChatCompletion(TransformersBaseChatCompletion):
+    """基于 Transformers 库的 Phi-4-mini-reasoning 聊天完成实现"""
+    
+    def __init__(
+        self,
+        model_name: str = "microsoft/Phi-4-mini-reasoning",
+        use_4bit_quantization: bool = False,
+        device_map: Optional[str] = "auto",
+        device: Optional[str] = None,
+        trust_remote_code: bool = True
+    ):
+        # Phi-4 使用 bfloat16 作为推荐数据类型
+        super().__init__(
+            model_name=model_name,
+            use_4bit_quantization=use_4bit_quantization,
+            device_map=device_map,
+            device=device,
+            trust_remote_code=trust_remote_code,
+            torch_dtype=torch.bfloat16
+        )
+    
+    def _print_error_hints(self):
+        """打印Phi-4特定的错误提示信息"""
+        super()._print_error_hints()
+        print("Phi-4 特殊要求:")
+        print("- 建议使用 Transformers >= 4.51.3")
+        print("- 推荐使用 bfloat16 数据类型")
+        print("- 模型支持 128K token 上下文长度")
+    
+    def _format_phi4_messages(self, messages: List[Dict[str, str]]) -> str:
+        """
+        格式化消息为 Phi-4 的聊天格式
+        Phi-4 使用特定的聊天模板格式
+        """
+        # 使用 tokenizer 的内置聊天模板
+        if hasattr(self.tokenizer, 'apply_chat_template'):
+            return self.tokenizer.apply_chat_template(
+                messages, 
+                tokenize=False, 
+                add_generation_prompt=True
+            )
+        else:
+            # 如果没有聊天模板，使用 Phi-4 的标准格式
+            formatted_prompt = ""
+            for message in messages:
+                role = message.get("role", "user")
+                content = message.get("content", "")
+                
+                if role == "system":
+                    formatted_prompt += f"<|system|>\n{content}<|end|>\n"
+                elif role == "user":
+                    formatted_prompt += f"<|user|>\n{content}<|end|>\n"
+                elif role == "assistant":
+                    formatted_prompt += f"<|assistant|>\n{content}<|end|>\n"
+            
+            # 添加助手开始标记
+            formatted_prompt += "<|assistant|>\n"
+            return formatted_prompt
+    
+    def _generate_response(
+        self,
+        prompt_str: str,
+        temperature: float,
+        max_tokens: int,
+        top_p: float,
+        enable_reasoning: bool = True,
+        **kwargs
+    ) -> str:
+        """使用 transformers 生成响应，针对 Phi-4 推理功能优化"""
+        
+        # 对提示进行编码
+        inputs = self.tokenizer.encode(prompt_str, return_tensors="pt")
+        
+        # 移动输入到正确的设备
+        if self.device_map is None or self.device.type == "mps":
+            inputs = inputs.to(self.device)
+        
+        # Phi-4-mini-reasoning 优化的生成参数
+        generation_config = {
+            "max_new_tokens": min(max_tokens, 32768),  # Phi-4-mini 支持最大 32K token
+            "temperature": temperature,
+            "top_p": top_p,
+            "do_sample": True if temperature > 0 else False,
+            "pad_token_id": self.tokenizer.pad_token_id,
+            "eos_token_id": self.tokenizer.eos_token_id,
+            "repetition_penalty": kwargs.get("repetition_penalty", 1.1),
+            "no_repeat_ngram_size": kwargs.get("no_repeat_ngram_size", 3),
+        }
+        
+        # 推理模式配置
+        if enable_reasoning and "reasoning" in self.model_name.lower():
+            # 为推理任务优化的配置
+            generation_config.update({
+                "temperature": max(temperature, 0.1),  # 推理模式下保持一定的温度
+                "top_p": min(top_p, 0.95),  # 推理模式下限制 top_p
+                "do_sample": True,  # 推理模式下总是启用采样
+                "early_stopping": False,  # 允许完整的推理过程
+            })
+        
+        # 如果温度为0，使用贪婪解码
+        if temperature == 0:
+            generation_config["do_sample"] = False
+            generation_config.pop("temperature", None)
+            generation_config.pop("top_p", None)
+        
+        try:
+            # 生成响应
+            with torch.no_grad():
+                outputs = self.model.generate(
+                    inputs,
+                    **generation_config
+                )
+            
+            # 解码生成的文本，跳过输入部分
+            generated_tokens = outputs[0][len(inputs[0]):]
+            generated_text = self.tokenizer.decode(generated_tokens, skip_special_tokens=True)
+            
+            return generated_text
+            
+        except Exception as e:
+            print(f"生成响应时出错: {e}")
+            raise
+    
+    def create(
+        self,
+        messages: List[Dict[str, str]],
+        temperature: float = 0.7,
+        max_tokens: int = 2048,
+        top_p: float = 1.0,
+        model: Optional[str] = None,
+        enable_reasoning: bool = True,
+        **kwargs,
+    ):
+        """
+        创建聊天完成响应，支持Phi-4特有的推理功能
+        """
+        if model and model != self.model_name:
+            print(f"警告: 'model' 参数 ({model}) 与初始化的模型 ({self.model_name}) 不同。"
+                  f"正在使用初始化的模型。要使用不同的模型，请重新初始化该类。")
+
+        # 检查是否为推理任务
+        is_reasoning_task = self._is_reasoning_task(messages)
+        
+        # 格式化消息为 Phi-4 聊天格式
+        if is_reasoning_task and enable_reasoning:
+            prompt_str = self._format_reasoning_prompt(messages)
+        else:
+            prompt_str = self._format_phi4_messages(messages)
+
+        # 生成响应
+        response_text = self._generate_response(
+            prompt_str, 
+            temperature, 
+            max_tokens, 
+            top_p, 
+            enable_reasoning=enable_reasoning and is_reasoning_task,
+            **kwargs
+        )
+        
+        # 后处理响应（使用基类的方法，但针对Phi-4调整）
+        assistant_message_content = self._post_process_phi4_response(response_text, prompt_str)
+        
+        # 计算token使用量
+        token_usage = self._calculate_tokens(prompt_str, assistant_message_content)
+        
+        # 构建响应对象
+        response = self._build_chat_completion_response(assistant_message_content, token_usage)
+        
+        # 添加Phi-4特有的信息
+        response["reasoning_enabled"] = enable_reasoning and is_reasoning_task
+        
+        return response
+    
+    def _post_process_phi4_response(self, response_text: str, prompt_str: str) -> str:
+        """
+        后处理Phi-4生成的响应文本
+        """
+        # Phi-4的输出通常不包含输入提示，直接返回生成的内容
+        assistant_message_content = response_text.strip()
+        
+        # 清理可能的特殊标记
+        if assistant_message_content.endswith("<|end|>"):
+            assistant_message_content = assistant_message_content[:-7].strip()
+        
+        return assistant_message_content
+    
+    def _is_reasoning_task(self, messages: List[Dict[str, str]]) -> bool:
+        """检测是否为推理任务"""
+        reasoning_keywords = [
+            "解题", "推理", "计算", "证明", "分析", "逻辑", "步骤",
+            "solve", "reasoning", "calculate", "prove", "analyze", "logic", "step"
+        ]
+        
+        for message in messages:
+            content = message.get("content", "").lower()
+            if any(keyword in content for keyword in reasoning_keywords):
+                return True
+        
+        return False
+    
+    def _format_reasoning_prompt(self, messages: List[Dict[str, str]]) -> str:
+        """
+        为推理任务格式化特殊的提示词
+        """
+        # 添加推理指导的系统消息
+        reasoning_system_msg = {
+            "role": "system",
+            "content": "你是一个专业的数学推理助手。请逐步分析问题，展示详细的推理过程，包括：\n1. 问题理解\n2. 解题思路\n3. 具体步骤\n4. 最终答案\n\n每个步骤都要清晰明了。"
+        }
+        
+        # 将推理系统消息添加到消息列表的开头
+        enhanced_messages = [reasoning_system_msg] + messages
+        
+        # 使用标准格式化方法
+        return self._format_phi4_messages(enhanced_messages)
+    
+    def reasoning_completion(
+        self,
+        messages: List[Dict[str, str]],
+        temperature: float = 0.3,  # 推理任务使用较低的温度
+        max_tokens: int = 2048,   # 推理任务需要更多 tokens
+        top_p: float = 0.9,
+        extract_reasoning_steps: bool = True,
+        **kwargs
+    ) -> Dict[str, Union[str, Dict, List]]:
+        """
+        专门用于推理任务的聊天完成接口
+        
+        Args:
+            messages: 对话消息列表
+            temperature: 采样温度（推理任务建议使用较低值）
+            max_tokens: 最大生成token数量
+            top_p: top-p采样参数
+            extract_reasoning_steps: 是否提取推理步骤
+            **kwargs: 其他参数
+        
+        Returns:
+            包含推理步骤的响应字典
+        """
+        # 强制启用推理模式
+        response = self.create(
+            messages=messages,
+            temperature=temperature,
+            max_tokens=max_tokens,
+            top_p=top_p,
+            enable_reasoning=True,
+            **kwargs
+        )
+        
+        if extract_reasoning_steps:
+            # 提取推理步骤
+            content = response["choices"][0]["message"]["content"]
+            reasoning_steps = self._extract_reasoning_steps(content)
+            response["reasoning_steps"] = reasoning_steps
+        
+        return response
+    
+    def _extract_reasoning_steps(self, content: str) -> List[Dict[str, str]]:
+        """
+        从响应内容中提取推理步骤
+        """
+        steps = []
+        lines = content.split('\n')
+        current_step = {"title": "", "content": ""}
+        
+        step_patterns = [
+            "1. 问题理解", "2. 解题思路", "3. 具体步骤", "4. 最终答案",
+            "步骤", "分析", "解答", "结论", "reasoning", "step", "analysis", "solution"
+        ]
+        
+        for line in lines:
+            line = line.strip()
+            if not line:
+                continue
+            
+            # 检查是否是新的步骤开始
+            is_new_step = any(pattern in line.lower() for pattern in step_patterns)
+            if is_new_step and current_step["content"]:
+                steps.append(current_step.copy())
+                current_step = {"title": line, "content": ""}
+            elif is_new_step:
+                current_step["title"] = line
+            else:
+                if current_step["title"]:
+                    current_step["content"] += line + "\n"
+                else:
+                    current_step["content"] = line + "\n"
+        
+        # 添加最后一个步骤
+        if current_step["title"] or current_step["content"]:
+            steps.append(current_step)
+        
+        return steps
+    
+    def get_model_info(self) -> Dict[str, Union[str, bool, int]]:
+        """获取 Phi-4 模型信息"""
+        model_info = super().get_model_info()
+        
+        # 添加Phi-4特有的信息
+        model_info.update({
+            "model_family": "Phi-4-mini-reasoning",
+            "parameters": "3.8B",
+            "context_length": "128K tokens",
+            "specialization": "数学推理优化",
+        })
+        
+        return model_info
+
+
+# 工厂函数
+def create_phi4_transformers_client(
+    model_name: str = "microsoft/Phi-4-mini-reasoning",
+    use_4bit_quantization: bool = False,
+    device: Optional[str] = None,
+    **kwargs
+) -> Phi4TransformersChatCompletion:
+    """
+    创建 Phi-4 Transformers 客户端的工厂函数
+    
+    Args:
+        model_name: 模型名称，默认为 microsoft/Phi-4-mini-reasoning
+        use_4bit_quantization: 是否使用4bit量化
+        device: 指定设备 ("cpu", "cuda", "mps", 等)
+        **kwargs: 其他传递给构造函数的参数
+    
+    Returns:
+        Phi4TransformersChatCompletion 实例
+    """
+    return Phi4TransformersChatCompletion(
+        model_name=model_name,
+        use_4bit_quantization=use_4bit_quantization,
+        device=device,
+        **kwargs
+    )
+
+def create_reasoning_client(
+    model_name: str = "microsoft/Phi-4-mini-reasoning",
+    use_4bit_quantization: bool = False,
+    device: Optional[str] = None,
+    **kwargs
+) -> Phi4TransformersChatCompletion:
+    """
+    创建专门用于推理任务的 Phi-4 客户端
+    
+    Args:
+        model_name: 模型名称，推荐使用 microsoft/Phi-4-mini-reasoning
+        use_4bit_quantization: 是否使用4bit量化
+        device: 指定设备 ("cpu", "cuda", "mps", 等)
+        **kwargs: 其他传递给构造函数的参数
+    
+    Returns:
+        优化了推理功能的 Phi4TransformersChatCompletion 实例
+    """
+    # 确保使用推理模型
+    if "reasoning" not in model_name.lower():
+        print("警告: 建议使用包含 'reasoning' 的模型名称以获得最佳推理性能")
+    
+    return Phi4TransformersChatCompletion(
+        model_name=model_name,
+        use_4bit_quantization=use_4bit_quantization,
+        device=device,
+        **kwargs
+    ) 

src/podcast_transcribe/llm/llm_router.py

@@ -0,0 +1,578 @@
+"""
+LLM模型调用路由器
+根据传递的provider参数调用不同的LLM实现，支持延迟加载
+"""
+
+import logging
+from typing import Dict, Any, Optional, List, Union
+from .llm_base import BaseChatCompletion
+from . import llm_gemma_mlx
+from . import llm_gemma_transfomers
+from . import llm_phi4_transfomers
+
+# 配置日志
+logger = logging.getLogger("llm")
+
+
+class LLMRouter:
+    """LLM模型调用路由器，支持多种实现的统一调用"""
+    
+    def __init__(self):
+        """初始化路由器"""
+        self._loaded_modules = {}  # 用于缓存已加载的模块
+        self._llm_instances = {}   # 用于缓存已实例化的LLM实例
+        
+        # 定义支持的provider配置
+        self._provider_configs = {
+            "gemma-mlx": {
+                "module_path": "llm_gemma_mlx",
+                "class_name": "GemmaMLXChatCompletion",
+                "default_model": "mlx-community/gemma-3-12b-it-4bit-DWQ",
+                "supported_params": ["model_name"],
+                "description": "基于MLX库的Gemma聊天完成实现"
+            },
+            "gemma-transformers": {
+                "module_path": "llm_gemma_transfomers",
+                "class_name": "GemmaTransformersChatCompletion",
+                "default_model": "google/gemma-3-12b-it",
+                "supported_params": [
+                    "model_name", "use_4bit_quantization", "device_map", 
+                    "device", "trust_remote_code"
+                ],
+                "description": "基于Transformers库的Gemma聊天完成实现"
+            },
+            "phi4-transformers": {
+                "module_path": "llm_phi4_transfomers",
+                "class_name": "Phi4TransformersChatCompletion",
+                "default_model": "microsoft/Phi-4-reasoning",
+                "supported_params": [
+                    "model_name", "use_4bit_quantization", "device_map", 
+                    "device", "trust_remote_code", "enable_reasoning"
+                ],
+                "description": "基于Transformers库的Phi-4推理聊天完成实现"
+            }
+        }
+    
+    def _lazy_load_module(self, provider: str):
+        """
+        获取指定provider的模块
+        
+        参数:
+            provider: provider名称
+            
+        返回:
+            对应的模块
+        """
+        if provider not in self._provider_configs:
+            raise ValueError(f"不支持的provider: {provider}")
+            
+        if provider not in self._loaded_modules:
+            module_path = self._provider_configs[provider]["module_path"]
+            logger.info(f"获取模块: {module_path}")
+            
+            # 根据module_path返回对应的模块
+            if module_path == "llm_gemma_mlx":
+                module = llm_gemma_mlx
+            elif module_path == "llm_gemma_transfomers":
+                module = llm_gemma_transfomers
+            elif module_path == "llm_phi4_transfomers":
+                module = llm_phi4_transfomers
+            else:
+                raise ImportError(f"未找到模块: {module_path}")
+            
+            self._loaded_modules[provider] = module
+            logger.info(f"模块 {module_path} 获取成功")
+        
+        return self._loaded_modules[provider]
+    
+    def _get_llm_class(self, provider: str):
+        """
+        获取指定provider的LLM类
+        
+        参数:
+            provider: provider名称
+            
+        返回:
+            LLM类
+        """
+        module = self._lazy_load_module(provider)
+        class_name = self._provider_configs[provider]["class_name"]
+        
+        if not hasattr(module, class_name):
+            raise AttributeError(f"模块中未找到类: {class_name}")
+            
+        return getattr(module, class_name)
+    
+    def _filter_params(self, provider: str, params: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        过滤参数，只保留指定provider支持的参数
+        
+        参数:
+            provider: provider名称
+            params: 原始参数字典
+            
+        返回:
+            过滤后的参数字典
+        """
+        supported_params = self._provider_configs[provider]["supported_params"]
+        filtered_params = {}
+        
+        for param in supported_params:
+            if param in params:
+                filtered_params[param] = params[param]
+        
+        # 如果没有指定model_name，使用默认模型
+        if "model_name" not in filtered_params and "model_name" in supported_params:
+            filtered_params["model_name"] = self._provider_configs[provider]["default_model"]
+        
+        return filtered_params
+    
+    def _get_instance_key(self, provider: str, params: Dict[str, Any]) -> str:
+        """
+        生成LLM实例的缓存键
+        
+        参数:
+            provider: provider名称
+            params: 参数字典
+            
+        返回:
+            实例缓存键
+        """
+        # 将参数转换为可哈希的字符串
+        param_str = "_".join([f"{k}={v}" for k, v in sorted(params.items())])
+        return f"{provider}_{param_str}"
+    
+    def _get_or_create_instance(self, provider: str, **kwargs) -> BaseChatCompletion:
+        """
+        获取或创建LLM实例（支持缓存复用）
+        
+        参数:
+            provider: provider名称
+            **kwargs: 构造函数参数
+            
+        返回:
+            LLM实例
+        """
+        # 过滤并准备参数
+        filtered_kwargs = self._filter_params(provider, kwargs)
+        
+        # 生成实例缓存键
+        instance_key = self._get_instance_key(provider, filtered_kwargs)
+        
+        # 检查是否已有缓存实例
+        if instance_key not in self._llm_instances:
+            try:
+                # 获取LLM类
+                llm_class = self._get_llm_class(provider)
+                
+                logger.debug(f"创建 {provider} LLM实例，参数: {filtered_kwargs}")
+                
+                # 创建实例
+                instance = llm_class(**filtered_kwargs)
+                
+                # 缓存实例
+                self._llm_instances[instance_key] = instance
+                
+                logger.info(f"LLM实例创建成功: {provider} ({instance.model_name})")
+                
+            except Exception as e:
+                logger.error(f"创建 {provider} LLM实例失败: {str(e)}", exc_info=True)
+                raise RuntimeError(f"创建LLM实例失败: {str(e)}")
+        
+        return self._llm_instances[instance_key]
+    
+    def chat_completion(
+        self,
+        messages: List[Dict[str, str]],
+        provider: str,
+        temperature: float = 0.7,
+        max_tokens: int = 2048,
+        top_p: float = 1.0,
+        model: Optional[str] = None,
+        **kwargs
+    ) -> Dict[str, Any]:
+        """
+        统一的聊天完成接口
+        
+        参数:
+            messages: 消息列表，每个消息包含role和content
+            provider: LLM提供者名称
+            temperature: 温度参数，控制生成的随机性
+            max_tokens: 最大生成token数
+            top_p: nucleus采样参数
+            model: 可选的模型名称，如果提供则覆盖默认model_name
+            **kwargs: 其他参数，如device、use_4bit_quantization等
+            
+        返回:
+            聊天完成响应字典
+        """
+        logger.info(f"使用provider '{provider}' 进行聊天完成，消息数量: {len(messages)}")
+        
+        if provider not in self._provider_configs:
+            available_providers = list(self._provider_configs.keys())
+            raise ValueError(f"不支持的provider: {provider}。支持的provider: {available_providers}")
+        
+        try:
+            # 如果提供了model参数，添加到kwargs中
+            if model is not None:
+                kwargs["model_name"] = model
+            
+            # 获取或创建LLM实例
+            llm_instance = self._get_or_create_instance(provider, **kwargs)
+            
+            # 调用聊天完成
+            result = llm_instance.create(
+                messages=messages,
+                temperature=temperature,
+                max_tokens=max_tokens,
+                top_p=top_p,
+                model=model,
+                **kwargs
+            )
+            
+            logger.info(f"聊天完成成功，使用tokens: {result.get('usage', {}).get('total_tokens', 'unknown')}")
+            return result
+            
+        except Exception as e:
+            logger.error(f"使用provider '{provider}' 进行聊天完成失败: {str(e)}", exc_info=True)
+            raise RuntimeError(f"聊天完成失败: {str(e)}")
+    
+    def reasoning_completion(
+        self,
+        messages: List[Dict[str, str]],
+        provider: str = "phi4-transformers",
+        temperature: float = 0.3,
+        max_tokens: int = 2048,
+        top_p: float = 0.9,
+        model: Optional[str] = None,
+        extract_reasoning_steps: bool = True,
+        **kwargs
+    ) -> Dict[str, Any]:
+        """
+        专门用于推理任务的聊天完成接口
+        
+        参数:
+            messages: 消息列表，每个消息包含role和content
+            provider: LLM提供者名称，默认使用phi4-transformers
+            temperature: 温度参数（推理任务建议使用较低值）
+            max_tokens: 最大生成token数
+            top_p: nucleus采样参数
+            model: 可选的模型名称
+            extract_reasoning_steps: 是否提取推理步骤
+            **kwargs: 其他参数
+            
+        返回:
+            包含推理步骤的响应字典
+        """
+        logger.info(f"使用provider '{provider}' 进行推理完成，消息数量: {len(messages)}")
+        
+        # 确保使用支持推理的provider
+        if provider not in ["phi4-transformers"]:
+            logger.warning(f"Provider '{provider}' 可能不支持推理功能，建议使用 'phi4-transformers'")
+        
+        try:
+            # 如果提供了model参数，添加到kwargs中
+            if model is not None:
+                kwargs["model_name"] = model
+            
+            # 获取或创建LLM实例
+            llm_instance = self._get_or_create_instance(provider, **kwargs)
+            
+            # 检查实例是否支持推理完成
+            if hasattr(llm_instance, 'reasoning_completion'):
+                result = llm_instance.reasoning_completion(
+                    messages=messages,
+                    temperature=temperature,
+                    max_tokens=max_tokens,
+                    top_p=top_p,
+                    extract_reasoning_steps=extract_reasoning_steps,
+                    **kwargs
+                )
+            else:
+                # 回退到普通聊天完成
+                logger.warning(f"Provider '{provider}' 不支持推理完成，回退到普通聊天完成")
+                result = llm_instance.create(
+                    messages=messages,
+                    temperature=temperature,
+                    max_tokens=max_tokens,
+                    top_p=top_p,
+                    model=model,
+                    **kwargs
+                )
+            
+            logger.info(f"推理完成成功，使用tokens: {result.get('usage', {}).get('total_tokens', 'unknown')}")
+            return result
+            
+        except Exception as e:
+            logger.error(f"使用provider '{provider}' 进行推理完成失败: {str(e)}", exc_info=True)
+            raise RuntimeError(f"推理完成失败: {str(e)}")
+    
+    def get_model_info(self, provider: str, **kwargs) -> Dict[str, Any]:
+        """
+        获取模型信息
+        
+        参数:
+            provider: provider名称
+            **kwargs: 构造函数参数
+            
+        返回:
+            模型信息字典
+        """
+        try:
+            llm_instance = self._get_or_create_instance(provider, **kwargs)
+            return llm_instance.get_model_info()
+        except Exception as e:
+            logger.error(f"获取模型信息失败: {str(e)}")
+            raise RuntimeError(f"获取模型信息失败: {str(e)}")
+    
+    def get_available_providers(self) -> Dict[str, str]:
+        """
+        获取所有可用的provider及其描述
+        
+        返回:
+            provider名称到描述的映射
+        """
+        return {
+            provider: config["description"] 
+            for provider, config in self._provider_configs.items()
+        }
+    
+    def get_provider_info(self, provider: str) -> Dict[str, Any]:
+        """
+        获取指定provider的详细信息
+        
+        参数:
+            provider: provider名称
+            
+        返回:
+            provider的配置信息
+        """
+        if provider not in self._provider_configs:
+            raise ValueError(f"不支持的provider: {provider}")
+            
+        return self._provider_configs[provider].copy()
+    
+    def clear_cache(self):
+        """清理缓存的实例"""
+        # 清理每个实例的GPU缓存
+        for instance in self._llm_instances.values():
+            if hasattr(instance, 'clear_cache'):
+                instance.clear_cache()
+        
+        # 清理实例缓存
+        self._llm_instances.clear()
+        logger.info("LLM实例缓存已清理")
+
+
+# 创建全局路由器实例
+_router = LLMRouter()
+
+
+def chat_completion(
+    messages: List[Dict[str, str]],
+    provider: str = "gemma-mlx",
+    temperature: float = 0.7,
+    max_tokens: int = 2048,
+    top_p: float = 1.0,
+    model: Optional[str] = None,
+    device: Optional[str] = None,
+    use_4bit_quantization: bool = False,
+    device_map: Optional[str] = "auto",
+    trust_remote_code: bool = True,
+    **kwargs
+) -> Dict[str, Any]:
+    """
+    统一的聊天完成接口函数
+    
+    参数:
+        messages: 消息列表，每个消息包含role和content字段
+        provider: LLM提供者，可选值：
+            - "gemma-mlx": 基于MLX库的Gemma聊天完成实现
+            - "gemma-transformers": 基于Transformers库的Gemma聊天完成实现
+            - "phi4-transformers": 基于Transformers库的Phi-4推理聊天完成实现
+        temperature: 温度参数，控制生成的随机性 (0.0-2.0)
+        max_tokens: 最大生成token数
+        top_p: nucleus采样参数 (0.0-1.0)
+        model: 模型名称，如果不指定则使用默认模型
+        device: 推理设备，'cpu'、'cuda'、'mps'（仅transformers provider支持）
+        use_4bit_quantization: 是否使用4bit量化（仅transformers provider支持）
+        device_map: 设备映射配置（仅transformers provider支持）
+        trust_remote_code: 是否信任远程代码（仅transformers provider支持）
+        **kwargs: 其他参数
+        
+    返回:
+        聊天完成响应字典，包含生成的消息和使用统计
+        
+    示例:
+        # 使用默认MLX实现
+        response = chat_completion(
+            messages=[{"role": "user", "content": "你好"}],
+            provider="gemma-mlx"
+        )
+        
+        # 使用Gemma transformers实现
+        response = chat_completion(
+            messages=[{"role": "user", "content": "你好"}],
+            provider="gemma-transformers",
+            model="google/gemma-3-12b-it",
+            device="cuda",
+            use_4bit_quantization=True
+        )
+        
+        # 使用Phi-4推理实现
+        response = chat_completion(
+            messages=[{"role": "user", "content": "解这个数学题：2x + 5 = 15"}],
+            provider="phi4-transformers",
+            model="microsoft/Phi-4-mini-reasoning",
+            device="cuda"
+        )
+        
+        # 自定义参数
+        response = chat_completion(
+            messages=[
+                {"role": "system", "content": "你是一个有用的助手"},
+                {"role": "user", "content": "请介绍自己"}
+            ],
+            provider="gemma-mlx",
+            temperature=0.8,
+            max_tokens=1024
+        )
+    """
+    # 准备参数
+    params = kwargs.copy()
+    if model is not None:
+        params["model_name"] = model
+    if device is not None:
+        params["device"] = device
+    if use_4bit_quantization:
+        params["use_4bit_quantization"] = use_4bit_quantization
+    if device_map != "auto":
+        params["device_map"] = device_map
+    if not trust_remote_code:
+        params["trust_remote_code"] = trust_remote_code
+    
+    return _router.chat_completion(
+        messages=messages,
+        provider=provider,
+        temperature=temperature,
+        max_tokens=max_tokens,
+        top_p=top_p,
+        model=model,
+        **params
+    )
+
+
+def reasoning_completion(
+    messages: List[Dict[str, str]],
+    provider: str = "phi4-transformers",
+    temperature: float = 0.3,
+    max_tokens: int = 2048,
+    top_p: float = 0.9,
+    model: Optional[str] = None,
+    device: Optional[str] = None,
+    use_4bit_quantization: bool = False,
+    device_map: Optional[str] = "auto",
+    trust_remote_code: bool = True,
+    extract_reasoning_steps: bool = True,
+    **kwargs
+) -> Dict[str, Any]:
+    """
+    专门用于推理任务的聊天完成接口函数
+    
+    参数:
+        messages: 消息列表，每个消息包含role和content字段
+        provider: LLM提供者，默认使用phi4-transformers
+        temperature: 温度参数（推理任务建议使用较低值）
+        max_tokens: 最大生成token数
+        top_p: nucleus采样参数
+        model: 模型名称，如果不指定则使用默认模型
+        device: 推理设备
+        use_4bit_quantization: 是否使用4bit量化
+        device_map: 设备映射配置
+        trust_remote_code: 是否信任远程代码
+        extract_reasoning_steps: 是否提取推理步骤
+        **kwargs: 其他参数
+        
+    返回:
+        包含推理步骤的响应字典
+        
+    示例:
+        # 数学推理任务
+        response = reasoning_completion(
+            messages=[{"role": "user", "content": "解这个方程：3x + 7 = 22"}],
+            provider="phi4-transformers",
+            extract_reasoning_steps=True
+        )
+        
+        # 逻辑推理任务
+        response = reasoning_completion(
+            messages=[{"role": "user", "content": "如果所有的猫都是动物，而小花是一只猫，那么小花是什么？"}],
+            provider="phi4-transformers",
+            temperature=0.2
+        )
+    """
+    # 准备参数
+    params = kwargs.copy()
+    if model is not None:
+        params["model_name"] = model
+    if device is not None:
+        params["device"] = device
+    if use_4bit_quantization:
+        params["use_4bit_quantization"] = use_4bit_quantization
+    if device_map != "auto":
+        params["device_map"] = device_map
+    if not trust_remote_code:
+        params["trust_remote_code"] = trust_remote_code
+    
+    return _router.reasoning_completion(
+        messages=messages,
+        provider=provider,
+        temperature=temperature,
+        max_tokens=max_tokens,
+        top_p=top_p,
+        model=model,
+        extract_reasoning_steps=extract_reasoning_steps,
+        **params
+    )
+
+
+def get_model_info(provider: str = "gemma-mlx", **kwargs) -> Dict[str, Any]:
+    """
+    获取模型信息
+    
+    参数:
+        provider: provider名称
+        **kwargs: 构造函数参数
+        
+    返回:
+        模型信息字典
+    """
+    return _router.get_model_info(provider, **kwargs)
+
+
+def get_available_providers() -> Dict[str, str]:
+    """
+    获取所有可用的LLM提供者
+    
+    返回:
+        provider名称到描述的映射
+    """
+    return _router.get_available_providers()
+
+
+def get_provider_info(provider: str) -> Dict[str, Any]:
+    """
+    获取指定provider的详细信息
+    
+    参数:
+        provider: provider名称
+        
+    返回:
+        provider的配置信息
+    """
+    return _router.get_provider_info(provider)
+
+
+def clear_cache():
+    """清理缓存的LLM实例"""
+    _router.clear_cache()

src/podcast_transcribe/rss/podcast_rss_parser.py

@@ -0,0 +1,162 @@
+import requests
+import feedparser
+# from dataclasses import dataclass, field # 已移除
+from typing import Optional # , List, Dict # List 和 Dict 不再需要
+from datetime import datetime
+import time
+
+from ..schemas import PodcastEpisode, PodcastChannel
+
+def _parse_date(date_str: Optional[str]) -> Optional[datetime]:
+    if not date_str:
+        return None
+    try:
+        # feedparser 已经将日期解析为 time.struct_time 类型
+        # 我们将其转换为 datetime 类型
+        if isinstance(date_str, time.struct_time):
+            return datetime.fromtimestamp(time.mktime(date_str))
+        # 如果 feedparser 解析失败或返回字符串，则回退使用其他字符串格式解析
+        # 这是一种常见的 RSS 日期格式
+        return datetime.strptime(date_str, '%a, %d %b %Y %H:%M:%S %z')
+    except (ValueError, TypeError):
+        try:
+            return datetime.strptime(date_str, '%a, %d %b %Y %H:%M:%S %Z') # 处理 GMT, EST 等时区
+        except (ValueError, TypeError):
+            # 如果时区缺失或无法解析，则尝试不带时区解析
+            try:
+                return datetime.strptime(date_str[:-6], '%a, %d %b %Y %H:%M:%S')
+            except (ValueError, TypeError):
+                print(f"Warning: Could not parse date string: {date_str}")
+                return None
+
+def fetch_rss_content(rss_url: str) -> Optional[bytes]:
+    """
+    通过 HTTP 请求获取 RSS feed 的内容。
+
+    参数:
+        rss_url: 播客 RSS feed 的 URL。
+
+    返回:
+        bytes 类型的 RSS 内容，如果获取失败则返回 None。
+    """
+    headers = {
+        'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.114 Safari/537.36'
+    }
+    try:
+        response = requests.get(rss_url, headers=headers, timeout=30)
+        response.raise_for_status() # 针对 HTTP 错误抛出异常
+        return response.content
+    except requests.exceptions.RequestException as e:
+        print(f"获取 RSS feed 时出错: {e}")
+        return None
+
+def parse_rss_xml_content(rss_content: bytes) -> Optional[PodcastChannel]:
+    """
+    解析播客 RSS XML 内容，并返回其主要信息和剧集详情。
+
+    参数:
+        rss_content: bytes 类型的 RSS XML 内容。
+
+    返回:
+        一个包含已解析信息的 PodcastChannel 对象，如果解析失败则返回 None。
+    """
+    feed = feedparser.parse(rss_content)
+
+    if feed.bozo:
+        # 如果 feed 格式不正确，bozo 为 True
+        # feed.bozo_exception 包含异常信息
+        print(f"警告: RSS feed 可能格式不正确。Bozo 异常: {feed.bozo_exception}")
+        # 即使格式不完全正确，feedparser 通常仍会尝试解析，所以我们不在此处直接返回 None
+        # 但如果关键的 feed 或 channel_info 缺失，后续会自然失败
+
+    channel_info = feed.get('feed', {})
+    if not channel_info: # 如果连基本的 feed 结构都没有，则认为解析失败
+        print("错误: RSS 内容无法解析为有效的 feed 结构。")
+        return None
+
+    podcast_channel = PodcastChannel(
+        title=channel_info.get('title'),
+        link=channel_info.get('link'),
+        description=channel_info.get('subtitle') or channel_info.get('description'),
+        language=channel_info.get('language'),
+        image_url=channel_info.get('image', {}).get('href') if channel_info.get('image') else None,
+        author=channel_info.get('author') or channel_info.get('itunes_author'),
+        last_build_date=_parse_date(channel_info.get('updated_parsed') or channel_info.get('published_parsed'))
+    )
+
+    for entry in feed.entries:
+        # 确定 shownotes：优先使用 content:encoded，然后是 itunes:summary，其次是 description/summary
+        shownotes = None
+        # 1. 优先尝试 <content:encoded>
+        # entry.content 是一个 FeedParserDict 对象列表
+        if 'content' in entry and entry.content:
+            for content_item in entry.content:
+                # 检查 content_item 是否有 value 属性并且该值非空
+                if hasattr(content_item, 'value') and content_item.value:
+                    shownotes = content_item.value
+                    break # 找到第一个有效的 content:encoded，停止查找
+        
+        # 2. 如果没有从 content:encoded 获得，尝试 itunes:summary
+        if not shownotes and 'itunes_summary' in entry:
+            shownotes = entry.itunes_summary
+        
+        # 3. 最后回退到 summary 或 description
+        if not shownotes: # 回退到 summary 或 description
+            shownotes = entry.get('summary') or entry.get('description')
+
+        # 从 enclosures 获取音频 URL
+        audio_url = None
+        if 'enclosures' in entry:
+            for enc in entry.enclosures:
+                if enc.get('type', '').startswith('audio/'):
+                    audio_url = enc.get('href')
+                    break
+        
+        # 解析特定于剧集的 iTunes 标签
+        itunes_season = None
+        try:
+            itunes_season_str = entry.get('itunes_season')
+            if itunes_season_str:
+                itunes_season = int(itunes_season_str)
+        except (ValueError, TypeError):
+            pass # 如果不是有效整数则忽略
+
+        itunes_episode_number = None
+        try:
+            itunes_episode_number_str = entry.get('itunes_episode')
+            if itunes_episode_number_str:
+                itunes_episode_number = int(itunes_episode_number_str)
+        except (ValueError, TypeError):
+            pass # 如果不是有效整数则忽略
+
+        episode = PodcastEpisode(
+            title=entry.get('title'),
+            link=entry.get('link'),
+            published_date=_parse_date(entry.get('published_parsed')),
+            summary=entry.get('summary'), # 这通常是较短的版本
+            shownotes=shownotes, # 这是我们尝试获取的更详细版本
+            audio_url=audio_url,
+            guid=entry.get('id') or entry.get('guid'),
+            duration=entry.get('itunes_duration'),
+            episode_type=entry.get('itunes_episodetype'),
+            season=itunes_season,
+            episode_number=itunes_episode_number
+        )
+        podcast_channel.episodes.append(episode)
+
+    return podcast_channel
+
+def parse_podcast_rss(rss_url: str) -> Optional[PodcastChannel]:
+    """
+    从给定的 RSS URL 获取并解析播客数据。
+
+    参数:
+        rss_url: 播客 RSS feed 的 URL。
+
+    返回:
+        一个包含已解析信息的 PodcastChannel 对象，如果获取或解析失败则返回 None。
+    """
+    rss_content = fetch_rss_content(rss_url)
+    if rss_content:
+        return parse_rss_xml_content(rss_content)
+    return None

src/podcast_transcribe/schemas.py

@@ -0,0 +1,63 @@
+from dataclasses import dataclass, field
+from typing import List, Optional, Dict, Union
+from datetime import datetime
+
+@dataclass
+class EnhancedSegment:
+    """增强的转录分段，包含说话人信息"""
+    start: float  # 开始时间（秒）
+    end: float  # 结束时间（秒）
+    text: str  # 转录的文本
+    speaker: str  # 说话人ID
+    language: str  # 检测到的语言
+    speaker_name: Optional[str] = None  # 识别出的说话人名称
+
+
+@dataclass
+class CombinedTranscriptionResult:
+    """结合ASR和说话人分离的转录结果"""
+    segments: List[EnhancedSegment]  # 包含说话人和文本的分段
+    text: str  # 完整转录文本
+    language: str  # 检测到的语言
+    num_speakers: int  # 检测到的说话人数量 
+
+
+@dataclass
+class PodcastEpisode:
+    title: Optional[str] = None
+    link: Optional[str] = None
+    published_date: Optional[datetime] = None
+    summary: Optional[str] = None # 简短摘要
+    shownotes: Optional[str] = None # 详细的shownotes，通常是HTML格式
+    audio_url: Optional[str] = None
+    guid: Optional[str] = None
+    duration: Optional[str] = None # 例如，来自 <itunes:duration>
+    episode_type: Optional[str] = None # 例如，来自 <itunes:episodetype>
+    season: Optional[int] = None # 例如，来自 <itunes:season>
+    episode_number: Optional[int] = None # 例如，来自 <itunes:episode>
+
+@dataclass
+class PodcastChannel:
+    title: Optional[str] = None
+    link: Optional[str] = None
+    description: Optional[str] = None
+    language: Optional[str] = None
+    image_url: Optional[str] = None
+    author: Optional[str] = None # 例如，来自 <itunes:author>
+    last_build_date: Optional[datetime] = None
+    episodes: List[PodcastEpisode] = field(default_factory=list) 
+
+
+@dataclass
+class TranscriptionResult:
+    """转录结果数据类"""
+    text: str  # 转录的文本
+    segments: List[Dict[str, Union[float, str]]]  # 包含时间戳的分段
+    language: str  # 检测到的语言
+
+
+@dataclass
+class DiarizationResult:
+    """说话人分离结果数据类"""
+    segments: List[Dict[str, Union[float, str, int]]]  # 包含时间戳和说话人ID的分段
+    num_speakers: int  # 检测到的说话人数量 

src/podcast_transcribe/summary/speaker_identify.py

@@ -0,0 +1,350 @@
+from typing import List, Dict, Optional
+import json
+import re
+
+from ..schemas import EnhancedSegment, PodcastChannel, PodcastEpisode
+from ..llm import llm_router
+
+
+class SpeakerIdentifier:
+    """
+    说话人识别器类，用于根据转录分段和播客元数据识别说话人的真实姓名或昵称
+    """
+    
+    def __init__(self, llm_model_name: str, llm_provider: str):
+        """
+        初始化说话人识别器
+        
+        参数:
+            llm_model_name: LLM模型名称，如果为None则使用默认模型
+            llm_provider: LLM提供者，默认为"gemma-mlx"
+        """
+        self.llm_model_name = llm_model_name
+        self.llm_provider = llm_provider
+    
+    def _clean_html(self, html_string: Optional[str]) -> str:
+        """
+        简单地从字符串中移除HTML标签并清理多余空白。
+        """
+        if not html_string:
+            return ""
+        # 移除HTML标签
+        text = re.sub(r'<[^>]+>', ' ', html_string)
+        # 替换HTML实体（简单版本，只处理常见几个）
+        text = text.replace('&nbsp;', ' ').replace('&amp;', '&').replace('&lt;', '<').replace('&gt;', '>')
+        # 移除多余的空白符
+        text = re.sub(r'\\s+', ' ', text).strip()
+        return text
+
+    def _get_dialogue_samples(
+        self,
+        segments: List[EnhancedSegment], 
+        max_samples_per_speaker: int = 3,  # 增加样本数量
+        max_length_per_sample: int = 200   # 增加样本长度
+    ) -> Dict[str, List[str]]:
+        """
+        为每个说话人提取对话样本。
+        """
+        speaker_dialogues: Dict[str, List[str]] = {}
+        for segment in segments:
+            speaker = segment.speaker
+            if speaker == "UNKNOWN" or not segment.text.strip(): # 跳过未知说话人或空文本
+                continue
+            
+            if speaker not in speaker_dialogues:
+                speaker_dialogues[speaker] = []
+            
+            if len(speaker_dialogues[speaker]) < max_samples_per_speaker:
+                text_sample = segment.text.strip()[:max_length_per_sample]
+                if len(segment.text.strip()) > max_length_per_sample:
+                    text_sample += "..."
+                speaker_dialogues[speaker].append(text_sample)
+        return speaker_dialogues
+
+    def recognize_speaker_names(
+        self,
+        segments: List[EnhancedSegment],
+        podcast_info: Optional[PodcastChannel],
+        episode_info: Optional[PodcastEpisode],
+        max_shownotes_length: int = 1500, 
+        max_desc_length: int = 500
+    ) -> Dict[str, str]:
+        """
+        使用LLM根据转录分段和播客/剧集元数据识别说话人的真实姓名或昵称。
+
+        参数:
+            segments: 转录后的 EnhancedSegment 列表。
+            podcast_info: 包含播客元数据的 PodcastChannel 对象。
+            episode_info: 包含单集播客元数据的 PodcastEpisode 对象。
+            max_shownotes_length: 用于Prompt的 Shownotes 最大字符数。
+            max_desc_length: 用于Prompt的播客描述最大字符数。
+
+        返回:
+            一个字典，键是原始的 "SPEAKER_XX"，值是识别出的说话人名称。
+        """
+        unique_speaker_ids = sorted(list(set(seg.speaker for seg in segments if seg.speaker != "UNKNOWN" and seg.text.strip())))
+        if not unique_speaker_ids:
+            print("未能从 segments 中提取到有效的 speaker_ids。")
+            return {}
+
+        dialogue_samples = self._get_dialogue_samples(segments)
+        
+        # 增加每个说话人的话语分析信息，包括话语频率和长度
+        speaker_stats = {}
+        for segment in segments:
+            speaker = segment.speaker
+            if speaker == "UNKNOWN" or not segment.text.strip():
+                continue
+                
+            if speaker not in speaker_stats:
+                speaker_stats[speaker] = {
+                    "total_segments": 0,
+                    "total_chars": 0,
+                    "avg_segment_length": 0,
+                    "intro_likely": False  # 是否有介绍性质的话语
+                }
+            
+            speaker_stats[speaker]["total_segments"] += 1
+            speaker_stats[speaker]["total_chars"] += len(segment.text)
+            
+            # 检测可能的自我介绍或他人介绍
+            lower_text = segment.text.lower()
+            intro_patterns = [
+                r'欢迎来到', r'欢迎收听', r'我是', r'我叫', r'大家好', r'今天的嘉宾是', r'我们请到了',
+                r'welcome to', r'i\'m your host', r'this is', r'today we have', r'joining us', 
+                r'our guest', r'my name is'
+            ]
+            if any(re.search(pattern, lower_text) for pattern in intro_patterns):
+                speaker_stats[speaker]["intro_likely"] = True
+        
+        # 计算平均话语长度
+        for speaker, stats in speaker_stats.items():
+            if stats["total_segments"] > 0:
+                stats["avg_segment_length"] = stats["total_chars"] / stats["total_segments"]
+        
+        # 创建增强的说话人信息，包含统计数据
+        speaker_info_for_prompt = []
+        for speaker_id in unique_speaker_ids:
+            samples = dialogue_samples.get(speaker_id, ["(No dialogue samples available)"])
+            stats = speaker_stats.get(speaker_id, {"total_segments": 0, "avg_segment_length": 0, "intro_likely": False})
+            
+            speaker_info_for_prompt.append({
+                "speaker_id": speaker_id,
+                "dialogue_samples": samples,
+                "speech_stats": {
+                    "total_segments": stats["total_segments"],
+                    "avg_segment_length": round(stats["avg_segment_length"], 2),
+                    "has_intro_pattern": stats["intro_likely"]
+                }
+            })
+
+        # 安全地访问属性，提供默认值
+        podcast_title = podcast_info.title if podcast_info and podcast_info.title else "Unknown Podcast"
+        podcast_author = podcast_info.author if podcast_info and podcast_info.author else "Unknown"
+        
+        raw_podcast_desc = podcast_info.description if podcast_info and podcast_info.description else ""
+        cleaned_podcast_desc = self._clean_html(raw_podcast_desc)
+        podcast_desc_for_prompt = cleaned_podcast_desc[:max_desc_length]
+        if len(cleaned_podcast_desc) > max_desc_length:
+            podcast_desc_for_prompt += "..."
+        
+        episode_title = episode_info.title if episode_info and episode_info.title else "Unknown Episode"
+        
+        raw_episode_summary = episode_info.summary if episode_info and episode_info.summary else ""
+        cleaned_episode_summary = self._clean_html(raw_episode_summary)
+        episode_summary_for_prompt = cleaned_episode_summary[:max_desc_length] # 使用与描述相同的长度限制
+        if len(cleaned_episode_summary) > max_desc_length:
+            episode_summary_for_prompt += "..."
+
+        raw_episode_shownotes = episode_info.shownotes if episode_info and episode_info.shownotes else ""
+        cleaned_episode_shownotes = self._clean_html(raw_episode_shownotes)
+        episode_shownotes_for_prompt = cleaned_episode_shownotes[:max_shownotes_length]
+        if len(cleaned_episode_shownotes) > max_shownotes_length:
+            episode_shownotes_for_prompt += "..."
+
+        system_prompt = """You are an experienced podcast content analyst. Your task is to accurately identify the real names, nicknames, or roles of different speakers (tagged in SPEAKER_XX format) in a podcast episode, based on the provided metadata, episode information, dialogue snippets, and speech patterns. Your analysis should NOT rely on the order of speakers or speaker IDs."""
+
+        user_prompt_template = f"""
+Contextual Information:
+
+1.  **Podcast Information**:
+    *   Podcast Title: {podcast_title}
+    *   Podcast Author/Producer: {podcast_author} (This information often points to the main host or production team)
+    *   Podcast Description: {podcast_desc_for_prompt}
+
+2.  **Current Episode Information**:
+    *   Episode Title: {episode_title}
+    *   Episode Summary: {episode_summary_for_prompt}
+    *   Detailed Episode Notes (Shownotes):
+        ```text
+        {episode_shownotes_for_prompt}
+        ```
+        (Pay close attention to any host names, guest names, positions, or social media handles mentioned in the Shownotes.)
+
+3.  **Speakers to Identify and Their Information**:
+    ```json
+    {json.dumps(speaker_info_for_prompt, ensure_ascii=False, indent=2)}
+    ```
+    (Analyze dialogue samples and speech statistics to understand speaker roles and identities. DO NOT use speaker IDs to determine roles - SPEAKER_00 is not necessarily the host.)
+
+Task:
+Based on all the information above, assign the most accurate name or role to each "speaker_id".
+
+Analysis Guidance:
+* A host typically has more frequent, shorter segments, often introduces the show or guests, and may mention the podcast name
+* In panel discussion formats, there might be multiple hosts or co-hosts of similar speaking patterns
+* In interview formats, the host typically asks questions while guests give longer answers
+* Speakers who make introductory statements or welcome listeners are likely hosts
+* Use dialogue content (not just speaking patterns) to identify names and roles
+
+Output Requirements and Guidelines:
+*   Please return the result strictly in JSON format. The keys of the JSON object should be the original "speaker_id" (e.g., "SPEAKER_00"), and the values should be the identified person's name or role (string type).
+*   **Prioritize Specific Names/Nicknames**: If there is sufficient information (e.g., guests explicitly listed in Shownotes, or names mentioned in dialogue), please use the identified specific names, such as "John Doe", "AI Assistant", "Dr. Evelyn Reed". Do NOT append roles like "(Host)" or "(Guest)" if a specific name is found.
+*   **Host Identification**:
+    *   Hosts may be identified by analyzing speech patterns - they often speak more frequently in shorter segments
+    *   Look for introduction patterns in dialogue where speakers welcome listeners or introduce the show
+    *   The podcast author (if provided and credible) is often a host but verify through dialogue
+    *   There may be multiple hosts (co-hosts) in panel-style podcasts
+    *   If a host's name is identified, use the identified name directly (e.g., "Lex Fridman"). Do not append "(Host)".
+    *   If the host's name cannot be determined but the role is clearly a host, use "Podcast Host".
+*   **Guest Identification**:
+    *   Guests often give longer responses and speak less frequently than hosts
+    *   For other non-host speakers, if a specific name is identified, use the identified name directly (e.g., "John Carmack"). Do not append "(Guest)".
+    *   If specific names cannot be identified for guests, label them sequentially as "Guest 1", "Guest 2", etc.
+*   **Handling Multiple Hosts/Guests**: If there are multiple hosts or guests and they can be distinguished by name, use their names. If you cannot distinguish specific identities but know there are multiple hosts, use "Host 1", "Host 2", etc. Similarly for guests without specific names, use "Guest 1", "Guest 2".
+*   **Ensure Completeness**: The returned JSON object must include all "speaker_id"s listed in the input as keys.
+
+JSON Output Example:
+```json
+{{
+  "SPEAKER_00": "Jane Smith",
+  "SPEAKER_01": "Podcast Host",
+  "SPEAKER_02": "Alex Green"
+}}
+```
+Note that in this example, SPEAKER_01 is identified as the host, not SPEAKER_00, based on content analysis, not ID order.
+
+Please begin your analysis and provide the JSON result.
+"""
+
+        messages = [
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": user_prompt_template}
+        ]
+
+        # 预设默认映射，使用更智能的启发式方法而不是简单依赖顺序
+        final_map = {}
+        
+        # 尝试使用说话模式启发式方法来初步识别角色
+        # 1. 说话次数最多的可能是主持人
+        # 2. 有介绍性话语的可能是主持人
+        # 3. 其他角色先标记为嘉宾
+        
+        host_candidates = []
+        for speaker_id, stats in speaker_stats.items():
+            if stats["intro_likely"]:
+                host_candidates.append((speaker_id, 2))  # 优先级2：有介绍性话语
+            else:
+                # 按说话次数排序
+                host_candidates.append((speaker_id, stats["total_segments"]))
+        
+        # 按可能性排序（介绍性话语 > 说话次数）
+        host_candidates.sort(key=lambda x: (-1 if x[1] == 2 else 0, x[1]), reverse=True)
+        
+        if host_candidates:
+            # 最可能的主持人
+            host_id = host_candidates[0][0]
+            final_map[host_id] = "Podcast Host"
+            
+            # 其他人先标为嘉宾
+            guest_counter = 1
+            for speaker_id in unique_speaker_ids:
+                if speaker_id != host_id:
+                    final_map[speaker_id] = f"Guest {guest_counter}"
+                    guest_counter += 1
+        else:
+            # 如果没有明显线索，使用传统的顺序方法作为备选
+            is_host_assigned = False
+            guest_counter = 1
+            for speaker_id in unique_speaker_ids:
+                if not is_host_assigned:
+                    final_map[speaker_id] = "Podcast Host"
+                    is_host_assigned = True
+                else:
+                    final_map[speaker_id] = f"Guest {guest_counter}"
+                    guest_counter += 1
+            
+        try:
+            response = llm_router.chat_completion(
+                messages=messages, 
+                provider=self.llm_provider,
+                model=self.llm_model_name,
+                temperature=0.1, 
+                max_tokens=1024
+            )
+            assistant_response_content = response["choices"][0]["message"]["content"]
+            
+            parsed_llm_output = None
+            # 尝试从Markdown代码块中提取JSON
+            json_match = re.search(r'```json\s*(\{.*?\})\s*```', assistant_response_content, re.DOTALL)
+            if json_match:
+                json_str = json_match.group(1)
+            else:
+                # 如果没有markdown块，尝试找到第一个 '{' 到最后一个 '}'
+                first_brace = assistant_response_content.find('{')
+                last_brace = assistant_response_content.rfind('}')
+                if first_brace != -1 and last_brace != -1 and last_brace > first_brace:
+                    json_str = assistant_response_content[first_brace : last_brace+1]
+                else: # 如果还是找不到，就认为整个回复都是JSON（可能需要更复杂的清理）
+                    json_str = assistant_response_content.strip()
+            
+            try:
+                parsed_llm_output = json.loads(json_str)
+                if not isinstance(parsed_llm_output, dict): # 确保解析出来是字典
+                    print(f"LLM返回的JSON不是一个字典: {parsed_llm_output}")
+                    parsed_llm_output = None # 重置，以便使用默认值
+            except json.JSONDecodeError as e:
+                print(f"LLM返回的JSON解析失败: {e}")
+                print(f"用于解析的字符串: '{json_str}'")
+                # parsed_llm_output 保持为 None，将使用默认值
+
+            if parsed_llm_output:
+                # 直接使用LLM的有效输出，不再依赖预设的角色分配逻辑
+                final_map = {}
+                unknown_counter = 1
+                
+                # 先处理LLM识别出的角色
+                for spk_id in unique_speaker_ids:
+                    if spk_id in parsed_llm_output and isinstance(parsed_llm_output[spk_id], str) and parsed_llm_output[spk_id].strip():
+                        final_map[spk_id] = parsed_llm_output[spk_id].strip()
+                    else:
+                        # 如果LLM没有给出特定ID的结果，使用"Unknown Speaker"
+                        final_map[spk_id] = f"Unknown Speaker {unknown_counter}"
+                        unknown_counter += 1
+                
+                # 检查是否有"Host"或"主持人"标识
+                has_host = any("主持人" in name or "Host" in name for name in final_map.values())
+                
+                # 如果没有任何主持人标识，且存在"Unknown Speaker"，可以考虑将最活跃的未知说话人设为主持人
+                if not has_host and any("Unknown Speaker" in name for name in final_map.values()):
+                    # 找出最活跃的未知说话人
+                    most_active_unknown = None
+                    max_segments = 0
+                    
+                    for spk_id, name in final_map.items():
+                        if "Unknown Speaker" in name and spk_id in speaker_stats:
+                            if speaker_stats[spk_id]["total_segments"] > max_segments:
+                                max_segments = speaker_stats[spk_id]["total_segments"]
+                                most_active_unknown = spk_id
+                    
+                    if most_active_unknown:
+                        final_map[most_active_unknown] = "Podcast Host"
+            
+            return final_map
+
+        except Exception as e:
+            import traceback
+            print(f"调用LLM或处理响应时发生严重错误: {e}")
+            print(traceback.format_exc())
+            # 发生任何严重错误，返回初始的启发式映射
+            return final_map

src/podcast_transcribe/transcriber.py

@@ -0,0 +1,588 @@
+"""
+整合ASR和说话人分离的转录器模块，支持流式处理长语音对话
+"""
+
+import os
+from pydub import AudioSegment
+from typing import Dict, List, Union, Optional, Any
+import logging
+from concurrent.futures import ThreadPoolExecutor
+import re
+
+from .summary.speaker_identify import SpeakerIdentifier # 新增导入
+
+# 导入ASR和说话人分离模块，使用相对导入
+from .asr import asr_router
+from .asr.asr_base import TranscriptionResult
+from .diarization import diarizer_router
+from .schemas import EnhancedSegment, CombinedTranscriptionResult, PodcastChannel, PodcastEpisode, DiarizationResult
+
+# 配置日志
+logger = logging.getLogger("podcast_transcribe")
+
+class CombinedTranscriber:
+    """整合ASR和说话人分离的转录器"""
+    
+    def __init__(
+        self,
+        asr_model_name: str,
+        asr_provider: str,
+        diarization_provider: str,
+        diarization_model_name: str,
+        llm_model_name: Optional[str] = None,
+        llm_provider: Optional[str] = None,
+        hf_token: Optional[str] = None,
+        device: Optional[str] = None,
+        segmentation_batch_size: int = 64,
+        parallel: bool = False,
+    ):
+        """
+        初始化转录器
+        
+        参数:
+            asr_model_name: ASR模型名称
+            asr_provider: ASR提供者名称
+            diarization_provider: 说话人分离提供者名称
+            diarization_model_name: 说话人分离模型名称
+            hf_token: Hugging Face令牌
+            device: 推理设备，'cpu'或'cuda'
+            segmentation_batch_size: 分割批处理大小，默认为64
+            parallel: 是否并行执行ASR和说话人分离，默认为False
+        """
+        if not device:
+            import torch
+            if torch.backends.mps.is_available():
+                device = "mps"
+                if not llm_model_name:
+                    llm_model_name = "mlx-community/gemma-3-12b-it-4bit-DWQ"
+                if not llm_provider:
+                    llm_provider = "gemma-mlx"
+
+            elif torch.cuda.is_available():
+                device = "cuda"
+                if not llm_model_name:
+                    llm_model_name = "google/gemma-3-12b-it"
+                if not llm_provider:
+                    llm_provider = "gemma-transformers"
+            else:
+                device = "cpu"
+                if not llm_model_name:
+                    llm_model_name = "google/gemma-3-12b-it"
+                if not llm_provider:
+                    llm_provider = "gemma-transformers"
+
+        self.asr_model_name = asr_model_name
+        self.asr_provider = asr_provider
+        self.diarization_provider = diarization_provider
+        self.diarization_model_name = diarization_model_name
+        self.hf_token = hf_token or os.environ.get("HF_TOKEN")
+        self.device = device
+        self.segmentation_batch_size = segmentation_batch_size
+        self.parallel = parallel
+
+        self.speaker_identifier = SpeakerIdentifier(
+            llm_model_name=llm_model_name,
+            llm_provider=llm_provider
+        )
+        
+        logger.info(f"初始化组合转录器，ASR提供者: {asr_provider}，ASR模型: {asr_model_name}，分离提供者: {diarization_provider}，分离模型: {diarization_model_name}，分割批处理大小: {segmentation_batch_size}，并行执行: {parallel}，推理设备: {device}")
+    
+    
+    def _merge_adjacent_text_segments(self, segments: List[EnhancedSegment]) -> List[EnhancedSegment]:
+        """
+        合并相邻的、可能属于同一句子的 EnhancedSegment。
+        合并条件：同一说话人，时间基本连续，文本内容可拼接。
+        """
+        if not segments:
+            return []
+
+        merged_segments: List[EnhancedSegment] = []
+        if not segments: # 重复检查，可移除
+            return merged_segments
+
+        current_merged_segment = segments[0]
+
+        for i in range(1, len(segments)):
+            next_segment = segments[i]
+            
+            time_gap_seconds = next_segment.start - current_merged_segment.end
+            
+            can_merge_text = False
+            if current_merged_segment.text and next_segment.text:
+                current_text_stripped = current_merged_segment.text.strip()
+                if current_text_stripped and not current_text_stripped[-1] in ".。?!？！":
+                    can_merge_text = True
+            
+            if (current_merged_segment.speaker == next_segment.speaker and
+                0 <= time_gap_seconds < 0.75 and 
+                can_merge_text):
+                current_merged_segment = EnhancedSegment(
+                    start=current_merged_segment.start,
+                    end=next_segment.end,
+                    text=(current_merged_segment.text.strip() + " " + next_segment.text.strip()).strip(),
+                    speaker=current_merged_segment.speaker,
+                    language=current_merged_segment.language
+                )
+            else:
+                merged_segments.append(current_merged_segment)
+                current_merged_segment = next_segment
+        
+        merged_segments.append(current_merged_segment)
+        
+        return merged_segments
+
+    def _run_asr(self, audio: AudioSegment) -> TranscriptionResult:
+        """执行ASR处理"""
+        logger.debug("执行ASR...")
+        return asr_router.transcribe_audio(
+            audio,
+            provider=self.asr_provider,
+            model_name=self.asr_model_name,
+            device=self.device
+        )
+        
+    def _run_diarization(self, audio: AudioSegment) -> DiarizationResult:
+        """执行说话人分离处理"""
+        logger.debug("执行说话人分离...")
+        return diarizer_router.diarize_audio(
+            audio,
+            provider=self.diarization_provider,
+            model_name=self.diarization_model_name,
+            token=self.hf_token,
+            device=self.device,
+            segmentation_batch_size=self.segmentation_batch_size
+        )
+
+    def transcribe(self, audio: AudioSegment) -> CombinedTranscriptionResult:
+        """
+        转录整个音频 (新的非流式逻辑将在这里实现)
+        
+        参数:
+            audio: 要转录的AudioSegment对象
+            
+        返回:
+            包含完整转录和说话人信息的结果
+        """
+        logger.info(f"开始转录 {len(audio)/1000:.2f} 秒的音频 (非流式)")
+
+        if self.parallel:
+            # 并行执行ASR和说话人分离
+            logger.info("并行执行ASR和说话人分离")
+            with ThreadPoolExecutor(max_workers=2) as executor:
+                asr_future = executor.submit(self._run_asr, audio)
+                diarization_future = executor.submit(self._run_diarization, audio)
+                
+                asr_result: TranscriptionResult = asr_future.result()
+                diarization_result: DiarizationResult = diarization_future.result()
+                
+            logger.debug(f"ASR完成，识别语言: {asr_result.language}，得到 {len(asr_result.segments)} 个分段")
+            logger.debug(f"说话人分离完成，得到 {len(diarization_result.segments)} 个说话人分段，检测到 {diarization_result.num_speakers} 个说话人")
+        else:
+            # 顺序执行ASR和说话人分离
+            # 步骤1: 对整个音频执行ASR
+            logger.debug("执行ASR...")
+            asr_result: TranscriptionResult = asr_router.transcribe_audio(
+                audio,
+                provider=self.asr_provider,
+                model_name=self.asr_model_name,
+                device=self.device
+            )
+            logger.debug(f"ASR完成，识别语言: {asr_result.language}，得到 {len(asr_result.segments)} 个分段")
+
+            # 步骤2: 对整个音频执行说话人分离
+            logger.debug("执行说话人分离...")
+            diarization_result: DiarizationResult = diarizer_router.diarize_audio(
+                audio,
+                provider=self.diarization_provider,
+                model_name=self.diarization_model_name,
+                token=self.hf_token,
+                device=self.device,
+                segmentation_batch_size=self.segmentation_batch_size
+            )
+            logger.debug(f"说话人分离完成，得到 {len(diarization_result.segments)} 个说话人分段，检测到 {diarization_result.num_speakers} 个说话人")
+        
+        # 步骤3: 创建增强分段
+        all_enhanced_segments: List[EnhancedSegment] = self._create_enhanced_segments_with_splitting(
+            asr_result.segments, 
+            diarization_result.segments, 
+            asr_result.language
+        )
+        
+        # 步骤4: （可选）合并相邻的文本分段
+        if all_enhanced_segments:
+            logger.debug(f"合并前有 {len(all_enhanced_segments)} 个增强分段，尝试合并相邻分段...")
+            final_segments = self._merge_adjacent_text_segments(all_enhanced_segments)
+            logger.debug(f"合并后有 {len(final_segments)} 个增强分段")
+        else:
+            final_segments = []
+            logger.debug("没有增强分段可供合并。")
+
+        # 整理合并的文本
+        full_text = " ".join([segment.text for segment in final_segments]).strip()
+        
+        # 计算最终说话人数
+        num_speakers_set = set(s.speaker for s in final_segments if s.speaker != "UNKNOWN")
+
+        return CombinedTranscriptionResult(
+            segments=final_segments,
+            text=full_text,
+            language=asr_result.language or "unknown",
+            num_speakers=len(num_speakers_set) if num_speakers_set else diarization_result.num_speakers
+        )
+
+    # 新方法：根据标点分割ASR文本片段
+    def _split_asr_segment_by_punctuation(
+        self,
+        asr_seg_text: str,
+        asr_seg_start: float,
+        asr_seg_end: float
+    ) -> List[Dict[str, Any]]:
+        """
+        根据标点符号分割ASR文本片段，并按字符比例估算子片段的时间戳。
+        返回: 字典列表，每个字典包含 'text', 'start', 'end'。
+        """
+        sentence_terminators = ".。?!？！;；"
+        # 正则表达式：匹配句子内容以及紧随其后的标点（如果存在）
+        # 使用 re.split 保留分隔符，然后重组
+        parts = re.split(f'([{sentence_terminators}])', asr_seg_text)
+
+        sub_texts_final = []
+        current_s = ""
+        for s_part in parts:
+            if not s_part:
+                continue
+            current_s += s_part
+            if s_part in sentence_terminators:
+                if current_s.strip():
+                    sub_texts_final.append(current_s.strip())
+                current_s = ""
+        if current_s.strip():
+            sub_texts_final.append(current_s.strip())
+
+        if not sub_texts_final or (len(sub_texts_final) == 1 and sub_texts_final[0] == asr_seg_text.strip()):
+            # 没有有效分割或分割后只有一个句子（等于原始文本）
+            return [{"text": asr_seg_text.strip(), "start": asr_seg_start, "end": asr_seg_end}]
+
+        output_sub_segments = []
+        total_text_len = len(asr_seg_text) # 使用原始文本长度进行比例计算
+        if total_text_len == 0:
+             return [{"text": "", "start": asr_seg_start, "end": asr_seg_end}]
+
+        current_time = asr_seg_start
+        original_duration = asr_seg_end - asr_seg_start
+
+        for i, sub_text in enumerate(sub_texts_final):
+            sub_len = len(sub_text)
+            sub_duration = (sub_len / total_text_len) * original_duration
+            
+            sub_start_time = current_time
+            sub_end_time = current_time + sub_duration
+            
+            # 对于最后一个分片，确保其结束时间与原始分段的结束时间一致，以避免累积误差
+            if i == len(sub_texts_final) - 1:
+                sub_end_time = asr_seg_end
+            
+            # 确保结束时间不超过原始结束时间，并且开始时间不晚于结束时间
+            sub_end_time = min(sub_end_time, asr_seg_end)
+            if sub_start_time >= sub_end_time and sub_start_time == asr_seg_end : # 如果开始等于原始结束，允许微小片段
+                 if sub_text: # 仅当有文本时
+                    output_sub_segments.append({"text": sub_text, "start": sub_start_time, "end": sub_end_time})
+            elif sub_start_time < sub_end_time :
+                output_sub_segments.append({"text": sub_text, "start": sub_start_time, "end": sub_end_time})
+
+            current_time = sub_end_time
+            if current_time >= asr_seg_end and i < len(sub_texts_final) -1: # 如果时间已用完，但还有句子
+                # 将剩余句子附加到最后一个有效的时间段，或创建零长度的段
+                logger.warning(f"时间已在分割过程中用尽，但仍有文本未分配时间。原始段: [{asr_seg_start}-{asr_seg_end}], 当前子句: '{sub_text}'")
+                # 为后续未分配时间的文本创建零时长或极短时长的片段，附着在末尾
+                for k in range(i + 1, len(sub_texts_final)):
+                    remaining_text = sub_texts_final[k]
+                    if remaining_text:
+                         output_sub_segments.append({"text": remaining_text, "start": asr_seg_end, "end": asr_seg_end})
+                break
+
+
+        # 如果处理后没有任何子分段（例如原始文本为空，或分割逻辑问题），返回原始信息作为一个分段
+        if not output_sub_segments and asr_seg_text.strip():
+            return [{"text": asr_seg_text.strip(), "start": asr_seg_start, "end": asr_seg_end}]
+        elif not output_sub_segments and not asr_seg_text.strip():
+             return [{"text": "", "start": asr_seg_start, "end": asr_seg_end}]
+
+
+        return output_sub_segments
+
+    # 新的核心方法：创建增强分段，包含说话人分配和按需分裂逻辑
+    def _create_enhanced_segments_with_splitting(
+        self,
+        asr_segments: List[Dict[str, Union[float, str]]],
+        diarization_segments: List[Dict[str, Union[float, str, int]]],
+        language: str
+    ) -> List[EnhancedSegment]:
+        """
+        为ASR分段分配说话人，如果ASR分段跨越多个说话人，则尝试按标点分裂。
+        """
+        final_enhanced_segments: List[EnhancedSegment] = []
+
+        if not asr_segments:
+            return []
+        
+        # 为了快速查找，可以预处理 diarization_segments，但对于数量不多的情况，直接遍历也可
+        # diarization_segments.sort(key=lambda x: x['start']) # 确保有序
+
+        for asr_seg in asr_segments:
+            asr_start = float(asr_seg["start"])
+            asr_end = float(asr_seg["end"])
+            asr_text = str(asr_seg["text"]).strip()
+
+            if not asr_text or asr_start >= asr_end: # 跳过无效的ASR分段
+                continue
+
+            # 找出与当前ASR分段在时间上重叠的所有说话人分段
+            overlapping_diar_segs = []
+            for diar_seg in diarization_segments:
+                diar_start = float(diar_seg["start"])
+                diar_end = float(diar_seg["end"])
+                
+                overlap_start = max(asr_start, diar_start)
+                overlap_end = min(asr_end, diar_end)
+                
+                if overlap_end > overlap_start: # 有重叠
+                    overlapping_diar_segs.append({
+                        "speaker": str(diar_seg["speaker"]),
+                        "start": diar_start,
+                        "end": diar_end,
+                        "overlap_duration": overlap_end - overlap_start
+                    })
+            
+            distinct_speakers_in_overlap = set(d['speaker'] for d in overlapping_diar_segs)
+
+            segments_to_process_further: List[Dict[str, Any]] = []
+
+            if len(distinct_speakers_in_overlap) > 1:
+                logger.debug(f"ASR段 [{asr_start:.2f}-{asr_end:.2f}] \"{asr_text[:50]}...\" 跨越 {len(distinct_speakers_in_overlap)} 个说话人。尝试按标点分裂。")
+                # 跨多个说话人，尝试按标点分裂ASR segment
+                sub_asr_segments_data = self._split_asr_segment_by_punctuation(
+                    asr_text,
+                    asr_start,
+                    asr_end
+                )
+                if len(sub_asr_segments_data) > 1:
+                     logger.debug(f"成功将ASR段分裂成 {len(sub_asr_segments_data)} 个子句。")
+                segments_to_process_further.extend(sub_asr_segments_data)
+            else:
+                # 单一说话人或无说话人重叠（也视为单一处理单位）
+                segments_to_process_further.append({"text": asr_text, "start": asr_start, "end": asr_end})
+
+            # 为每个原始或分裂后的ASR（子）分段分配说话人
+            for current_proc_seg_data in segments_to_process_further:
+                proc_text = current_proc_seg_data["text"].strip()
+                proc_start = current_proc_seg_data["start"]
+                proc_end = current_proc_seg_data["end"]
+
+                if not proc_text or proc_start >= proc_end: # 跳过无效的子分段
+                    continue
+
+                # 为当前处理的（可能是子）分段确定最佳说话人
+                speaker_overlaps_for_proc_seg = {}
+                for diar_seg_info in overlapping_diar_segs: # 使用之前计算的、与原始ASR段重叠的diar_segs
+                    # 现在需要计算这个 diar_seg_info 与 proc_seg 的重叠
+                    overlap_start = max(proc_start, diar_seg_info["start"])
+                    overlap_end = min(proc_end, diar_seg_info["end"])
+                    
+                    if overlap_end > overlap_start:
+                        overlap_duration = overlap_end - overlap_start
+                        speaker = diar_seg_info["speaker"]
+                        speaker_overlaps_for_proc_seg[speaker] = \
+                            speaker_overlaps_for_proc_seg.get(speaker, 0) + overlap_duration
+                
+                best_speaker = "UNKNOWN"
+                if speaker_overlaps_for_proc_seg:
+                    best_speaker = max(speaker_overlaps_for_proc_seg.items(), key=lambda x: x[1])[0]
+                elif overlapping_diar_segs: # 如果子分段本身没有重叠，但原始ASR段有
+                    # 可以选择原始ASR段中占比最大的，或者最近的
+                    # 为简化，如果子分段无直接重叠，也可能标记为UNKNOWN，或尝试找最近的
+                    # 这里采用：如果子分段无直接重叠，但在原始ASR段中有说话人，则使用原始ASR段中重叠最长的
+                    # （此逻辑分支效果待观察，更简单的是直接UNKNOWN）
+                    # 此处简化：若子分段无重叠，则为UNKNOWN
+                    pass # best_speaker 默认为 UNKNOWN
+
+                # 如果 best_speaker 仍为 UNKNOWN，但原始ASR段只有一个说话者，则使用该说话者
+                if best_speaker == "UNKNOWN" and len(distinct_speakers_in_overlap) == 1:
+                    best_speaker = list(distinct_speakers_in_overlap)[0]
+                elif best_speaker == "UNKNOWN" and not overlapping_diar_segs:
+                    # 如果整个ASR段都没有任何说话人信息，则确实是UNKNOWN
+                    pass
+
+
+                final_enhanced_segments.append(
+                    EnhancedSegment(
+                        start=proc_start,
+                        end=proc_end,
+                        text=proc_text,
+                        speaker=best_speaker,
+                        language=language # 所有子分段继承原始ASR段的语言
+                    )
+                )
+        
+        # 对最终结果按开始时间排序
+        final_enhanced_segments.sort(key=lambda seg: seg.start)
+        return final_enhanced_segments
+
+    def transcribe_podcast(
+        self, 
+        audio: AudioSegment, 
+        podcast_info: PodcastChannel,
+        episode_info: PodcastEpisode,
+    ) -> CombinedTranscriptionResult:
+        """
+        专门针对播客剧集的音频转录方法
+        
+        参数:
+            audio: 要转录的AudioSegment对象
+            podcast_info: 播客频道信息
+            episode_info: 播客剧集信息
+            
+        返回:
+            包含完整转录和识别后说话人名称的结果
+        """
+        logger.info(f"开始转录播客剧集 {len(audio)/1000:.2f} 秒的音频")
+        
+        # 1. 先执行基础转录流程
+        transcription_result = self.transcribe(audio)
+
+        # 3. 识别说话人名称
+        logger.info("识别说话人名称...")
+        speaker_name_map = self.speaker_identifier.recognize_speaker_names(
+            transcription_result.segments,
+            podcast_info,
+            episode_info
+        )
+        
+        # 4. 将识别的说话人名称添加到转录结果中
+        enhanced_segments_with_names = []
+        for segment in transcription_result.segments:
+            # 复制原始段落并添加说话人名称
+            speaker_id = segment.speaker
+            speaker_name = speaker_name_map.get(speaker_id, None)
+            
+            # 创建新的段落对象，包含说话人名称
+            new_segment = EnhancedSegment(
+                start=segment.start,
+                end=segment.end,
+                text=segment.text,
+                speaker=speaker_id,
+                language=segment.language,
+                speaker_name=speaker_name
+            )
+            enhanced_segments_with_names.append(new_segment)
+        
+        # 5. 创建并返回新的转录结果
+        return CombinedTranscriptionResult(
+            segments=enhanced_segments_with_names,
+            text=transcription_result.text,
+            language=transcription_result.language,
+            num_speakers=transcription_result.num_speakers
+        )
+
+
+def transcribe_audio(
+    audio_segment: AudioSegment,
+    asr_model_name: str = "distil-whisper/distil-large-v3.5",
+    asr_provider: str = "distil_whisper_transformers",
+    diarization_model_name: str = "pyannote/speaker-diarization-3.1",
+    diarization_provider: str = "pyannote_transformers",
+    hf_token: Optional[str] = None,
+    device: Optional[str] = None,
+    segmentation_batch_size: int = 64,
+    parallel: bool = False,
+) -> CombinedTranscriptionResult: # 返回类型固定为 CombinedTranscriptionResult
+    """
+    整合ASR和说话人分离的音频转录函数 (仅支持非流式)
+    
+    参数:
+        audio_segment: 输入的AudioSegment对象
+        asr_model_name: ASR模型名称
+        asr_provider: ASR提供者名称
+        diarization_model_name: 说话人分离模型名称
+        diarization_provider: 说话人分离提供者名称
+        hf_token: Hugging Face令牌
+        device: 推理设备，'cpu'或'cuda'
+        segmentation_batch_size: 分割批处理大小，默认为64
+        parallel: 是否并行执行ASR和说话人分离，默认为False
+        
+    返回:
+        完整转录结果
+    """
+    logger.info(f"调用transcribe_audio函数 (非流式)，音频长度: {len(audio_segment)/1000:.2f}秒")
+    
+    transcriber = CombinedTranscriber(
+        asr_model_name=asr_model_name,
+        asr_provider=asr_provider,
+        diarization_model_name=diarization_model_name,
+        diarization_provider=diarization_provider,
+        hf_token=hf_token,
+        device=device,
+        segmentation_batch_size=segmentation_batch_size,
+        parallel=parallel
+    )
+    
+    # 直接调用 transcribe 方法
+    return transcriber.transcribe(audio_segment)
+
+def transcribe_podcast_audio(
+    audio_segment: AudioSegment,
+    podcast_info: PodcastChannel,
+    episode_info: PodcastEpisode,
+    asr_model_name: str = "distil-whisper/distil-large-v3.5",
+    asr_provider: str = "distil_whisper_transformers",
+    diarization_model_name: str = "pyannote/speaker-diarization-3.1",
+    diarization_provider: str = "pyannote_transformers",
+    llm_model_name: Optional[str] = None,
+    llm_provider: Optional[str] = None,
+    hf_token: Optional[str] = None,
+    device: Optional[str] = None,
+    segmentation_batch_size: int = 64,
+    parallel: bool = False,
+) -> CombinedTranscriptionResult:
+    """
+    针对播客剧集的音频转录函数，包含说话人名称识别
+    
+    参数:
+        audio_segment: 输入的AudioSegment对象
+        podcast_info: 播客频道信息
+        episode_info: 播客剧集信息
+        asr_model_name: ASR模型名称
+        asr_provider: ASR提供者名称
+        diarization_provider: 说话人分离提供者名称
+        diarization_model_name: 说话人分离模型名称
+        llm_model_name: LLM模型名称，如果为None则无法识别说话人名称
+        llm_provider: LLM提供者名称，如果为None则无法识别说话人名称
+        hf_token: Hugging Face令牌
+        device: 推理设备，'cpu'或'cuda'
+        segmentation_batch_size: 分割批处理大小，默认为64
+        parallel: 是否并行执行ASR和说话人分离，默认为False
+        
+    返回:
+        包含说话人名称的完整转录结果
+    """
+    logger.info(f"调用transcribe_podcast_audio函数，音频长度: {len(audio_segment)/1000:.2f}秒")
+    
+    transcriber = CombinedTranscriber(
+        asr_model_name=asr_model_name,
+        asr_provider=asr_provider,
+        diarization_provider=diarization_provider,
+        diarization_model_name=diarization_model_name,
+        llm_model_name=llm_model_name,
+        llm_provider=llm_provider,
+        hf_token=hf_token,
+        device=device,
+        segmentation_batch_size=segmentation_batch_size,
+        parallel=parallel
+    )
+    
+    # 调用播客专用转录方法
+    return transcriber.transcribe_podcast(
+        audio=audio_segment,
+        podcast_info=podcast_info,
+        episode_info=episode_info,
+    )

src/podcast_transcribe/webui/app.py

@@ -0,0 +1,585 @@
+import gradio as gr
+import requests
+import io
+from pydub import AudioSegment
+import traceback # 用于打印更详细的错误信息
+import tempfile
+import os
+import uuid
+import atexit
+import shutil
+
+# 尝试相对导入，这在通过 `python -m src.podcast_transcribe.webui.app` 运行时有效
+try:
+    from podcast_transcribe.rss.podcast_rss_parser import parse_podcast_rss
+    from podcast_transcribe.schemas import PodcastChannel, PodcastEpisode, CombinedTranscriptionResult, EnhancedSegment
+    from podcast_transcribe.transcriber import transcribe_podcast_audio
+except ImportError:
+    # 如果直接运行此脚本，并且项目根目录不在PYTHONPATH中，
+    # 则需要将项目根目录添加到 sys.path
+    import sys
+    import os
+    # 获取当前脚本文件所在的目录 (src/podcast_transcribe/webui)
+    current_dir = os.path.dirname(os.path.abspath(__file__))
+    # 获取项目根目录 (向上三级: webui -> podcast_transcribe -> src -> project_root)
+    # 修正：应该是 src 的父目录是项目根
+    project_root = os.path.dirname(os.path.dirname(os.path.dirname(current_dir)))
+    # 将 src 目录添加到 sys.path，因为模块是 podcast_transcribe.xxx
+    src_path = os.path.join(project_root, "src")
+    if src_path not in sys.path:
+        sys.path.insert(0, src_path)
+    
+    from podcast_transcribe.rss.podcast_rss_parser import parse_podcast_rss
+    from podcast_transcribe.schemas import PodcastChannel, PodcastEpisode, CombinedTranscriptionResult, EnhancedSegment
+    from podcast_transcribe.transcriber import transcribe_podcast_audio
+
+# 用于存储应用程序使用的所有临时文件路径
+temp_files = []
+
+def cleanup_temp_files():
+    """清理应用程序使用的临时文件"""
+    global temp_files
+    print(f"应用程序退出，清理 {len(temp_files)} 个临时文件...")
+    
+    for filepath in temp_files:
+        try:
+            if os.path.exists(filepath):
+                os.remove(filepath)
+                print(f"已删除临时文件: {filepath}")
+        except Exception as e:
+            print(f"无法删除临时文件 {filepath}: {e}")
+    
+    # 清空列表
+    temp_files = []
+
+# 注册应用程序退出时的清理函数
+atexit.register(cleanup_temp_files)
+
+def parse_rss_feed(rss_url: str):
+    """回调函数：解析 RSS Feed"""
+    print(f"开始解析RSS: {rss_url}")
+    
+    if not rss_url:
+        print("RSS地址为空")
+        return {
+            status_message_area: gr.update(value="错误：请输入 RSS 地址。"),
+            podcast_title_display: gr.update(value="", visible=False),
+            episode_dropdown: gr.update(choices=[], value=None, interactive=False),
+            podcast_data_state: None,
+            audio_player: gr.update(value=None),
+            current_audio_url_state: None,
+            episode_shownotes: gr.update(value="", visible=False),
+            transcription_output_df: gr.update(value=None, headers=["说话人", "文本", "时间"]),
+            transcribe_button: gr.update(interactive=False),
+            selected_episode_index_state: None
+        }
+    
+    try:
+        print(f"正在解析RSS: {rss_url}")
+        # 先更新状态消息，但由于不再使用生成器，我们直接在解析后更新UI
+        
+        podcast_data: PodcastChannel = parse_podcast_rss(rss_url)
+        print(f"RSS解析结果: 频道名称={podcast_data.title if podcast_data else 'None'}, 剧集数量={len(podcast_data.episodes) if podcast_data and podcast_data.episodes else 0}")
+        
+        if podcast_data and podcast_data.episodes:
+            choices = []
+            for i, episode in enumerate(podcast_data.episodes):
+                # 使用 (标题 (时长), guid 或索引) 作为选项
+                # 如果 guid 不可靠或缺失，可以使用索引
+                label = f"{episode.title or '无标题'} (时长: {episode.duration or '未知'})"
+                # 将 episode 对象直接作为值传递，或仅传递一个唯一标识符
+                # 为了简单起见，我们使用索引作为唯一ID，因为我们需要从 podcast_data_state 中检索完整的 episode
+                choices.append((label, i)) 
+            
+            # 显示播客标题
+            podcast_title = f"## 🎙️ {podcast_data.title or '未知播客'}"
+            if podcast_data.author:
+                podcast_title += f"\n**主播/制作人：** {podcast_data.author}"
+            if podcast_data.description:
+                # 限制描述长度，避免界面过长
+                description = podcast_data.description[:300]
+                if len(podcast_data.description) > 300:
+                    description += "..."
+                podcast_title += f"\n\n**播客简介：** {description}"
+            
+            return {
+                status_message_area: gr.update(value=f"成功解析到 {len(podcast_data.episodes)} 个剧集。请选择一个剧集。"),
+                podcast_title_display: gr.update(value=podcast_title, visible=True),
+                episode_dropdown: gr.update(choices=choices, value=None, interactive=True),
+                podcast_data_state: podcast_data,
+                audio_player: gr.update(value=None),
+                current_audio_url_state: None,
+                episode_shownotes: gr.update(value="", visible=False),
+                transcription_output_df: gr.update(value=None),
+                transcribe_button: gr.update(interactive=False),
+                selected_episode_index_state: None
+            }
+        elif podcast_data: # 有 channel 信息但没有 episodes
+            print("解析成功但未找到剧集")
+            podcast_title = f"## 🎙️ {podcast_data.title or '未知播客'}"
+            if podcast_data.author:
+                podcast_title += f"\n**主播/制作人：** {podcast_data.author}"
+            
+            return {
+                status_message_area: gr.update(value="解析成功，但未找到任何剧集。"),
+                podcast_title_display: gr.update(value=podcast_title, visible=True),
+                episode_dropdown: gr.update(choices=[], value=None, interactive=False),
+                podcast_data_state: podcast_data, # 仍然存储，以防万一
+                audio_player: gr.update(value=None),
+                current_audio_url_state: None,
+                episode_shownotes: gr.update(value="", visible=False),
+                transcription_output_df: gr.update(value=None),
+                transcribe_button: gr.update(interactive=False),
+                selected_episode_index_state: None
+            }
+        else:
+            print(f"解析RSS失败: {rss_url}")
+            return {
+                status_message_area: gr.update(value=f"解析 RSS失败: {rss_url}。请检查URL或网络连接。"),
+                podcast_title_display: gr.update(value="", visible=False),
+                episode_dropdown: gr.update(choices=[], value=None, interactive=False),
+                podcast_data_state: None,
+                audio_player: gr.update(value=None),
+                current_audio_url_state: None,
+                episode_shownotes: gr.update(value="", visible=False),
+                transcription_output_df: gr.update(value=None),
+                transcribe_button: gr.update(interactive=False),
+                selected_episode_index_state: None
+            }
+    except Exception as e:
+        print(f"解析 RSS 时发生错误: {e}")
+        traceback.print_exc()
+        return {
+            status_message_area: gr.update(value=f"解析 RSS 时发生严重错误: {e}"),
+            podcast_title_display: gr.update(value="", visible=False),
+            episode_dropdown: gr.update(choices=[], value=None, interactive=False),
+            podcast_data_state: None,
+            audio_player: gr.update(value=None),
+            current_audio_url_state: None,
+            episode_shownotes: gr.update(value="", visible=False),
+            transcription_output_df: gr.update(value=None),
+            transcribe_button: gr.update(interactive=False),
+            selected_episode_index_state: None
+        }
+
+def load_episode_audio(selected_episode_index: int, podcast_data: PodcastChannel):
+    """回调函数：当用户从下拉菜单选择一个剧集时加载音频"""
+    global temp_files
+    print(f"开始加载剧集音频，选择的索引: {selected_episode_index}")
+    
+    if selected_episode_index is None or podcast_data is None or not podcast_data.episodes:
+        print("未选择剧集或无播客数据")
+        return {
+            audio_player: gr.update(value=None),
+            current_audio_url_state: None,
+            status_message_area: gr.update(value="请先解析 RSS 并选择一个剧集。"),
+            episode_shownotes: gr.update(value="", visible=False),
+            transcription_output_df: gr.update(value=None),
+            local_audio_file_path: None,
+            transcribe_button: gr.update(interactive=False),
+            selected_episode_index_state: None
+        }
+
+    try:
+        episode = podcast_data.episodes[selected_episode_index]
+        audio_url = episode.audio_url
+        print(f"获取到剧集信息，标题: {episode.title}, 音频URL: {audio_url}")
+
+        # 准备剧集信息显示
+        episode_shownotes_content = ""
+        
+        # 准备shownotes内容
+        if episode.shownotes:
+            # 清理HTML标签并格式化shownotes
+            import re
+            # 简单的HTML标签清理
+            clean_shownotes = re.sub(r'<[^>]+>', '', episode.shownotes)
+            # 替换HTML实体
+            clean_shownotes = clean_shownotes.replace('&nbsp;', ' ').replace('&amp;', '&').replace('&lt;', '<').replace('&gt;', '>')
+            # 清理多余空白
+            clean_shownotes = re.sub(r'\s+', ' ', clean_shownotes).strip()
+            
+            episode_shownotes_content = f"### 📝 剧集详情\n\n**标题：** {episode.title or '无标题'}\n\n"
+            if episode.published_date:
+                episode_shownotes_content += f"**发布日期：** {episode.published_date.strftime('%Y年%m月%d日')}\n\n"
+            if episode.duration:
+                episode_shownotes_content += f"**时长：** {episode.duration}\n\n"
+            
+            episode_shownotes_content += f"**节目介绍：**\n\n{clean_shownotes}"
+        elif episode.summary:
+            # 如果没有shownotes，使用summary
+            episode_shownotes_content = f"### 📝 剧集详情\n\n**标题：** {episode.title or '无标题'}\n\n"
+            if episode.published_date:
+                episode_shownotes_content += f"**发布日期：** {episode.published_date.strftime('%Y年%m月%d日')}\n\n"
+            if episode.duration:
+                episode_shownotes_content += f"**时长：** {episode.duration}\n\n"
+            
+            episode_shownotes_content += f"**节目简介：**\n\n{episode.summary}"
+        else:
+            # 最基本的信息
+            episode_shownotes_content = f"### 📝 剧集详情\n\n**标题：** {episode.title or '无标题'}\n\n"
+            if episode.published_date:
+                episode_shownotes_content += f"**发布日期：** {episode.published_date.strftime('%Y年%m月%d日')}\n\n"
+            if episode.duration:
+                episode_shownotes_content += f"**时长：** {episode.duration}\n\n"
+
+        if audio_url:
+            # 更新状态消息
+            print(f"正在下载音频: {audio_url}")
+            
+            # 下载音频文件
+            try:
+                headers = {
+                    'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.114 Safari/537.36'
+                }
+                
+                # 创建临时文件
+                temp_dir = tempfile.gettempdir()
+                # 使用UUID生成唯一文件名，避免冲突
+                unique_filename = f"podcast_audio_{uuid.uuid4().hex}"
+                
+                # 先发送一个HEAD请求获取内容类型
+                head_response = requests.head(audio_url, timeout=30, headers=headers)
+                
+                # 根据内容类型确定文件扩展名
+                content_type = head_response.headers.get('Content-Type', '').lower()
+                if 'mp3' in content_type:
+                    file_ext = '.mp3'
+                elif 'mpeg' in content_type:
+                    file_ext = '.mp3'
+                elif 'mp4' in content_type or 'm4a' in content_type:
+                    file_ext = '.mp4'
+                elif 'wav' in content_type:
+                    file_ext = '.wav'
+                elif 'ogg' in content_type:
+                    file_ext = '.ogg'
+                else:
+                    # 默认扩展名
+                    file_ext = '.mp3'
+                
+                temp_filepath = os.path.join(temp_dir, unique_filename + file_ext)
+                
+                # 将文件路径添加到全局临时文件列表
+                temp_files.append(temp_filepath)
+                
+                # 保存到临时文件
+                # 使用流式下载，避免一次性加载整个文件到内存
+                with open(temp_filepath, 'wb') as f:
+                    # 使用流式响应并设置较大的块大小提高效率
+                    response = requests.get(audio_url, timeout=60, headers=headers, stream=True)
+                    response.raise_for_status()
+                    
+                    # 从响应中获取文件大小（如果服务器提供）
+                    total_size = int(response.headers.get('content-length', 0))
+                    downloaded = 0
+                    chunk_size = 8192  # 8KB 的块大小
+                    
+                    # 分块下载并写入文件
+                    for chunk in response.iter_content(chunk_size=chunk_size):
+                        if chunk:  # 过滤掉保持连接活跃的空块
+                            f.write(chunk)
+                            downloaded += len(chunk)
+                            # 可以在这里添加下载进度更新
+                            if total_size > 0:
+                                download_percentage = downloaded / total_size
+                                print(f"下载进度: {download_percentage:.1%}")
+                    
+                print(f"音频已下载到临时文件: {temp_filepath}")
+                
+                return {
+                    audio_player: gr.update(value=temp_filepath, label=f"当前播放: {episode.title or '无标题'}"),
+                    current_audio_url_state: audio_url,
+                    status_message_area: gr.update(value=f"已加载剧集: {episode.title or '无标题'}。"),
+                    episode_shownotes: gr.update(value=episode_shownotes_content, visible=True),
+                    transcription_output_df: gr.update(value=None),
+                    local_audio_file_path: temp_filepath,
+                    transcribe_button: gr.update(interactive=True),
+                    selected_episode_index_state: selected_episode_index
+                }
+            except requests.exceptions.RequestException as e:
+                print(f"下载音频失败: {e}")
+                traceback.print_exc()
+                return {
+                    audio_player: gr.update(value=None),
+                    current_audio_url_state: None,
+                    status_message_area: gr.update(value=f"错误：下载音频失败: {e}"),
+                    episode_shownotes: gr.update(value=episode_shownotes_content, visible=True),
+                    transcription_output_df: gr.update(value=None),
+                    local_audio_file_path: None,
+                    transcribe_button: gr.update(interactive=False),
+                    selected_episode_index_state: None
+                }
+        else:
+            print(f"剧集 '{episode.title}' 缺少有效的音频URL")
+            return {
+                audio_player: gr.update(value=None),
+                current_audio_url_state: None,
+                status_message_area: gr.update(value=f"错误：选中的剧集 '{episode.title}' 没有提供有效的音频URL。"),
+                episode_shownotes: gr.update(value=episode_shownotes_content, visible=True),
+                transcription_output_df: gr.update(value=None),
+                local_audio_file_path: None,
+                transcribe_button: gr.update(interactive=False),
+                selected_episode_index_state: None
+            }
+    except IndexError:
+        print(f"无效的剧集索引: {selected_episode_index}")
+        return {
+            audio_player: gr.update(value=None),
+            current_audio_url_state: None,
+            status_message_area: gr.update(value="错误：选择的剧集索引无效。"),
+            episode_shownotes: gr.update(value="", visible=False),
+            transcription_output_df: gr.update(value=None),
+            local_audio_file_path: None,
+            transcribe_button: gr.update(interactive=False),
+            selected_episode_index_state: None
+        }
+    except Exception as e:
+        print(f"加载音频时发生错误: {e}")
+        traceback.print_exc()
+        return {
+            audio_player: gr.update(value=None),
+            current_audio_url_state: None,
+            status_message_area: gr.update(value=f"加载音频时发生严重错误: {e}"),
+            episode_shownotes: gr.update(value="", visible=False),
+            transcription_output_df: gr.update(value=None),
+            local_audio_file_path: None,
+            transcribe_button: gr.update(interactive=False),
+            selected_episode_index_state: None
+        }
+
+def disable_buttons_before_transcription(local_audio_file_path: str):
+    """在开始转录前禁用按钮"""
+    print("禁用界面按钮以防止转录期间的交互")
+    return {
+        parse_button: gr.update(interactive=False),
+        episode_dropdown: gr.update(interactive=False),
+        transcribe_button: gr.update(interactive=False),
+        status_message_area: gr.update(value="开始转录过程，请耐心等待...")
+    }
+
+def start_transcription(local_audio_file_path: str, podcast_data: PodcastChannel, selected_episode_index: int, progress=gr.Progress(track_tqdm=True)):
+    """回调函数：开始转录当前加载的音频"""
+    print(f"开始转录本地音频文件: {local_audio_file_path}, 选中剧集索引: {selected_episode_index}")
+    
+    if not local_audio_file_path or not os.path.exists(local_audio_file_path):
+        print("没有可用的本地音频文件")
+        return {
+            transcription_output_df: gr.update(value=None),
+            status_message_area: gr.update(value="错误：没有有效的音频文件用于转录。请先选择一个剧集。"),
+            parse_button: gr.update(interactive=True),
+            episode_dropdown: gr.update(interactive=True),
+            transcribe_button: gr.update(interactive=True)
+        }
+
+    try:
+        # 先更新状态消息并禁用按钮
+        progress(0, desc="初始化转录过程...")
+        
+        # 使用progress回调来更新进度
+        progress(0.2, desc="加载音频文件...")
+        
+        # 从文件加载音频
+        audio_segment = AudioSegment.from_file(local_audio_file_path)
+        print(f"音频加载完成，时长: {len(audio_segment)/1000}秒")
+            
+        progress(0.4, desc="音频加载完成，开始转录 (此过程可能需要较长时间)...")
+        
+        # 获取当前选中的剧集信息
+        episode_info = None
+        if podcast_data and podcast_data.episodes and selected_episode_index is not None:
+            if 0 <= selected_episode_index < len(podcast_data.episodes):
+                episode_info = podcast_data.episodes[selected_episode_index]
+                print(f"获取到当前选中剧集信息: {episode_info.title if episode_info else '无'}")
+        
+        # 调用转录函数
+        print("开始转录音频...")
+        result: CombinedTranscriptionResult = transcribe_podcast_audio(audio_segment,
+                                                                       podcast_info=podcast_data,
+                                                                       episode_info=episode_info,
+                                                                       segmentation_batch_size=64,
+                                                                       parallel=True)
+        print(f"转录完成，结果: {result is not None}, 段落数: {len(result.segments) if result and result.segments else 0}")
+        progress(0.9, desc="转录完成，正在格式化结果...")
+        
+        if result and result.segments:
+            formatted_segments = []
+            for seg in result.segments:
+                time_str = f"{seg.start:.2f}s - {seg.end:.2f}s"
+                formatted_segments.append([seg.speaker, seg.speaker_name, seg.text, time_str])
+            
+            progress(1.0, desc="转录结果已生成!")
+            return {
+                transcription_output_df: gr.update(value=formatted_segments),
+                status_message_area: gr.update(value=f"转录完成！共 {len(result.segments)} 个片段。检测到 {result.num_speakers} 个说话人。"),
+                parse_button: gr.update(interactive=True),
+                episode_dropdown: gr.update(interactive=True),
+                transcribe_button: gr.update(interactive=True)
+            }
+        elif result: # 有 result 但没有 segments
+            progress(1.0, desc="转录完成，但无文本片段")
+            return {
+                transcription_output_df: gr.update(value=None),
+                status_message_area: gr.update(value="转录完成，但未生成任何文本片段。"),
+                parse_button: gr.update(interactive=True),
+                episode_dropdown: gr.update(interactive=True),
+                transcribe_button: gr.update(interactive=True)
+            }
+        else: # result 为 None
+            progress(1.0, desc="转录失败")
+            return {
+                transcription_output_df: gr.update(value=None),
+                status_message_area: gr.update(value="转录失败，未能获取结果。"),
+                parse_button: gr.update(interactive=True),
+                episode_dropdown: gr.update(interactive=True),
+                transcribe_button: gr.update(interactive=True)
+            }
+    except Exception as e:
+        print(f"转录过程中发生错误: {e}")
+        traceback.print_exc()
+        progress(1.0, desc="转录失败: 处理错误")
+        return {
+            transcription_output_df: gr.update(value=None),
+            status_message_area: gr.update(value=f"转录过程中发生严重错误: {e}"),
+            parse_button: gr.update(interactive=True),
+            episode_dropdown: gr.update(interactive=True),
+            transcribe_button: gr.update(interactive=True)
+        }
+
+# --- Gradio 界面定义 ---
+with gr.Blocks(title="播客转录工具 v2", css="""
+.status-message-container {
+    min-height: 50px;
+    height: auto;
+    max-height: none;
+    overflow-y: visible;
+    white-space: normal;
+    word-wrap: break-word;
+    margin-top: 10px;
+    margin-bottom: 10px;
+    border-radius: 6px;
+    background-color: rgba(32, 36, 45, 0.03);
+    border: 1px solid rgba(32, 36, 45, 0.1);
+    color: #303030;
+}
+.episode-cover {
+    max-width: 300px;
+    max-height: 300px;
+    border-radius: 8px;
+    box-shadow: 0 4px 8px rgba(0,0,0,0.1);
+}
+""") as demo:
+    gr.Markdown("# 🎙️ 播客转录工具")
+
+    # 状态管理
+    podcast_data_state = gr.State(None) # 存储解析后的 PodcastChannel 对象
+    current_audio_url_state = gr.State(None) # 存储当前选中剧集的音频URL
+    local_audio_file_path = gr.State(None) # 存储下载到本地的音频文件路径
+    selected_episode_index_state = gr.State(None) # 存储当前选中的剧集索引
+
+    with gr.Row():
+        rss_url_input = gr.Textbox(
+            label="播客 RSS 地址", 
+            placeholder="例如: https://your-podcast-feed.com/rss.xml",
+            elem_id="rss-url-input"
+        )
+        parse_button = gr.Button("🔗 解析 RSS", elem_id="parse-rss-button")
+
+    status_message_area = gr.Markdown(
+        "", 
+        elem_id="status-message",
+        elem_classes="status-message-container",  # 添加自定义CSS类
+        show_label=False
+    )
+
+    # 播客标题显示区域
+    podcast_title_display = gr.Markdown(
+        "",
+        visible=False,
+        elem_id="podcast-title-display"
+    )
+
+    episode_dropdown = gr.Dropdown(
+        label="选择剧集", 
+        choices=[], 
+        interactive=False, # 初始时不可交互，解析成功后设为 True
+        elem_id="episode-dropdown"
+    )
+    
+    # 剧集信息显示区域
+    with gr.Row():
+        with gr.Column(scale=2):
+            episode_shownotes = gr.Markdown(
+                "",
+                visible=False,
+                elem_id="episode-shownotes"
+            )
+    
+    audio_player = gr.Audio(
+        label="播客音频播放器", 
+        interactive=False, # 音频源由程序控制，用户不能直接修改
+        elem_id="audio-player"
+    )
+
+    transcribe_button = gr.Button("🔊 开始转录", elem_id="transcribe-button", interactive=False)
+    
+    gr.Markdown("## 📝 转录结果")
+    transcription_output_df = gr.DataFrame(
+        headers=["说话人ID", "说话人名称", "转录文本", "起止时间"], 
+        interactive=False,
+        wrap=True, # 允许文本换行
+        row_count=(10, "dynamic"), # 显示10行，可滚动
+        col_count=(4, "fixed"),
+        elem_id="transcription-output"
+    )
+
+    # --- 事件处理 ---
+    parse_button.click(
+        fn=parse_rss_feed,
+        inputs=[rss_url_input],
+        outputs=[
+            status_message_area, 
+            podcast_title_display,
+            episode_dropdown, 
+            podcast_data_state, 
+            audio_player, 
+            current_audio_url_state, 
+            episode_shownotes,
+            transcription_output_df,
+            transcribe_button,
+            selected_episode_index_state
+        ]
+    )
+
+    episode_dropdown.change(
+        fn=load_episode_audio,
+        inputs=[episode_dropdown, podcast_data_state],
+        outputs=[
+            audio_player, 
+            current_audio_url_state, 
+            status_message_area, 
+            episode_shownotes,
+            transcription_output_df,
+            local_audio_file_path,
+            transcribe_button,
+            selected_episode_index_state
+        ]
+    )
+
+    # 首先禁用按钮，然后执行转录
+    transcribe_button.click(
+        fn=disable_buttons_before_transcription,
+        inputs=[local_audio_file_path],
+        outputs=[parse_button, episode_dropdown, transcribe_button, status_message_area]
+    ).then(
+        fn=start_transcription,
+        inputs=[local_audio_file_path, podcast_data_state, selected_episode_index_state],
+        outputs=[transcription_output_df, status_message_area, parse_button, episode_dropdown, transcribe_button]
+    )
+
+if __name__ == "__main__":
+    try:
+        # demo.launch(debug=True, share=True) # share=True 会生成一个公开链接
+        demo.launch(debug=True)
+    finally:
+        # 确保在应用程序退出时清理临时文件
+        cleanup_temp_files()