first

Dockerfile

@@ -0,0 +1,23 @@
+FROM python:3.11-slim
+
+# 環境変数設定
+ENV PYTHONUNBUFFERED=1 \
+    PIP_NO_CACHE_DIR=off \
+    PIP_DISABLE_PIP_VERSION_CHECK=on \
+    PIP_DEFAULT_TIMEOUT=100 \
+    POETRY_VERSION=1.6.1
+
+# 必要なパッケージをインストール
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    gcc \
+    libpq-dev \
+    ffmpeg \
+    && rm -rf /var/lib/apt/lists/*
+
+# 作業ディレクトリの作成
+WORKDIR /app
+
+# 依存関係のインストール
+COPY requirements.txt ./
+RUN pip install --no-cache-dir -r requirements.txt
+

app.py

@@ -0,0 +1,1164 @@
+# -*- coding: utf-8 -*-
+import os
+import time
+import random
+from flask import Flask, render_template, request, jsonify
+import yt_dlp
+import requests # requestsライブラリをインポート
+import base64
+# from google import genai # genai を直接インポートする代わりに google.generativeai を使う
+import google.generativeai as genai
+import json
+import time
+import os
+import re
+import random
+import logging
+import traceback
+
+# --- アプリケーション設定 ---
+app = Flask(__name__)
+# セキュリティのため、実際の運用では環境変数などから読み込むことを推奨
+app.secret_key = os.getenv('FLASK_SECRET_KEY', os.urandom(24))
+
+# --- GAS Web App URL ---
+# 環境変数から取得するか、直接記述（テスト用）
+GAS_WEB_APP_URL = os.getenv('GAS_WEB_APP_URL', 'https://script.google.com/macros/s/AKfycbzcOZSPIvKq__QQJlMH5wBgnjjiio-vgtCpNrxAYO5hE3LVIY42I0GsGFO32hwraV4g/exec') # 環境変数から取得、なければプレースホルダ
+
+# --- ログ設定 ---
+logging.basicConfig(
+    level=logging.DEBUG, # 開発中はDEBUG、本番ではINFOなどに変更
+    format="%(asctime)s [%(levelname)s] [%(filename)s:%(lineno)d] %(message)s",
+    handlers=[
+        logging.StreamHandler() # コンソールに出力
+        # Hugging Face Spacesではファイルへの永続的な書き込みは制限されるため、ファイルハンドラはコメントアウト推奨
+        # logging.FileHandler(os.path.join('/tmp', "app.log"), encoding='utf-8') # <<< 修正 >>> ログファイルパス変更 (もし使う場合)
+    ]
+)
+logging.getLogger('urllib3').setLevel(logging.WARNING) # requestsライブラリのログレベル調整
+logging.getLogger('google').setLevel(logging.WARNING) # googleライブラリのログレベル調整
+logging.getLogger('yt_dlp').setLevel(logging.INFO) # yt-dlpのログレベルをINFOに設定 (DEBUGだと多すぎる可能性)
+
+# --- 一時ディレクトリ定義 ---
+# <<< 修正 >>> Hugging Face Spacesで利用可能な一時ディレクトリ
+TEMP_DIR = '/tmp'
+
+# --- バックエンド処理関数 ---
+
+def download_and_extract_audio(youtube_url):
+    """
+    yt-dlpを使って動画をダウンロードし、音声をMP3形式で抽出する。
+    成功したら (音声ファイルパス, 動画情報) のタプルを、失敗したら (None, None) を返す。
+    """
+    # <<< 修正 >>> 一時ディレクトリを使用
+    output_dir = os.path.join(TEMP_DIR, 'downloads')
+    os.makedirs(output_dir, exist_ok=True)
+    logging.debug(f"音声保存ディレクトリ: {os.path.abspath(output_dir)}")
+
+    output_template = os.path.join(output_dir, '%(id)s.%(ext)s')
+
+    ydl_opts = {
+        'format': 'bestaudio/best',
+        'postprocessors': [{
+            'key': 'FFmpegExtractAudio',
+            'preferredcodec': 'mp3',
+            'preferredquality': '192',
+        }],
+        'outtmpl': output_template,
+        'noplaylist': True,
+        'logger': logging.getLogger('yt_dlp'),
+        'verbose': False,
+    }
+
+    audio_file_path = None
+    info_dict_result = None
+
+    try:
+        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+            logging.info(f"yt-dlp: {youtube_url} のダウンロードと音声抽出を開始")
+            info_dict = ydl.extract_info(youtube_url, download=True)
+            video_id = info_dict.get('id', 'unknown_id')
+            # 動画情報も返すようにする
+            info_dict_result = {
+                'id': video_id,
+                'title': info_dict.get('title', f'動画 {video_id}'),
+                'thumbnail': info_dict.get('thumbnail'), # サムネイルURL
+                'uploader': info_dict.get('uploader'),
+                'duration': info_dict.get('duration'),
+            }
+            logging.info(f"yt-dlp: 動画情報取得完了 (ID: {video_id}, Title: {info_dict_result['title']})")
+
+            base_filename = ydl.prepare_filename(info_dict)
+            # yt-dlp の prepare_filename は絶対パスを返すことがあるので、
+            # 確実に /tmp 配下のパスにするため、ファイル名だけ取得して結合する
+            # expected_mp3_path = os.path.splitext(base_filename)[0] + '.mp3'
+            expected_mp3_filename = os.path.splitext(os.path.basename(base_filename))[0] + '.mp3'
+            expected_mp3_path = os.path.join(output_dir, expected_mp3_filename)
+            logging.debug(f"yt-dlp: 期待されるMP3ファイルパス -> {expected_mp3_path}")
+
+
+            wait_time = 0
+            max_wait = 15 # 少し長めに待つ (15秒) / 環境によっては時間がかかる場合あり
+            while not os.path.exists(expected_mp3_path) and wait_time < max_wait:
+                logging.debug(f"MP3ファイル待機中: {expected_mp3_path} (待機時間: {wait_time}秒)")
+                time.sleep(1)
+                wait_time += 1
+
+            if os.path.exists(expected_mp3_path):
+                 audio_file_path = expected_mp3_path
+                 logging.info(f"yt-dlp: 音声抽出完了 -> {audio_file_path}")
+                 return audio_file_path, info_dict_result
+            else:
+                 logging.warning(f"期待されたMP3ファイルが見つかりません: {expected_mp3_path}")
+                 # output_dir 内のファイルをリストアップして確認
+                 potential_files = [f for f in os.listdir(output_dir) if f.startswith(video_id) and f.endswith('.mp3')]
+                 if potential_files:
+                     # output_dirを基準に絶対パスを生成
+                     audio_file_path = os.path.join(output_dir, potential_files[0])
+                     logging.info(f"yt-dlp: 代替検索で見つかった音声ファイル -> {audio_file_path}")
+                     return audio_file_path, info_dict_result
+                 else:
+                    logging.error("yt-dlp: 音声抽出後のMP3ファイル特定に失敗しました。")
+                    logging.error(f"Downloads directory ({output_dir}) contents: {os.listdir(output_dir)}")
+                    return None, info_dict_result # ファイルパスはNoneだが情報は返す
+
+    except yt_dlp.utils.DownloadError as e:
+        logging.error(f"yt-dlp ダウンロードエラー: {e}")
+        if "confirm your age" in str(e).lower():
+             logging.error("年齢確認が必要な動画の可能性があります。クッキーファイルの使用を検討してください。")
+        elif "video unavailable" in str(e).lower():
+             logging.error("動画が利用不可能なようです。")
+        elif "Private video" in str(e):
+             logging.error("非公開動画のようです。")
+        return None, None
+    except Exception as e:
+        logging.error("yt-dlp: 音声抽出中に予期せぬエラーが発生しました。", exc_info=True)
+        return None, None
+
+def transcribe_audio(audio_path):
+    """
+    Google Gemini API を使用して音声ファイルを文字起こし・要約する。
+    成功した場合は、Geminiが生成したテキスト（JSON形式を期待）を返す。
+    失敗した場合は None を返す。
+    """
+    # 環境変数名は 'GEMINI_API_KEY' を推奨 (コード内と合わせる)
+    api_key = os.getenv('GEMINI_API_KEY') # 環境変数名を修正 (より一般的なキー名に)
+    if not api_key:
+        logging.error("環境変数 'GEMINI_API_KEY' が設定されていません。")
+        return None
+
+    try:
+        genai.configure(api_key=api_key)
+    except Exception as config_err:
+         logging.error(f"Gemini API キーの設定に失敗しました: {config_err}")
+         return None
+
+    audio_file_resource = None # finally で使うため
+    try:
+        logging.info(f"Gemini: ファイルアップロード開始 - {audio_path}")
+        # 大きなファイルの場合、タイムアウト時間を長く設定
+        audio_file_resource = genai.upload_file(path=audio_path, request_options={'timeout': 600})
+        logging.info(f"Gemini: ファイルアップロード完了 - Name: {audio_file_resource.name}, URI: {audio_file_resource.uri}")
+
+        # モデル指定を環境変数から取得できるようにする（任意）
+        gemini_model_name = os.getenv('GEMINI_MODEL', 'models/gemini-1.5-pro-latest')
+        logging.info(f"Gemini: 使用モデル - {gemini_model_name}")
+        model = genai.GenerativeModel(gemini_model_name)
+
+        # プロンプト: 文字起こし、要約、JSON形式での出力を明確に指示 (日本語版)
+        prompt_parts = [
+            "提供された音声ファイルに対して、以下のタスクを実行してください：",
+            "1. 音声の内容を正確にテキストに文字起こししてください。",
+            "2. 文字起こし結果に基づき、プレゼンテーションのスライドに適した、論理的なポイントやセクションに分けた簡潔な要約を生成してください。",
+            "3. 生成された要約は、**厳密にJSONリスト形式**でフォーマットしてください。JSONリストそのもの以外には、**一切のテキスト（導入文、説明、謝罪、```jsonのようなマークダウン形式など）を含めないでください**。",
+            "\n**必須のJSON構造:**",
+            "出力は**必ず**有効なJSONリスト `[]` でなければなりません。",
+            "リストの各要素は**必ず**以下のキーを持つJSONオブジェクト `{}` でなければなりません：",
+            "  - `\"id\"`: スライド番号を表す文字列（例: \"s1\", \"s2\", \"s3\"）。",
+            "  - `\"type\"`: 文字列であり、**必ず**正確に `\"summary\"` でなければなりません。",
+            "  - `\"text\"`: スライドの要約テキストを含む文字列。テキスト内の改行には `\\n` を使用してください。",
+            "\n**必須のJSON出力形式の例（この例自体を応答に含めないでください）：**",
+            '[{"id": "s1", "type": "summary", "text": "This is the first summary point.\\nIt can span multiple lines."}, {"id": "s2", "type": "summary", "text": "This is the second summary point."}]',
+            "\nそれでは、以下の音声ファイルを処理してください：",
+            audio_file_resource # アップロードしたファイルリソースを渡す
+        ]
+
+        logging.info("Gemini: 文字起こし・要約生成リクエスト送信中...")
+        generation_config = genai.types.GenerationConfig(
+            temperature=0.5,
+            # response_mime_type="application/json" # 期待通り動作しない場合があるためコメントアウト
+        )
+        safety_settings = [ # デフォルトより緩めに設定 (必要に応じて調整)
+            {"category": "HARM_CATEGORY_HARASSMENT", "threshold": "BLOCK_ONLY_HIGH"},
+            {"category": "HARM_CATEGORY_HATE_SPEECH", "threshold": "BLOCK_ONLY_HIGH"},
+            {"category": "HARM_CATEGORY_SEXUALLY_EXPLICIT", "threshold": "BLOCK_ONLY_HIGH"},
+            {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "BLOCK_ONLY_HIGH"},
+        ]
+
+        response = model.generate_content(
+            prompt_parts,
+            generation_config=generation_config,
+            safety_settings=safety_settings,
+            request_options={'timeout': 600} # 生成自体のタイムアウトも設定
+        )
+        logging.info("Gemini: 応答受信完了")
+
+        if not response.candidates or not response.candidates[0].content.parts:
+             logging.error("Gemini: 応答に有効なコンテンツが含まれていません。")
+             logging.debug(f"Gemini Full Response: {response}")
+             # 安全性フィルターによるブロックの可能性を確認
+             if response.prompt_feedback and response.prompt_feedback.block_reason:
+                  logging.error(f"Gemini: プロンプトがブロックされました。理由: {response.prompt_feedback.block_reason}")
+             if response.candidates and response.candidates[0].finish_reason != 'STOP':
+                  logging.error(f"Gemini: 生成が予期せず終了しました。理由: {response.candidates[0].finish_reason}")
+             return None
+
+        generated_text = response.text.strip()
+        logging.debug(f"Gemini Generated Text (raw):\n---\n{generated_text}\n---")
+
+        # 応答からJSONを抽出する試み (```json ... ``` も考慮)
+        json_str = None
+        match_code_block = re.search(r'```(?:json)?\s*([\s\S]+?)\s*```', generated_text, re.IGNORECASE | re.DOTALL)
+        if match_code_block:
+            json_str = match_code_block.group(1).strip()
+            logging.debug("Gemini: 応答から ```json ... ``` ブロックを抽出しました。")
+        else:
+             # コードブロックがない場合、全体がJSONか試す
+             json_match = re.search(r'^\s*([\[{].*[\]}])\s*$', generated_text, re.DOTALL)
+             if json_match:
+                 json_str = json_match.group(1)
+                 logging.debug("Gemini: 応答全体がJSON形式の可能性があります。")
+             else:
+                 logging.warning("Gemini: 応答が期待されるJSON形式（コードブロックまたは全体）ではありませんでした。")
+
+        if json_str:
+            try:
+                parsed_json = json.loads(json_str)
+                if isinstance(parsed_json, list):
+                    logging.info("Gemini: 応答は期待通りのJSONリスト形式でした。")
+                    # <<< 修正 >>> デバッグ用ファイルパス変更
+                    output_filename = os.path.join(TEMP_DIR, "gemini_summary_output.json")
+                    try:
+                        with open(output_filename, "w", encoding="utf-8") as f:
+                            json.dump(parsed_json, f, ensure_ascii=False, indent=2)
+                        logging.debug(f"Gemini 応答 (JSON) を {output_filename} に保存しました。")
+                    except IOError as e:
+                        logging.error(f"Gemini 応答のファイル保存に失敗: {e}")
+                    return json_str # JSON文字列を返す
+                else:
+                    logging.warning("Gemini: 応答はJSONでしたが、リスト形式ではありませんでした。テキストとして扱います。")
+                    # JSONだがリストでない場合も、元のテキスト全体を返す方が情報損失が少ないかも
+                    # return json_str
+            except json.JSONDecodeError as e:
+                logging.warning(f"Gemini: 抽出したJSON文字列のパースに失敗しました: {e}。応答全体をテキストとして扱います。")
+                # パース失敗した場合も、元のテキスト全体を返す
+
+        # JSONとして処理できなかった場合、元の生成テキスト全体を返す
+        logging.warning("Gemini: 応答をJSONリストとして処理できませんでした。応答テキスト全体を返します。")
+        # <<< 修正 >>> デバッグ用ファイルパス変更
+        output_filename = os.path.join(TEMP_DIR, "gemini_non_json_output.txt")
+        try:
+            with open(output_filename, "w", encoding="utf-8") as f:
+                f.write(generated_text)
+            logging.debug(f"Gemini 応答 (非JSON/エラー) を {output_filename} に保存しました。")
+        except IOError as e:
+            logging.error(f"Gemini 応答のファイル保存に失敗: {e}")
+        return generated_text # 元のテキストをそのまま返す
+
+    except genai.types.generation_types.BlockedPromptException as e:
+        logging.error(f"Gemini: プロンプトが安全上の理由でブロックされました: {e}")
+        return None
+    except genai.types.generation_types.StopCandidateException as e:
+         logging.error(f"Gemini: 生成が予期せず停止しました (例: 安全フィルター): {e}")
+         return None
+    except Exception as e:
+        # google.api_core.exceptions.DeadlineExceeded などもここで捕捉
+        if "DeadlineExceeded" in str(type(e)):
+             logging.error(f"Gemini: API呼び出しがタイムアウトしました: {e}")
+        else:
+             logging.error(f"Gemini API 呼び出し中に予期せぬエラーが発生しました。", exc_info=True)
+        return None
+    finally:
+        # ファイル削除APIは非同期の場合があるため注意が必要。
+        # 現状のライブラリでは delete_file は同期的に見えるが、ドキュメント確認推奨。
+        if audio_file_resource:
+            try:
+                logging.info(f"Gemini: アップロード済みファイル削除試行 - {audio_file_resource.name}")
+                genai.delete_file(audio_file_resource.name) # 注意：同期/非同期を確認
+                logging.info(f"Gemini: アップロード済みファイル削除完了 - {audio_file_resource.name}")
+            except Exception as delete_err:
+                logging.error(f"Gemini: アップロード済みファイルの削除中にエラー - {audio_file_resource.name}: {delete_err}", exc_info=True)
+
+
+# --- OpenAI ライブラリ設定 (DeepSeek API用) ---
+try:
+    from openai import OpenAI, APIError, RateLimitError, APITimeoutError, APIConnectionError, AuthenticationError, BadRequestError
+except ImportError:
+    logging.error("OpenAIライブラリが見つかりません。`pip install openai` を実行してください。")
+    OpenAI = None
+    APIError = RateLimitError = APITimeoutError = APIConnectionError = AuthenticationError = BadRequestError = Exception # type: ignore
+
+# DeepSeek APIキーとベースURLを環境変数から取得
+api_key_deepseek = os.getenv('DEEPSEEK_API_KEY') # 環境変数名を修正
+base_url_deepseek = os.getenv('DEEPSEEK_BASE_URL', "https://api.deepseek.com/v1")
+
+client_deepseek = None
+deepseek_api_initialized = False
+
+if not api_key_deepseek:
+    logging.warning("環境変数 'DEEPSEEK_API_KEY' が設定されていません。DeepSeek APIは使用できません。")
+elif OpenAI:
+    try:
+        client_deepseek = OpenAI(
+            api_key=api_key_deepseek,
+            base_url=base_url_deepseek,
+            timeout=120.0,      # タイムアウトを延長 (120秒)
+            max_retries=1,     # ライブラリによるリトライを1回だけ許可 (念のため)
+        )
+        logging.info(f"DeepSeek APIクライアント初期化完了 (URL: {base_url_deepseek})")
+        deepseek_api_initialized = True
+        # # 起動時の接続テストは必須ではないのでコメントアウト
+        # try:
+        #     models = client_deepseek.models.list()
+        #     logging.debug(f"DeepSeek接続テスト成功。利用可能なモデル (一部): {[m.id for m in models.data[:5]]}")
+        # except Exception as test_err:
+        #      logging.error(f"DeepSeek APIへの接続テストに失敗しました: {test_err}")
+        #      logging.error("APIキーまたはベースURLを確認してください。初期化は続行しますが、API呼び出しは失敗する可能性があります。")
+    except Exception as e:
+        logging.error(f"DeepSeek APIクライアントの初期化中にエラーが発生しました: {e}", exc_info=True)
+else:
+    pass # OpenAIライブラリがない場合
+
+
+def call_deepseek_via_openai(prompt, model="deepseek-chat", max_tokens=3000, temperature=0.3, max_retries=2, initial_delay=3):
+    """
+    OpenAIライブラリ経由でDeepSeek APIを呼び出す関数。リトライ機能付き。
+    成功時はLLMが生成したテキスト(JSON形式を期待)を、失敗時はNoneを返す。
+    """
+    if not deepseek_api_initialized or not client_deepseek:
+        logging.error("DeepSeekクライアントが初期化されていないため、APIを呼び出せません。")
+        return None
+    if not OpenAI:
+        logging.error("OpenAIライブラリがないため、DeepSeek APIを呼び出せません。")
+        return None
+
+    logging.info(f"DeepSeek: API呼び出し開始 (Model: {model}, Temp: {temperature}, MaxTokens: {max_tokens})")
+    current_delay = initial_delay
+    last_exception = None
+
+    for attempt in range(max_retries + 1):
+        logging.debug(f"DeepSeek: API呼び出し試行 {attempt + 1}/{max_retries + 1}")
+        try:
+            start_time = time.time()
+            response = client_deepseek.chat.completions.create(
+                model=model,
+                messages=[
+                    {"role": "system", "content": "You are a helpful assistant that strictly follows instructions and outputs responses in the specified format ONLY. Ensure the output is valid JSON."},
+                    {"role": "user", "content": prompt}
+                ],
+                max_tokens=max_tokens,
+                temperature=temperature,
+                stream=False,
+                # response_format={"type": "json_object"}, # DeepSeekが対応していれば有効だが、未対応の場合エラーになるので注意
+            )
+            end_time = time.time()
+            duration = end_time - start_time
+            logging.debug(f"DeepSeek: API呼び出し成功 (所要時間: {duration:.2f}秒)")
+
+            if not response.choices:
+                logging.error("DeepSeek: API応答に choices が含まれていません。")
+                last_exception = ValueError("API response missing 'choices'")
+                # リトライしても無駄な可能性が高いので、待機時間を長くして最終試行に賭けるか、諦める
+                wait_time = current_delay * 2
+                if attempt < max_retries:
+                     logging.info(f"DeepSeek: choicesがないためリトライします ({wait_time:.1f}秒後)...")
+                     time.sleep(wait_time)
+                     current_delay *= 1.5 # Backoff控えめ
+                     continue # 次の試行へ
+                else:
+                     logging.error(f"DeepSeek: 最大リトライ回数 ({max_retries + 1}回) に達しました。choicesがありません。")
+                     return None
+
+
+            content = response.choices[0].message.content
+            finish_reason = response.choices[0].finish_reason
+            usage = response.usage
+
+            logging.debug(f"DeepSeek: 応答取得完了 (Finish Reason: {finish_reason}, Tokens: {usage.total_tokens if usage else 'N/A'})")
+            logging.debug(f"DeepSeek Generated Text (raw):\n---\n{content}\n---")
+
+            if finish_reason == 'length':
+                logging.warning(f"DeepSeek: max_tokens ({max_tokens}) に達したため、応答が途中で打ち切られている可能性があります。")
+
+            # --- LLM応答からJSON部分を抽出 ---
+            json_str = None
+            # 優先度1: ```json ... ``` ブロック
+            match_code_block = re.search(r'```(?:json)?\s*([\s\S]+?)\s*```', content, re.IGNORECASE | re.DOTALL)
+            if match_code_block:
+                json_str = match_code_block.group(1).strip()
+                logging.info("DeepSeek: 応答から ```json ... ``` ブロックを抽出しました。")
+            else:
+                # 優先度2: 応答全体がJSON形式か (前後の空白は許容)
+                json_match = re.search(r'^\s*([\[{].*[\]}])\s*$', content, re.DOTALL)
+                if json_match:
+                    json_str = json_match.group(1)
+                    logging.info("DeepSeek: 応答全体がJSON形式と判断しました。")
+
+            if json_str:
+                try:
+                    # 有効なJSONかパースしてみる (パースするだけで、返すのは文字列)
+                    json.loads(json_str)
+                    logging.info("DeepSeek: 抽出/判断されたJSON文字列は有効です。")
+                    # <<< 修正 >>> デバッグ用ファイルパス変更
+                    output_filename_base = f"deepseek_output_{'summary' if 'summary' in prompt else 'quiz'}.json"
+                    output_filename = os.path.join(TEMP_DIR, output_filename_base)
+                    try:
+                        with open(output_filename, "w", encoding="utf-8") as f:
+                             f.write(json_str) # パースしたものではなく、抽出した文字列を保存
+                        logging.debug(f"DeepSeek 応答 (JSON) を {output_filename} に保存しました。")
+                    except IOError as e:
+                        logging.error(f"DeepSeek 応答のファイル保存に失敗: {e}")
+                    return json_str # 有効なJSON文字列を返す
+                except json.JSONDecodeError as e:
+                    logging.warning(f"DeepSeek: 抽出/判断されたJSON文字列のパースに失敗: {e}")
+                    last_exception = e # エラー情報を保持
+                    # パース失敗した場合、リトライする価値はあるかもしれない
+            else:
+                # JSONが見つからなかった場合
+                logging.error("DeepSeek: 期待したJSON形式の応答（コードブロックまたは全体）が見つかりませんでした。")
+                logging.error(f"DeepSeek Raw Response: {content.strip()}")
+                last_exception = ValueError("No JSON found in response")
+                # JSONが得られなかった場合もリトライする価値はあるかもしれない
+
+            # リトライ処理 (JSONパース失敗 or JSONが見つからなかった場合)
+            if attempt < max_retries:
+                 wait_time = current_delay * (random.uniform(0.8, 1.2))
+                 logging.info(f"DeepSeek: JSON取得/パース失敗のためリトライします ({wait_time:.1f}秒後)...")
+                 time.sleep(wait_time)
+                 current_delay *= 2 # Exponential Backoff
+                 continue # 次の試行へ
+            else:
+                 # リトライ上限に達した場合
+                 logging.error(f"DeepSeek: 最大リトライ回数 ({max_retries + 1}回) に達しました。有効なJSON応答を得られませんでした。")
+                 return None # 失敗としてNoneを返す
+
+
+        # --- エラーハンドリングとリトライ ---
+        except AuthenticationError as e:
+            logging.error(f"DeepSeek: 認証エラー (試行 {attempt + 1}): {e}. APIキーを確認してください。")
+            return None # 認証エラーはリトライしない
+        except BadRequestError as e:
+             logging.error(f"DeepSeek: 不正なリクエストエラー (試行 {attempt + 1}): {e}. プロンプトやパラメータを確認してください。")
+             # プロンプトが長すぎる場合などもここに来る可能性
+             return None # リクエスト内容が悪い場合はリトライしない
+        except RateLimitError as e:
+            last_exception = e
+            logging.warning(f"DeepSeek: APIレート制限エラーが発生しました (試行 {attempt + 1}): {e}")
+            wait_time = current_delay * (random.uniform(1.0, 1.5)) # レート制限は少し長めに待つ
+            logging.info(f"DeepSeek: レート制限のためリトライします ({wait_time:.1f}秒後)...")
+        except (APITimeoutError, APIConnectionError) as e:
+             last_exception = e
+             logging.warning(f"DeepSeek: APIタイムアウト/接続エラーが発生しました (試行 {attempt + 1}): {e}")
+             wait_time = current_delay * (random.uniform(0.8, 1.2))
+             logging.info(f"DeepSeek: タイムアウト/接続エラーのためリトライします ({wait_time:.1f}秒後)...")
+        except APIError as e: # その他のAPIエラー (例: 5xxサーバーエラー)
+            last_exception = e
+            logging.warning(f"DeepSeek: APIエラーが発生しました (試行 {attempt + 1}): HTTP Status={getattr(e, 'status_code', 'N/A')}, Type={getattr(e, 'type', 'N/A')}, Message={getattr(e, 'message', str(e))}")
+            status_code = getattr(e, 'status_code', None)
+            if status_code and 500 <= status_code < 600:
+                 wait_time = current_delay * (random.uniform(0.8, 1.2))
+                 logging.info(f"DeepSeek: サーバーエラー({status_code})のためリトライします ({wait_time:.1f}秒後)...")
+            else:
+                logging.error(f"DeepSeek: リトライ不可能なAPIエラー({status_code})です。")
+                return None
+        except Exception as e:
+            last_exception = e
+            logging.error(f"DeepSeek: API呼び出し中に予期せぬPythonエラーが発生しました (試行 {attempt + 1}): {type(e).__name__}: {e}", exc_info=True)
+            wait_time = current_delay * (random.uniform(0.8, 1.2))
+            logging.info(f"DeepSeek: 予期せぬエラーのためリトライします ({wait_time:.1f}秒後)...")
+
+        # リトライ待機 (最終試行でなければ)
+        if attempt < max_retries:
+            time.sleep(wait_time)
+            current_delay *= 2 # 次の遅延時間を増やす (Exponential Backoff)
+        else:
+            logging.error(f"DeepSeek: 最大リトライ回数 ({max_retries + 1}回) に達しました。API呼び出しを諦めます。")
+            if last_exception:
+                logging.error(f"DeepSeek: 最後に発生したエラー: {last_exception}")
+            return None
+
+    return None # この行には到達しないはず
+
+
+def validate_summary_item(item, index):
+    """要約リストの単一要素を検証するヘルパー関数"""
+    if not isinstance(item, dict):
+        raise ValueError(f"要約要素 {index + 1} が辞書形式ではありません。")
+    required_keys = ["id", "type", "text"]
+    missing_keys = [k for k in required_keys if k not in item]
+    if missing_keys:
+        raise ValueError(f"要約要素 {index + 1} に必須キー ({', '.join(missing_keys)}) が不足しています。")
+    if not isinstance(item.get("id"), str) or not item.get("id"):
+        raise ValueError(f"要約要素 {index + 1} の 'id' が空でない文字列ではありません。")
+    if item.get("type") != "summary":
+        raise ValueError(f"要約要素 {index + 1} の 'type' が 'summary' ではありません。 Actual: '{item.get('type')}'")
+    if not isinstance(item.get("text"), str): # textは空文字列を許容
+        raise ValueError(f"要約要素 {index + 1} の 'text' が文字列ではありません。")
+    # 追加: textが過度に短い、または長すぎる場合のチェックなど？ (任意)
+    return item
+
+def generate_summary(transcript_or_json_str):
+    """
+    入力テキストまたはJSON文字列から、要約スライドのリストを生成する。
+    Geminiが直接有効なJSONを返した場合はそれを使い、そうでなければDeepSeekに依頼する。
+    成功時は要約リスト(Pythonオブジェクト)を、失敗時はNoneを返す。
+    """
+    logging.info("バックエンド: 要約生成処理 開始")
+    validated_list = None
+    transcript_text = transcript_or_json_str # DeepSeek用入力のデフォルト
+
+    # 1. 入力がGeminiからの有効なJSONリストか試す
+    if isinstance(transcript_or_json_str, str) and transcript_or_json_str.strip().startswith('['):
+        try:
+            parsed_data = json.loads(transcript_or_json_str)
+            if isinstance(parsed_data, list):
+                logging.debug("バックエンド: 入力はリスト形式のJSONです。Geminiからの応答として検証します。")
+                current_validated_list = []
+                if not parsed_data:
+                     # 空リストは許容しないことにする
+                     logging.warning("Gemini応答: JSONリストが空です。")
+                     # raise ValueError("Gemini応答: JSONリストが空です。") # エラーにするか、DeepSeekに回すか
+                     # DeepSeekに回すことにする
+                else:
+                     for i, item in enumerate(parsed_data):
+                          current_validated_list.append(validate_summary_item(item, i)) # ヘルパー関数で検証
+                     logging.info("バックエンド: Geminiからの直接生成された要約JSONを検証し、使用します。")
+                     validated_list = current_validated_list # 検証成功
+            else:
+                logging.warning("バックエンド: Gemini応答はJSONでしたがリスト形式ではありません。DeepSeekに要約を依頼します。")
+                # この場合、transcript_text は元の文字列のまま
+        except (json.JSONDecodeError, TypeError) as e:
+            # JSON文字列に見えたがパース失敗
+            logging.info(f"バックエンド: 入力は有効な要約JSONリストではありません ({type(e).__name__}: {e})。DeepSeekに要約を依頼します。")
+            # transcript_text は元の文字列のまま
+        except ValueError as ve:
+            # 形式はリストだが、中身の検証でエラー (validate_summary_item)
+             logging.warning(f"バックエンド: Gemini応答JSONリストの検証に失敗: {ve}。DeepSeekに要約を依頼します。")
+             # transcript_text は元の文字列のまま
+    else:
+        # 最初からJSON文字列ではなかった場合
+        logging.info("バックエンド: 入力がJSONリスト形式ではないため、DeepSeekに要約を依頼します。")
+        # transcript_text は元の文字列のまま
+
+    # 2. Geminiの結果が使えなかった場合、DeepSeekに要約生成を依頼する
+    if validated_list is None: # Geminiの結果が使えなかった場合のみ実行
+        if not deepseek_api_initialized:
+             logging.error("バックエンド: 要約生成失敗 (DeepSeekクライアント未初期化)")
+             return None
+        if not transcript_text: # DeepSeekへの入力が空でないか確認
+             logging.error("バックエンド: 要約生成失敗 (DeepSeekへの入力テキストが空です)")
+             return None
+
+
+        logging.info("バックエンド: DeepSeek APIによる要約生成 開始")
+        # <<< 修正 >>> DeepSeekモデル名を環境変数から取得（任意）
+        deepseek_model_name = os.getenv('DEEPSEEK_MODEL', 'deepseek-chat')
+        logging.info(f"DeepSeek: 使用モデル - {deepseek_model_name}")
+        prompt = f"""
+以下のテキストを分析し、内容の理解を助けるために、キーポイントを複数のスライド形式で要約してください。テキストが非常に長い場合は、主要な部分を網羅するようにしてください。
+
+**厳格な出力形式の指示:**
+結果は、**必ずJSONリスト `[]` のみ**としてくだ���い。JSONリストの前後に、**一切のテキスト（導入文、説明、補足、マークダウンの```json ... ```など）を含めないでください**。出力はJSONリストそのものでなければなりません。
+リストの各要素は、**必ず**以下のキーを持つJSONオブジェクト `{{}}` でなければなりません：
+- `"id"`: スライド番号を表す文字列。例のように `"s1"`, `"s2"`, `"s3"` と連番にしてください。
+- `"type"`: 文字列であり、**必ず** `"summary"` という値にしてください。
+- `"text"`: そのスライドの要約内容を含む文字列。簡潔かつ分かりやすく記述してください。テキスト内で改行する場合は `\\n` を使用してください。JSONとして有効なように、テキスト内の特殊文字（引用符など）は適切にエスケープしてください。
+
+**必須のJSON出力形式の例（この例自体を出力に含めないでください）：**
+[
+  {{"id": "s1", "type": "summary", "text": "First summary point for slide 1."}},
+  {{"id": "s2", "type": "summary", "text": "Second summary point.\\nThis one has a newline."}}
+]
+
+**入力テキスト:**
+---
+{transcript_text}
+---
+
+上記の指示に厳密に従い、要約スライドの**JSONリストのみ**を出力してください。出力は有効なJSONでなければなりません。他のテキストは一切含めないでください。
+"""
+        # DeepSeekへのリクエスト、長文に対応できるようmax_tokensを調整
+        response_str = call_deepseek_via_openai(prompt, model=deepseek_model_name, temperature=0.5, max_tokens=3000)
+
+        if response_str:
+            try:
+                summary_list_deepseek = json.loads(response_str)
+                if not isinstance(summary_list_deepseek, list):
+                    raise ValueError("DeepSeek応答がリスト形式ではありません。")
+                if not summary_list_deepseek:
+                    raise ValueError("DeepSeek応答リストが空です。")
+
+                validated_list_deepseek = []
+                for i, item in enumerate(summary_list_deepseek):
+                    validated_list_deepseek.append(validate_summary_item(item, i)) # ヘルパー関数で検証
+
+                logging.info("バックエンド: DeepSeekによる要約生成完了 (JSONパース・検証成功)")
+                return validated_list_deepseek # 検証済みのPythonリストを返す
+            except (json.JSONDecodeError, ValueError) as e:
+                logging.error(f"バックエンド: DeepSeek要約生成失敗 (JSONパースまたは検証エラー: {e})")
+                logging.error(f"DeepSeek応答 (生文字列):\n---\n{response_str}\n---")
+                return None
+        else:
+            logging.error("バックエンド: DeepSeek要約生成失敗 (API呼び出し失敗または有効なJSON応答なし)")
+            return None
+    else:
+        # Geminiの結果が使えた場合
+        return validated_list
+
+
+def validate_quiz_item(item, index):
+    """クイズリストの単一要素を検証するヘルパー関数"""
+    if not isinstance(item, dict):
+        raise ValueError(f"クイズ要素 {index + 1} が辞書形式ではありません。")
+    required_keys = ["id", "type", "text", "options", "answer"]
+    missing_keys = [k for k in required_keys if k not in item]
+    if missing_keys:
+        raise ValueError(f"クイズ要素 {index + 1} に必須キー ({', '.join(missing_keys)}) が不足しています。")
+    if not isinstance(item.get("id"), str) or not item.get("id"):
+        raise ValueError(f"クイズ要素 {index + 1} の 'id' が空でない文字列ではありません。")
+    if item.get("type") != "question":
+        raise ValueError(f"クイズ要素 {index + 1} の 'type' が 'question' ではありません。 Actual: '{item.get('type')}'")
+    if not isinstance(item.get("text"), str) or not item.get("text"):
+        raise ValueError(f"クイズ要素 {index + 1} の 'text' (質問文) が空でない文字列ではありません。")
+    options = item.get("options")
+    # オプションの数をチェック (例: 3個または4個を期待する場合)
+    expected_options_count = 4 # 例として4択を期待
+    if not isinstance(options, list) or len(options) != expected_options_count:
+        raise ValueError(f"クイズ要素 {index + 1} の 'options' が正確に{expected_options_count}個の要素を持つリストではありません (現在: {len(options) if isinstance(options, list) else '非リスト'})。")
+    if not all(isinstance(opt, str) and opt for opt in options):
+        raise ValueError(f"クイズ要素 {index + 1} の 'options' の要素がすべて空でない文字列ではありません。")
+    answer = item.get("answer")
+    if not isinstance(answer, str) or not answer:
+        raise ValueError(f"クイズ要素 {index + 1} の 'answer' が空でない文字列ではありません。")
+    if answer not in options:
+        # 答えが選択肢内にないのは致命的
+        raise ValueError(f"クイズ要素 {index + 1} の 'answer' ('{answer}') が 'options' {options} 内に見つかりません。")
+    return item
+
+
+def generate_quiz(transcript_or_json_str):
+    """
+    入力テキストまたはJSON文字列から、クイズのリストを生成する (DeepSeek APIを使用)。
+    成功時はクイズリスト(Pythonオブジェクト)を、失敗時はNoneを返す。
+    """
+    logging.info("バックエンド: クイズ生成処理 開始 (DeepSeek API)")
+
+    transcript_text = transcript_or_json_str
+    # 入力がJSON文字列かどうかをチェック（ログ出力用）
+    is_json_input = False
+    if isinstance(transcript_text, str):
+        try:
+            json.loads(transcript_text)
+            if transcript_text.strip().startswith(('[', '{')):
+                is_json_input = True
+        except (json.JSONDecodeError, TypeError):
+            pass
+    if is_json_input:
+        logging.warning("バックエンド: クイズ生成への入力がJSON形式でした。そのままテキストとして扱います。")
+
+    if not deepseek_api_initialized:
+         logging.error("バックエンド: クイズ生成失敗 (DeepSeekクライアント未初期化)")
+         return None
+    if not transcript_text:
+        logging.error("バックエンド: クイズ生成失敗 (入力テキストが空です)")
+        return None
+
+    # --- クイズ設定 ---
+    num_questions = 5  # 生成する問題数
+    num_options = 4    # 各問題の選択肢の数
+
+    logging.info(f"バックエンド: DeepSeek APIによるクイズ生成 開始 ({num_questions}問, {num_options}択)")
+    # <<< 修正 >>> DeepSeekモデル名を環境変数から取得（任意）
+    deepseek_model_name = os.getenv('DEEPSEEK_MODEL', 'deepseek-chat')
+    logging.info(f"DeepSeek: 使用モデル - {deepseek_model_name}")
+    prompt = f"""
+以下のテキストを分析し、内容の理解度をテストするために、**正確に{num_questions}個**の多肢選択式クイズ問題を生成してください。各問題には、それぞれ**正確に{num_options}個**の異なる選択肢が必要です。
+
+**厳格な出力形式の指示:**
+結果は、**必ずJSONリスト `[]` のみ**としてください。JSONリストの前後に、**一切のテキスト（導入文、説明、補足、マークダウンの```json ... ```など）を含めないでください**。出力はJSONリストそのものでなければなりません。
+リストの各要素は、**必ず**以下のキーを持つJSONオブジェクト `{{}}` でなければなりません：
+- `"id"`: 質問番号を表す文字列。 `"q1"`, `"q2"`, ..., `"q{num_questions}"` と連番にしてください。
+- `"type"`: 文字列であり、**必ず** `"question"` という値にしてください。
+- `"text"`: 質問文そのものを含む文字列。具体的で明確な質問にしてください。
+- `"options"`: 文字列のリスト `[]` であり、**正確に{num_options}個**の解答選択肢を含めてください。選択肢は互いに区別可能で、正解以外の選択肢（不正解の選択肢）ももっともらしいものにしてください。
+- `"answer"`: 正しい答えを指定する文字列。この文字列は、**必ず**その質問の `"options"` リストに含まれる文字列のいずれかでなければなりません。
+
+**必須のJSON出力形式の例（{num_questions}=3, {num_options}=4の場合 - この例自体を出力に含めないでください）：**
+[
+  {{"id": "q1", "type": "question", "text": "What was the primary focus of the discussion?", "options": ["Topic A", "Topic B", "Topic C", "Topic D"], "answer": "Topic B"}},
+  {{"id": "q2", "type": "question", "text": "Which specific example was mentioned?", "options": ["Example X", "Example Y", "Example Z", "Example W"], "answer": "Example Y"}},
+  {{"id": "q3", "type": "question", "text": "What is the recommended next action?", "options": ["Action 1", "Action 2", "Action 3", "Action 4"], "answer": "Action 1"}}
+]
+
+**入力テキスト:**
+---
+{transcript_text}
+---
+
+上記の指示に厳密に従ってください。**正確に{num_questions}個**のクイズ問題を生成し、**JSONリストのみ**を出力してください。他のテキストは一切含めないでください。出力は有効なJSONでなければなりません。
+"""
+    # クイズ生成は比較的短い応答で済むことが多いが、入力テキストによっては長くかかる可能性
+    # max_tokens は num_questions や num_options に応じて調整
+    max_tokens_quiz = num_questions * (150 + num_options * 50) # 大まかな目安 (質問文+選択肢)
+    response_str = call_deepseek_via_openai(prompt, model=deepseek_model_name, temperature=0.4, max_tokens=max_tokens_quiz)
+
+    if response_str:
+        try:
+            quiz_list = json.loads(response_str)
+            if not isinstance(quiz_list, list):
+                raise ValueError("DeepSeek応答がリスト形式ではありません。")
+            # 生成された問題数をチェック
+            if len(quiz_list) != num_questions:
+                logging.warning(f"DeepSeekが生成したクイズ数が指定と異なります (期待: {num_questions}, 実際: {len(quiz_list)})")
+                # ここでエラーにするか、そのまま使うかは要件次第
+                # if len(quiz_list) == 0: raise ValueError("DeepSeek応答クイズリストが空です。") # 空の場合はエラー
+            if not quiz_list:
+                 raise ValueError("DeepSeek応答クイズリストが空です。")
+
+            validated_list = []
+            for i, item in enumerate(quiz_list):
+                 # IDを q1, q2... に強制的に振り直す (LLMが従わない場合があるため)
+                 item['id'] = f'q{i+1}'
+                 validated_list.append(validate_quiz_item(item, i)) # ヘルパー関数で検証
+
+            logging.info(f"バックエンド: DeepSeekによるクイズ生成完了 ({len(validated_list)}問 JSONパース・検証成功)")
+            return validated_list
+        except (json.JSONDecodeError, ValueError) as e:
+            logging.error(f"バックエンド: DeepSeekクイズ生成失敗 (JSONパースまたは検証エラー: {e})")
+            logging.error(f"DeepSeek応答 (生文字列):\n---\n{response_str}\n---")
+            return None
+    else:
+        logging.error("バックエンド: DeepSeekクイズ生成失敗 (API呼び出し失敗または有効なJSON応答なし)")
+        return None
+
+
+# --- Flask ルーティング (HTMLページ表示) ---
+
+@app.route('/')
+@app.route('/input')
+def input_page():
+    """入力画面を表示"""
+    logging.debug("Routing: /input ページ表示")
+    return render_template('input.html')
+
+@app.route('/history')
+def history_page():
+    """履歴画面を表示"""
+    logging.debug("Routing: /history ページ表示")
+    history_items = []
+    error_message = None
+
+    # ↓↓↓ チェックを修正: 未設定または空文字列の場合のみエラーとする ↓↓↓
+    if not GAS_WEB_APP_URL:
+        logging.error("/history: GAS_WEB_APP_URLが設定されていません。") # エラーメッセージも少し具体的に
+        error_message = "データベース接続設定が不完全なため、履歴を取得できません。(URL未設定)"
+    else:
+        # GASへのリクエスト処理
+        try:
+            logging.debug(f"/history: GASへの履歴取得リクエスト送信 - URL: {GAS_WEB_APP_URL}")
+            # GETリクエスト (idパラメータなし) を送る
+            gas_response = requests.get(GAS_WEB_APP_URL, timeout=60)
+            gas_response.raise_for_status() # HTTPエラーチェック
+
+            gas_result = gas_response.json()
+            logging.debug(f"/history: GASからの応答受信: {gas_result}")
+
+            # GAS応答を検証 (変更なし)
+            if gas_result.get("success") and isinstance(gas_result.get("data"), list):
+                history_items = gas_result["data"]
+                logging.info(f"/history: GASからの履歴取得 成功 ({len(history_items)}件)")
+            elif not gas_result.get("success"):
+                gas_error_msg = gas_result.get('message', 'GASからの履歴取得中に不明なエラーが発生しました。')
+                logging.error(f"/history: GASからの履歴取得失敗 (GAS側エラー): {gas_error_msg}")
+                error_message = f"データベースエラー: {gas_error_msg}"
+            else:
+                logging.error(f"/history: GASからの応答形式が予期しないものです (dataがリストでない等)。")
+                error_message = "データベースからの応答形式が不正です。"
+
+        except requests.exceptions.Timeout:
+             logging.error("/history: GASへの接続がタイムアウトしました。")
+             error_message = "データベースへの接続がタイムアウトしました。"
+        except requests.exceptions.HTTPError as http_err:
+             status_code = http_err.response.status_code if http_err.response else "N/A"
+             logging.error(f"/history: GASへの接続でHTTPエラーが発生: Status={status_code}, Error={http_err}")
+             error_message = f"データベース接続エラー (HTTP {status_code})。"
+        except requests.exceptions.RequestException as req_err:
+             logging.error(f"/history: GASへの接続中にネットワークエラー等が発生: {req_err}")
+             error_message = f"データベース接続エラー: {req_err}"
+        except json.JSONDecodeError as json_err:
+             raw_gas_response = gas_response.text if 'gas_response' in locals() else "N/A"
+             logging.error(f"/history: GASからの応答JSONのパースに失敗: {json_err}")
+             logging.error(f"GAS Raw Response: {raw_gas_response[:500]}...")
+             error_message = "データベースからの応答形式が不正です。"
+        except Exception as e:
+             logging.error(f"/history: 履歴取得中に予期せぬエラーが発生: {e}", exc_info=True)
+             error_message = "サーバー内部エラーが発生しました。"
+
+    # 取得したデータまたはエラーメッセージをテンプレートに渡す (変更なし)
+    return render_template('history.html', history_items=history_items, error_message=error_message)
+
+@app.route('/learning')
+def learning_page():
+    """学習画面を表示"""
+    content_id = request.args.get('id')
+    logging.debug(f"Routing: /learning ページ表示リクエスト (Content ID: {content_id})")
+    if not content_id:
+         logging.warning("学習画面リクエストで content_id が指定されていません。")
+         return render_template('learning.html', error_message="表示するコンテンツIDが指定されていません。", content_id=None, title="エラー")
+    # タイトルはJSがAPIから取得して設定する想定
+    return render_template('learning.html', content_id=content_id, title="学習コンテンツ読み込み中...")
+
+@app.route('/settings')
+def settings_page():
+    """設定画面を表示"""
+    logging.debug("Routing: /settings ページ表示")
+    return render_template('settings.html')
+
+# --- Flask APIエンドポイント ---
+
+@app.route('/api/generate', methods=['POST'])
+def generate_content():
+    """
+    YouTube URLを受け取り、音声抽出、文字起こし、要約、クイズ生成を行い、
+    結果をGASに保存し、クライアントにも返すAPI。
+    """
+    start_time_generate = time.time()
+    logging.info("API /api/generate: リクエスト受信")
+
+    if not request.is_json:
+        logging.warning("API /api/generate: リクエスト形式が不正 (非JSON)")
+        return jsonify({"success": False, "message": "リクエストはJSON形式である必要があります。"}), 400
+
+    data = request.get_json()
+    youtube_url = data.get('url')
+
+    if not youtube_url:
+        logging.warning("API /api/generate: URLが指定されていません")
+        return jsonify({"success": False, "message": "YouTubeのURLが指定されていません。"}), 400
+
+    # URL形式チェック (yt-dlpに任せるので緩め)
+    if not isinstance(youtube_url, str) or 'youtube.com' not in youtube_url and 'youtu.be' not in youtube_url:
+         logging.warning(f"API /api/generate: YouTube URLとして疑わしい形式です: {youtube_url}")
+         # ここでエラーにするか、yt-dlpのエラーに任せるか選択
+         # return jsonify({"success": False, "message": "有効なYouTubeのURLを指定してください。"}), 400
+
+    logging.info(f"API /api/generate: URL='{youtube_url}' で処理開始")
+
+    audio_path = None
+    generated_data = None
+    content_id = None
+    video_info = None # 動画情報を格納
+
+    try:
+        # --- 1. 音声抽出 & 動画情報取得 ---
+        step_start_time = time.time()
+        logging.info("API /api/generate: (1/5) 音声抽出 & 動画情報取得 開始")
+        # download_and_extract_audio は (audio_path, video_info) を返すように修正
+        audio_path, video_info = download_and_extract_audio(youtube_url)
+        if not audio_path:
+            # video_info にエラーメッセージなどが入っている可能性もあるが、audio_pathがなければ失敗
+            raise ValueError("音声ファイルの抽出に失敗しました。URLが正しいか、動画が利用可能か確認してください。")
+        logging.info(f"API /api/generate: (1/5) 音声抽出完了 - Path: {audio_path} (所要時間: {time.time() - step_start_time:.2f}秒)")
+        if not video_info: # audio_pathがあってもvideo_infoがない場合 (通常はありえないはず)
+             video_info = {'title': '不明な動画', 'thumbnail': None}
+             logging.warning("API /api/generate: 動画情報の取得に失敗しましたが、音声抽出は成功しました。")
+
+
+        # --- 2. 文字起こし・初期要約 (Gemini) ---
+        step_start_time = time.time()
+        logging.info("API /api/generate: (2/5) 文字起こし・初期要約 (Gemini) 開始")
+        transcript_or_summary_json = transcribe_audio(audio_path)
+        if transcript_or_summary_json is None:
+             raise ValueError("Geminiによる文字起こし・初期要約処理に失敗しました。APIキーやクォータを確認してください。")
+        if not transcript_or_summary_json:
+             logging.warning("API /api/generate: Geminiからの応答が空でした。")
+             raise ValueError("Geminiによる文字起こし・初期要約結果が空です。音声が無音でないか確認してください。")
+        logging.info(f"API /api/generate: (2/5) 文字起こし・初期要約 (Gemini) 完了 (��要時間: {time.time() - step_start_time:.2f}秒)")
+
+        # --- 3. 最終的な要約リスト生成 (Gemini結果 or DeepSeek) ---
+        step_start_time = time.time()
+        logging.info("API /api/generate: (3/5) 最終要約リスト生成 開始")
+        summary_items = generate_summary(transcript_or_summary_json)
+        if not summary_items:
+            # generate_summary内でエラーログが出力されているはず
+            raise ValueError("要約リストの生成に失敗しました。モデルの応答形式を確認してください。")
+        logging.info(f"API /api/generate: (3/5) 最終要約リスト生成 完了 ({len(summary_items)}項目) (所要時間: {time.time() - step_start_time:.2f}秒)")
+
+        # --- 4. クイズ生成 (DeepSeek) ---
+        step_start_time = time.time()
+        logging.info("API /api/generate: (4/5) クイズ生成 開始")
+        # クイズ生成にはGeminiの応答（JSON文字列またはテキスト）を使う
+        question_items = generate_quiz(transcript_or_summary_json)
+        if not question_items:
+             raise ValueError("クイズの生成に失敗しました。モデルの応答形式を確認してください。")
+        logging.info(f"API /api/generate: (4/5) クイズ生成 完了 ({len(question_items)}項目) (所要時間: {time.time() - step_start_time:.2f}秒)")
+
+        # --- 成功データの準備 ---
+        content_id = f"cont_{int(time.time())}_{random.randint(1000, 9999)}"
+        # yt-dlpから取得した情報を使用
+        video_title = video_info.get('title', f"生成コンテンツ {content_id[-4:]}")
+        # サムネイルURLもyt-dlpから取得、なければデフォルト
+        thumbnail_url = video_info.get('thumbnail')
+        if not thumbnail_url and video_info.get('id'):
+             # yt-dlpで取得できなかった場合、標準的なURLを試す
+             thumbnail_url = f"https://i.ytimg.com/vi/{video_info['id']}/mqdefault.jpg"
+
+        generated_data = {
+            "id": content_id,
+            "title": video_title,
+            "thumbnail": thumbnail_url or '', # Noneではなく空文字を渡す
+            "summary": summary_items,   # Pythonリスト
+            "questions": question_items # Pythonリスト
+        }
+        logging.debug(f"API /api/generate: 生成データ準備完了 (ID: {content_id})")
+
+        # --- 5. GASにデータを保存 ---
+        step_start_time = time.time()
+        logging.info("API /api/generate: (5/5) GASへのデータ保存 開始")
+        # GAS URLのチェックを強化
+        if not GAS_WEB_APP_URL or 'YOUR_PLACEHOLDER_GAS_URL' in GAS_WEB_APP_URL or not GAS_WEB_APP_URL.startswith('https://script.google.com/macros/s/'):
+            logging.warning("API /api/generate: GAS_WEB_APP_URLが無効または設定されていません。データは保存されません。")
+            # 保存失敗でも処理は続行し、生成データを返す
+        else:
+            try:
+                headers = {'Content-Type': 'application/json'}
+                # GASのdoPostに送信するデータ (Python dict)
+                # GAS側で summary と questions を stringify するので、ここではリストのまま送る
+                payload_to_gas = generated_data.copy() # 元のデータを変更しないようにコピー
+
+                gas_response = requests.post(
+                    GAS_WEB_APP_URL,
+                    headers=headers,
+                    data=json.dumps(payload_to_gas), # Python dictをJSON文字列に変換
+                    timeout=60 # GASのタイムアウトを少し長めに設定 (60秒)
+                )
+                gas_response.raise_for_status()
+
+                gas_result = gas_response.json()
+                if gas_result.get("success"):
+                    returned_content_id = gas_result.get("content_id")
+                    logging.info(f"API /api/generate: (5/5) GASへのデータ保存 成功 (GASが返したID: {returned_content_id}) (所要時間: {time.time() - step_start_time:.2f}秒)")
+                    # Flask側で生成したIDとGASが返したIDが一致するか確認 (任意)
+                    if returned_content_id != content_id:
+                         logging.warning(f"GAS保存後のContent ID不一致: Flask側={content_id}, GAS側={returned_content_id}")
+                else:
+                    gas_error_msg = gas_result.get('message', 'GAS側でエラーが発生しました。')
+                    logging.error(f"API /api/generate: GASへのデータ保存失敗 (GAS応答): {gas_error_msg}")
+                    # 警告に留める
+
+            except requests.exceptions.Timeout:
+                 logging.error("API /api/generate: GASへの接続がタイムアウトしました。データは保存されませんでした。")
+            except requests.exceptions.RequestException as req_err:
+                # HTTPエラーの詳細（ステータスコード、応答内容）をログ���出力
+                status_code = req_err.response.status_code if req_err.response else "N/A"
+                response_text = req_err.response.text if req_err.response else "N/A"
+                logging.error(f"API /api/generate: GASへのデータ保存中にネットワーク/HTTPエラーが発生: Status={status_code}, Error={req_err}. Response: {response_text[:500]}...") # 応答が長い場合に切り詰める
+            except json.JSONDecodeError as json_err:
+                 logging.error(f"API /api/generate: GASからの応答JSONのパースに失敗: {json_err}")
+                 # GASからの生応答を出力 (gas_response 変数が存在する場合)
+                 raw_gas_response = "N/A"
+                 if 'gas_response' in locals() and hasattr(gas_response, 'text'):
+                     raw_gas_response = gas_response.text
+                 logging.error(f"GAS Raw Response: {raw_gas_response[:500]}...")
+            # GAS保存失敗は警告として処理を続行
+
+        # --- 最終的な成功応答 ---
+        total_duration = time.time() - start_time_generate
+        logging.info(f"API /api/generate: 全処理成功 (Total Time: {total_duration:.2f}秒) - Content ID: {content_id}")
+        # 生成したデータを返す (GAS保存の成否に関わらず)
+        return jsonify({"success": True, "data": generated_data}), 200
+
+    except ValueError as ve: # バックエンド処理中の予期されたエラー
+        total_duration = time.time() - start_time_generate
+        logging.error(f"API /api/generate: 処理中にエラーが発生しました (ValueError): {ve} (Total Time: {total_duration:.2f}秒)")
+        # ユーザーフレンドリーなメッセージを返す
+        return jsonify({"success": False, "message": f"コンテンツ生成エラー: {str(ve)}"}), 400 # Bad Request
+    except Exception as e: # その他の予期せぬエラー
+        total_duration = time.time() - start_time_generate
+        logging.error(f"API /api/generate: 処理中に予期せぬエラーが発生しました: {type(e).__name__}: {e} (Total Time: {total_duration:.2f}秒)", exc_info=True)
+        return jsonify({"success": False, "message": "サーバー内部で予期せぬエラーが発生しました。管理者にご連絡ください。"}), 500 # Internal Server Error
+
+    finally:
+        # --- 一時音声ファイルの削除 ---
+        # <<< 修正 >>> audio_pathが /tmp 配下のパスであることを想定
+        if audio_path and os.path.exists(audio_path):
+            try:
+                os.remove(audio_path)
+                logging.info(f"一時音声ファイル {audio_path} を削除しました。")
+            except OSError as rm_err:
+                logging.error(f"一時音声ファイル {audio_path} の削除に失敗しました: {rm_err}")
+
+
+@app.route('/api/learning/<content_id>', methods=['GET'])
+def get_learning_content(content_id):
+    """
+    指定されたIDの学習コンテンツ（要約とクイズ）をGASから取得するAPI。
+    GASのdoGetは、指定IDのデータを {success: true, data: {id:.., title:.., ..., items: [...], totalItems: ...}} の形で返す想定。
+    """
+    start_time_learning = time.time()
+    logging.info(f"API /api/learning/{content_id}: リクエスト受信")
+
+    if not content_id:
+        logging.warning(f"API /api/learning: content_id が指定されていません。")
+        return jsonify({"success": False, "message": "コンテンツIDが指定されていません。"}), 400
+
+    # GAS URLのチェック
+    if not GAS_WEB_APP_URL or 'YOUR_PLACEHOLDER_GAS_URL' in GAS_WEB_APP_URL or not GAS_WEB_APP_URL.startswith('https://script.google.com/macros/s/'):
+        logging.error(f"API /api/learning/{content_id}: GAS_WEB_APP_URLが無効または設定されていません。")
+        return jsonify({"success": False, "message": "データベース接続設定が不完全です。"}), 500
+
+    try:
+        params = {'id': content_id}
+        logging.debug(f"API /api/learning/{content_id}: GASへのデータ取得リクエスト送信 - URL: {GAS_WEB_APP_URL} Params: {params}")
+
+        gas_response = requests.get(GAS_WEB_APP_URL, params=params, timeout=60) # タイムアウト60秒
+        gas_response.raise_for_status()
+
+        gas_result = gas_response.json()
+        logging.debug(f"API /api/learning/{content_id}: GASからの応答受信 (raw): {gas_result}")
+
+        # GAS側の応答形式を検証 (success と data が存在するか)
+        if "success" in gas_result and "data" in gas_result:
+             if gas_result["success"] and gas_result["data"] is not None:
+                 # GASから受け取った 'data' フィールドの中身をそのままクライアントに返す
+                 response_data = gas_result["data"]
+                 # 'items' が存在し、リストであることを念のため確認
+                 if isinstance(response_data.get("items"), list):
+                     duration = time.time() - start_time_learning
+                     logging.info(f"API /api/learning/{content_id}: GASからのデータ取得 成功 ({response_data.get('totalItems', '?')}項目) (Total Time: {duration:.2f}秒)")
+                     return jsonify({"success": True, "data": response_data}), 200
+                 else:
+                     logging.error(f"API /api/learning/{content_id}: GAS応答の 'data.items' がリスト形式ではありません。")
+                     return jsonify({"success": False, "message": "データベースからの応答形式が不正です (items)。"}), 500
+             elif not gas_result["success"]:
+                 # GAS側で success: false が返ってきた場合
+                 gas_error_msg = gas_result.get('message', 'GASからのデータ取得中に不明なエラーが発生しました。')
+                 if "not found" in gas_error_msg.lower():
+                     logging.warning(f"API /api/learning/{content_id}: コンテンツが見つかりませんでした (GAS応答)")
+                     return jsonify({"success": False, "message": f"指定されたコンテンツID '{content_id}' が見つかりません。"}), 404 # Not Found
+                 else:
+                     logging.error(f"API /api/learning/{content_id}: GASからのデータ取得失敗 (GAS側エラー): {gas_error_msg}")
+                     return jsonify({"success": False, "message": f"データベースエラー: {gas_error_msg}"}), 500 # Internal Server Error (or Bad Gateway 502)
+             else: # success: true だけど data が null の場合 (GASがそのように返す場合)
+                 logging.warning(f"API /api/learning/{content_id}: GASは成功と応答しましたが、データが見つかりませんでした (data is null)。")
+                 return jsonify({"success": False, "message": f"指定されたコンテンツID '{content_id}' が見つかりません。"}), 404 # Not Found
+        else:
+            # success または data フィールド自体が欠落している場合
+            logging.error(f"API /api/learning/{content_id}: GASからの応答形式が予期しないものです (success/data欠落)。 Response: {gas_result}")
+            return jsonify({"success": False, "message": "データベースからの応答形式が不正です。"}), 500
+
+    except requests.exceptions.Timeout:
+         logging.error(f"API /api/learning/{content_id}: GASへの接続がタイムアウトしました。")
+         return jsonify({"success": False, "message": "データベースへの接続がタイムアウトしました。"}), 504 # Gateway Timeout
+    except requests.exceptions.HTTPError as http_err:
+         status_code = http_err.response.status_code if http_err.response else "N/A"
+         response_text = http_err.response.text[:500] if http_err.response else "N/A"
+         logging.error(f"API /api/learning/{content_id}: GASへの接続でHTTPエラーが発生: Status={status_code}, Error={http_err}. Response: {response_text}...")
+         if status_code == 404:
+              return jsonify({"success": False, "message": "データベースのエンドポイントが見つかりません。"}), 404
+         else:
+              return jsonify({"success": False, "message": f"データベース接続エラー (HTTP {status_code})。"}), 502 # Bad Gateway が適切か
+    except requests.exceptions.RequestException as req_err:
+         logging.error(f"API /api/learning/{content_id}: GASへの接続中にネットワークエラー等が発生: {req_err}")
+         return jsonify({"success": False, "message": f"データベース接続エラー: {req_err}"}), 500
+    except json.JSONDecodeError as json_err:
+         raw_gas_response = "N/A"
+         if 'gas_response' in locals() and hasattr(gas_response, 'text'):
+             raw_gas_response = gas_response.text
+         logging.error(f"API /api/learning/{content_id}: GASからの応答JSONのパースに失敗: {json_err}")
+         logging.error(f"GAS Raw Response: {raw_gas_response[:500]}...")
+         return jsonify({"success": False, "message": "データベースからの応答形式が不正です。"}), 500
+    except Exception as e:
+         logging.error(f"API /api/learning/{content_id}: コンテンツ取得中に予期せぬエラーが発生: {e}", exc_info=True)
+         return jsonify({"success": False, "message": f"サーバー内部エラーが発生しました。"}), 500
+
+
+# --- アプリケーションの実行 ---
+if __name__ == '__main__':
+    print("*"*60)
+    print("Flaskアプリケーション起動準備")
+    print("*"*60)
+
+    # --- 環境変数チェック ---
+    print("環境変数チェック:")
+    # 必須の環境変数リスト (キー名を修正)
+    required_env_vars = ['GEMINI_API_KEY', 'DEEPSEEK_API_KEY', 'GAS_WEB_APP_URL']
+    missing_vars = []
+    env_vars_status = {}
+
+    # GEMINI_API_KEY チェック
+    gemini_key = os.getenv('GEMINI_API_KEY') # <<< 修正 >>> キー名変更
+    if not gemini_key:
+        missing_vars.append('GEMINI_API_KEY')
+        env_vars_status['GEMINI_API_KEY'] = "未設定"
+    else:
+        env_vars_status['GEMINI_API_KEY'] = "設定済み"
+
+    # DEEPSEEK_API_KEY チェック
+    deepseek_key = os.getenv('DEEPSEEK_API_KEY') # <<< 修正 >>> キー名変更
+    if not deepseek_key:
+        missing_vars.append('DEEPSEEK_API_KEY')
+        env_vars_status['DEEPSEEK_API_KEY'] = "未設定"
+    else:
+        env_vars_status['DEEPSEEK_API_KEY'] = "設定済み"
+
+    # GAS_WEB_APP_URL チェック (文字列チェックを削除)
+    gas_url = os.getenv('GAS_WEB_APP_URL')
+    if not gas_url: # 未設定または空文字列の場合のみチェック
+        missing_vars.append('GAS_WEB_APP_URL')
+        env_vars_status['GAS_WEB_APP_URL'] = "未設定"
+    else: # 何らかの値が設定されていればOKとする
+        # 設定されている場合は、その値をそのまま表示
+        env_vars_status['GAS_WEB_APP_URL'] = f"設定済み: {gas_url}"
+
+    # 結果表示 (変更なし)
+    print(f"  GEMINI_API_KEY: {env_vars_status['GEMINI_API_KEY']}")
+    print(f"  DEEPSEEK_API_KEY: {env_vars_status['DEEPSEEK_API_KEY']}")
+    print(f"  GAS_WEB_APP_URL: {env_vars_status['GAS_WEB_APP_URL']}") # 設定されていればURLが表示される
+
+    # 未設定の場合の警告メッセージ (GAS_WEB_APP_URLの内容に関する警告は削除)
+    if missing_vars:
+        print("\n[警告] 以下の必須環境変数が設定されていません:")
+        # missing_vars に GAS_WEB_APP_URL が含まれていれば表示される
+        for var in missing_vars:
+            print(f"  - {var}")
+        print("関連する機能が動作しない可能性があります。")
+    else:
+         # すべて設定されていればメッセージを表示
+         print("\n必要な環境変数は設定されているようです。")
+
+    print("-"*60)
+
+    # --- 起動 --- (以降変更なし)
+    # Hugging Face Spacesでは通常ポート7860が使われることが多い
+    debug_mode = os.getenv('FLASK_DEBUG', 'False').lower() in ['true', '1']
+    host = os.getenv('FLASK_HOST', '0.0.0.0') # Space内で公開するには 0.0.0.0 が必要
+    port = int(os.getenv('PORT', 7860)) # Hugging Face Spacesは PORT 環境変数を設定することがある
+
+    print(f"Flaskサーバーを起動します...")
+    print(f"  モード: {'デバッグ' if debug_mode else '本番'}")
+    print(f"  ホスト: {host}")
+    print(f"  ポート: {port}")
+    print(f"  一時ディレクトリ: {TEMP_DIR}") # <<< 追加 >>> 一時ディレクトリ確認
+    try:
+        import socket
+        hostname = socket.gethostname()
+        local_ip = socket.gethostbyname(hostname)
+        print(f"  アクセスURL (ローカル): http://127.0.0.1:{port}/ または http://{local_ip}:{port}/")
+        print(f"  アクセスURL (Hugging Face Space): Spaceの公開URLを確認してください。")
+    except:
+        print(f"  アクセスURL (基本): http://{host}:{port}/")
+    print("*"*60)
+
+    # アプリケーションの起動（デバッグモードは環境変数で制御）
+    app.run(host=host, port=port, debug=debug_mode)

gemini_output.txt

@@ -0,0 +1,67 @@
+皆さんこんにちは。みどうです。
+
+今回は、ミニPCで有名なメーカーであるMINISFORUMのPC、UN100Lを購入し、同じCPUであるIntel N100を搭載したTRIGKEY製のミニPCと比較しながらベンチマークを取り、その性能や特徴について詳しくレビューしていきます。
+
+MINISFORUMは比較的高スペック寄りのミニPCを多く出しており、中華系ミニPC界隈では珍しく、日本の家電量販店でも取り扱いがあり、安心感があります。今回購入したUN100Lは、Intel N100を搭載した激安ミニPCです。メモリとSSDの容量の組み合わせで価格が変わりますが、最も安い8GBメモリと256GB SSDの組み合わせで、セールと合わせて27,980円で購入できました。
+
+## 開封と外観
+
+まずは開封から。箱の一番上には説明書類が入っています。日本語キーボード使用時の注意点が書いてある紙、日本語ではなくよくわからない紙、多言語対応の説明書（日本語もちゃんと書いてあります）の順に入っています。
+
+本体は本当に手のひらサイズです。その他、ACアダプター、HDMIケーブル、予備のゴム足、2.5インチSSD取り付け用のネジが入っていました。ACアダプターは36Wです。
+
+本体は手のサイズより小さく、可愛いPCです。全体がシルバーで質感はなかなか良いです。天板はMINISFORUMのロゴと文字だけのシンプルなデザイン。正面はCMOSクリアスイッチ、電源スイッチ、USB3.2 Gen2 Type-Aが2つ、イヤホンジャックが付いています。側面は両サイドとも通気口だけ…と思わせておいて、microSDのスロットが付いています。背面は端子がいろいろあります。左から順にHDMI端子、USB3.2 Gen2 Type-Cポート、2.5Gbps LANポート、DisplayPort、USB2.0が2つ、ACアダプターのポートとなっています。
+
+特筆すべき点として、Type-Cのポートがデータ通信だけでなく、ディスプレイ出力およびPD給電に対応している点が挙げられます。PD対応のディスプレイを持っていたり、Type-Cのドッキングステーションを持っていれば、このPCを持ってきて繋ぐだけで直ぐに使えます。持ち運びやすい形状を活かすという意味で、とてもありがたいです。
+
+また、USB Type-Aが計4つ付いているのも、今の時代としては多めです。しかも2.0と3.2が2つずつなので、使い分けできて便利です。底面は吸気口で、中身が透けています。重さも364.5gと非常に軽量です。
+
+## 内部構造
+
+4つのゴム足を引っ張って外し、その下のネジを外すと簡単にアクセスできます。ネジは想像以上に長く、外すとNVMeのSSDと空中配線が目立つ基板が出てきます。
+
+SSDのメーカーはGokepuという聞いたことのないメーカーです。調べてみてもあまり情報がヒットしないので、Samsung製のようなハードな使い方をする場合、交換が必要かもしれません。
+
+Intel製のWi-Fiチップも見えます。空中配線はここから出て、そのまま基板裏に引っ張られています。もう1つの空中配線は2.5インチSSD増設用のSATAケーブルです。これを使って蓋に2.5インチSSDが付けられるようです。使わない人でも、これが付いたままなので少し気になりますね。
+
+さらに4つ小さいネジを外すと基板が取り外せます。裏側はCPUファンで覆われていてよく見えませんが、オンボードのメモリが取り付けられているようです。このPCはメモリスロットがないので、自分で増設したりはできません。N100自体が16GBまでしか対応していませんが、16GB欲しい人は最初から16GBのモデルを買う必要がある点は注意です。立派なCPUファンが付いていますが、TDP6Wの省電力CPUなので、おそらく過剰スペックでしょう。
+
+PCの筐体はプラスチックですが、内側は金属フレームになっています。耐久性とWi-Fiのアンテナを兼ねているようです…と思っていましたが、Wi-Fiアンテナは別に付いているようなので、耐久性だけの金属フレームのようです。
+
+Wi-Fiアンテナについては、裏側がCPUファンで覆われているせいで、表側のWi-Fiカードから長めの配線をする羽目になっています。半田付けされているので勝手に抜けたりはしませんが、分解すると少し危険です。
+
+## 性能評価
+
+初期起動はWindows 11 Homeのセットアップ画面に遷移します。無名メーカーの怪しげなPCと違って安心です。
+
+### スペック
+
+* CPU: Intel N100 (4コア4スレッド、基本速度0.80GHz、最大3.4GHz、全コア動作時2.9GHz)
+* メモリ: DDR5-4800 8GB (オンボード)
+* SSD: Gokepu 256GB (PCIe 3.0 x1)
+* GPU: Intel UHD Graphics
+
+Windows 11 HomeのOEM版が入っていました。
+
+### ベンチマーク
+
+* FF14ベンチ: 4085 (普通評価)
+* FF15ベンチ: 800 (動作困難)
+* Cinebench R23: マルチ2468、シングル900
+* CPU-Z: マルチ1281、シングル383
+* PassMark: CPU 5679、3D Graphics 831、Memory 2173、Disk 4505
+* CrystalDiskMark: Seq Read/Write 850MB/s
+
+オフィスソフトの起動はスムーズで、オフィスワークにストレスはあまりかからないでしょう。
+
+## TRIGKEY製N100ミニPCとの比較
+
+以前購入したTRIGKEY製N100搭載ミニPCと比較してみると、各ベンチマークでTRIGKEY製の方が性能が高いことがわかりました。しかし、消費電力的にはMINISFORUMが半分程度だったので、性能のTRIGKEY、消費電力のMINISFORUMという結果になりました。
+
+MINISFORUM製は消費電力が低いのに加え、動作音も小さく、扱いやすいPCです。さすがにFF14ベンチは無理そうですが、公式の評価は「普通」で、軽いオフィス作業や動画鑑賞は余裕でこなせます。
+
+## まとめ
+
+価格、省電力性、性能、メーカーの安心感、どの視点から見ても良いPCだと思います。TRIGKEY製のミニPCのようにサーバーにする前提でLANが2つ付いている、といった特徴はありませんし、メモリ増設もできませんが、総合的にレベルの高いN100搭載機の決定版と言えるでしょう。
+
+もし安くてそこそこ動くサブPCが欲しい方や、子供に初めてのPCとして渡してみたい方など、是非検討してみてはいかがでしょうか。

gemini_summary_output.json

@@ -0,0 +1,32 @@
+[
+  {
+    "id": "s1",
+    "type": "summary",
+    "text": "ミニPCメーカーMINISFORUMのUM700を購入\n他メーカーと比較して国内での取り扱いがあり安心感がある"
+  },
+  {
+    "id": "s2",
+    "type": "summary",
+    "text": "UM700のスペック\nCPU：Intel N100\nメモリ：8GB/DDR5 4800MHz\nSSD：256GB"
+  },
+  {
+    "id": "s3",
+    "type": "summary",
+    "text": "外観：手のひらサイズ、シルバーで質感も良い\nインターフェース：USB Type-A x4, Type-C x1, HDMI x2, DisplayPort x1, イヤホンジャック, MicroSDスロット, 2.5インチSSD増設用SATAケーブル"
+  },
+  {
+    "id": "s4",
+    "type": "summary",
+    "text": "ベンチマーク結果\nFF14：普通評価\nFF15：動作困難\nCinebench R23：マルチ2468, シングル900\nCPU-Z：マルチ1281, シングル383\nPassMark：CPU 5679, 3D Graphics 831, Memory 2173, Disk 4505"
+  },
+  {
+    "id": "s5",
+    "type": "summary",
+    "text": "他社N100搭載機と比較\n消費電力は半分で温度も低い\n性能は1割程度低い\n総合的に見て価格・性能・消費電力のバランスが良い"
+  },
+  {
+    "id": "s6",
+    "type": "summary",
+    "text": "用途\nオフィスソフト：快適に動作\n動画編集：やや厳しい\n動画鑑賞：問題なし\nサブPCや子供用PCにおすすめ"
+  }
+]

requirements.txt

@@ -0,0 +1,9 @@
+
+
+numpy==1.23.5
+requests
+yt-dlp
+google-generativeai
+google-genai
+openai
+youtube-transcript-api

static/script.js

@@ -0,0 +1,474 @@
+// static/script.js
+
+"use strict"; // より厳格なエラーチェック
+
+// --- グローバル変数 ---
+let learningData = null;    // 学習データ (learning.html用)
+let currentItemIndex = 0;   // 現在表示中のアイテムインデックス (learning.html用)
+let currentMode = 'quiz';   // 現在のモード 'quiz' or 'summary' (learning.html用)
+
+// --- 共通関数 ---
+
+/**
+ * 指定されたURLに遷移します。
+ * @param {string} url - 遷移先のURL
+ */
+function navigateTo(url) {
+    window.location.href = url;
+}
+
+/**
+ * メニューボタンがクリックされたときの処理（仮）
+ * TODO: 実際のメニューUIを実装する
+ */
+function openMenu() {
+    console.log("Menu button clicked. Implement menu display logic here.");
+    // 例: サイドバーメニューを表示する、モーダルを表示するなど
+    alert("メニュー機能は未実装です。\nフッターのナビゲーションを使用してください。");
+}
+
+/**
+ * ローディングスピナーを表示/非表示します。
+ * @param {boolean} show - trueで表示、falseで非表示
+ */
+function toggleLoading(show) {
+    const spinner = document.querySelector('.loading-spinner'); // input.html用
+    const buttonText = document.querySelector('.button-text'); // input.html用
+    const generateButton = document.getElementById('generate-button'); // input.html用
+
+    if (spinner && buttonText && generateButton) {
+        spinner.style.display = show ? 'inline-block' : 'none';
+        buttonText.textContent = show ? '生成中...' : '生成する';
+        generateButton.disabled = show;
+    }
+    // learning.html 用のローディング表示/非表示も必要に応じて追加
+    const loadingCard = document.getElementById('loading-card-indicator'); // 仮のID
+    if (loadingCard) {
+        loadingCard.style.display = show ? 'block' : 'none';
+    }
+}
+
+/**
+ * エラーメッセージを表示します。
+ * @param {string} message - 表示するエラーメッセージ
+ * @param {string} elementId - メッセージを表示する要素のID (デフォルト: 'error-message')
+ */
+function displayErrorMessage(message, elementId = 'error-message') {
+    const errorElement = document.getElementById(elementId);
+    if (errorElement) {
+        errorElement.textContent = message;
+        errorElement.style.display = message ? 'block' : 'none';
+    }
+}
+
+// --- 画面遷移用関数 ---
+function goToInput() {
+    navigateTo('/'); // input.html はルートパスに割り当てる想定
+}
+
+function goToHistory() {
+    navigateTo('/history');
+}
+
+function goToSettings() {
+    navigateTo('/settings');
+}
+
+function goToLearning(contentId) {
+    if (contentId) {
+        navigateTo(`/learning?id=${encodeURIComponent(contentId)}`);
+    } else {
+        console.error('goToLearning requires a content ID.');
+        alert('学習コンテンツIDが見つかりません。');
+    }
+}
+
+
+// --- input.html 用の処理 ---
+
+/**
+ * 生成フォームの送信処理
+ */
+async function handleGenerateSubmit() {
+    const urlInput = document.getElementById('youtube-url');
+    const youtubeUrl = urlInput.value.trim();
+    displayErrorMessage(''); // 前のエラーメッセージをクリア
+
+    if (!youtubeUrl) {
+        displayErrorMessage('YouTubeリンクを入力してください。');
+        return false; // prevent default form submission
+    }
+
+    // 簡単なURL形式チェック（より厳密なチェックも可能）
+    if (!youtubeUrl.includes('youtube.com/') && !youtubeUrl.includes('youtu.be/')) {
+         displayErrorMessage('有効なYouTubeリンクを入力してください。');
+         return false;
+    }
+
+
+    toggleLoading(true); // ローディング開始
+
+    try {
+        const response = await fetch('/api/generate', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({ url: youtubeUrl }),
+        });
+
+        const result = await response.json();
+
+        if (response.ok && result.success && result.data && result.data.id) {
+            // 成功したら学習画面へ遷移
+            alert('生成に成功しました！学習画面に移動します。');
+            goToLearning(result.data.id);
+        } else {
+            // 失敗したらエラーメッセージ表示
+            console.error('Generation failed:', result);
+            displayErrorMessage(result.message || '生成中にエラーが発生しました。');
+        }
+
+    } catch (error) {
+        console.error('Error during generation request:', error);
+        displayErrorMessage('通信エラーが発生しました。');
+    } finally {
+        toggleLoading(false); // ローディング終了
+    }
+
+    return false; // prevent default form submission
+}
+
+
+// --- learning.html 用の処理 ---
+
+/**
+ * learning.html の初期化
+ */
+async function initializeLearningScreen() {
+    console.log('Initializing Learning Screen...');
+    const params = new URLSearchParams(window.location.search);
+    const contentId = params.get('id');
+    const loadingIndicator = document.getElementById('mode-indicator'); // 仮にモード表示部を使う
+    const cardElement = document.getElementById('learning-card');
+    const paginationElement = document.querySelector('.pagination');
+
+    if (!contentId) {
+        displayLearningError('コンテンツIDが指定されていません。');
+        return;
+    }
+    console.log('Content ID:', contentId);
+
+    // ローディング表示（簡易版）
+    if (loadingIndicator) loadingIndicator.textContent = '読み込み中...';
+    if (cardElement) cardElement.style.opacity = '0.5'; // 少し薄くする
+    if (paginationElement) paginationElement.style.display = 'none';
+
+
+    try {
+        const response = await fetch(`/api/learning/${contentId}`);
+        if (!response.ok) {
+            const errorData = await response.json().catch(() => ({ message: `HTTPエラー: ${response.status}` }));
+            throw new Error(errorData.message || `サーバーからのデータ取得に失敗しました (${response.status})`);
+        }
+
+        const result = await response.json();
+        console.log('Fetched data:', result);
+
+        if (result.success && result.data) {
+            learningData = result.data; // グローバル変数に格納
+            if (!learningData.items || learningData.items.length === 0) {
+                 throw new Error('学習データが空です。');
+            }
+            // タイトルを設定
+            const titleElement = document.getElementById('learning-title');
+            if (titleElement) {
+                titleElement.textContent = learningData.title || '学習コンテンツ';
+            }
+
+            // 最初のアイテムを表示
+            currentItemIndex = 0;
+            displayCurrentItem();
+             if (paginationElement) paginationElement.style.display = 'flex'; // ページネーション表示
+
+        } else {
+            throw new Error(result.message || '学習データの読み込みに失敗しました。');
+        }
+
+    } catch (error) {
+        console.error('Error initializing learning screen:', error);
+        displayLearningError(`読み込みエラー: ${error.message}`);
+    } finally {
+        // ローディング表示終了（簡易版）
+        if (cardElement) cardElement.style.opacity = '1';
+        // mode-indicatorはdisplayCurrentItemで更新される
+    }
+}
+
+/**
+ * 現在の学習アイテムをカードに表示
+ */
+function displayCurrentItem() {
+    if (!learningData || !learningData.items || currentItemIndex < 0 || currentItemIndex >= learningData.items.length) {
+        console.error('Invalid learning data or index');
+        displayLearningError('学習データを表示できません。');
+        return;
+    }
+
+    const item = learningData.items[currentItemIndex];
+    const cardTextElement = document.getElementById('card-text');
+    const answerTextElement = document.getElementById('answer-text');
+    const tapToShowElement = document.getElementById('tap-to-show');
+    const optionsArea = document.getElementById('options-area');
+    const modeIndicator = document.getElementById('mode-indicator');
+
+    // リセット
+    cardTextElement.innerHTML = '';
+    answerTextElement.style.display = 'none';
+    tapToShowElement.style.display = 'none';
+    optionsArea.innerHTML = '';
+    optionsArea.style.display = 'none';
+
+    if (item.type === 'question') {
+        currentMode = 'quiz';
+        modeIndicator.textContent = 'クイズモード';
+        cardTextElement.textContent = item.text; // 質問文
+        answerTextElement.textContent = `答え: ${item.answer}`; // 答えを事前に設定（非表示）
+        tapToShowElement.style.display = 'block'; // タップして表示を表示
+
+        // 選択肢ボタンを生成（解答チェックはここではしない）
+        if (item.options && Array.isArray(item.options)) {
+            optionsArea.style.display = 'block';
+            item.options.forEach(option => {
+                const button = document.createElement('button');
+                button.classList.add('option-button');
+                button.textContent = option;
+                // ★★★ 選択肢クリック時の動作を変更: 正誤判定ではなく解答表示 ★★★
+                button.onclick = revealAnswer; // どのボタンを押しても解答表示
+                optionsArea.appendChild(button);
+            });
+        }
+
+    } else if (item.type === 'summary') {
+        currentMode = 'summary';
+        modeIndicator.textContent = '要約モード';
+        cardTextElement.innerHTML = item.text.replace(/\n/g, '<br>'); // 要約文（改行対応）
+
+        // 要約モードでは答えも選択肢も不要
+    } else {
+        console.warn('Unknown item type:', item.type);
+        cardTextElement.textContent = `[不明なデータタイプ: ${item.type}] ${item.text || ''}`;
+        modeIndicator.textContent = '不明モード';
+    }
+
+    updatePagination();
+}
+
+/**
+ * クイズの解答を表示する
+ */
+function revealAnswer() {
+    // クイズモードの場合のみ動作
+    if (currentMode === 'quiz') {
+        const answerTextElement = document.getElementById('answer-text');
+        const tapToShowElement = document.getElementById('tap-to-show');
+        const optionsArea = document.getElementById('options-area');
+
+        if (answerTextElement) {
+            answerTextElement.style.display = 'block'; // 答えを表示
+        }
+        if (tapToShowElement) {
+            tapToShowElement.style.display = 'none'; // 「タップして表示」を隠す
+        }
+
+        // 選択肢ボタンを正解・不正解で色付け＆無効化
+        if (optionsArea && learningData && learningData.items[currentItemIndex]) {
+             const correctAnswer = learningData.items[currentItemIndex].answer;
+             const buttons = optionsArea.getElementsByTagName('button');
+             for (let btn of buttons) {
+                btn.disabled = true; // ボタンを無効化
+                if (btn.textContent === correctAnswer) {
+                    btn.classList.add('correct'); // 正解スタイル
+                } else {
+                    btn.classList.add('disabled'); // 不正解または他の選択肢スタイル
+                }
+                // クリックイベントを削除（任意）
+                btn.onclick = null;
+            }
+        }
+    }
+}
+
+
+/**
+ * 次のアイテムへ移動
+ */
+function goToNext() {
+    if (learningData && currentItemIndex < learningData.items.length - 1) {
+        currentItemIndex++;
+        displayCurrentItem();
+    }
+}
+
+/**
+ * 前のアイテムへ移動
+ */
+function goToPrev() {
+    if (learningData && currentItemIndex > 0) {
+        currentItemIndex--;
+        displayCurrentItem();
+    }
+}
+
+/**
+ * ページネーション表示を更新
+ */
+function updatePagination() {
+    const pageInfo = document.getElementById('page-info');
+    const prevButton = document.getElementById('prev-button');
+    const nextButton = document.getElementById('next-button');
+
+    if (pageInfo && prevButton && nextButton && learningData && learningData.items) {
+        const totalItems = learningData.items.length;
+        pageInfo.textContent = `${currentItemIndex + 1} / ${totalItems}`;
+        prevButton.disabled = currentItemIndex === 0;
+        nextButton.disabled = currentItemIndex === totalItems - 1;
+    }
+}
+
+/**
+ * learning.html でエラーを表示
+ */
+function displayLearningError(message) {
+    const cardElement = document.getElementById('learning-card');
+    const titleElement = document.getElementById('learning-title');
+    const paginationElement = document.querySelector('.pagination');
+    const optionsArea = document.getElementById('options-area');
+    const modeIndicator = document.getElementById('mode-indicator');
+    const tapToShow = document.getElementById('tap-to-show');
+
+    if (titleElement) titleElement.textContent = 'エラー';
+    if (cardElement) cardElement.innerHTML = `<p class="main-text" style="color: red; text-align: center;">${message}</p>`;
+    if (paginationElement) paginationElement.style.display = 'none';
+    if (optionsArea) optionsArea.style.display = 'none';
+    if (modeIndicator) modeIndicator.style.display = 'none';
+    if (tapToShow) tapToShow.style.display = 'none';
+}
+
+
+// --- settings.html 用の処理 ---
+
+/**
+ * トグルスイッチの変更ハンドラ
+ */
+function handleToggleChange(checkbox, type) {
+    console.log(`Toggle changed for ${type}: ${checkbox.checked}`);
+    if (type === 'dark') {
+        document.body.classList.toggle('dark-mode', checkbox.checked);
+        try {
+            localStorage.setItem('darkModeEnabled', checkbox.checked);
+        } catch (e) {
+            console.warn('Could not save dark mode preference to localStorage.');
+        }
+    }
+    // 他のトグル（例: プッシュ通知）の処理もここに追加
+}
+
+/**
+ * ログアウトボタンの処理
+ */
+function handleLogout() {
+    console.log("Logout clicked");
+    // TODO: 実際のログアウト処理（API呼び出し、セッションクリアなど）
+    alert("ログアウト機能は未実装です。");
+    // 必要であればログイン画面などに遷移
+    // navigateTo('/login');
+}
+
+/**
+ * ダークモード設定を読み込んで適用する
+ */
+function applyDarkModePreference() {
+     try {
+        const darkModeEnabled = localStorage.getItem('darkModeEnabled') === 'true';
+        document.body.classList.toggle('dark-mode', darkModeEnabled);
+        // 設定画面のトグルスイッチの状態も合わせる
+        const toggle = document.querySelector('input[onchange*="handleToggleChange"][onchange*="dark"]');
+        if (toggle) {
+            toggle.checked = darkModeEnabled;
+        }
+    } catch (e) {
+        console.warn('Could not load dark mode preference from localStorage.');
+    }
+}
+
+
+// --- ページの初期化処理 ---
+document.addEventListener('DOMContentLoaded', () => {
+    const pathname = window.location.pathname;
+
+    applyDarkModePreference(); // 全ページでダークモード設定を適用
+
+    if (pathname === '/' || pathname === '/input') {
+        // input.html の初期化（特に不要かもしれないが、フォームイベントリスナーなど）
+        const form = document.getElementById('generate-form');
+        if (form) {
+            form.addEventListener('submit', (event) => {
+                 event.preventDefault(); // デフォルトの送信をキャンセル
+                 handleGenerateSubmit();
+            });
+        }
+    } else if (pathname === '/learning') {
+        initializeLearningScreen();
+    } else if (pathname === '/history') {
+        // history.html の初期化（動的にリストを生成する場合など）
+        // このサンプルでは静的なので特に不要
+    } else if (pathname === '/settings') {
+        // settings.html の初期化（ダークモードの適用は applyDarkModePreference で実施済み）
+    }
+
+    // フッターナビゲーションのアクティブ状態設定（任意）
+    updateFooterNavActiveState(pathname);
+});
+
+
+/**
+ * フッターナビゲーションのアクティブ状態を更新
+ */
+ function updateFooterNavActiveState(pathname) {
+    const footerNav = document.querySelector('.footer-nav');
+    if (!footerNav) return;
+
+    const buttons = footerNav.querySelectorAll('button');
+    buttons.forEach(button => {
+        button.classList.remove('active'); // Reset all
+        const onclickAttr = button.getAttribute('onclick');
+        if (onclickAttr) {
+            if ((pathname === '/' || pathname === '/input') && onclickAttr.includes('goToInput')) {
+                button.classList.add('active');
+            } else if (pathname === '/history' && onclickAttr.includes('goToHistory')) {
+                button.classList.add('active');
+            } else if (pathname === '/settings' && onclickAttr.includes('goToSettings')) {
+                button.classList.add('active');
+            }
+        }
+    });
+}
+
+
+// デバッグ用に一部関数をグローバルスコープに公開（開発中のみ推奨）
+window.debug = {
+    navigateTo,
+    goToInput,
+    goToHistory,
+    goToSettings,
+    goToLearning,
+    openMenu,
+    handleGenerateSubmit,
+    initializeLearningScreen,
+    revealAnswer,
+    goToNext,
+    goToPrev,
+    handleToggleChange,
+    handleLogout
+};

