fible 0.1.0__py3-none-any.whl

fible/__init__.py

@@ -0,0 +1 @@
+

fible/__main__.py

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

fible/cli.py

@@ -0,0 +1,218 @@
+#!/usr/bin/env python3
+"""fible — 一句话生成视频。  用法: fible "介绍一下量子计算"  """
+
+import argparse
+import glob
+import os
+import sys
+import time
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich import print as rprint
+
+from fible.pipeline.segmenter import segment_text
+from fible.pipeline.tts import generate_all_speeches, list_voices, DEFAULT_VOICE
+from fible.pipeline.matcher import download_materials
+from fible.pipeline.composer import compose_video
+from fible.config import (
+    text_hash, OUTPUT_DIR, SCRIPTS_DIR,
+    get_deepseek_api_key, DEEPSEEK_BASE_URL, DEEPSEEK_MODEL,
+)
+
+console = Console()
+
+SCRIPT_GEN_PROMPT = """你是一个专业的视频文案撰稿人。根据用户给出的主题，撰写一段适合口播配音的视频文案。
+
+要求：
+1. 长度控制在 300-800 字，适合 1-3 分钟的视频
+2. 语言口语化、自然流畅，像在跟朋友聊天
+3. 结构清晰：引入 → 展开 → 总结
+4. 有信息密度，不要空话套话
+5. 只输出文案正文，不要标题、署名、解释等任何额外内容"""
+
+
+def _generate_script(prompt: str) -> str:
+    """用 DeepSeek 根据 prompt 生成视频文案"""
+    from openai import OpenAI
+
+    print("  AI 正在为你撰写文案...\n")
+    client = OpenAI(
+        api_key=get_deepseek_api_key(),
+        base_url=DEEPSEEK_BASE_URL,
+    )
+    response = client.chat.completions.create(
+        model=DEEPSEEK_MODEL,
+        messages=[
+            {"role": "system", "content": SCRIPT_GEN_PROMPT},
+            {"role": "user", "content": prompt},
+        ],
+        temperature=0.8,
+        max_tokens=2048,
+    )
+    return response.choices[0].message.content.strip()
+
+
+def _run_pipeline(text: str, args, start_time: float) -> str:
+    """核心管线：文案 → 视频"""
+    session_id = text_hash(text)
+
+    if args.force:
+        rprint(f"[yellow]--force：清除会话 {session_id} 缓存[/yellow]")
+        base = str(OUTPUT_DIR)
+        for pattern in [
+            f"{session_id}_scene_*.mp3",
+            f"{session_id}_material_*.mp4",
+            f"{session_id}_scene_*.mp4",
+            f"{session_id}_concat_list.txt",
+        ]:
+            for f in glob.glob(os.path.join(base, pattern)):
+                os.remove(f)
+
+    # Step 1: 分镜
+    rprint("\n[bold cyan]▸ Step 1/4: AI 分镜分析[/bold cyan]")
+    script = segment_text(text, force=args.force)
+    scenes = script["scenes"]
+    title = script.get("title", "未命名")
+
+    table = Table(title=f"分镜脚本: {title}")
+    table.add_column("序号", style="dim")
+    table.add_column("旁白摘要", max_width=40)
+    table.add_column("时长", justify="right")
+    table.add_column("关键词")
+    for s in scenes:
+        table.add_row(
+            str(s["index"]),
+            s["narration"][:35] + ("..." if len(s["narration"]) > 35 else ""),
+            f"{s.get('duration_sec', '?')}s",
+            ", ".join(s.get("keywords_en", [])[:3])
+        )
+    console.print(table)
+
+    # Step 2: 配音
+    rprint("\n[bold cyan]▸ Step 2/4: 生成配音[/bold cyan]")
+    scenes = generate_all_speeches(scenes, session_id=session_id, voice=args.voice)
+
+    rprint(f"  完成 {len(scenes)} 段配音")
+    for s in scenes:
+        rprint(f"    分镜 {s['index']}: {s['narration'][:30]}... [{s.get('actual_duration_sec', 0):.1f}s]")
+
+    # Step 3: 素材匹配
+    if not args.no_material:
+        rprint("\n[bold cyan]▸ Step 3/4: 匹配素材[/bold cyan]")
+        scenes = download_materials(scenes, session_id=session_id)
+        matched = sum(1 for s in scenes if s.get("material_file"))
+        rprint(f"  匹配成功 {matched}/{len(scenes)} 个分镜")
+
+    # Step 4: 合成
+    rprint("\n[bold cyan]▸ Step 4/4: 合成视频[/bold cyan]")
+    output_path = compose_video(scenes, session_id=session_id, output_name=args.output)
+
+    elapsed = time.time() - start_time
+    rprint(Panel(f"[bold green]完成！[/bold green]\n"
+                 f"文件: {output_path}\n"
+                 f"耗时: {elapsed:.1f}s"))
+
+    return output_path
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="fible — 一句话生成视频",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+用法:
+  fible "介绍量子计算的发展历程"     AI 写稿 → 你确认 → 出片
+  fible -i 文案.txt                  直接用已有文案
+  fible -i 文案.txt -o 视频.mp4      指定输出路径
+  fible -i 文案.txt --no-material    纯配音+字幕
+  fible -i 文案.txt --force          忽略缓存
+  fible --list-voices                查看可用音色
+        """
+    )
+    parser.add_argument("prompt", nargs="?", help="一句话主题，AI 自动生成文案")
+    parser.add_argument("-i", "--input", help="已有文案文件路径 (.txt)")
+    parser.add_argument("-o", "--output", default="output.mp4", help="输出视频路径")
+    parser.add_argument("-v", "--voice", default=DEFAULT_VOICE, help="配音音色")
+    parser.add_argument("--list-voices", action="store_true", help="列出可用配音音色")
+    parser.add_argument("--no-material", action="store_true", help="不使用素材")
+    parser.add_argument("--force", action="store_true", help="忽略缓存，强制重新生成")
+
+    args = parser.parse_args()
+
+    if args.list_voices:
+        rprint("[bold]可用配音音色:[/bold]\n")
+        list_voices()
+        return
+
+    # 模式 1: -i 指定文案文件
+    if args.input:
+        if not os.path.exists(args.input):
+            rprint(f"[red]文件不存在: {args.input}[/red]")
+            sys.exit(1)
+        with open(args.input, "r", encoding="utf-8") as f:
+            text = f.read().strip()
+        if not text:
+            rprint("[red]文案文件为空[/red]")
+            sys.exit(1)
+
+        start_time = time.time()
+        _run_pipeline(text, args, start_time)
+        return
+
+    # 模式 2: 传入 prompt，AI 生成文案
+    if not args.prompt:
+        parser.print_help()
+        return
+
+    prompt = args.prompt
+    rprint(Panel(f"[bold]fible[/bold]\n主题: {prompt}\n音色: {args.voice}"))
+
+    # 检查是否有已保存的匹配文案
+    import hashlib
+    prompt_hash = hashlib.sha256(prompt.encode()).hexdigest()[:12]
+    saved_script_file = SCRIPTS_DIR / f"{prompt_hash}.txt"
+
+    if saved_script_file.exists() and not args.force:
+        with open(saved_script_file, "r", encoding="utf-8") as f:
+            text = f.read().strip()
+        rprint(f"\n[dim]找到已保存的文案 ({saved_script_file.name})[/dim]")
+        rprint(Panel(text, title="文案预览", border_style="dim"))
+        answer = input("\n使用这份文案？[Y/n] ").strip().lower()
+        if answer in ("", "y", "yes"):
+            start_time = time.time()
+            _run_pipeline(text, args, start_time)
+            return
+
+    # 生成新文案
+    text = _generate_script(prompt)
+    rprint(Panel(text, title="AI 生成的文案", border_style="green"))
+
+    print()
+    answer = input("确认使用这份文案生成视频？[Y/n/s(保存)] ").strip().lower()
+
+    if answer == "s":
+        saved_script_file.parent.mkdir(parents=True, exist_ok=True)
+        with open(saved_script_file, "w", encoding="utf-8") as f:
+            f.write(text)
+        rprint(f"[green]文案已保存到 {saved_script_file}[/green]")
+        answer2 = input("现在生成视频？[Y/n] ").strip().lower()
+        if answer2 not in ("", "y", "yes"):
+            rprint("下次运行相同主题时会复用这份文案。")
+            return
+    elif answer not in ("", "y", "yes"):
+        rprint("已取消。")
+        return
+
+    # 保存文案供复用
+    saved_script_file.parent.mkdir(parents=True, exist_ok=True)
+    with open(saved_script_file, "w", encoding="utf-8") as f:
+        f.write(text)
+
+    start_time = time.time()
+    _run_pipeline(text, args, start_time)
+
+
+if __name__ == "__main__":
+    main()

fible/config.py

@@ -0,0 +1,84 @@
+import os
+import hashlib
+import json
+import tempfile
+from pathlib import Path
+from dotenv import load_dotenv
+
+# 按优先级加载 .env：当前目录 → ~/.fible/.env
+load_dotenv(Path.cwd() / ".env")
+load_dotenv(Path.home() / ".fible" / ".env")
+
+DEEPSEEK_BASE_URL = "https://api.deepseek.com"
+DEEPSEEK_MODEL = "deepseek-chat"
+
+# 工作目录：优先 FIBLE_HOME，否则 ~/.fible/
+FIBLE_HOME = Path(os.getenv("FIBLE_HOME", Path.home() / ".fible"))
+FIBLE_HOME.mkdir(parents=True, exist_ok=True)
+
+OUTPUT_DIR = FIBLE_HOME / "output"
+OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+
+CACHE_DIR = FIBLE_HOME / "cache"
+CACHE_DIR.mkdir(parents=True, exist_ok=True)
+
+SCRIPTS_DIR = FIBLE_HOME / "scripts"
+SCRIPTS_DIR.mkdir(parents=True, exist_ok=True)
+
+# ffmpeg 中文字体路径（不同平台不同）
+_FONT_CANDIDATES = [
+    "/System/Library/Fonts/STHeiti Medium.ttc",  # macOS
+    "/usr/share/fonts/truetype/wqy/wqy-zenhei.ttc",  # Linux
+    "/usr/share/fonts/opentype/noto/NotoSansCJK-Regular.ttc",  # Linux
+    "C:/Windows/Fonts/simhei.ttf",  # Windows
+]
+FONT_PATH = next((f for f in _FONT_CANDIDATES if os.path.exists(f)), "")
+
+
+def get_deepseek_api_key():
+    key = os.getenv("DEEPSEEK_API_KEY")
+    if not key:
+        raise ValueError(
+            "请设置环境变量 DEEPSEEK_API_KEY。\n"
+            "注册: https://platform.deepseek.com/\n"
+            "方式: export DEEPSEEK_API_KEY=sk-xxx  或写入 ~/.fible/.env"
+        )
+    return key
+
+
+def get_pexels_api_key():
+    key = os.getenv("PEXELS_API_KEY")
+    if not key:
+        raise ValueError(
+            "请设置环境变量 PEXELS_API_KEY。\n"
+            "注册: https://www.pexels.com/api/\n"
+            "方式: export PEXELS_API_KEY=xxx  或写入 ~/.fible/.env"
+        )
+    return key
+
+
+def text_hash(text: str) -> str:
+    return hashlib.sha256(text.encode()).hexdigest()[:12]
+
+
+def save_json(data: dict, filepath: Path | str):
+    path = Path(filepath)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump(data, f, ensure_ascii=False, indent=2)
+
+
+def load_json(filepath: Path | str) -> dict | None:
+    path = Path(filepath)
+    if path.exists():
+        with open(path, "r", encoding="utf-8") as f:
+            return json.load(f)
+    return None
+
+
+def resolve_output_path(output_name: str) -> str:
+    p = Path(output_name)
+    if not p.is_absolute():
+        p = Path.cwd() / p
+    p.parent.mkdir(parents=True, exist_ok=True)
+    return str(p)

fible/pipeline/composer.py

@@ -0,0 +1,188 @@
+import os
+import subprocess
+from fible.config import OUTPUT_DIR, FONT_PATH, resolve_output_path
+
+
+def compose_video(scenes: list, session_id: str, output_name: str = "final.mp4") -> str:
+    output_path = resolve_output_path(output_name)
+    base = str(OUTPUT_DIR)
+    print(f"\n  合成视频 -> {output_path}")
+
+    temp_files = []
+
+    for scene in scenes:
+        material = scene.get("material_file")
+        audio = scene.get("audio_file")
+        dur = scene.get("actual_duration_sec", scene.get("duration_sec", 10))
+        narration = scene.get("narration", "")
+        idx_str = f"{scene['index']:02d}"
+
+        temp_output = os.path.join(base, f"{session_id}_scene_{idx_str}.mp4")
+        temp_files.append(temp_output)
+
+        if os.path.exists(temp_output) and os.path.getsize(temp_output) > 0:
+            print(f"    分镜 {scene['index']}: [缓存命中] 已渲染 ({dur:.1f}s)")
+            continue
+
+        cmd = ["ffmpeg", "-y"]
+
+        material_dur = _get_video_duration(material) if material else 0
+        need_loop = material_dur > 0 and material_dur < dur
+        if need_loop:
+            cmd += ["-stream_loop", "-1"]
+
+        if material and os.path.exists(material):
+            cmd += ["-i", material]
+
+        has_audio = audio and os.path.exists(audio)
+        if has_audio:
+            cmd += ["-i", audio]
+
+        filters = []
+
+        if material and os.path.exists(material):
+            filters.append(
+                f"[0:v]trim=0:{dur},setpts=PTS-STARTPTS,"
+                f"scale=1920:1080:force_original_aspect_ratio=decrease,"
+                f"pad=1920:1080:(ow-iw)/2:(oh-ih)/2,"
+                f"fps=30"
+            )
+        else:
+            filters.append(f"color=c=black:s=1920x1080:d={dur}:r=30")
+
+        timed_segments = _segment_by_speech(narration, dur)
+        font_size = 36
+        y_pos = "h-text_h-80"
+
+        fontfile = f"fontfile='{FONT_PATH}':" if FONT_PATH else ""
+
+        for seg in timed_segments:
+            escaped_text = _escape_drawtext(seg["text"])
+            filters.append(
+                f"drawtext={fontfile}text='{escaped_text}':"
+                f"fontsize={font_size}:fontcolor=white:"
+                f"x=(w-text_w)/2:y={y_pos}:"
+                f"bordercolor=black@0.6:borderw=2:"
+                f"enable='between(t,{seg['start']},{seg['end']})'"
+            )
+
+        vf_chain = ",".join(filters) + "[vout]"
+
+        if has_audio:
+            filter_complex = f"[1:a]atrim=0:{dur},afade=t=out:st={max(0, dur - 0.5)}:d=0.5[aout]"
+            full_filter = f"{filter_complex};{vf_chain}"
+            cmd += ["-filter_complex", full_filter,
+                    "-map", "[vout]", "-map", "[aout]"]
+        else:
+            cmd += ["-filter_complex", vf_chain,
+                    "-map", "[vout]"]
+
+        cmd += ["-c:v", "libx264", "-preset", "fast", "-crf", "23",
+                "-pix_fmt", "yuv420p",
+                "-t", str(dur)]
+
+        if has_audio:
+            cmd += ["-c:a", "aac", "-b:a", "128k"]
+
+        cmd.append(temp_output)
+
+        try:
+            subprocess.run(cmd, capture_output=True, check=True)
+            print(f"    分镜 {scene['index']}: 渲染完成 ({dur:.1f}s)" +
+                  (" [循环素材]" if need_loop else ""))
+        except subprocess.CalledProcessError as e:
+            stderr = e.stderr.decode("utf-8", errors="replace")
+            print(f"    分镜 {scene['index']}: 渲染失败")
+            print(f"      {stderr[-300:]}")
+            if os.path.exists(temp_output):
+                os.remove(temp_output)
+            temp_files.remove(temp_output)
+
+    if not temp_files:
+        raise RuntimeError("没有成功渲染的分镜，无法合成")
+
+    concat_list = os.path.join(base, f"{session_id}_concat_list.txt")
+    with open(concat_list, "w") as f:
+        for tf in temp_files:
+            f.write(f"file '{tf}'\n")
+
+    out_dir = os.path.dirname(output_path)
+    if out_dir:
+        os.makedirs(out_dir, exist_ok=True)
+
+    concat_cmd = [
+        "ffmpeg", "-y",
+        "-f", "concat", "-safe", "0",
+        "-i", concat_list,
+        "-c:v", "libx264", "-preset", "fast", "-crf", "23",
+        "-c:a", "aac", "-b:a", "128k",
+        "-pix_fmt", "yuv420p",
+        "-movflags", "+faststart",
+        output_path
+    ]
+
+    result = subprocess.run(concat_cmd, capture_output=True)
+    if result.returncode != 0:
+        stderr = result.stderr.decode("utf-8", errors="replace")
+        raise RuntimeError(f"视频拼接失败:\n{stderr[-500:]}")
+
+    print(f"\n  成品输出: {output_path}")
+    return output_path
+
+
+def _get_video_duration(filepath: str) -> float:
+    if not filepath or not os.path.exists(filepath):
+        return 0
+    result = subprocess.run(
+        ["ffprobe", "-v", "error", "-show_entries", "format=duration",
+         "-of", "default=noprint_wrappers=1:nokey=1", filepath],
+        capture_output=True, text=True
+    )
+    try:
+        return float(result.stdout.strip())
+    except ValueError:
+        return 0
+
+
+def _segment_by_speech(text: str, total_duration: float) -> list:
+    import re
+    parts = re.split(r'([，。！？,!\n])', text)
+
+    segments = []
+    current = ""
+    for part in parts:
+        if part in "，。！？,!\n":
+            current += part
+            if current.strip():
+                segments.append(current.strip())
+            current = ""
+        else:
+            current += part
+    if current.strip():
+        segments.append(current.strip())
+
+    if not segments:
+        segments = [text]
+
+    char_counts = [len(s) for s in segments]
+    total_chars = sum(char_counts) or 1
+
+    timed = []
+    elapsed = 0.0
+    for s in segments:
+        seg_dur = (len(s) / total_chars) * total_duration
+        timed.append({
+            "text": s,
+            "start": round(elapsed, 1),
+            "end": round(elapsed + seg_dur, 1),
+        })
+        elapsed += seg_dur
+
+    return timed
+
+
+def _escape_drawtext(text: str) -> str:
+    text = text.replace("'", "'\\\\\\''")
+    text = text.replace(":", "\\:")
+    text = text.replace("%", "\\\\%")
+    return text

fible/pipeline/matcher.py

@@ -0,0 +1,95 @@
+import os
+import requests
+from fible.config import get_pexels_api_key, OUTPUT_DIR
+
+PEXELS_VIDEO_URL = "https://api.pexels.com/videos/search"
+
+
+def _download_video(url: str, save_path: str):
+    headers = {"User-Agent": "Mozilla/5.0"}
+    resp = requests.get(url, headers=headers, stream=True, timeout=60)
+    resp.raise_for_status()
+    with open(save_path, "wb") as f:
+        for chunk in resp.iter_content(chunk_size=8192):
+            f.write(chunk)
+
+
+def search_videos(keywords: list, per_page: int = 5) -> list:
+    api_key = get_pexels_api_key()
+    headers = {"Authorization": api_key}
+
+    all_videos = []
+    for kw in keywords[:3]:
+        params = {"query": kw, "per_page": per_page, "orientation": "landscape"}
+        resp = requests.get(PEXELS_VIDEO_URL, headers=headers, params=params, timeout=15)
+        resp.raise_for_status()
+        videos = resp.json().get("videos", [])
+        all_videos.extend(videos)
+        if len(all_videos) >= per_page:
+            break
+
+    return all_videos
+
+
+def pick_best_clip(videos: list, target_duration: float) -> dict:
+    best = None
+    best_score = -1
+
+    for video in videos:
+        for vf in video.get("video_files", []):
+            if vf.get("width", 0) < 1280:
+                continue
+
+            duration = vf.get("duration", 0) or 15
+            dur_match = 1 - min(abs(duration - target_duration) / target_duration, 1)
+            quality = video.get("user", {}).get("name", "") != ""
+            score = dur_match * 0.7 + (0.3 if quality else 0)
+
+            if score > best_score:
+                best_score = score
+                best = vf
+
+    if best is None and videos:
+        best = videos[0].get("video_files", [{}])[0]
+
+    return best
+
+
+def download_materials(scenes: list, session_id: str) -> list:
+    base = str(OUTPUT_DIR)
+    for scene in scenes:
+        keywords = scene.get("keywords_en", [])
+        target_dur = scene.get("actual_duration_sec", scene.get("duration_sec", 10))
+        idx_str = f"{scene['index']:02d}"
+
+        save_path = os.path.join(base, f"{session_id}_material_{idx_str}.mp4")
+        if os.path.exists(save_path) and os.path.getsize(save_path) > 0:
+            scene["material_file"] = save_path
+            print(f"    分镜 {scene['index']}: [缓存命中] 素材已存在")
+            continue
+
+        if not keywords:
+            keywords = ["nature", "landscape"]
+
+        videos = search_videos(keywords)
+        clip = pick_best_clip(videos, target_dur)
+
+        if clip:
+            url = clip.get("link")
+            if not url:
+                print(f"    分镜 {scene['index']}: 未找到可用素材链接")
+                scene["material_file"] = None
+                continue
+
+            try:
+                print(f"    分镜 {scene['index']}: 下载素材 (关键词: {keywords[0]})...")
+                _download_video(url, save_path)
+                scene["material_file"] = save_path
+            except Exception as e:
+                print(f"    分镜 {scene['index']}: 下载失败 - {e}")
+                scene["material_file"] = None
+        else:
+            print(f"    分镜 {scene['index']}: 未搜索到素材")
+            scene["material_file"] = None
+
+    return scenes

fible/pipeline/segmenter.py

@@ -0,0 +1,86 @@
+import json
+import re
+from openai import OpenAI
+from fible.config import get_deepseek_api_key, DEEPSEEK_BASE_URL, DEEPSEEK_MODEL, text_hash, save_json, load_json, CACHE_DIR
+
+SYSTEM_PROMPT = """你是一个专业的视频分镜师。根据用户提供的文案，将其拆分为多个分镜场景。
+
+要求：
+1. 每个分镜的旁白长度控制在 8-15 秒（约 40-80 个汉字）
+2. 画面描述要具体、有画面感，适合搜索视频素材
+3. 提供中英文搜索关键词，英文关键词用于 Pexels/Pixabay 搜素视频，中文用于备用
+4. 相邻分镜的画面风格可以不同，保持视觉节奏感
+5. 返回严格的 JSON 格式，不要包含任何其他文字
+
+输出 JSON 格式：
+{
+  "title": "视频标题",
+  "scenes": [
+    {
+      "index": 1,
+      "narration": "旁白文本",
+      "visual_desc": "画面描述（中文）",
+      "keywords_en": ["keyword1", "keyword2", "keyword3"],
+      "keywords_zh": ["关键词1", "关键词2", "关键词3"],
+      "duration_sec": 10
+    }
+  ]
+}
+
+duration_sec 根据 narration 文本长度合理估算，约每 4 个汉字 1 秒。"""
+
+CACHE_FILE_TEMPLATE = "segment_{hash}.json"
+
+
+def segment_text(text: str, force: bool = False) -> dict:
+    h = text_hash(text)
+    cache_file = CACHE_DIR / CACHE_FILE_TEMPLATE.format(hash=h)
+
+    if not force:
+        cached = load_json(cache_file)
+        if cached and "scenes" in cached:
+            print(f"  [缓存命中] 使用已保存的分镜结果 ({cache_file.name})")
+            return cached
+
+    print("  调用 DeepSeek API 分析分镜...")
+    client = OpenAI(
+        api_key=get_deepseek_api_key(),
+        base_url=DEEPSEEK_BASE_URL,
+    )
+
+    response = client.chat.completions.create(
+        model=DEEPSEEK_MODEL,
+        messages=[
+            {"role": "system", "content": SYSTEM_PROMPT},
+            {"role": "user", "content": f"请为以下文案设计分镜：\n\n{text}"},
+        ],
+        temperature=0.7,
+        max_tokens=4096,
+    )
+
+    content = response.choices[0].message.content.strip()
+
+    json_match = re.search(r'```(?:json)?\s*(.*?)\s*```', content, re.DOTALL)
+    if json_match:
+        content = json_match.group(1)
+
+    try:
+        script = json.loads(content)
+    except json.JSONDecodeError:
+        raise ValueError(f"DeepSeek 返回的分镜脚本无法解析为 JSON:\n{content}")
+
+    if "scenes" not in script:
+        raise ValueError("分镜脚本缺少 'scenes' 字段")
+
+    seen_indices = set()
+    for scene in script["scenes"]:
+        required = ["index", "narration", "keywords_en", "duration_sec"]
+        for field in required:
+            if field not in scene:
+                raise ValueError(f"分镜 {scene.get('index', '?')} 缺少字段 '{field}'")
+        if scene["index"] in seen_indices:
+            raise ValueError(f"分镜 index={scene['index']} 重复")
+        seen_indices.add(scene["index"])
+
+    save_json(script, cache_file)
+    return script

fible/pipeline/tts.py

@@ -0,0 +1,59 @@
+import os
+import asyncio
+import subprocess
+import edge_tts
+from fible.config import OUTPUT_DIR
+
+VOICES = {
+    "zh-CN-XiaoxiaoNeural": "晓晓（女，温柔）",
+    "zh-CN-YunxiNeural": "云希（男，温暖）",
+    "zh-CN-YunjianNeural": "云健（男，沉稳）",
+    "zh-CN-XiaoyiNeural": "晓伊（女，活泼）",
+    "zh-CN-YunyangNeural": "云扬（男，新闻感）",
+    "zh-CN-XiaochenNeural": "晓辰（女，自然）",
+}
+
+DEFAULT_VOICE = "zh-CN-YunyangNeural"
+
+
+def list_voices():
+    for k, v in VOICES.items():
+        print(f"  {k}  —  {v}")
+
+
+async def _tts_single(text: str, voice: str, output_file: str, rate: str = "+0%"):
+    communicate = edge_tts.Communicate(text, voice, rate=rate)
+    await communicate.save(output_file)
+
+
+def _get_audio_duration(filepath: str) -> float:
+    result = subprocess.run(
+        ["ffprobe", "-v", "error", "-show_entries", "format=duration",
+         "-of", "default=noprint_wrappers=1:nokey=1", filepath],
+        capture_output=True, text=True
+    )
+    try:
+        return float(result.stdout.strip())
+    except ValueError:
+        return 0
+
+
+def generate_all_speeches(scenes: list, session_id: str, voice: str = DEFAULT_VOICE) -> list:
+    async def generate_one(scene):
+        name = f"{session_id}_scene_{scene['index']:02d}"
+        path = os.path.join(str(OUTPUT_DIR), f"{name}.mp3")
+
+        if os.path.exists(path):
+            print(f"    分镜 {scene['index']}: [缓存命中] 配音已存在")
+            dur = _get_audio_duration(path)
+            return {**scene, "audio_file": path, "actual_duration_sec": dur}
+
+        print(f"    分镜 {scene['index']}: 生成配音...")
+        await _tts_single(scene["narration"], voice, path)
+        dur = _get_audio_duration(path)
+        return {**scene, "audio_file": path, "actual_duration_sec": dur}
+
+    async def run_all():
+        return [await generate_one(s) for s in scenes]
+
+    return asyncio.run(run_all())

fible-0.1.0.dist-info/METADATA

@@ -0,0 +1,276 @@
+Metadata-Version: 2.4
+Name: fible
+Version: 0.1.0
+Summary: 一句话生成视频 — AI 文案 + 配音 + 素材 + 合成的视频创作 CLI
+Author: mx
+License: MIT
+Requires-Python: >=3.10
+Requires-Dist: edge-tts>=6.1.0
+Requires-Dist: moviepy>=2.0.0
+Requires-Dist: openai>=1.0.0
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: requests>=2.31.0
+Requires-Dist: rich>=13.0.0
+Description-Content-Type: text/markdown
+
+# AI 视频创作 CLI
+
+一段文案 → 一个带配音和字幕的视频。全链路本地化，免费开源。
+
+## 管线流程
+
+```
+文案.txt → DeepSeek V4 Pro 分镜 → edge-tts 配音 → Pexels 素材匹配 → FFmpeg 合成 → 输出.mp4
+```
+
+## 环境要求
+
+- Python 3.10+
+- [uv](https://docs.astral.sh/uv/)（Python 包管理器，自动管理虚拟环境）
+- FFmpeg（macOS: `brew install ffmpeg`）
+- 两个 API Key：
+  - [DeepSeek API Key](https://platform.deepseek.com/) — 用于文案分镜
+  - [Pexels API Key](https://www.pexels.com/api/) — 用于搜索视频素材（免费注册）
+
+## 安装
+
+```bash
+# 1. 安装 uv（如已安装可跳过）
+curl -LsSf https://astral.sh/uv/install.sh | sh
+source $HOME/.local/bin/env
+
+# 2. 进入项目目录
+cd video-creator
+
+# 3. 一键同步依赖 + 创建虚拟环境
+uv sync
+```
+
+## 配置
+
+```bash
+# 复制配置模板
+cp .env.example .env
+```
+
+编辑 `.env` 文件，填入你的 API Key：
+
+```
+DEEPSEEK_API_KEY=sk-xxxxxxxxxxxxxxxx
+PEXELS_API_KEY=xxxxxxxxxxxxxxxx
+```
+
+## 使用
+
+### 基本用法
+
+```bash
+# 从文案文件生成视频
+uv run python cli.py -i 文案.txt
+
+# 指定输出文件名和音色
+uv run python cli.py -i 文案.txt -o 我的视频.mp4 -v zh-CN-YunyangNeural
+
+# 仅配音+字幕，不使用视频素材
+uv run python cli.py -i 文案.txt --no-material
+```
+
+### 查看可用音色
+
+```bash
+uv run python cli.py --list-voices
+```
+
+输出示例：
+
+```
+zh-CN-XiaoxiaoNeural  —  晓晓（女，温柔）
+zh-CN-YunxiNeural     —  云希（男，温暖）
+zh-CN-YunjianNeural   —  云健（男，沉稳）
+zh-CN-XiaoyiNeural    —  晓伊（女，活泼）
+zh-CN-YunyangNeural   —  云扬（男，新闻感）
+zh-CN-XiaochenNeural  —  晓辰（女，自然）
+```
+
+不指定音色时默认使用 `YunyangNeural`（云扬，适合知识类内容）。
+
+### 运行示例
+
+```bash
+# 使用内置测试文案
+uv run python cli.py -i test_story.txt -o output/test.mp4
+```
+
+执行过程输出：
+
+```
+AI 视频创作
+输入: test_story.txt
+输出: output/test.mp4
+音色: zh-CN-YunyangNeural
+
+▸ Step 1/4: AI 分镜分析
+┌──────┬────────────────┬──────┬────────────┐
+│ 序号 │ 旁白摘要       │ 时长 │ 关键词     │
+├──────┼────────────────┼──────┼────────────┤
+│ 1    │ 人工智能正以... │ 10s  │ AI, daily. │
+│ 2    │ 在医疗领域...  │ 9s   │ medical,.. │
+│ 3    │ 然而技术进...  │ 10s  │ privacy,.. │
+│ 4    │ 未来随着技...  │ 8s   │ future, AI │
+└──────┴────────────────┴──────┴────────────┘
+
+▸ Step 2/4: 生成配音
+  ✓ 完成 4 段配音
+
+▸ Step 3/4: 匹配素材
+  搜索并下载素材...
+    分镜 1: material_01.mp4
+    分镜 2: material_02.mp4
+    分镜 3: material_03.mp4
+    分镜 4: material_04.mp4
+
+▸ Step 4/4: 合成视频
+    分镜 1: 渲染完成 (10.2s)
+    分镜 2: 渲染完成 (9.5s)
+    分镜 3: 渲染完成 (10.0s)
+    分镜 4: 渲染完成 (8.3s)
+
+  成品输出: /path/to/output/test.mp4
+
+✓ 视频创作完成！
+文件: /path/to/output/test.mp4
+耗时: 45.3s
+```
+
+## 产出质量
+
+- 分辨率：1920×1080（1080p）
+- 帧率：30fps
+- 编码：H.264 + AAC
+- 字幕：硬字幕，白字黑边，居中显示
+
+## 项目结构
+
+```
+video-creator/
+├── cli.py                  # 命令行入口
+├── config.py               # 配置管理（API Key、输出路径）
+├── pyproject.toml          # 项目元数据与依赖声明
+├── uv.lock                 # 依赖锁定文件
+├── pipeline/
+│   ├── __init__.py
+│   ├── segmenter.py        # DeepSeek V4 Pro 文案分镜
+│   ├── tts.py              # edge-tts 语音合成
+│   ├── matcher.py          # Pexels 素材搜索与下载
+│   └── composer.py         # FFmpeg 视频合成
+├── output/                 # 生成文件存放目录
+├── .env.example            # API Key 配置模板
+└── test_story.txt          # 测试文案
+```
+
+## 模块说明
+
+### segmenter.py — AI 分镜
+
+调用 DeepSeek API 将输入文案拆分为分镜脚本。
+
+- **模型：** `deepseek-chat`
+- **输入：** 原始文案文本
+- **输出：** 结构化 JSON，包含每个分镜的旁白、画面描述、中英文关键词、预估时长
+
+DeepSeek 的系统提示词会引导模型：
+- 将文案拆分为 8-15 秒/个的分镜
+- 提供具体有画面感的视觉描述
+- 生成英文关键词用于 Pexels 素材搜索
+- 估算每个分镜的时长（约 4 字/秒）
+
+### tts.py — 语音合成
+
+使用微软 edge-tts 将旁白文本转为语音。
+
+- **方案：** edge-tts（免费，无调用限制）
+- **音色：** 6 种中文神经网络音色可选
+- **格式：** MP3
+- **输出：** 自动探测音频实际时长，回填到分镜数据中
+
+### matcher.py — 素材匹配
+
+通过 Pexels API 搜索并下载视频素材。
+
+- **API：** Pexels Videos Search（免费，每月 200 次请求）
+- **搜索策略：** 按英文关键词逐个搜索，取前 5 个结果
+- **筛选逻辑：**
+  1. 过滤 720p 以下低分辨率素材
+  2. 按"时长匹配度（70%）+ 创作者可信度（30%）"评分
+  3. 选最高分的素材片段下载
+- **下载格式：** 原始分辨率 MP4
+
+### composer.py — 视频合成
+
+使用 FFmpeg 将素材、配音、字幕合成为最终视频。
+
+- **处理步骤：**
+  1. 素材裁剪到分镜时长 → 缩放居中为 1920×1080
+  2. 叠加配音音频（自动截取对应时长）
+  3. 添加硬字幕（drawtext 滤镜，白字黑边）
+  4. 所有分镜拼接为完整视频
+- **字幕处理：** 长文本自动换行，最多显示 2-3 行，逐行叠加
+- **中文字体：** 使用 macOS 系统字体 `STHeiti Medium`
+
+## 故障排查
+
+### 分镜阶段报错
+
+```
+ValueError: DeepSeek 返回的分镜脚本无法解析为 JSON
+```
+
+原因：DeepSeek 返回格式异常。重试即可，模型偶有输出不稳定。
+
+### 配音阶段无声音或报错
+
+```bash
+# 手动测试 edge-tts 是否正常
+uv run python -c "
+import asyncio, edge_tts
+async def test():
+    c = edge_tts.Communicate('测试语音', 'zh-CN-YunyangNeural')
+    await c.save('test.mp3')
+    print('OK')
+asyncio.run(test())
+"
+```
+
+如果失败，检查网络连接（edge-tts 需访问微软服务）。
+
+### 素材搜索返回空
+
+- 确认 Pexels API Key 正确配置在 `.env` 中
+- Pexels 免费账户每月限额 200 次请求，超出会返回 429
+- 某些中文概念的英文关键词可能匹配度低，可尝试使用 `--no-material` 跳过素材
+
+### 合成阶段中文乱码
+
+确认系统中存在中文字体：
+```bash
+ls /System/Library/Fonts/STHeiti\ Medium.ttc
+```
+
+Linux 系统需修改 `composer.py` 中的 `FONT_PATH`。
+
+### FFmpeg not found
+
+```bash
+# macOS
+brew install ffmpeg
+
+# Ubuntu/Debian
+sudo apt install ffmpeg
+
+# Windows
+# 下载 https://ffmpeg.org/download.html，解压后加入 PATH
+```
+
+## 许可证
+
+MIT

fible-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+fible/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+fible/__main__.py,sha256=IWwhw6-HFlr00jcG6e6A7egfN7PPJ-9QUA45n09rOyw,66
+fible/cli.py,sha256=qFt07kCRt7WStNkv-ddc0tlLXWN_munJV-XPSFTfi-w,7960
+fible/config.py,sha256=5dTywFF0sbWtG7GEcYHfp-lci0MjgTKB_8vOtMJXpW0,2497
+fible/pipeline/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fible/pipeline/composer.py,sha256=Ddd-oruej3YqGvlGc3zqRs5jugGHh9PM8B6-WwQ7xUA,6085
+fible/pipeline/matcher.py,sha256=Ie_vC2fgRp7dXH986iOUx6L-H2scea2P8Sc7o_GBBgI,3225
+fible/pipeline/segmenter.py,sha256=Cn_7D5UW7AAYbM0syolaLjRZzMexREMIDovd9wSy-Zg,2950
+fible/pipeline/tts.py,sha256=FHHOslDpRPDPaZXqi0NTiXfoM35GZgK5FO9YXPaGJPM,1947
+fible-0.1.0.dist-info/METADATA,sha256=zyEnxaqdRFdYo6vNMGu1jJ4obyzInQLFJxmVmeU0_hc,7599
+fible-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+fible-0.1.0.dist-info/entry_points.txt,sha256=-gheghuNGzy_kYHNMLXIR5FVGTGr3xcM_kjoq-vLinM,41
+fible-0.1.0.dist-info/RECORD,,

fible-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

fible-0.1.0.dist-info/entry_points.txt

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