groq-whisper-cli 0.1.0__tar.gz

groq_whisper_cli-0.1.0/.gitignore

@@ -0,0 +1,30 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+tmp.*
+tmp/
+presentations/
+
+# Playwright
+node_modules/
+/test-results/
+/playwright-report/
+/blob-report/
+/playwright/.cache/
+/playwright/.auth/
+work_product/
+.env
+TODO
+archive/
+docs/
+key/
+backup_archives.ps1
+.codex/
+.opencode/

groq_whisper_cli-0.1.0/PKG-INFO

@@ -0,0 +1,115 @@
+Metadata-Version: 2.4
+Name: groq-whisper-cli
+Version: 0.1.0
+Summary: Groq Whisper 多 Key 并发语音转写 CLI 工具
+Author: Your Name
+License-Expression: MIT
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Multimedia :: Sound/Audio :: Speech
+Requires-Python: >=3.12
+Requires-Dist: httpx>=0.27
+Requires-Dist: numpy>=2.0
+Requires-Dist: onnxruntime>=1.19
+Requires-Dist: silero-vad>=5.1
+Description-Content-Type: text/markdown
+
+# groq-whisper-cli
+
+Groq Whisper 多 Key 并发语音转写 CLI 工具。
+
+## 功能
+
+- silero-vad 本地 VAD 智能切片
+- 多 API Key 配额感知负载均衡
+- 429 自动退避 + Key 切换
+- 异步并发协程池
+- 输出 SRT 字幕 + TXT 文本
+
+## 安装
+
+```bash
+# 直接通过 uvx 运行（无需安装）
+uvx run groq-whisper-cli -i audio.mp3
+
+# 或安装到本地
+uv tool install groq-whisper-cli
+groq-whisper-cli -i audio.mp3
+```
+
+## 前置要求
+
+- Python 3.12+
+- ffmpeg（用于音频提取）
+
+## API Key 配置
+
+按优先级查找：
+
+1. `--key-file` / `-k` 参数指定文件（每行一个 key）
+2. 当前目录下的 `key.txt`
+3. 环境变量 `GROQ_API_KEY`（多个 key 用逗号分隔）
+
+```bash
+# 方式一：环境变量
+export GROQ_API_KEY="gsk_xxx,gsk_yyy"
+
+# 方式二：key 文件
+echo "gsk_xxx" > key.txt
+echo "gsk_yyy" >> key.txt
+
+# 方式三：命令行参数
+groq-whisper-cli -i audio.mp3 -k /path/to/key.txt
+```
+
+## 用法
+
+```bash
+# 基本用法
+groq-whisper-cli -i audio.mp3
+
+# 指定语言和输出目录
+groq-whisper-cli -i video.mp4 -l en -o ./output
+
+# 多文件处理
+groq-whisper-cli -i *.mp4 -w 8
+
+# 完整参数
+groq-whisper-cli -i audio.mp3 \
+  -k key.txt \
+  -o ./transcript \
+  -w 4 \
+  --chunk-sec 120 \
+  -l zh \
+  --retries 8
+```
+
+## 参数
+
+| 参数 | 缩写 | 默认值 | 说明 |
+|------|------|--------|------|
+| `input` | - | 必填 | 输入文件路径，支持通配符 |
+| `--key-file` | `-k` | - | API Key 文件路径 |
+| `--out` | `-o` | `./transcript` | 输出目录 |
+| `--workers` | `-w` | `4` | 并发 worker 数 |
+| `--chunk-sec` | - | `120` | VAD 切片最大时长（秒） |
+| `--lang` | `-l` | `zh` | ISO-639-1 语言代码 |
+| `--retries` | - | `8` | 每个分片最大重试次数 |
+
+## 作为库使用
+
+```python
+from groq_whisper import GroqKeyManager, AudioSplitter, GroqTranscriber
+
+key_manager = GroqKeyManager(["gsk_xxx", "gsk_yyy"])
+splitter = AudioSplitter(max_chunk_sec=120)
+chunks = splitter.split("audio.mp3")
+
+transcriber = GroqTranscriber(key_manager=key_manager, language="zh")
+results = asyncio.run(transcriber.transcribe_all(chunks))
+```
+
+## License
+
+MIT

groq_whisper_cli-0.1.0/README.md

