Gemini TTS + Veo 3.1で朗読チャンネルを構築する

import anthropic
import base64
from pathlib import Path
 
def generate_narration_flash(
    text: str,
    voice_id: str = "ja-JP-Neural2-B",  # 男性, 落ち着いた声
    output_file: str = "narration.mp3"
) -> str:
    """
    Gemini Flash TTS で音声ナレーションを生成
 
    Args:
        text: 朗読テキスト
        voice_id: 音声ID (ja-JP-Neural2-A～D)
        output_file: 出力MP3ファイルパス
 
    Returns:
        出力ファイルパス
    """
    client = anthropic.Anthropic(api_key="YOUR_GEMINI_API_KEY")
 
    system_prompt = f"""
    You are a professional Japanese narrator for educational YouTube videos.
    Generate natural, engaging narration with proper pacing.
    Voice preference: {voice_id}
    Do NOT include markdown or extra formatting.
    Output audio file directly.
    """
 
    response = client.messages.create(
        model="gemini-2.0-flash",
        max_tokens=2048,
        messages=[
            {
                "role": "user",
                "content": f"以下のテキストを朗読してください：\n\n{text}"
            }
        ]
    )
 
    # Base64エンコードされた音声を取得
    audio_data = base64.b64decode(response.content[0].text)
 
    with open(output_file, "wb") as f:
        f.write(audio_data)
 
    print(f"✓ Narration saved: {output_file} ({len(audio_data)/1024/1024:.1f}MB)")
    return output_file
 
def generate_narration_pro(
    text: str,
    output_file: str = "narration_pro.mp3"
) -> dict:
    """
    Gemini Pro TTS で高品質音声生成（複数話者対応）
 
    Args:
        text: 朗読テキスト
        output_file: 出力ファイルパス
 
    Returns:
        メタデータ（生成時間、品質スコアなど）
    """
    client = anthropic.Anthropic(api_key="YOUR_GEMINI_API_KEY")
 
    response = client.messages.create(
        model="gemini-2.0-pro",
        max_tokens=4096,
        messages=[
            {
                "role": "user",
                "content": f"""
                Generate high-quality Japanese narration for a YouTube educational video.
                Requirements:
                - Natural pacing with emotional nuance
                - Proper emphasis on important terms
                - Professional tone suitable for a 7-minute video
                - Output as high-quality MP3 (320kbps recommended)
 
                Text to narrate:
                {text}
                """
            }
        ]
    )
 
    audio_path = Path(output_file)
    audio_path.write_bytes(base64.b64decode(response.content[0].text))
 
    metadata = {
        "output_file": str(audio_path.absolute()),
        "file_size_mb": audio_path.stat().st_size / 1024 / 1024,
        "model": "gemini-2.0-pro",
        "quality": "studio"
    }
 
    return metadata
 
# 実行例
if __name__ == "__main__":
    sample_text = """
    今日のテーマは、AI動画生成の最新トレンドです。
    2026年現在、テキストから高品質な動画を生成できるようになりました。
    Veo 3.1はその最たる例で、プロンプトエンジニアリング次第で、
    プロが制作したような映像を数秒で作り出します。
    """
 
    # Flash版（コスト重視）
    narration_file = generate_narration_flash(sample_text)
 
    # Pro版（品質重視）
    metadata = generate_narration_pro(sample_text)
    print(f"Pro TTS result: {metadata}")

text_with_hints = """
[強調] Gemini API [/強調] は、Google Cloud の最新サービスです。
 
[遅く] 特に注目すべき点は、以下の3つです。 [/遅く]
 
1. 高速処理（0.5秒以下）
2. 日本語への深い理解
3. マルチモーダル対応
"""

import anthropic
import json
import requests
from typing import List
 
