shellus-voice2text 1.0.1__tar.gz

shellus_voice2text-1.0.1/PKG-INFO

@@ -0,0 +1,77 @@
+Metadata-Version: 2.4
+Name: shellus-voice2text
+Version: 1.0.1
+Summary: 火山引擎语音识别 CLI 工具
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: requests
+Requires-Dist: boto3
+
+# voice2text
+
+火山引擎语音识别 CLI 工具，支持智能缓存和并发处理。
+
+## 安装
+
+```bash
+pip install shellus-voice2text
+```
+
+## 使用
+
+```bash
+# 单文件处理
+voice2text audio.mp3
+
+# 批量处理（自动生成 .srt 文件）
+voice2text *.mp3
+
+# 输出纯文本
+voice2text audio.mp3 --txt
+
+# 输出 LRC 歌词
+voice2text audio.mp3 --lrc
+
+# 输出原始 JSON
+voice2text audio.mp3 --json
+
+# 控制并发数
+voice2text *.mp3 --max-workers 5
+```
+
+## 特性
+
+- **智能缓存**：相同文件自动跳过，避免重复识别
+- **并发处理**：支持多文件并发，默认3个
+- **自动输出**：完成后自动生成对应格式文件
+- **断点续传**：失败任务可重新运行，已完成的直接跳过
+
+## 配置
+
+首次使用运行交互式初始化：
+
+```bash
+voice2text init
+```
+
+配置保存在 `~/.voice2text/config.json`，包含：
+
+```json
+{
+  "app_key": "your_app_key",
+  "access_key": "your_access_key",
+  "resource_id": "volc.seedasr.auc",
+  "s3_endpoint": "https://tos-cn-guangzhou.volces.com",
+  "s3_bucket": "your_bucket",
+  "s3_access_key": "your_s3_key",
+  "s3_secret_key": "your_s3_secret",
+  "max_concurrent_tasks": "3"
+}
+```
+
+环境变量可覆盖配置文件：`VOLC_APP_KEY`, `VOLC_ACCESS_KEY`, `VOLC_RESOURCE_ID`, `S3_ENDPOINT`, `S3_BUCKET`, `S3_ACCESS_KEY`, `S3_SECRET_KEY`, `MAX_CONCURRENT_TASKS`。
+
+## API 文档
+
+- [大模型录音文件识别 API](https://www.volcengine.com/docs/6561/1354868)
+- [火山引擎控制台](https://console.volcengine.com/speech/service/8)

shellus_voice2text-1.0.1/README.md

@@ -0,0 +1,68 @@
+# voice2text
+
+火山引擎语音识别 CLI 工具，支持智能缓存和并发处理。
+
+## 安装
+
+```bash
+pip install shellus-voice2text
+```
+
+## 使用
+
+```bash
+# 单文件处理
+voice2text audio.mp3
+
+# 批量处理（自动生成 .srt 文件）
+voice2text *.mp3
+
+# 输出纯文本
+voice2text audio.mp3 --txt
+
+# 输出 LRC 歌词
+voice2text audio.mp3 --lrc
+
+# 输出原始 JSON
+voice2text audio.mp3 --json
+
+# 控制并发数
+voice2text *.mp3 --max-workers 5
+```
+
+## 特性
+
+- **智能缓存**：相同文件自动跳过，避免重复识别
+- **并发处理**：支持多文件并发，默认3个
+- **自动输出**：完成后自动生成对应格式文件
+- **断点续传**：失败任务可重新运行，已完成的直接跳过
+
+## 配置
+
+首次使用运行交互式初始化：
+
+```bash
+voice2text init
+```
+
+配置保存在 `~/.voice2text/config.json`，包含：
+
+```json
+{
+  "app_key": "your_app_key",
+  "access_key": "your_access_key",
+  "resource_id": "volc.seedasr.auc",
+  "s3_endpoint": "https://tos-cn-guangzhou.volces.com",
+  "s3_bucket": "your_bucket",
+  "s3_access_key": "your_s3_key",
+  "s3_secret_key": "your_s3_secret",
+  "max_concurrent_tasks": "3"
+}
+```
+
+环境变量可覆盖配置文件：`VOLC_APP_KEY`, `VOLC_ACCESS_KEY`, `VOLC_RESOURCE_ID`, `S3_ENDPOINT`, `S3_BUCKET`, `S3_ACCESS_KEY`, `S3_SECRET_KEY`, `MAX_CONCURRENT_TASKS`。
+
+## API 文档
+
+- [大模型录音文件识别 API](https://www.volcengine.com/docs/6561/1354868)
+- [火山引擎控制台](https://console.volcengine.com/speech/service/8)

shellus_voice2text-1.0.1/pyproject.toml

@@ -0,0 +1,17 @@
+[build-system]
+requires = ["setuptools>=45", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "shellus-voice2text"
+version = "1.0.1"
+description = "火山引擎语音识别 CLI 工具"
+readme = "README.md"
+requires-python = ">=3.7"
+dependencies = [
+    "requests",
+    "boto3",
+]
+
+[project.scripts]
+voice2text = "volc_asr.cli:main"

shellus_voice2text-1.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

shellus_voice2text-1.0.1/setup.py

@@ -0,0 +1,6 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="shellus-voice2text",
+    packages=find_packages(),
+)

shellus_voice2text-1.0.1/shellus_voice2text.egg-info/PKG-INFO

@@ -0,0 +1,77 @@
+Metadata-Version: 2.4
+Name: shellus-voice2text
+Version: 1.0.1
+Summary: 火山引擎语音识别 CLI 工具
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: requests
+Requires-Dist: boto3
+
+# voice2text
+
+火山引擎语音识别 CLI 工具，支持智能缓存和并发处理。
+
+## 安装
+
+```bash
+pip install shellus-voice2text
+```
+
+## 使用
+
+```bash
+# 单文件处理
+voice2text audio.mp3
+
+# 批量处理（自动生成 .srt 文件）
+voice2text *.mp3
+
+# 输出纯文本
+voice2text audio.mp3 --txt
+
+# 输出 LRC 歌词
+voice2text audio.mp3 --lrc
+
+# 输出原始 JSON
+voice2text audio.mp3 --json
+
+# 控制并发数
+voice2text *.mp3 --max-workers 5
+```
+
+## 特性
+
+- **智能缓存**：相同文件自动跳过，避免重复识别
+- **并发处理**：支持多文件并发，默认3个
+- **自动输出**：完成后自动生成对应格式文件
+- **断点续传**：失败任务可重新运行，已完成的直接跳过
+
+## 配置
+
+首次使用运行交互式初始化：
+
+```bash
+voice2text init
+```
+
+配置保存在 `~/.voice2text/config.json`，包含：
+
+```json
+{
+  "app_key": "your_app_key",
+  "access_key": "your_access_key",
+  "resource_id": "volc.seedasr.auc",
+  "s3_endpoint": "https://tos-cn-guangzhou.volces.com",
+  "s3_bucket": "your_bucket",
+  "s3_access_key": "your_s3_key",
+  "s3_secret_key": "your_s3_secret",
+  "max_concurrent_tasks": "3"
+}
+```
+
+环境变量可覆盖配置文件：`VOLC_APP_KEY`, `VOLC_ACCESS_KEY`, `VOLC_RESOURCE_ID`, `S3_ENDPOINT`, `S3_BUCKET`, `S3_ACCESS_KEY`, `S3_SECRET_KEY`, `MAX_CONCURRENT_TASKS`。
+
+## API 文档
+
+- [大模型录音文件识别 API](https://www.volcengine.com/docs/6561/1354868)
+- [火山引擎控制台](https://console.volcengine.com/speech/service/8)

shellus_voice2text-1.0.1/shellus_voice2text.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+README.md
+pyproject.toml
+setup.py
+shellus_voice2text.egg-info/PKG-INFO
+shellus_voice2text.egg-info/SOURCES.txt
+shellus_voice2text.egg-info/dependency_links.txt
+shellus_voice2text.egg-info/entry_points.txt
+shellus_voice2text.egg-info/requires.txt
+shellus_voice2text.egg-info/top_level.txt
+volc_asr/__init__.py
+volc_asr/__main__.py
+volc_asr/cache.py
+volc_asr/cli.py
+volc_asr/core.py

shellus_voice2text-1.0.1/shellus_voice2text.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

shellus_voice2text-1.0.1/shellus_voice2text.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+voice2text = volc_asr.cli:main

shellus_voice2text-1.0.1/shellus_voice2text.egg-info/requires.txt

@@ -0,0 +1,2 @@
+requests
+boto3

shellus_voice2text-1.0.1/shellus_voice2text.egg-info/top_level.txt

@@ -0,0 +1 @@
+volc_asr

shellus_voice2text-1.0.1/volc_asr/__init__.py

@@ -0,0 +1 @@
+# volc_asr package

shellus_voice2text-1.0.1/volc_asr/__main__.py

@@ -0,0 +1,4 @@
+from volc_asr.cli import main
+
+if __name__ == "__main__":
+    main()

shellus_voice2text-1.0.1/volc_asr/cache.py

@@ -0,0 +1,66 @@
+import hashlib
+import json
+from pathlib import Path
+from datetime import datetime
+
+CACHE_DIR = Path.home() / ".voice2text"
+TASKS_FILE = CACHE_DIR / "tasks.json"
+RESULTS_DIR = CACHE_DIR / "results"
+
+def compute_file_hash(filepath):
+    """计算文件唯一标识: sha256(绝对路径 + 文件内容hash)"""
+    path = Path(filepath).resolve()
+
+    # 计算文件内容hash
+    h = hashlib.sha256()
+    with open(path, "rb") as f:
+        for chunk in iter(lambda: f.read(8192), b""):
+            h.update(chunk)
+    content_hash = h.hexdigest()
+
+    # 组合路径和内容hash
+    combined = f"{path}:{content_hash}"
+    return hashlib.sha256(combined.encode()).hexdigest()
+
+def _ensure_cache_dir():
+    """确保缓存目录存在"""
+    CACHE_DIR.mkdir(parents=True, exist_ok=True)
+    RESULTS_DIR.mkdir(exist_ok=True)
+    if not TASKS_FILE.exists():
+        TASKS_FILE.write_text(json.dumps({"tasks": {}}, ensure_ascii=False))
+
+def _load_tasks():
+    """加载任务列表"""
+    _ensure_cache_dir()
+    return json.loads(TASKS_FILE.read_text())
+
+def _save_tasks(data):
+    """保存任务列表"""
+    TASKS_FILE.write_text(json.dumps(data, ensure_ascii=False, indent=2))
+
+def get_task(file_hash):
+    """获取任务，不存在返回 None"""
+    data = _load_tasks()
+    return data["tasks"].get(file_hash)
+
+def save_task(file_hash, task_data):
+    """立即保存任务状态"""
+    data = _load_tasks()
+    if file_hash not in data["tasks"]:
+        task_data["created"] = datetime.now().isoformat(timespec="seconds")
+    task_data["updated"] = datetime.now().isoformat(timespec="seconds")
+    data["tasks"][file_hash] = task_data
+    _save_tasks(data)
+
+def get_result(request_id):
+    """从缓存读取API结果，不存在返回 None"""
+    result_file = RESULTS_DIR / f"{request_id}.json"
+    if result_file.exists():
+        return json.loads(result_file.read_text())
+    return None
+
+def save_result(request_id, result):
+    """保存API结果到缓存"""
+    _ensure_cache_dir()
+    result_file = RESULTS_DIR / f"{request_id}.json"
+    result_file.write_text(json.dumps(result, ensure_ascii=False, indent=2))

shellus_voice2text-1.0.1/volc_asr/cli.py

@@ -0,0 +1,183 @@
+"""voice2text 统一批量处理入口"""
+
+import argparse
+import json
+import os
+import sys
+import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
+
+from volc_asr.cache import compute_file_hash, get_task, save_task, get_result, save_result, CACHE_DIR
+from volc_asr.core import load_config, CONFIG_FILE, prepare_audio_url, submit_task, query_result, format_result
+
+
+def process_file(filepath, config, fmt, force=False):
+    """处理单个文件：检查缓存 → 提交 → 轮询 → 保存结果"""
+    path = Path(filepath)
+    file_hash = compute_file_hash(filepath)
+    app_key = config["app_key"]
+    access_key = config["access_key"]
+    resource_id = config["resource_id"]
+
+    # 检查缓存
+    if not force:
+        task = get_task(file_hash)
+        if task and task.get("status") == "completed":
+            request_id = task["request_id"]
+            result = get_result(request_id)
+            if result:
+                print(f"[缓存] {path.name}", file=sys.stderr)
+                return {"file": str(path), "status": "completed", "result": result, "from_cache": True}
+
+        # 检查 pending 任务，继续轮询
+        if task and task.get("status") == "pending" and task.get("request_id"):
+            request_id = task["request_id"]
+            print(f"[继续] {path.name} ({request_id[:8]}...)", file=sys.stderr)
+        else:
+            request_id = None
+    else:
+        request_id = None
+
+    if not request_id:
+        # 准备音频URL
+        try:
+            audio_url = prepare_audio_url(str(path), config)
+        except Exception as e:
+            print(f"[失败] {path.name}: {e}", file=sys.stderr)
+            return {"file": str(path), "status": "failed", "error": str(e)}
+
+        # 提交任务
+        try:
+            request_id = submit_task(audio_url, app_key, access_key, resource_id)
+        except Exception as e:
+            print(f"[失败] {path.name}: {e}", file=sys.stderr)
+            return {"file": str(path), "status": "failed", "error": str(e)}
+
+        # 保存任务状态
+        save_task(file_hash, {
+            "file": str(path),
+            "request_id": request_id,
+            "status": "pending",
+        })
+
+        label = "[重新提交]" if force else "[提交]"
+        print(f"{label} {path.name} ({request_id[:8]}...)", file=sys.stderr)
+
+    # 轮询结果
+    while True:
+        time.sleep(3)
+        code, body = query_result(request_id, app_key, access_key, resource_id)
+
+        if code == "20000000":
+            save_result(request_id, body)
+            save_task(file_hash, {
+                "file": str(path),
+                "request_id": request_id,
+                "status": "completed",
+            })
+            print(f"[完成] {path.name}", file=sys.stderr)
+            return {"file": str(path), "status": "completed", "result": body, "from_cache": False}
+        elif code in ("20000001", "20000002"):
+            continue
+        else:
+            error = f"[{code}] {body}"
+            save_task(file_hash, {
+                "file": str(path),
+                "request_id": request_id,
+                "status": "failed",
+                "error": error,
+            })
+            print(f"[失败] {path.name}: {error}", file=sys.stderr)
+            return {"file": str(path), "status": "failed", "error": error}
+
+
+def init_config():
+    """交互式初始化配置"""
+    print("voice2text 配置初始化\n")
+
+    fields = [
+        ("app_key", "VOLC App Key", None),
+        ("access_key", "VOLC Access Key", None),
+        ("resource_id", "Resource ID", "volc.seedasr.auc"),
+        ("s3_endpoint", "S3 Endpoint", "https://tos-cn-guangzhou.volces.com"),
+        ("s3_bucket", "S3 Bucket", None),
+        ("s3_access_key", "S3 Access Key", None),
+        ("s3_secret_key", "S3 Secret Key", None),
+        ("max_concurrent_tasks", "最大并发数", "3"),
+    ]
+
+    # 读取已有配置
+    existing = {}
+    if CONFIG_FILE.exists():
+        existing = json.loads(CONFIG_FILE.read_text())
+
+    config = {}
+    for key, label, default in fields:
+        current = existing.get(key, default)
+        prompt = f"  {label}"
+        if current:
+            prompt += f" [{current}]"
+        prompt += ": "
+        val = input(prompt).strip()
+        config[key] = val if val else (current or "")
+
+    CACHE_DIR.mkdir(parents=True, exist_ok=True)
+    CONFIG_FILE.write_text(json.dumps(config, ensure_ascii=False, indent=2))
+    print(f"\n配置已保存到 {CONFIG_FILE}")
+
+
+def main():
+    # init 子命令单独处理
+    if len(sys.argv) >= 2 and sys.argv[1] == "init":
+        init_config()
+        return
+
+    parser = argparse.ArgumentParser(description="voice2text - 火山引擎语音识别工具",
+                                     epilog="子命令: voice2text init  交互式初始化配置")
+    parser.add_argument("files", nargs="+", help="音频文件路径")
+    parser.add_argument("--srt", action="store_true", help="输出SRT字幕 (默认)")
+    parser.add_argument("--txt", action="store_true", help="输出纯文本")
+    parser.add_argument("--json", action="store_true", help="输出原始JSON")
+    parser.add_argument("--lrc", action="store_true", help="输出LRC歌词")
+    parser.add_argument("--force", action="store_true", help="忽略缓存，强制重新识别")
+    parser.add_argument("--max-workers", type=int, default=None, help="最大并发数 (默认3)")
+    args = parser.parse_args()
+
+    try:
+        config = load_config()
+    except ValueError as e:
+        print(f"错误: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    max_workers = args.max_workers or int(config.get("max_concurrent_tasks", "3"))
+    fmt = "json" if args.json else "txt" if args.txt else "lrc" if args.lrc else "srt"
+
+    # 并发处理
+    with ThreadPoolExecutor(max_workers=max_workers) as executor:
+        futures = {
+            executor.submit(process_file, f, config, fmt, args.force): f
+            for f in args.files
+        }
+
+        results = []
+        for future in as_completed(futures):
+            results.append(future.result())
+
+    # 生成输出文件
+    for r in results:
+        if r["status"] == "completed":
+            path = Path(r["file"])
+            ext = {"srt": ".srt", "txt": ".txt", "json": ".json", "lrc": ".lrc"}[fmt]
+            out_path = path.with_suffix(ext)
+            out_path.write_text(format_result(r["result"], fmt), encoding="utf-8")
+
+    # 统计
+    total = len(results)
+    completed = sum(1 for r in results if r["status"] == "completed")
+    failed = total - completed
+    print(f"\n完成 {completed}/{total}" + (f" | 失败 {failed}" if failed else ""), file=sys.stderr)
+
+
+if __name__ == "__main__":
+    main()

shellus_voice2text-1.0.1/volc_asr/core.py

@@ -0,0 +1,176 @@
+"""火山引擎 ASR API 核心逻辑"""
+
+import json
+import os
+import uuid
+from pathlib import Path
+
+import boto3
+import requests
+
+from volc_asr.cache import CACHE_DIR
+
+SUBMIT_URL = "https://openspeech.bytedance.com/api/v3/auc/bigmodel/submit"
+QUERY_URL = "https://openspeech.bytedance.com/api/v3/auc/bigmodel/query"
+CONFIG_FILE = CACHE_DIR / "config.json"
+
+
+def load_config():
+    """加载配置：读取 ~/.voice2text/config.json，环境变量覆盖"""
+    config = {}
+    if CONFIG_FILE.exists():
+        config = json.loads(CONFIG_FILE.read_text())
+
+    # 环境变量覆盖（config key → 环境变量名）
+    env_map = {
+        "app_key": "VOLC_APP_KEY",
+        "access_key": "VOLC_ACCESS_KEY",
+        "resource_id": "VOLC_RESOURCE_ID",
+        "s3_endpoint": "S3_ENDPOINT",
+        "s3_bucket": "S3_BUCKET",
+        "s3_access_key": "S3_ACCESS_KEY",
+        "s3_secret_key": "S3_SECRET_KEY",
+        "max_concurrent_tasks": "MAX_CONCURRENT_TASKS",
+    }
+    for key, env_key in env_map.items():
+        env_val = os.getenv(env_key)
+        if env_val:
+            config[key] = env_val
+
+    # 默认值
+    config.setdefault("resource_id", "volc.seedasr.auc")
+    config.setdefault("max_concurrent_tasks", "3")
+
+    if not config.get("app_key") or not config.get("access_key"):
+        raise ValueError("请运行 voice2text init 初始化配置，或设置 VOLC_APP_KEY 和 VOLC_ACCESS_KEY 环境变量")
+
+    return config
+
+
+def make_headers(app_key, access_key, resource_id, request_id):
+    return {
+        "Content-Type": "application/json",
+        "X-Api-App-Key": app_key,
+        "X-Api-Access-Key": access_key,
+        "X-Api-Resource-Id": resource_id,
+        "X-Api-Request-Id": request_id,
+    }
+
+
+def guess_format(url):
+    lower = url.lower()
+    for fmt in ("mp3", "wav", "ogg", "m4a"):
+        if f".{fmt}" in lower:
+            return fmt
+    return "mp3"
+
+
+def prepare_audio_url(audio_input, config):
+    """处理音频输入，返回公网 URL。本地文件不存在或缺少配置时抛异常。"""
+    if audio_input.startswith(("http://", "https://")):
+        return audio_input
+
+    path = Path(audio_input)
+    if not path.exists():
+        raise FileNotFoundError(f"文件不存在: {audio_input}")
+
+    endpoint = config.get("s3_endpoint")
+    bucket = config.get("s3_bucket")
+    access_key = config.get("s3_access_key")
+    secret_key = config.get("s3_secret_key")
+    if not all([endpoint, bucket, access_key, secret_key]):
+        raise ValueError("本地文件需配置 s3_endpoint, s3_bucket, s3_access_key, s3_secret_key")
+
+    s3 = boto3.client(
+        "s3",
+        endpoint_url=endpoint,
+        aws_access_key_id=access_key,
+        aws_secret_access_key=secret_key,
+        region_name="cn-guangzhou",
+        config=boto3.session.Config(s3={'addressing_style': 'virtual'}),
+    )
+    key = f"{uuid.uuid4().hex}{path.suffix}"
+    s3.upload_file(str(path), bucket, key)
+    return s3.generate_presigned_url("get_object", Params={"Bucket": bucket, "Key": key}, ExpiresIn=86400)
+
+
+def submit_task(audio_url, app_key, access_key, resource_id):
+    """提交识别任务，返回 request_id。失败时抛 RuntimeError。"""
+    request_id = str(uuid.uuid4())
+    headers = make_headers(app_key, access_key, resource_id, request_id)
+    headers["X-Api-Sequence"] = "-1"
+
+    payload = {
+        "user": {"uid": "volc_asr_cli"},
+        "audio": {"format": guess_format(audio_url), "url": audio_url},
+        "request": {
+            "model_name": "bigmodel",
+            "enable_itn": True,
+            "enable_punc": True,
+            "show_utterances": True,
+        },
+    }
+
+    resp = requests.post(SUBMIT_URL, json=payload, headers=headers)
+    status_code = resp.headers.get("X-Api-Status-Code", "")
+    message = resp.headers.get("X-Api-Message", "")
+
+    if status_code != "20000000":
+        raise RuntimeError(f"提交失败: [{status_code}] {message}")
+
+    return request_id
+
+
+def query_result(request_id, app_key, access_key, resource_id):
+    """查询识别结果，返回 (status_code, body)"""
+    headers = make_headers(app_key, access_key, resource_id, request_id)
+    resp = requests.post(QUERY_URL, json={}, headers=headers)
+    status_code = resp.headers.get("X-Api-Status-Code", "")
+    body = resp.json() if resp.text.strip() else {}
+    return status_code, body
+
+
+def format_time(seconds):
+    h = int(seconds // 3600)
+    m = int((seconds % 3600) // 60)
+    s = int(seconds % 60)
+    ms = int((seconds % 1) * 1000)
+    return f"{h:02d}:{m:02d}:{s:02d},{ms:03d}"
+
+
+def to_srt(utterances):
+    lines = []
+    for i, seg in enumerate(utterances, 1):
+        start = seg["start_time"] / 1000
+        end = seg["end_time"] / 1000
+        lines.append(str(i))
+        lines.append(f"{format_time(start)} --> {format_time(end)}")
+        lines.append(seg["text"])
+        lines.append("")
+    return "\n".join(lines)
+
+
+def to_lrc(utterances):
+    lines = []
+    for seg in utterances:
+        start = seg["start_time"] / 1000
+        m = int(start // 60)
+        s = start % 60
+        lines.append(f"[{m:02d}:{s:05.2f}]{seg['text']}")
+    return "\n".join(lines)
+
+
+def format_result(body, fmt="srt"):
+    """按指定格式返回结果字符串。fmt: srt / txt / json / lrc"""
+    if fmt == "json":
+        return json.dumps(body, ensure_ascii=False, indent=2)
+    result = body.get("result", {})
+    if fmt == "txt":
+        return result.get("text", "")
+    utterances = result.get("utterances", [])
+    if fmt == "lrc":
+        return to_lrc(utterances) if utterances else result.get("text", "")
+    # srt
+    if utterances:
+        return to_srt(utterances)
+    return result.get("text", "")