@@ -0,0 +1,98 @@
+# groq-whisper-cli
+
+Groq Whisper 多 Key 并发语音转写 CLI 工具。
+
+## 功能
+
+- silero-vad 本地 VAD 智能切片
+- 多 API Key 配额感知负载均衡
+- 429 自动退避 + Key 切换
+- 异步并发协程池
+- 输出 SRT 字幕 + TXT 文本
+
+## 安装
+
+```bash
+# 直接通过 uvx 运行（无需安装）
+uvx run groq-whisper-cli -i audio.mp3
+
+# 或安装到本地
+uv tool install groq-whisper-cli
+groq-whisper-cli -i audio.mp3
+```
+
+## 前置要求
+
+- Python 3.12+
+- ffmpeg（用于音频提取）
+
+## API Key 配置
+
+按优先级查找：
+
+1. `--key-file` / `-k` 参数指定文件（每行一个 key）
+2. 当前目录下的 `key.txt`
+3. 环境变量 `GROQ_API_KEY`（多个 key 用逗号分隔）
+
+```bash
+# 方式一：环境变量
+export GROQ_API_KEY="gsk_xxx,gsk_yyy"
+
+# 方式二：key 文件
+echo "gsk_xxx" > key.txt
+echo "gsk_yyy" >> key.txt
+
+# 方式三：命令行参数
+groq-whisper-cli -i audio.mp3 -k /path/to/key.txt
+```
+
+## 用法
+
+```bash
+# 基本用法
+groq-whisper-cli -i audio.mp3
+
+# 指定语言和输出目录
+groq-whisper-cli -i video.mp4 -l en -o ./output
+
+# 多文件处理
+groq-whisper-cli -i *.mp4 -w 8
+
+# 完整参数
+groq-whisper-cli -i audio.mp3 \
+  -k key.txt \
+  -o ./transcript \
+  -w 4 \
+  --chunk-sec 120 \
+  -l zh \
+  --retries 8
+```
+
+## 参数
+
+| 参数 | 缩写 | 默认值 | 说明 |
+|------|------|--------|------|
+| `input` | - | 必填 | 输入文件路径，支持通配符 |
+| `--key-file` | `-k` | - | API Key 文件路径 |
+| `--out` | `-o` | `./transcript` | 输出目录 |
+| `--workers` | `-w` | `4` | 并发 worker 数 |
+| `--chunk-sec` | - | `120` | VAD 切片最大时长（秒） |
+| `--lang` | `-l` | `zh` | ISO-639-1 语言代码 |
+| `--retries` | - | `8` | 每个分片最大重试次数 |
+
+## 作为库使用
+
+```python
+from groq_whisper import GroqKeyManager, AudioSplitter, GroqTranscriber
+
+key_manager = GroqKeyManager(["gsk_xxx", "gsk_yyy"])
+splitter = AudioSplitter(max_chunk_sec=120)
+chunks = splitter.split("audio.mp3")
+
+transcriber = GroqTranscriber(key_manager=key_manager, language="zh")
+results = asyncio.run(transcriber.transcribe_all(chunks))
+```
+
+## License
+
+MIT

groq_whisper_cli-0.1.0/groq_whisper/__init__.py

@@ -0,0 +1,6 @@
+from .key_manager import GroqKeyManager
+from .audio_splitter import AudioSplitter
+from .transcriber import GroqTranscriber
+from .utils import wav_bytes
+
+__all__ = ["GroqKeyManager", "AudioSplitter", "GroqTranscriber", "wav_bytes"]

groq_whisper_cli-0.1.0/groq_whisper/__main__.py

