updated audio

README.md

@@ -61,6 +61,46 @@ API_KEY="你的Key"
 - 讲解/MCQ 使用 OpenAI-compatible `/chat/completions`
 - TTS 优先尝试 `/audio/speech`，失败后回退 DashScope TTS 接口
 
+## 使用同 Organization 的 HF Audio Space 做 TTS
+
+你的 `audio` 项目已经暴露 API：`/tts_chunk(text, voice, language)`。
+
+### 1. 部署 `/Users/lexi/workplace/audio` 到 HF Space
+
+先在 Hugging Face 里创建组织下的 Space（例如 `your-org/audio`），然后推送代码：
+
+```bash
+cd /Users/lexi/workplace/audio
+git remote add hf https://huggingface.co/spaces/your-org/audio
+git push hf main
+```
+
+如果该 Space 是私有仓库，请在 HF 里创建一个可访问该组织 Space 的 token（read 权限即可调用）。
+
+### 2. 在 `/Users/lexi/workplace/genai/.env` 配置调用
+
+```env
+# 讲解/MCQ 仍走 DashScope/OpenAI-compatible
+API_UR="https://dashscope.aliyuncs.com/compatible-mode/v1"
+API_KEY="你的Key"
+USE_MOCK_MODELS=0
+
+# TTS 走 HF Space（优先）
+HF_TTS_SPACE_ID="your-org/audio"
+# 如果是私有 Space，填 token；公开 Space 可不填
+HF_TOKEN="hf_xxx"
+HF_TTS_API_NAME="/tts_chunk"
+HF_TTS_VOICE="male"      # male 或 female
+HF_TTS_LANGUAGE="Chinese"
+# 1=HF失败时回退到原有TTS；0=只用HF，失败就报错
+HF_TTS_ALLOW_FALLBACK=1
+```
+
+可选：
+
+- 如果你更希望用完整 URL，可以改为 `HF_TTS_SPACE_URL="https://your-org-audio.hf.space"`。
+- 如果不想回退到原 TTS 接口，设置 `HF_TTS_ALLOW_FALLBACK=0`。
+
 ## 角色目录结构（自动发现）
 
 下拉/角色按钮会自动读取 `characters/` 下的所有子目录。
@@ -112,4 +152,3 @@ pip install pypdf
 ### 3. MCQ 生成失败 / JSON 错误
 
 模型可能返回不完整 JSON，代码里已做重试与解析兜底；如果仍失败可重试一次或更换角色 prompt。
-

app.py

@@ -14,6 +14,11 @@ from typing import Any, Dict, List, Optional
 import gradio as gr
 import requests
 
+try:
+    from gradio_client import Client as HFSpaceClient
+except Exception:  # pragma: no cover
+    HFSpaceClient = None  # type: ignore
+
 try:
     import spaces  # type: ignore
 except Exception:
@@ -62,6 +67,18 @@ CHAT_MODEL_ID = os.getenv("QWEN_VL_MODEL_ID", "qwen-vl-max")
 TTS_MODEL_ID = os.getenv("QWEN_TTS_MODEL_ID", "qwen-tts")
 TTS_SPEAKER = os.getenv("QWEN_TTS_SPEAKER", "longxiaochun_v2")
 TTS_FORMAT = os.getenv("QWEN_TTS_FORMAT", "wav")