static/style.css

@@ -0,0 +1,465 @@
+/* 基本スタイル */
+body {
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
+    margin: 0;
+    background-color: #f0f0f0;
+    display: flex; /* 中央揃えのため */
+    justify-content: center; /* 中央揃えのため */
+    align-items: flex-start; /* 上端揃え */
+    min-height: 100vh;
+    padding: 20px 0; /* 上下に余白 */
+    box-sizing: border-box;
+}
+
+.screen {
+    width: 100%; /* 横幅いっぱい */
+    max-width: 400px; /* スマホ画面幅を想定 */
+    background-color: #fff;
+    border: 1px solid #ccc;
+    min-height: 700px; /* 高さを確保 */
+    box-shadow: 0 2px 8px rgba(0,0,0,0.1);
+    display: flex;
+    flex-direction: column; /* 子要素を縦に並べる */
+    overflow: hidden; /* はみ出しを隠す */
+}
+
+.header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 10px 15px;
+    background-color: #f8f8f8;
+    border-bottom: 1px solid #eee;
+    flex-shrink: 0; /* ヘッダーが縮まないように */
+}
+
+.header .menu-btn, .header .action-btn {
+    background: none;
+    border: none;
+    font-size: 24px;
+    cursor: pointer;
+    padding: 5px;
+}
+
+.header .action-btn {
+    width: 30px;
+    height: 30px;
+    background-color: #007bff; /* 青い丸 */
+    border-radius: 50%;
+    padding: 0; /* 内側の余白を削除 */
+    /* 必要ならアイコンや文字を配置 */
+}
+
+.header .title {
+    font-size: 18px;
+    font-weight: bold;
+    margin: 0;
+    text-align: center;
+    flex-grow: 1; /* 中央に配置するために */
+}
+
+main {
+    padding: 15px;
+    flex-grow: 1; /* 残りの高さを埋める */
+    overflow-y: auto; /* 内容が多い場合にスクロール */
+}
+
+/* List Styles */
+ul.list {
+    list-style: none;
+    padding: 0;
+    margin: 0;
+}
+
+li.list-item {
+    border-bottom: 1px solid #eee;
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 0; /* paddingはボタン側で調整 */
+}
+li.list-item:last-child {
+    border-bottom: none;
+}
+
+/* ListItemをボタンとして使えるように */
+.list-item-button {
+    display: flex;
+    align-items: center;
+    width: 100%;
+    padding: 12px 15px;
+    text-decoration: none;
+    color: inherit;
+    background-color: transparent;
+    border: none;
+    cursor: pointer;
+    text-align: left;
+}
+.list-item-button:hover {
+    background-color: #f9f9f9;
+}
+
+.list-item-content {
+    display: flex;
+    align-items: center;
+    flex-grow: 1; /* テキスト部分が幅を取るように */
+    margin-right: 10px; /* 矢印とのスペース */
+}
+
+.list-item-icon {
+    margin-right: 12px;
+    font-size: 22px;
+    color: #007bff; /* アイコンの色 */
+    width: 24px; /* 幅を固定して揃える */
+    text-align: center;
+}
+
+.list-item-text h3 {
+    font-size: 16px;
+    margin: 0 0 4px 0;
+    font-weight: 500;
+    white-space: nowrap; /* 長いタイトルを省略 */
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+
+.list-item-text p {
+    font-size: 13px;
+    color: #777;
+    margin: 0;
+}
+
+.list-arrow {
+    color: #ccc;
+    font-size: 20px;
+    flex-shrink: 0; /* 矢印が縮まないように */
+}
+
+/* Learning Screen Card */
+.card {
+    background-color: #fff;
+    padding: 30px 20px; /* 少し調整 */
+    border-radius: 12px; /* 少し調整 */
+    border: 1px solid #eee; /* 境界線を追加 */
+    box-shadow: 0 2px 5px rgba(0,0,0,0.05);
+    text-align: center;
+    margin: 15px 0; /* 少し調整 */
+    min-height: 180px; /* 少し調整 */
+    display: flex;
+    flex-direction: column;
+    justify-content: center;
+    cursor: pointer; /* タップ可能を示す */
+}
+.card p.main-text {
+    margin: 0;
+    line-height: 1.7; /* 行間調整 */
+    font-size: 16px;
+}
+.card p.answer-text {
+    margin-top: 15px;
+    font-size: 18px;
+    font-weight: bold;
+    color: #007bff;
+}
+.tap-to-show {
+    text-align: center;
+    color: #888;
+    font-size: 14px;
+    margin-top: 10px;
+    cursor: pointer; /* タップ可能を示す */
+}
+
+/* Pagination */
+.pagination {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    padding: 15px 0 5px 0; /* 下の余白を少し減らす */
+    flex-shrink: 0; /* 縮まないように */
+}
+.pagination button {
+    background: none;
+    border: none;
+    font-size: 30px;
+    color: #007bff;
+    cursor: pointer;
+    padding: 5px 15px; /* タップしやすく */
+}
+.pagination button:disabled {
+    color: #ccc;
+    cursor: default;
+}
+.pagination span {
+    font-size: 16px;
+    font-weight: 500;
+}
+
+/* Settings Screen */
+.settings-item {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    width: 100%;
+}
+.settings-item span {
+    flex-grow: 1;
+    padding-left: 12px; /* アイコンとのスペース */
+}
+
+/* Toggle Switch (簡易版) */
+.toggle-switch {
+    position: relative;
+    display: inline-block;
+    width: 50px;
+    height: 24px;
+    cursor: pointer;
+}
+.toggle-switch input {
+    opacity: 0;
+    width: 0;
+    height: 0;
+}
+.slider {
+    position: absolute;
+    cursor: pointer;
+    top: 0;
+    left: 0;
+    right: 0;
+    bottom: 0;
+    background-color: #ccc;
+    transition: .3s;
+    border-radius: 24px;
+}
+.slider:before {
+    position: absolute;
+    content: "";
+    height: 18px;
+    width: 18px;
+    left: 3px;
+    bottom: 3px;
+    background-color: white;
+    transition: .3s;
+    border-radius: 50%;
+}
+input:checked + .slider {
+    background-color: #007bff;
+}
+input:checked + .slider:before {
+    transform: translateX(26px);
+}
+
+.section-title {
+    color: #666; /* 少し濃く */
+    font-size: 14px;
+    font-weight: 500;
+    margin: 20px 0 8px 0;
+    padding-left: 15px;
+}
+
+.logout {
+    color: red;
+    font-weight: bold;
+}
+
+/* Input Screen */
+.input-area {
+    text-align: center;
+    padding-top: 40px; /* ヘッダーがない場合の余白 */
+}
+.input-area h2 {
+    font-size: 20px; /* 少し大きく */
+    font-weight: bold;
+    margin-bottom: 25px;
+    line-height: 1.4;
+}
+.input-area input[type="text"] {
+    width: calc(100% - 44px); /* 左右padding分引く */
+    padding: 12px 15px;
+    border: 1px solid #ccc;
+    border-radius: 8px;
+    font-size: 16px;
+    margin-bottom: 20px;
+    box-sizing: border-box;
+}
+.input-area .generate-button {
+    background-color: #ff3b30; /* iOS風の赤 */
+    color: white;
+    border: none;
+    padding: 12px 25px;
+    font-size: 16px;
+    font-weight: bold;
+    border-radius: 25px;
+    cursor: pointer;
+    display: inline-flex; /* アイコンとテキストを横並び */
+    align-items: center;
+    justify-content: center;
+    margin: 0 auto 25px auto;
+    transition: background-color 0.2s;
+}
+.input-area .generate-button:hover {
+    background-color: #e03024;
+}
+.input-area .generate-button:disabled {
+    background-color: #fca9a4;
+    cursor: not-allowed;
+}
+.input-area .generate-button .icon { /* 再生ボタン風アイコン */
+    margin-left: 8px;
+    font-size: 14px;
+}
+.input-area .loading-spinner {
+    border: 3px solid rgba(255, 255, 255, 0.3);
+    border-radius: 50%;
+    border-top-color: #fff;
+    width: 16px;
+    height: 16px;
+    animation: spin 1s linear infinite;
+    margin-right: 8px; /* テキストとのスペース */
+}
+@keyframes spin {
+    to { transform: rotate(360deg); }
+}
+
+
+.image-placeholder {
+    width: 85%; /* 画面幅に対する割合 */
+    max-width: 300px; /* 最大幅 */
+    aspect-ratio: 16 / 9; /* 縦横比 */
+    background-color: #e9e9e9;
+    border: 1px dashed #ccc;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    color: #aaa;
+    margin: 0 auto;
+    border-radius: 10px;
+    overflow: hidden; /* 画像表示用 */
+}
+.image-placeholder img {
+    display: block;
+    width: 100%;
+    height: 100%;
+    object-fit: cover;
+}
+.error-message {
+    color: red;
+    font-size: 13px;
+    margin-top: -15px; /* ボタンとの間を詰める */
+    margin-bottom: 15px;
+    min-height: 1em; /* エラーなくても高さを確保 */
+}
+/* static/style.css に追加 */
+
+/* --- フッターナビゲーション --- */
+.footer-nav {
+    position: fixed;
+    bottom: 0;
+    left: 0;
+    width: 100%;
+    background-color: #f8f8f8;
+    border-top: 1px solid #e0e0e0;
+    display: flex;
+    justify-content: space-around;
+    padding: 4px 0 8px 0; /* 上下少し調整 */
+    box-shadow: 0 -1px 4px rgba(0,0,0,0.08);
+    z-index: 1000;
+}
+
+.footer-nav button {
+    background: none;
+    border: none;
+    cursor: pointer;
+    padding: 5px;
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    font-size: 10px;
+    color: #888; /* 非アクティブ時の色 */
+    flex-grow: 1; /* ボタンが均等に幅を取るように */
+    transition: color 0.2s ease;
+}
+
+.footer-nav .nav-icon {
+    font-size: 22px;
+    margin-bottom: 2px;
+}
+
+.footer-nav button.active {
+    color: #007bff; /* アクティブ時の色 (例: 青) */
+}
+
+/* --- main要素の底上げ --- */
+/* フッターにコンテンツが隠れないように */
+main {
+   padding-bottom: 70px; /* フッターの高さに応じて調整 */
+}
+
+/* --- ローディングスピナー (input.html用) --- */
+.loading-spinner {
+    border: 3px solid rgba(0, 0, 0, 0.1);
+    border-left-color: #fff; /* スピナーの色 */
+    border-radius: 50%;
+    width: 16px;
+    height: 16px;
+    animation: spin 1s linear infinite;
+    display: inline-block; /* ボタン内で表示 */
+    margin-left: 8px; /* ボタンテキストとの間隔 */
+    vertical-align: middle;
+}
+
+@keyframes spin {
+    0% { transform: rotate(0deg); }
+    100% { transform: rotate(360deg); }
+}
+
+/* --- learning.html のローディング（簡易版）--- */
+/* 必要であれば .loading-spinner-large などを定義 */
+
+
+/* --- learning.html の解答ボタン スタイル --- */
+.option-button.correct {
+    background-color: #d4edda; /* 緑系 */
+    color: #155724;
+    border-color: #c3e6cb;
+}
+
+.option-button.incorrect { /* これは revealAnswer では使わないかも */
+    background-color: #f8d7da; /* 赤系 */
+    color: #721c24;
+    border-color: #f5c6cb;
+}
+
+.option-button.disabled {
+    background-color: #e9ecef;
+    color: #6c757d;
+    border-color: #ced4da;
+    opacity: 0.7;
+}
+
+
+/* --- ダークモード用スタイル (一部) --- */
+body.dark-mode {
+    background-color: #121212;
+    color: #e0e0e0;
+}
+body.dark-mode .screen { background-color: #1e1e1e; }
+body.dark-mode .header { background-color: #1f1f1f; border-bottom-color: #333; }
+body.dark-mode .header .title, body.dark-mode .header .menu-btn { color: #e0e0e0; }
+body.dark-mode .footer-nav { background-color: #1f1f1f; border-top-color: #333; }
+body.dark-mode .footer-nav button { color: #888; }
+body.dark-mode .footer-nav button.active { color: #58a6ff; } /* ダークモードでのアクティブ色 */
+body.dark-mode .card { background-color: #2c2c2c; border-color: #444; color: #e0e0e0; }
+body.dark-mode .list-item-button { background-color: #2c2c2c; border-bottom-color: #444; }
+body.dark-mode .list-item-text h3, body.dark-mode .list-item-text p { color: #e0e0e0; }
+body.dark-mode .list-arrow { color: #aaa; }
+body.dark-mode .settings-item span { color: #e0e0e0; }
+body.dark-mode .section-title { color: #aaa; }
+body.dark-mode input[type="text"] { background-color: #333; border-color: #555; color: #e0e0e0; }
+body.dark-mode .generate-button { background-color: #3081d8; color: white; }
+body.dark-mode .option-button { background-color: #444; color: #e0e0e0; border-color: #666; }
+body.dark-mode .option-button.correct { background-color: #2a6831; color: #e0e0e0; border-color: #41984b; }
+body.dark-mode .option-button.disabled { background-color: #333; color: #888; border-color: #555; opacity: 0.7; }
+body.dark-mode .pagination button:disabled { color: #666; }
+body.dark-mode .toggle-switch .slider { background-color: #555; }
+body.dark-mode .toggle-switch input:checked + .slider { background-color: #58a6ff; }
+/* 他の要素も必要に応じてダークモードスタイルを追加 */

templates/history.html

@@ -0,0 +1,109 @@
+<!DOCTYPE html>
+<html lang="ja">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>履歴</title>
+    <link rel="stylesheet" href="{{ url_for('static', filename='style.css') }}">
+    <style>
+        /* サムネイル用のスタイルを追加 (任意) */
+        .list-item-thumbnail {
+            width: 80px; /* 幅を調整 */
+            height: 45px; /* 高さを調整 (16:9) */
+            object-fit: cover; /* 画像のアスペクト比を保ちつつコンテナにフィット */
+            margin-right: 10px; /* テキストとの間隔 */
+            border-radius: 4px; /* 角丸 */
+            flex-shrink: 0; /* コンテナが縮んでも画像サイズを維持 */
+        }
+        .list-item-content {
+            display: flex; /* サムネイルとテキストを横並び */
+            align-items: center; /* 垂直方向中央揃え */
+            flex-grow: 1; /* 利用可能なスペースを埋める */
+            overflow: hidden; /* はみ出したタイトルを隠す */
+        }
+        .list-item-text h3 {
+            white-space: nowrap; /* タイトルを1行に */
+            overflow: hidden; /* はみ出しを隠す */
+            text-overflow: ellipsis; /* はみ出しを...で表示 */
+            margin-bottom: 4px; /* 日付との間隔 */
+        }
+        .list-item-text p {
+             font-size: 0.8em; /* 日付のフォントサイズ */
+             color: #666;    /* 日付の色 */
+             margin: 0;
+        }
+        .list-item-empty, .list-item-error {
+            text-align: center;
+            color: #888;
+            padding: 20px;
+        }
+        .list-item-error {
+            color: red;
+        }
+    </style>
+</head>
+<body>
+    <div class="screen">
+        <header class="header">
+            <button class="menu-btn" aria-label="メニュー" onclick="openMenu()">☰</button>
+            <h1 class="title">履歴</h1>
+            <button class="action-btn" aria-label="アクション"></button> <!-- 右上のボタンは不要なら削除 -->
+        </header>
+        <main>
+            <ul class="list" id="history-list">
+                {# エラーメッセージがあれば表示 #}
+                {% if error_message %}
+                    <li class="list-item-error">履歴の取得に失敗しました: {{ error_message }}</li>
+                {% endif %}
+
+                {# 履歴アイテムがあればループ処理 #}
+                {% if history_items %}
+                    {% for item in history_items %}
+                    <li class="list-item">
+                        {# 各アイテムに学習ページへのリンクを設定 #}
+                        <a href="{{ url_for('learning_page', id=item.id) }}" class="list-item-button">
+                            <div class="list-item-content">
+                                {# サムネイルがあれば表示、なければデフォルトアイコン #}
+                                {% if item.thumbnail %}
+                                    <img src="{{ item.thumbnail }}" alt="Thumbnail" class="list-item-thumbnail" onerror="this.style.display='none'; this.nextElementSibling.style.display='inline-block';"> {# 画像読み込み失敗時の代替アイコン表示用 #}
+                                    <span class="list-item-icon" style="display: none;">📄</span> {# 代替アイコン (最初は非表示) #}
+                                {% else %}
+                                    {# typeがないのでデフォルトアイコン #}
+                                    <span class="list-item-icon">📄</span>
+                                {% endif %}
+                                <div class="list-item-text">
+                                    {# タイトルと日付を表示 #}
+                                    <h3>{{ item.title }}</h3>
+                                    <p>{{ item.date }}</p>
+                                </div>
+                            </div>
+                            <span class="list-arrow">></span>
+                        </a>
+                    </li>
+                    {% endfor %}
+                {# 履歴アイテムがなく、エラーもない場合は「履歴なし」メッセージ #}
+                {% elif not error_message %}
+                    <li class="list-item-empty">履歴はありません。</li>
+                {% endif %}
+            </ul>
+        </main>
+        <!-- フッターナビゲーション -->
+        <footer class="footer-nav">
+            <button onclick="goToInput()" aria-label="入力">
+                 <span class="nav-icon">➕</span>
+                 <span class="nav-text">入力</span>
+            </button>
+            <button onclick="goToHistory()" aria-label="履歴" class="active"> {# 現在のページをアクティブに #}
+                 <span class="nav-icon">🕒</span>
+                 <span class="nav-text">履歴</span>
+            </button>
+            <button onclick="goToSettings()" aria-label="設定">
+                 <span class="nav-icon">⚙️</span>
+                 <span class="nav-text">設定</span>
+            </button>
+        </footer>
+    </div>
+    {# script.js はナビゲーション用などに必要なら残す #}
+    <script src="{{ url_for('static', filename='script.js') }}"></script>
+</body>
+</html>

templates/input.html

@@ -0,0 +1,50 @@
+<!DOCTYPE html>
+<html lang="ja">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>動画からクイズ＆要約生成</title>
+    <link rel="stylesheet" href="{{ url_for('static', filename='style.css') }}">
+</head>
+<!-- 例: フッターナビゲーション (各HTMLの </body> の直前に追加) -->
+<footer class="footer-nav">
+    <button onclick="goToInput()" aria-label="入力">
+         <span class="nav-icon">➕</span> <!-- アイコンは好みで変更 -->
+         <span class="nav-text">入力</span>
+    </button>
+    <button onclick="goToHistory()" aria-label="履歴">
+         <span class="nav-icon">🕒</span>
+         <span class="nav-text">履歴</span>
+    </button>
+    <button onclick="goToSettings()" aria-label="設定">
+         <span class="nav-icon">⚙️</span>
+         <span class="nav-text">設定</span>
+    </button>
+</footer>
+<body>
+    <div class="screen">
+        <!-- この画面にはヘッダーなし -->
+        <main class="input-area">
+            <h2>動画リンクから<br>クイズ＆要約を自動生成！</h2>
+
+            <form id="generate-form">
+                <input type="text" id="youtube-url" placeholder="ここにYouTubeリンクをペースト" required aria-label="YouTubeリンク">
+                <div class="error-message" id="error-message"></div>
+                <button type="submit" class="generate-button" id="generate-button">
+                    <span class="button-text">生成する</span>
+                    <span class="icon">▶</span>
+                    <div class="loading-spinner" style="display: none;"></div>
+                </button>
+            </form>
+
+            <div class="image-placeholder" id="image-placeholder">
+                <span>(イメージ表示エリア)</span>
+                <!-- <img src="..." alt="動画サムネイル" style="display: none;"> -->
+            </div>
+        </main>
+        <!-- フッターナビゲーションなどを追加する場合はここに -->
+    </div>
+
+    <script src="{{ url_for('static', filename='script.js') }}"></script>
+</body>
+</html>

templates/learning.html

@@ -0,0 +1,61 @@
+<!DOCTYPE html>
+<html lang="ja">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>学習画面</title>
+    <link rel="stylesheet" href="{{ url_for('static', filename='style.css') }}">
+</head>
+<!-- 例: フッターナビゲーション (各HTMLの </body> の直前に追加) -->
+<footer class="footer-nav">
+    <button onclick="goToInput()" aria-label="入力">
+         <span class="nav-icon">➕</span> <!-- アイコンは好みで変更 -->
+         <span class="nav-text">入力</span>
+    </button>
+    <button onclick="goToHistory()" aria-label="履歴">
+         <span class="nav-icon">🕒</span>
+         <span class="nav-text">履歴</span>
+    </button>
+    <button onclick="goToSettings()" aria-label="設定">
+         <span class="nav-icon">⚙️</span>
+         <span class="nav-text">設定</span>
+    </button>
+</footer>
+<body>
+    <div class="screen">
+        <header class="header">
+            <button class="menu-btn" aria-label="メニュー" onclick="openMenu()">☰</button>
+            <h1 class="title" id="learning-title">学習セット: 面白い動画の分析</h1>
+            <!-- 右上のボタンは不要なら削除 -->
+            <button class="action-btn" aria-label="アクション"></button>
+        </header>
+        <main>
+            <p style="text-align: center; color: #555; font-size: 14px; margin-bottom: 10px;" id="mode-indicator">クイズモード</p>
+
+            <div class="card" id="learning-card" onclick="revealAnswer()">
+                <p class="main-text" id="card-text">ここに表示される問題文または要約テキストはカードの中心に来るように調整されます。(サンプルテキスト)</p>
+                <p class="answer-text" id="answer-text" style="display: none;">答え: 正解の選択肢</p>
+            </div>
+
+            <p class="tap-to-show" id="tap-to-show" onclick="revealAnswer()">タップして解答を表示</p>
+
+            <!-- クイズの選択肢表示エリア (JSで動的に生成) -->
+            <div id="options-area" style="margin-top: 15px;">
+                <!-- 例:
+                <button class="option-button">A: 選択肢A</button>
+                <button class="option-button">B: 選択肢B</button>
+                ...
+                -->
+            </div>
+
+            <div class="pagination">
+                <button id="prev-button" aria-label="前へ" onclick="goToPrev()"><</button>
+                <span id="page-info">5 / 10</span>
+                <button id="next-button" aria-label="次へ" onclick="goToNext()">></button>
+            </div>
+        </main>
+    </div>
+    <script src="{{ url_for('static', filename='script.js') }}"></script>
+    
+</body>
+</html>

templates/settings.html

@@ -0,0 +1,84 @@
+<!DOCTYPE html>
+<html lang="ja">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>設定</title>
+    <link rel="stylesheet" href="{{ url_for('static', filename='style.css') }}">
+</head>
+<!-- 例: フッターナビゲーション (各HTMLの </body> の直前に追加) -->
+<footer class="footer-nav">
+    <button onclick="goToInput()" aria-label="入力">
+         <span class="nav-icon">➕</span> <!-- アイコンは好みで変更 -->
+         <span class="nav-text">入力</span>
+    </button>
+    <button onclick="goToHistory()" aria-label="履歴">
+         <span class="nav-icon">🕒</span>
+         <span class="nav-text">履歴</span>
+    </button>
+    <button onclick="goToSettings()" aria-label="設定">
+         <span class="nav-icon">⚙️</span>
+         <span class="nav-text">設定</span>
+    </button>
+</footer>
+<body>
+    <div class="screen">
+        <header class="header">
+            <button class="menu-btn" aria-label="メニュー" onclick="openMenu()">☰</button>
+            <h1 class="title">設定</h1>
+             <!-- 右上のボタンは不要なら削除 -->
+            <button class="action-btn" aria-label="アクション"></button>
+        </header>
+        <main>
+            <ul class="list">
+                <li class="list-item">
+                    <a href="#" class="list-item-button" onclick="alert('アカウント情報画面へ（未実装）')">
+                        <div class="settings-item">
+                            <span>アカウント情報</span>
+                            <span class="list-arrow">></span>
+                        </div>
+                    </a>
+                </li>
+                <li class="list-item" style="padding: 12px 15px;"> <!-- ボタンにしない場合 -->
+                    <div class="settings-item">
+                        <span>プッシュ通知</span>
+                        <label class="toggle-switch">
+                            <input type="checkbox" checked onchange="handleToggleChange(this, 'push')">
+                            <span class="slider"></span>
+                        </label>
+                    </div>
+                </li>
+                 <li class="list-item" style="padding: 12px 15px;">
+                    <div class="settings-item">
+                        <span>ダークモード</span>
+                         <label class="toggle-switch">
+                            <input type="checkbox" onchange="handleToggleChange(this, 'dark')">
+                            <span class="slider"></span>
+                        </label>
+                    </div>
+                </li>
+            </ul>
+
+            <h3 class="section-title">その他</h3>
+             <ul class="list">
+                 <li class="list-item">
+                    <a href="#" class="list-item-button" onclick="alert('アプリについて画面へ（未実装）')">
+                        <div class="settings-item">
+                            <span>このアプリについて</span>
+                            <span class="list-arrow">></span>
+                        </div>
+                    </a>
+                </li>
+                <li class="list-item">
+                    <button class="list-item-button" style="color: red;" onclick="handleLogout()">
+                        <div class="settings-item">
+                            <span class="logout">ログアウト</span>
+                        </div>
+                    </button>
+                </li>
+            </ul>
+        </main>
+    </div>
+    <script src="{{ url_for('static', filename='script.js') }}"></script>
+</body>
+</html>