@@ -0,0 +1,232 @@
+"""
+Groq Whisper 多 Key 并发语音转写 CLI 工具
+
+支持 silero-vad 本地 VAD 切片、多 key 配额感知负载均衡、
+429 自动退避 + key 切换、并发协程池，输出 SRT + TXT。
+"""
+
+import argparse
+import asyncio
+import os
+import sys
+import time
+from pathlib import Path
+
+from . import GroqKeyManager, AudioSplitter, GroqTranscriber
+
+
+def _fmt_srt_time(sec: float) -> str:
+    h = int(sec // 3600)
+    m = int((sec % 3600) // 60)
+    s = sec % 60
+    return f"{h:02d}:{m:02d}:{s:06.3f}".replace(".", ",")
+
+
+def write_outputs(results: list[dict], video_path: str, out_dir: str):
+    stem = Path(video_path).stem
+    out = Path(out_dir)
+    out.mkdir(parents=True, exist_ok=True)
+
+    full_text_parts = []
+    srt_parts = []
+
+    for r in results:
+        if r is None:
+            continue
+        full_text_parts.append((r["start"], r["text"]))
+        srt_parts.append((r["start"], r["segments"]))
+
+    if not full_text_parts:
+        print(f"  Warning: all chunks failed for {Path(video_path).name}, no output written")
+        return
+
+    # TXT
+    full_text_parts.sort(key=lambda x: x[0])
+    txt_path = out / f"{stem}.txt"
+    txt_content = "\n".join(t[1] for t in full_text_parts)
+    txt_path.write_text(txt_content, encoding="utf-8")
+    print(f"  TXT -> {txt_path}")
+
+    # SRT
+    srt_lines = []
+    seg_idx = 0
+    srt_parts.sort(key=lambda x: x[0])
+    for chunk_start, segments in srt_parts:
+        for seg in segments:
+            seg_idx += 1
+            s = chunk_start + seg.get("start", 0)
+            e = chunk_start + seg.get("end", 0)
+            text = seg.get("text", "").strip()
+            if not text:
+                continue
+            srt_lines.append(f"{seg_idx}")
+            srt_lines.append(f"{_fmt_srt_time(s)} --> {_fmt_srt_time(e)}")
+            srt_lines.append(text)
+            srt_lines.append("")
+
+    srt_path = out / f"{stem}.srt"
+    srt_path.write_text("\n".join(srt_lines), encoding="utf-8")
+    print(f"  SRT -> {srt_path}")
+
+
+def load_keys(key_file: str | None) -> list[str]:
+    # 1. --key-file 参数优先
+    if key_file is not None:
+        if not Path(key_file).exists():
+            print(f"Error: key file not found: {key_file}")
+            sys.exit(1)
+        return _read_key_file(key_file)
+
+    # 2. 当前目录 key.txt
+    local_keys = Path("key.txt")
+    if local_keys.exists():
+        return _read_key_file(str(local_keys))
+
+    # 3. 环境变量 GROQ_API_KEY（逗号分隔）
+    env_keys = os.environ.get("GROQ_API_KEY", "").strip()
+    if env_keys:
+        keys = [k.strip() for k in env_keys.split(",") if k.strip()]
+        if keys:
+            return keys
+
+    return []
+
+
+def _read_key_file(path: str) -> list[str]:
+    text = Path(path).read_text(encoding="utf-8")
+    keys = [k.strip() for k in text.strip().splitlines() if k.strip() and not k.strip().startswith("#")]
+    return keys
+
+
+def progress_callback(completed: int, total: int, elapsed: float, eta: float, key_status: list[str]):
+    pass
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="groq-whisper-cli",
+        description="Transcribe long audio/video via Groq Whisper with multi-key concurrency",
+    )
+    parser.add_argument(
+        "input", nargs="+",
+        help="input MP4/audio file path(s), supports wildcards",
+    )
+    parser.add_argument(
+        "--key-file", "-k",
+        default=None,
+        help="path to key file (one key per line); falls back to GROQ_API_KEY env var",
+    )
+    parser.add_argument(
+        "--out", "-o",
+        default="./transcript",
+        help="output directory (default: ./transcript)",
+    )
+    parser.add_argument(
+        "--workers", "-w",
+        type=int, default=4,
+        help="number of concurrent workers (default: 4)",
+    )
+    parser.add_argument(
+        "--chunk-sec",
+        type=float, default=120.0,
+        help="max VAD chunk duration in seconds (default: 120)",
+    )
+    parser.add_argument(
+        "--lang", "-l",
+        default="zh",
+        help="audio language ISO-639-1 code (default: zh)",
+    )
+    parser.add_argument(
+        "--retries",
+        type=int, default=8,
+        help="max retries per chunk (default: 8)",
+    )
+
+    args = parser.parse_args()
+
+    # resolve input files
+    input_files = []
+    for pat in args.input:
+        p = Path(pat)
+        if any(c in pat for c in "*?"):
+            if p.is_absolute():
+                parent = p.parent
+                pattern = p.name
+                matched = list(parent.glob(pattern))
+            else:
+                matched = list(Path().glob(pat))
+        else:
+            matched = [p]
+        for m in matched:
+            if m.suffix.lower() in (".mp4", ".m4a", ".mp3", ".wav", ".flac", ".ogg"):
+                input_files.append(m)
+
+    if not input_files:
+        print("Error: no valid audio/video files found")
+        sys.exit(1)
+
+    # read keys
+    keys = load_keys(args.key_file)
+    if not keys:
+        print("Error: no API keys found. Use --key-file, set GROQ_API_KEY env var, or place key.txt in current directory")
+        sys.exit(1)
+    for i, k in enumerate(keys, 1):
+        print(f"  key{i}: {k[:16]}...{k[-4:]}")
+    print(f"Loaded {len(keys)} Groq API keys")
+
+    key_manager = GroqKeyManager(keys)
+    splitter = AudioSplitter(max_chunk_sec=args.chunk_sec)
+
+    total_chunks = 0
+
+    for video_idx, video_path in enumerate(input_files, 1):
+        print(f"\n[{video_idx}/{len(input_files)}] Processing: {video_path.name}")
+        print(f"  Path: {video_path.resolve()}")
+
+        t0 = time.monotonic()
+        chunks = splitter.split(str(video_path))
+        dt = time.monotonic() - t0
+        print(f"  Split: {len(chunks)} chunks in {dt:.1f}s")
+        total_chunks += len(chunks)
+
+        if not chunks:
+            print(f"  Warning: no valid audio chunks, skipping")
+            continue
+
+        total_audio_sec = sum(c["end"] - c["start"] for c in chunks)
+        print(f"  Total audio: {total_audio_sec:.0f}s ({total_audio_sec/60:.1f}min)")
+
+        transcriber = GroqTranscriber(
+            key_manager=key_manager,
+            language=args.lang,
+            workers=args.workers,
+            max_retries=args.retries,
+        )
+        transcriber.on_progress(progress_callback)
+
+        try:
+            results = asyncio.run(transcriber.transcribe_all(chunks))
+        except KeyboardInterrupt:
+            print("\nInterrupted by user")
+            sys.exit(1)
+        print()
+
+        success = sum(1 for r in results if r is not None)
+        failed = sum(1 for r in results if r is None)
+        print(f"  Result: {success}/{len(results)} ok", end="")
+        if failed:
+            print(f", {failed} failed", end="")
+        print()
+
+        write_outputs(results, str(video_path), args.out)
+
+    # final summary
+    print(f"\n{'='*40}")
+    print(f"All done: {len(input_files)} files, {total_chunks} chunks")
+    for line in key_manager.status_lines():
+        print(line)
+    print(f"{'='*40}")
+
+
+if __name__ == "__main__":
+    main()

groq_whisper_cli-0.1.0/groq_whisper/audio_splitter.py

@@ -0,0 +1,172 @@
+import subprocess
+import time
+import numpy as np
+from pathlib import Path
+from typing import Optional
+
+SAMPLE_RATE = 16000
+
+
+class AudioSplitter:
+    """ffmpeg 提取音频 + silero-vad 语音活动检测切片"""
+
+    def __init__(self, max_chunk_sec: float = 120.0, min_speech_ms: int = 1000, min_silence_ms: int = 500):
+        self.max_chunk_sec = max_chunk_sec
+        self.min_speech_ms = min_speech_ms
+        self.min_silence_ms = min_silence_ms
+        self._vad_model = None
+
+    def _load_vad(self):
+        if self._vad_model is None:
+            from silero_vad import load_silero_vad, get_speech_timestamps
+            self._vad_model = load_silero_vad(onnx=True)
+            self._get_speech_timestamps = get_speech_timestamps
+
+    def _ffmpeg_extract_pcm(self, mp4_path: str) -> np.ndarray:
+        """ffmpeg 提取音频为 16kHz mono float32 numpy array"""
+        import subprocess as sp
+        cmd = [
+            "ffmpeg", "-i", mp4_path,
+            "-f", "f32le",
+            "-acodec", "pcm_f32le",
+            "-ar", str(SAMPLE_RATE),
+            "-ac", "1",
+            "-loglevel", "error",
+            "-"
+        ]
+        try:
+            result = sp.run(cmd, capture_output=True, check=True)
+        except FileNotFoundError:
+            raise RuntimeError(
+                "ffmpeg not found. Please install ffmpeg: https://ffmpeg.org/download.html"
+            )
+        except sp.CalledProcessError as e:
+            raise RuntimeError(
+                f"ffmpeg failed (exit {e.returncode}): {e.stderr.decode(errors='replace')[:500]}"
+            ) from e
+        return np.frombuffer(result.stdout, dtype=np.float32)
+
+    def _get_duration_sec(self, mp4_path: str) -> float:
+        """ffprobe 获取音频时长（秒）"""
+        import subprocess as sp
+        import json
+        cmd = [
+            "ffprobe", "-v", "error",
+            "-show_entries", "format=duration",
+            "-of", "json",
+            mp4_path
+        ]
+        try:
+            result = sp.run(cmd, capture_output=True, check=True, text=True)
+        except FileNotFoundError:
+            raise RuntimeError(
+                "ffprobe not found. Please install ffmpeg: https://ffmpeg.org/download.html"
+            )
+        except sp.CalledProcessError as e:
+            raise RuntimeError(
+                f"ffprobe failed (exit {e.returncode}): {e.stderr.decode(errors='replace')[:500]}"
+            ) from e
+        data = json.loads(result.stdout)
+        return float(data["format"]["duration"])
+
+    def split(self, mp4_path: str) -> list[dict]:
+        """
+        提取音频并用 VAD 切分。
+
+        返回 [{"start": float, "end": float, "audio": np.ndarray}, ...]
+        """
+        self._load_vad()
+
+        path = Path(mp4_path)
+        if not path.exists():
+            raise FileNotFoundError(f"File not found: {mp4_path}")
+
+        t0 = time.monotonic()
+
+        total_sec = self._get_duration_sec(mp4_path)
+        file_size_mb = path.stat().st_size / 1024 / 1024
+        print(f"  File size: {file_size_mb:.0f}MB, duration: {total_sec:.0f}s ({total_sec/60:.1f}min)")
+
+        print(f"  ffmpeg extract PCM (16kHz mono)...", end=" ", flush=True)
+        t1 = time.monotonic()
+        audio = self._ffmpeg_extract_pcm(mp4_path)
+        print(f"{len(audio)/SAMPLE_RATE:.0f}s audio in {time.monotonic()-t1:.1f}s")
+
+        print(f"  silero-vad detecting speech...", end=" ", flush=True)
+        t1 = time.monotonic()
+        speech_ts = self._get_speech_timestamps(
+            audio,
+            self._vad_model,
+            sampling_rate=SAMPLE_RATE,
+            min_speech_duration_ms=self.min_speech_ms,
+            min_silence_duration_ms=self.min_silence_ms,
+        )
+        print(f"{len(speech_ts)} segments in {time.monotonic()-t1:.1f}s")
+
+        if not speech_ts:
+            print(f"  Warning: VAD detected no speech, falling back to uniform split")
+            return self._fallback_split(audio)
+
+        print(f"  Merging and splitting at {self.max_chunk_sec}s max...", end=" ", flush=True)
+        chunks = self._merge_and_chunk(audio, speech_ts)
+        total_audio = sum(c["end"] - c["start"] for c in chunks)
+        print(f"{len(chunks)} chunks, {total_audio:.0f}s audio, done in {time.monotonic()-t0:.1f}s")
+
+        # preview first few chunks
+        preview = min(3, len(chunks))
+        for i in range(preview):
+            dur = chunks[i]["end"] - chunks[i]["start"]
+            print(f"    chunk[{i}]: {chunks[i]['start']:.1f}s - {chunks[i]['end']:.1f}s ({dur:.1f}s)")
+        if len(chunks) > preview:
+            print(f"    ... {len(chunks)} total")
+
+        return chunks
+
+    def _merge_and_chunk(self, audio: np.ndarray, speech_ts: list) -> list[dict]:
+        """合并短语音段（间隔 < 1s），再按 max_chunk_sec 切分"""
+        merged = []
+        for seg in speech_ts:
+            start_s = seg["start"]
+            end_s = seg["end"]
+            if merged and (start_s - merged[-1]["end"]) / SAMPLE_RATE < 1.0:
+                merged[-1]["end"] = end_s
+            else:
+                merged.append({"start": start_s, "end": end_s})
+
+        chunks = []
+        for seg in merged:
+            start = seg["start"]
+            end = seg["end"]
+            dur_sec = (end - start) / SAMPLE_RATE
+
+            if dur_sec <= self.max_chunk_sec:
+                chunks.append({
+                    "start": start / SAMPLE_RATE,
+                    "end": end / SAMPLE_RATE,
+                    "audio": audio[start:end].copy(),
+                })
+            else:
+                chunk_samples = int(self.max_chunk_sec * SAMPLE_RATE)
+                for s in range(start, end, chunk_samples):
+                    e = min(s + chunk_samples, end)
+                    chunks.append({
+                        "start": s / SAMPLE_RATE,
+                        "end": e / SAMPLE_RATE,
+                        "audio": audio[s:e].copy(),
+                    })
+
+        return chunks
+
+    def _fallback_split(self, audio: np.ndarray) -> list[dict]:
+        """VAD 无结果回退：等距切片"""
+        total_samples = len(audio)
+        chunk_samples = int(self.max_chunk_sec * SAMPLE_RATE)
+        chunks = []
+        for s in range(0, total_samples, chunk_samples):
+            e = min(s + chunk_samples, total_samples)
+            chunks.append({
+                "start": s / SAMPLE_RATE,
+                "end": e / SAMPLE_RATE,
+                "audio": audio[s:e].copy(),
+            })
+        return chunks