def extract_scenes(narration_script: str, num_scenes: int = 4) -> List[dict]:
    """
    ナレーションスクリプトを複数シーンに分割し、各シーンのプロンプトを生成
 
    Args:
        narration_script: 朗読スクリプト
        num_scenes: 分割シーン数
 
    Returns:
        シーンデータのリスト
        例: [
            {"scene_id": 1, "duration": 8, "prompt": "..."},
            {"scene_id": 2, "duration": 8, "prompt": "..."},
        ]
    """
    client = anthropic.Anthropic(api_key="YOUR_GEMINI_API_KEY")
 
    extraction_prompt = f"""
    Divide this YouTube narration script into {num_scenes} visual scenes.
    For each scene, create a cinematic visual prompt suitable for Veo 3.1.
 
    Output as JSON:
    {{
        "scenes": [
            {{"scene_id": 1, "duration": 8, "prompt": "detailed visual description..."}},
            ...
        ]
    }}
 
    Requirements:
    - Each scene should be 8 seconds (Veo 3.1 limit)
    - Prompts should be specific, evocative, and visually concrete
    - Use cinematic language (lighting, composition, color palette)
    - Include motion if appropriate
 
    Script to visualize:
    {narration_script}
    """
 
    response = client.messages.create(
        model="gemini-2.0-flash",
        max_tokens=2048,
        messages=[
            {"role": "user", "content": extraction_prompt}
        ]
    )
 
    scenes_json = json.loads(response.content[0].text)
    return scenes_json["scenes"]
 
def generate_veo_videos(scenes: List[dict]) -> List[str]:
    """
    Veo 3.1 API で複数の背景動画を生成
 
    Args:
        scenes: extract_scenes() の出力
 
    Returns:
        生成動画のURLリスト
    """
    video_urls = []
 
    for scene in scenes:
        print(f"Generating Veo video for scene {scene['scene_id']}...")
 
        veo_payload = {
            "prompt": scene["prompt"],
            "duration_seconds": scene["duration"],
            "resolution": "1080p",  # または "4k"
            "style": "cinematic"
        }
 
        response = requests.post(
            "https://generativelanguage.googleapis.com/v1/veo:generateVideo",
            json=veo_payload,
            headers={
                "Authorization": f"Bearer {YOUR_GEMINI_API_KEY}",
                "Content-Type": "application/json"
            }
        )
 
        if response.status_code == 200:
            video_url = response.json()["videoUrl"]
            video_urls.append(video_url)
            print(f"  ✓ Scene {scene['scene_id']}: {video_url}")
        else:
            print(f"  ✗ Failed: {response.status_code}")
 
    return video_urls
 
# 実行例
if __name__ == "__main__":
    script = """
    AI動画生成は、現在、プロダクション業界を変えています。
 
    かつては、高品質な映像制作に莫大な予算と時間が必要でした。
    しかし今、テキストから瞬時に映像を作り出すことが可能です。
 
    その中心にあるのが、Google Veo 3.1です。
    """
 
    scenes = extract_scenes(script, num_scenes=3)
    print(f"Extracted {len(scenes)} scenes:")
    for scene in scenes:
        print(f"  Scene {scene['scene_id']}: {scene['prompt'][:60]}...")
 
    # 実際の生成（APIキー設定時）
    # video_urls = generate_veo_videos(scenes)

import os
import json
import time
from datetime import datetime
 