+HF_TTS_SPACE_ID = os.getenv("HF_TTS_SPACE_ID", "").strip()
+HF_TTS_SPACE_URL = os.getenv("HF_TTS_SPACE_URL", "").strip()
+_hf_tts_api_name_raw = (os.getenv("HF_TTS_API_NAME", "/tts_chunk") or "").strip()
+HF_TTS_API_NAME = f"/{_hf_tts_api_name_raw.lstrip('/')}" if _hf_tts_api_name_raw else "/tts_chunk"
+HF_TTS_VOICE = os.getenv("HF_TTS_VOICE", "male")
+HF_TTS_LANGUAGE = os.getenv("HF_TTS_LANGUAGE", "Chinese")
+HF_TTS_ALLOW_FALLBACK = os.getenv("HF_TTS_ALLOW_FALLBACK", "1") == "1"
+HF_TOKEN = (
+    os.getenv("HF_TOKEN")
+    or os.getenv("HUGGINGFACEHUB_API_TOKEN")
+    or os.getenv("HF_API_TOKEN", "")
+)
 API_TIMEOUT_SEC = int(os.getenv("API_TIMEOUT_SEC", "180"))
 QWEN_VL_MAX_PAGES = int(os.getenv("QWEN_VL_MAX_PAGES", "4"))
 QWEN_VL_RENDER_SCALE = float(os.getenv("QWEN_VL_RENDER_SCALE", "1.5"))
@@ -388,6 +405,54 @@ def _save_binary_audio(audio_bytes: bytes, out_path: str) -> str:
     return out_path
 
 
+def _is_hf_tts_enabled() -> bool:
+    return bool(HF_TTS_SPACE_ID or HF_TTS_SPACE_URL)
+
+
+def _tts_backend_name() -> str:
+    if _is_hf_tts_enabled():
+        return f"hf_space:{HF_TTS_SPACE_ID or HF_TTS_SPACE_URL}"
+    if USE_MOCK_MODELS:
+        return "mock_tts"
+    return "api_tts"
+
+
+def _extract_audio_source(result: Any) -> str:
+    if isinstance(result, str):
+        return result
+    if isinstance(result, dict):
+        for key in ("path", "name", "url"):
+            value = result.get(key)
+            if isinstance(value, str) and value.strip():
+                return value
+        nested = result.get("audio")
+        if nested is not None:
+            return _extract_audio_source(nested)
+    if isinstance(result, (list, tuple)):
+        for item in result:
+            try:
+                return _extract_audio_source(item)
+            except RuntimeError:
+                continue
+    raise RuntimeError(f"Unsupported HF Space audio output: {result!r}")
+
+
+def _read_audio_bytes_from_source(source: str) -> bytes:
+    source = (source or "").strip()
+    if not source:
+        raise RuntimeError("HF Space returned an empty audio source.")
+    if source.startswith("http://") or source.startswith("https://"):
+        resp = requests.get(source, timeout=API_TIMEOUT_SEC)
+        if resp.status_code >= 400:
+            raise RuntimeError(f"Failed to fetch HF Space audio URL {resp.status_code}: {resp.text[:500]}")
+        return resp.content
+
+    path = Path(source)
+    if path.exists():
+        return path.read_bytes()
+    raise RuntimeError(f"HF Space audio path does not exist: {source}")
+
+
 def split_text_for_tts(text: str, max_len: int = 480) -> List[str]:
     cleaned = re.sub(r"\s+", " ", (text or "")).strip()
     if not cleaned:
@@ -456,7 +521,7 @@ class QwenPipelineEngine:
     This ships with a mock mode by default so the workflow is runnable immediately.
     When USE_MOCK_MODELS=0, it calls remote APIs:
     - VL: OpenAI-compatible /chat/completions (works with DashScope compatible-mode and vLLM-style APIs)
-    - TTS: DashScope multimodal generation API (returns audio URL)
+    - TTS: HF Space /tts_chunk (optional) or DashScope/OpenAI-compatible endpoints
     """
 
     def __init__(self) -> None:
@@ -464,6 +529,7 @@ class QwenPipelineEngine:
         self.vl_loaded = False
         self.tts_loaded = False
         self._pdf_page_cache: Dict[str, List[str]] = {}
+        self._hf_tts_client: Any = None
 
     def ensure_vl_loaded(self) -> None:
         if self.vl_loaded:
@@ -479,6 +545,10 @@ class QwenPipelineEngine:
     def ensure_tts_loaded(self) -> None:
         if self.tts_loaded:
             return
+        if _is_hf_tts_enabled():
+            self._ensure_hf_tts_client()
+            self.tts_loaded = True
+            return
         if self.mock_mode:
             self.tts_loaded = True
             return
@@ -487,16 +557,76 @@ class QwenPipelineEngine:
             raise RuntimeError("Missing API_KEY for TTS API calls.")
         self.tts_loaded = True
 
+    def _ensure_hf_tts_client(self) -> Any:
+        if HFSpaceClient is None:
+            raise RuntimeError("Missing gradio_client. Please install with: pip install gradio_client")
+        if self._hf_tts_client is not None:
+            return self._hf_tts_client
+        src = HF_TTS_SPACE_URL or HF_TTS_SPACE_ID
+        if not src:
+            raise RuntimeError("Missing HF_TTS_SPACE_ID or HF_TTS_SPACE_URL.")
+        token = (HF_TOKEN or "").strip()
+        # gradio_client constructor args differ across versions; handle both old/new signatures.
+        if not token:
+            self._hf_tts_client = HFSpaceClient(src)
+            return self._hf_tts_client
+        try:
+            self._hf_tts_client = HFSpaceClient(src, hf_token=token)
+        except TypeError:
+            try:
+                self._hf_tts_client = HFSpaceClient(src, token=token)
+            except TypeError:
+                self._hf_tts_client = HFSpaceClient(src, headers={"Authorization": f"Bearer {token}"})
+        return self._hf_tts_client
+
+    def _hf_space_tts_single(self, text: str, out_path: str) -> str:
+        client = self._ensure_hf_tts_client()
+        configured = (HF_TTS_API_NAME or "").strip()
+        normalized = configured.lstrip("/")
+        api_candidates: List[str] = []
+        for cand in [configured, f"/{normalized}" if normalized else "", normalized, "/tts_chunk", "tts_chunk", "/predict", "predict"]:
+            cand = cand.strip()
+            if cand and cand not in api_candidates:
+                api_candidates.append(cand)
+
+        result: Any = None
+        last_exc: Optional[Exception] = None
+        for api_name in api_candidates:
+            try:
+                result = client.predict(
+                    text,
+                    HF_TTS_VOICE,
+                    HF_TTS_LANGUAGE,
+                    api_name=api_name,
+                )
+                last_exc = None
+                break
+            except Exception as exc:
+                msg = str(exc)
+                if "Cannot find a function with api_name" in msg:
+                    last_exc = exc
+                    continue
+                raise
+        if last_exc is not None:
+            available_hint = ""
+            view_api = getattr(client, "view_api", None)
+            if callable(view_api):
+                try:
+                    api_info = view_api(return_format="dict")
+                    available_hint = f" Available endpoints: {api_info}"
+                except Exception:
+                    available_hint = ""
+            tried = ", ".join(api_candidates)
+            raise RuntimeError(f"No matching HF API endpoint. Tried: [{tried}].{available_hint}") from last_exc
+        source = _extract_audio_source(result)
+        audio_bytes = _read_audio_bytes_from_source(source)
+        return _save_binary_audio(audio_bytes, out_path)
+
     def _mock_generate_lecture(self, pdf_excerpt: str) -> str:
         excerpt = re.sub(r"\s+", " ", pdf_excerpt).strip()
         excerpt = excerpt[:1000]
         return (
-            "这是一段基于论文内容的课堂讲解（Mock 模式）。\n\n"
-            "1. 论文问题与背景：该工作试图解决一个具体任务中的效率/性能/泛化问题，核心动机通常是现有方法在成本、准确性或可解释性方面存在不足。\n"
-            "2. 核心方法：作者提出新的模型结构、训练策略或推理流程，并通过若干模块协同完成任务。\n"
-            "3. 实验与结果：论文通常会在标准数据集上与基线比较，并报告性能提升、效率改善或更稳定的表现。\n"
-            "4. 局限与适用场景：方法可能依赖特定数据分布、计算资源或任务设定，迁移到新领域需要额外验证。\n\n"
-            f"论文节选（用于生成讲解）: {excerpt}"
+            f" {excerpt}"
         )
 
     def _mock_generate_mcqs(self, lecture_text: str) -> List[MCQItem]:
@@ -609,6 +739,16 @@ class QwenPipelineEngine:
     def _real_tts_single(self, text: str, out_path: str) -> str:
         if not text.strip():
             return write_tone_wav("empty", out_path)
+
+        if _is_hf_tts_enabled():
+            try:
+                return self._hf_space_tts_single(text, out_path)
+            except Exception as exc:
+                if not HF_TTS_ALLOW_FALLBACK:
+                    raise RuntimeError(f"HF Space TTS failed and fallback is disabled: {type(exc).__name__}: {exc}")
+                if self.mock_mode:
+                    return write_tone_wav(text, out_path)
+
         openai_url = f"{_require_api_url()}/audio/speech"
         openai_payload = {
             "model": TTS_MODEL_ID,
@@ -787,7 +927,7 @@ class QwenPipelineEngine:
     def synthesize_tts(self, text: str, name_prefix: str = "audio") -> str:
         self.ensure_tts_loaded()
         out_path = str(TMP_DIR / f"{name_prefix}_{uuid.uuid4().hex}.wav")
-        if self.mock_mode:
+        if self.mock_mode and not _is_hf_tts_enabled():
             return write_tone_wav(text, out_path)
         return self._real_tts(text, out_path)
 
@@ -1576,14 +1716,20 @@ def play_lecture_audio(state: Dict[str, Any]):
     if not state.get("lecture_text"):
         state["status"] = "No lecture text available."
         return state, state["status"], state.get("lecture_audio_path"), "Generate lecture first."
+    backend = _tts_backend_name()
     try:
-        state["status"] = "Generating lecture audio..."
+        state["status"] = f"Generating lecture audio ({backend})..."
         state["lecture_audio_path"] = engine.synthesize_tts(state["lecture_text"], name_prefix="lecture")
         state["status"] = "Lecture audio ready."
-        return state, state["status"], state["lecture_audio_path"], "Lecture audio generated."
+        return state, state["status"], state["lecture_audio_path"], f"Lecture audio generated via `{backend}`."
     except Exception as exc:
         state["status"] = "Lecture audio generation failed."
-        return state, state["status"], state.get("lecture_audio_path"), f"TTS error: {type(exc).__name__}: {exc}"
+        return (
+            state,
+            state["status"],
+            state.get("lecture_audio_path"),
+            f"TTS error via `{backend}`: {type(exc).__name__}: {exc}",
+        )
 
 
 def play_explanation_audio(state: Dict[str, Any]):
@@ -2454,6 +2600,7 @@ with gr.Blocks(css=CSS) as demo:
                         )
                     with gr.Row(elem_id="lecture-actions"):
                         play_lecture_btn = gr.Button("Play Lecture Audio", interactive=False, scale=0)
+                    lecture_feedback = gr.Markdown("")
                     with gr.Row(elem_id="exam-entry-wrap"):
                         exam_btn = gr.Button("Go to Exam", interactive=False, variant="secondary", scale=0)
 
@@ -2591,8 +2738,8 @@ with gr.Blocks(css=CSS) as demo:
     play_lecture_btn.click(
         fn=play_lecture_audio,
         inputs=[state],
-        outputs=[state, status_box, lecture_audio, feedback_box],
-        show_progress="hidden",
+        outputs=[state, status_box, lecture_audio, lecture_feedback],
+        show_progress="minimal",
     )
 
 

requirements.txt

@@ -1,4 +1,5 @@
 gradio
+gradio_client
 spaces
 requests
 pypdf