class NarrationVideoFactory:
    """朗読ビデオの自動生成ファクトリークラス"""
 
    def __init__(self, gemini_api_key: str, vew_api_key: str = None):
        self.client = anthropic.Anthropic(api_key=gemini_api_key)
        self.vew_key = vew_api_key
        self.output_dir = "output/videos"
        os.makedirs(self.output_dir, exist_ok=True)
 
    def process_blog_article(self, article_content: str, article_title: str) -> dict:
        """
        ブログ記事 → 完成ビデオまでの全自動処理
 
        Args:
            article_content: ブログ記事のテキスト
            article_title: 記事タイトル
 
        Returns:
            成果物メタデータ
        """
 
        print(f"\n📄 Processing: {article_title}")
        timestamp = datetime.now().isoformat()
 
        # Step 1: スクリプト最適化
        print("  [1/5] Optimizing script...")
        script = self._optimize_script(article_content, article_title)
 
        # Step 2: ナレーション音声生成
        print("  [2/5] Generating narration audio...")
        audio_path = self._generate_audio(script, article_title)
 
        # Step 3: シーン抽出
        print("  [3/5] Extracting visual scenes...")
        scenes = extract_scenes(script, num_scenes=4)
 
        # Step 4: 背景動画生成
        print("  [4/5] Generating background videos...")
        video_paths = self._generate_background_videos(scenes)
 
        # Step 5: メタデータ生成
        print("  [5/5] Generating metadata...")
        metadata = self._generate_metadata(
            article_title=article_title,
            script=script,
            audio=audio_path,
            videos=video_paths
        )
 
        result = {
            "timestamp": timestamp,
            "title": article_title,
            "script": script,
            "audio_file": audio_path,
            "video_files": video_paths,
            "metadata": metadata,
            "status": "ready_for_vrew"
        }
 
        # JSON に保存
        result_file = os.path.join(self.output_dir, f"{article_title.replace(' ', '_')}.json")
        with open(result_file, "w", encoding="utf-8") as f:
            json.dump(result, f, ensure_ascii=False, indent=2)
 
        print(f"✓ Complete: {result_file}")
        return result
 
    def _optimize_script(self, content: str, title: str) -> str:
        """Gemini でスクリプト最適化"""
        response = self.client.messages.create(
            model="gemini-2.0-flash",
            max_tokens=2048,
            messages=[{
                "role": "user",
                "content": f"""
                Adapt this blog article into a YouTube narration script.
 
                Title: {title}
 
                Requirements:
                - 400-600 words
                - Conversational tone
                - Short sentences (under 12 words each)
                - Add pauses: [PAUSE 2] means 2-second pause
                - Define technical terms on first mention
 
                Article:
                {content}
                """
            }]
        )
        return response.content[0].text
 
    def _generate_audio(self, script: str, title: str) -> str:
        """Gemini TTS でナレーション音声化"""
        audio_file = os.path.join(
            self.output_dir,
            f"{title.replace(' ', '_')}.mp3"
        )
 
        # Flash版で高速化（本番ならPro版検討）
        response = self.client.messages.create(
            model="gemini-2.0-flash",
            max_tokens=2048,
            messages=[{
                "role": "user",
                "content": f"Generate professional Japanese narration:\n{script}"
            }]
        )
 
        # 実際の実装ではBase64デコード処理を追加
        # audio_data = base64.b64decode(response.content[0].text)
        # with open(audio_file, "wb") as f:
        #     f.write(audio_data)
 
        return audio_file
 
    def _generate_background_videos(self, scenes: List[dict]) -> List[str]:
        """Veo 3.1 で背景動画生成"""
        # generate_veo_videos() を呼び出し
        return generate_veo_videos(scenes)
 
    def _generate_metadata(self, **kwargs) -> dict:
        """YouTube用メタデータ生成（タイトル、説明、タグ）"""
 
        article_title = kwargs.get("article_title", "")
 
        response = self.client.messages.create(
            model="gemini-2.0-flash",
            max_tokens=1024,
            messages=[{
                "role": "user",
                "content": f"""
                Generate YouTube metadata for this article.
 
                Article Title: {article_title}
 
                Output JSON:
                {{
                    "youtube_title": "...",
                    "youtube_description": "...",
                    "tags": ["tag1", "tag2"],
                    "thumbnail_prompt": "..."
                }}
                """
            }]
        )
 
        return json.loads(response.content[0].text)
 
# 使用例
if __name__ == "__main__":
    factory = NarrationVideoFactory(gemini_api_key="YOUR_KEY")
 
    blog_article = """
    2026年のAI動画生成トレンド...
    [記事本文]
    """
 
    result = factory.process_blog_article(
        article_content=blog_article,
        article_title="AI動画生成の最新ワークフロー"
    )
 
    print(f"\nGenerated files:")
    print(f"  Audio: {result['audio_file']}")
    print(f"  Videos: {len(result['video_files'])} files")
    print(f"  Metadata: {json.dumps(result['metadata'], ensure_ascii=False)}")

{
  "timestamp": "2026-03-22T11:30:00",
  "title": "AI動画生成の最新ワークフロー",
  "status": "ready_for_vrew",
  "audio_file": "output/videos/AI動画生成の最新ワークフロー.mp3",
  "video_files": [
    "https://storage.googleapis.com/veo-videos/scene1.mp4",
    "https://storage.googleapis.com/veo-videos/scene2.mp4"
  ],
  "metadata": {
    "youtube_title": "AI朗読:最新動画生成ワークフロー【2026版】",
    "youtube_description": "...",
    "tags": ["ai", "video", "workflow"],
    "thumbnail_prompt": "..."
  }
}

from concurrent.futures import ThreadPoolExecutor
 
articles = [article1, article2, article3, ...]
factory = NarrationVideoFactory(api_key)
 
with ThreadPoolExecutor(max_workers=3) as executor:
    results = list(executor.map(
        lambda art: factory.process_blog_article(art["content"], art["title"]),
        articles
    ))

voices = {
    "narrator": "ja-JP-Neural2-A",  # 女性
    "intro": "ja-JP-Neural2-B",     # 男性
}