Spaces:

JunyiAcademy
/

vaitor2

Sleeping

App Files Files Community

vaitor2 / app.py

youngtsai

====generate_transcription_by_gemini====

d3e9f06 7 months ago

raw

history blame contribute delete

213 kB

	import urllib.parse
	import re

	import gradio as gr
	from starlette.middleware.base import BaseHTTPMiddleware
	from starlette.responses import Response
	from starlette.types import ASGIApp
	from fastapi import status, FastAPI

	class BlockFileRedirectMiddleware(BaseHTTPMiddleware):
	def __init__(self, app: ASGIApp):
	super().__init__(app)

	async def dispatch(self, request, call_next):
	# URL decode the path first
	path = urllib.parse.unquote(request.url.path)

	# Check all possible file endpoint patterns
	if any(
	pattern in path
	for pattern in [
	"/gradio_api/file=",
	"/gradio/api/file=",
	"/api/file=",
	"/file=",
	]
	):
	# Extract everything after file=
	file_part = path.split("file=", 1)[1]
	# Block if it's a URL (starts with http:// or https://)
	if file_part.lower().startswith(("http://", "https://")):
	return Response(
	status_code=status.HTTP_403_FORBIDDEN,
	content="Direct URL redirects are not allowed",
	)
	return await call_next(request)

	import pandas as pd
	import requests
	from docx import Document
	import os
	from openai import OpenAI
	from groq import Groq
	import uuid
	from gtts import gTTS
	import math
	from pydub import AudioSegment


	from youtube_transcript_api import YouTubeTranscriptApi
	from youtube_transcript_api.proxies import WebshareProxyConfig

	from youtube_transcript_api._errors import NoTranscriptFound
	import yt_dlp

	from moviepy.editor import VideoFileClip
	from pytube import YouTube
	import os
	import io
	import time
	import json
	from datetime import datetime, timezone, timedelta
	from urllib.parse import urlparse, parse_qs

	from google.cloud import storage
	from google.cloud import bigquery
	from google.oauth2 import service_account
	from googleapiclient.discovery import build
	from googleapiclient.http import MediaFileUpload
	from googleapiclient.http import MediaIoBaseDownload
	from googleapiclient.http import MediaIoBaseUpload

	from educational_material import EducationalMaterial
	from storage_service import GoogleCloudStorage
	from sheet_service import SheetService
	from google.oauth2.service_account import Credentials
	import vertexai
	from vertexai.generative_models import GenerativeModel, Part


	# import boto3

	from chatbot import Chatbot

	is_env_local = os.getenv("IS_ENV_LOCAL", "false") == "true"
	print(f"is_env_local: {is_env_local}")

	print("===gr__version__===")
	print(gr.__version__)

	# KEY CONFIG
	if is_env_local:
	with open("local_config.json") as f:
	config = json.load(f)
	IS_ENV_PROD = "False"
	PASSWORD = config["PASSWORD"]
	GCS_KEY = json.dumps(config["GOOGLE_APPLICATION_CREDENTIALS_JSON"])
	DRIVE_KEY = json.dumps(config["GOOGLE_APPLICATION_CREDENTIALS_JSON"])
	GBQ_KEY = json.dumps(config["GOOGLE_APPLICATION_CREDENTIALS_JSON"])
	SHEET_KEY = json.dumps(config["GOOGLE_APPLICATION_CREDENTIALS_JSON"])
	OPEN_AI_KEY = config["OPEN_AI_KEY"]
	OPEN_AI_ASSISTANT_ID_GPT4_BOT1 = config["OPEN_AI_ASSISTANT_ID_GPT4_BOT1"]
	OPEN_AI_ASSISTANT_ID_GPT3_BOT1 = config["OPEN_AI_ASSISTANT_ID_GPT3_BOT1"]
	GROQ_API_KEY = config["GROQ_API_KEY"]
	PERPLEXITY_API_KEY = config["PERPLEXITY_API_KEY"]
	JUTOR_CHAT_KEY = config["JUTOR_CHAT_KEY"]
	AWS_ACCESS_KEY = config["AWS_ACCESS_KEY"]
	AWS_SECRET_KEY = config["AWS_SECRET_KEY"]
	AWS_REGION_NAME = config["AWS_REGION_NAME"]
	OUTPUT_PATH = config["OUTPUT_PATH"]
	PROXY_USERNAME = config["PROXY_USERNAME"]
	PROXY_PASSWORD = config["PROXY_PASSWORD"]

	else:
	IS_ENV_PROD = os.getenv("IS_ENV_PROD", "False")
	PASSWORD = os.getenv("PASSWORD")
	GCS_KEY = os.getenv("GOOGLE_APPLICATION_CREDENTIALS_JSON")
	DRIVE_KEY = os.getenv("GOOGLE_APPLICATION_CREDENTIALS_JSON")
	GBQ_KEY = os.getenv("GOOGLE_APPLICATION_CREDENTIALS_JSON")
	SHEET_KEY = os.getenv("GOOGLE_APPLICATION_CREDENTIALS_JSON")
	OPEN_AI_KEY = os.getenv("OPEN_AI_KEY")
	OPEN_AI_ASSISTANT_ID_GPT4_BOT1 = os.getenv("OPEN_AI_ASSISTANT_ID_GPT4_BOT1")
	OPEN_AI_ASSISTANT_ID_GPT3_BOT1 = os.getenv("OPEN_AI_ASSISTANT_ID_GPT3_BOT1")
	GROQ_API_KEY = os.getenv("GROQ_API_KEY")
	PERPLEXITY_API_KEY = os.getenv("PERPLEXITY_API_KEY")
	JUTOR_CHAT_KEY = os.getenv("JUTOR_CHAT_KEY")
	AWS_ACCESS_KEY = os.getenv("AWS_ACCESS_KEY")
	AWS_SECRET_KEY = os.getenv("AWS_SECRET_KEY")
	AWS_REGION_NAME = 'us-west-2'
	OUTPUT_PATH = 'videos'
	PROXY_USERNAME = os.getenv("PROXY_USERNAME")
	PROXY_PASSWORD = os.getenv("PROXY_PASSWORD")

	TRANSCRIPTS = []
	CURRENT_INDEX = 0
	CHAT_LIMIT = 5

	# Google aiplatform
	google_service_account_info_dict = json.loads(GBQ_KEY)
	GOOGPE_SCOPES = ["https://www.googleapis.com/auth/cloud-platform"]
	google_creds = Credentials.from_service_account_info(
	google_service_account_info_dict, scopes=GOOGPE_SCOPES
	)
	vertexai.init(
	project="junyiacademy",
	service_account=google_service_account_info_dict,
	credentials=google_creds,
	)

	# CLIENTS CONFIG
	GBQ_CLIENT = bigquery.Client.from_service_account_info(json.loads(GBQ_KEY))
	GROQ_CLIENT = Groq(api_key=GROQ_API_KEY)
	GCS_SERVICE = GoogleCloudStorage(GCS_KEY)
	GCS_CLIENT = GCS_SERVICE.client
	SHEET_SERVICE = SheetService(SHEET_KEY)
	PERPLEXITY_CLIENT = OpenAI(api_key=PERPLEXITY_API_KEY, base_url="https://api.perplexity.ai")

	# check open ai access
	def check_open_ai_access(open_ai_api_key):
	# set key in OpenAI client and run to check status, if it is work, return True
	client = OpenAI(api_key=open_ai_api_key)
	try:
	response = client.chat.completions.create(
	model="gpt-4o",
	messages=[
	{"role": "user", "content": "This is a test."},
	],
	)
	if response.choices[0].message.content:
	return True
	else:
	return False
	except Exception as e:
	print(f"Error: {str(e)}")
	return False

	open_ai_api_key_assistant_id_list = [
	{
	"account":"bot1",
	"open_ai_api_key": OPEN_AI_KEY,
	"assistant_gpt4_id": OPEN_AI_ASSISTANT_ID_GPT4_BOT1,
	"assistant_gpt3_id": OPEN_AI_ASSISTANT_ID_GPT3_BOT1,
	},
	]
	for open_ai_api_key_assistant_id in open_ai_api_key_assistant_id_list:
	account = open_ai_api_key_assistant_id["account"]
	open_ai_api_key = open_ai_api_key_assistant_id["open_ai_api_key"]
	if check_open_ai_access(open_ai_api_key):
	OPEN_AI_CLIENT = OpenAI(api_key=open_ai_api_key)
	OPEN_AI_ASSISTANT_ID_GPT4 = open_ai_api_key_assistant_id["assistant_gpt4_id"]
	OPEN_AI_ASSISTANT_ID_GPT3 = open_ai_api_key_assistant_id["assistant_gpt3_id"]
	print(f"OpenAI access is OK, account: {account}")
	break

	# 驗證 password
	def verify_password(password):
	if password == PASSWORD:
	return True
	else:
	raise gr.Error("密碼錯誤")

	# # ====drive====初始化
	def init_drive_service():
	credentials_json_string = DRIVE_KEY
	credentials_dict = json.loads(credentials_json_string)
	SCOPES = ['https://www.googleapis.com/auth/drive']
	credentials = service_account.Credentials.from_service_account_info(
	credentials_dict, scopes=SCOPES)
	service = build('drive', 'v3', credentials=credentials)
	return service

	def create_folder_if_not_exists(service, folder_name, parent_id):
	print("检查是否存在特定名称的文件夹，如果不存在则创建")
	query = f"mimeType='application/vnd.google-apps.folder' and name='{folder_name}' and '{parent_id}' in parents and trashed=false"
	response = service.files().list(q=query, spaces='drive', fields="files(id, name)").execute()
	folders = response.get('files', [])
	if not folders:
	# 文件夹不存在，创建新文件夹
	file_metadata = {
	'name': folder_name,
	'mimeType': 'application/vnd.google-apps.folder',
	'parents': [parent_id]
	}
	folder = service.files().create(body=file_metadata, fields='id').execute()
	return folder.get('id')
	else:
	# 文件夹已存在
	return folders[0]['id']

	# 检查Google Drive上是否存在文件
	def check_file_exists(service, folder_name, file_name):
	query = f"name = '{file_name}' and '{folder_name}' in parents and trashed = false"
	response = service.files().list(q=query).execute()
	files = response.get('files', [])
	return len(files) > 0, files[0]['id'] if files else None

	def upload_content_directly(service, file_name, folder_id, content):
	"""
	直接将内容上传到Google Drive中的新文件。
	"""
	if not file_name:
	raise ValueError("文件名不能为空")
	if not folder_id:
	raise ValueError("文件夹ID不能为空")
	if content is None: # 允许空字符串上传，但不允许None
	raise ValueError("内容不能为空")

	file_metadata = {'name': file_name, 'parents': [folder_id]}
	# 使用io.BytesIO为文本内容创建一个内存中的文件对象
	try:
	with io.BytesIO(content.encode('utf-8')) as fh:
	media = MediaIoBaseUpload(fh, mimetype='text/plain', resumable=True)

	print("==content==")
	print(content)
	print("==content==")

	print("==media==")
	print(media)
	print("==media==")
	# 执行上传
	file = service.files().create(body=file_metadata, media_body=media, fields='id').execute()
	return file.get('id')
	except Exception as e:
	print(f"上传文件时发生错误: {e}")
	raise # 重新抛出异常，调用者可以根据需要处理或忽略

	def upload_file_directly(service, file_name, folder_id, file_path):
	# 上傳 .json to Google Drive
	file_metadata = {'name': file_name, 'parents': [folder_id]}
	media = MediaFileUpload(file_path, mimetype='application/json')
	file = service.files().create(body=file_metadata, media_body=media, fields='id').execute()


	# return file.get('id') # 返回文件ID
	return True

	def upload_img_directly(service, file_name, folder_id, file_path):
	file_metadata = {'name': file_name, 'parents': [folder_id]}
	media = MediaFileUpload(file_path, mimetype='image/jpeg')
	file = service.files().create(body=file_metadata, media_body=media, fields='id').execute()
	return file.get('id') # 返回文件ID

	def download_file_as_string(service, file_id):
	"""
	从Google Drive下载文件并将其作为字符串返回。
	"""
	request = service.files().get_media(fileId=file_id)
	fh = io.BytesIO()
	downloader = MediaIoBaseDownload(fh, request)
	done = False
	while done is False:
	status, done = downloader.next_chunk()
	fh.seek(0)
	content = fh.read().decode('utf-8')
	return content

	def set_public_permission(service, file_id):
	service.permissions().create(
	fileId=file_id,
	body={"type": "anyone", "role": "reader"},
	fields='id',
	).execute()

	def update_file_on_drive(service, file_id, file_content):
	"""
	更新Google Drive上的文件内容。

	参数:
	- service: Google Drive API服务实例。
	- file_id: 要更新的文件的ID。
	- file_content: 新的文件内容，字符串格式。
	"""
	# 将新的文件内容转换为字节流
	fh = io.BytesIO(file_content.encode('utf-8'))
	media = MediaIoBaseUpload(fh, mimetype='application/json', resumable=True)

	# 更新文件
	updated_file = service.files().update(
	fileId=file_id,
	media_body=media
	).execute()

	print(f"文件已更新，文件ID: {updated_file['id']}")

	# ---- Text file ----
	def process_file(password, file):
	verify_password(password)

	# 读取文件
	if file.name.endswith('.csv'):
	df = pd.read_csv(file)
	text = df_to_text(df)
	elif file.name.endswith('.xlsx'):
	df = pd.read_excel(file)
	text = df_to_text(df)
	elif file.name.endswith('.docx'):
	text = docx_to_text(file)
	else:
	raise ValueError("Unsupported file type")

	df_string = df.to_string()
	# 宜蘭：移除@XX@符号 to \|
	df_string = df_string.replace("@XX@", "\|")

	# 根据上传的文件内容生成问题
	questions = generate_questions(df_string)
	summary = generate_summarise(df_string)

	# 返回按钮文本和 DataFrame 字符串
	return questions[0] if len(questions) > 0 else "", \
	questions[1] if len(questions) > 1 else "", \
	questions[2] if len(questions) > 2 else "", \
	summary, \
	df_string

	def df_to_text(df):
	# 将 DataFrame 转换为纯文本
	return df.to_string()

	def docx_to_text(file):
	# 将 Word 文档转换为纯文本
	doc = Document(file)
	return "\n".join([para.text for para in doc.paragraphs])


	# ---- YouTube link ----
	def parse_time(time_str):
	"""將時間字符串 'HH:MM:SS' 或 'MM:SS' 轉換為 timedelta 物件。"""
	parts = list(map(int, time_str.split(':')))
	if len(parts) == 3:
	hours, minutes, seconds = parts
	elif len(parts) == 2:
	hours = 0 # 沒有小時部分時，將小時設為0
	minutes, seconds = parts
	else:
	raise ValueError("時間格式不正確，應為 'HH:MM:SS' 或 'MM:SS'")
	return timedelta(hours=hours, minutes=minutes, seconds=seconds)

	def format_seconds_to_time(seconds):
	"""将秒数格式化为时:分:秒的形式"""
	hours = int(seconds // 3600)
	minutes = int((seconds % 3600) // 60)
	seconds = int(seconds % 60)
	return f"{hours:02}:{minutes:02}:{seconds:02}"

	def extract_youtube_id(url):
	parsed_url = urlparse(url)

	if "youtube.com" in parsed_url.netloc:
	# 对于标准链接，视频ID在查询参数'v'中
	query_params = parse_qs(parsed_url.query)
	return query_params.get("v")[0] if "v" in query_params else None
	elif "youtu.be" in parsed_url.netloc:
	# 对于短链接，视频ID是路径的一部分
	return parsed_url.path.lstrip('/')
	else:
	return None

	def try_get_transcript(video_id, use_proxy=False):
	if use_proxy:
	proxy_config = WebshareProxyConfig(
	proxy_username=PROXY_USERNAME,
	proxy_password=PROXY_PASSWORD
	)
	transcript_list = YouTubeTranscriptApi.list_transcripts(video_id, proxies=proxy_config)
	else:
	transcript_list = YouTubeTranscriptApi.list_transcripts(video_id)
	# 指定語言優先順序
	language_priority = ["en", "zh-TW", "zh-CN", "ja"]
	# 取得 transcript_list 中有的語言，並依照 priority 排序
	available_languages = [t.language_code for t in transcript_list]
	languages = [lang for lang in language_priority if lang in available_languages]
	for language in languages:
	print("===language===")
	print(f"use language: {language}")
	print("===language===")
	try:
	if use_proxy:
	yt_api_transcript = YouTubeTranscriptApi.get_transcript(video_id, languages=[language], proxies=proxy_config)
	else:
	yt_api_transcript = YouTubeTranscriptApi.get_transcript(video_id, languages=[language])
	print("===transcript===")
	print(yt_api_transcript)
	original_transcript = ""
	for entry in yt_api_transcript:
	transcript_part = (f"{entry['start']:.0f}s: {entry['text']}")
	print(transcript_part)
	original_transcript += f"{transcript_part} \n"
	print("===transcript===")
	transcript = convert_transcription_to_json(original_transcript)
	return transcript
	except NoTranscriptFound:
	continue
	raise NoTranscriptFound("No transcript found for supported languages.")

	def get_transcript_by_yt_api(video_id):
	print("====get_transcript_by_yt_api====")
	# 先不用 proxy
	try:
	print("====try_get_transcript without proxy====")
	return try_get_transcript(video_id, use_proxy=False)
	except Exception as e1:
	print(f"No proxy transcript error: {e1}")
	# 再用 proxy
	try:
	print("====try_get_transcript with proxy====")
	return try_get_transcript(video_id, use_proxy=True)
	except Exception as e2:
	print(f"With proxy transcript error: {e2}")
	raise e2

	def generate_transcription_by_gemini(video_id):
	"""使用 Google Gemini 生成影片逐字稿"""
	print("====generate_transcription_by_gemini====")
	# 準備 YouTube 影片 URL
	video_url = f"https://www.youtube.com/watch?v={video_id}"
	model = vertexai.generative_models.GenerativeModel("gemini-2.5-flash")

	# 建立影片部分
	video_part = Part.from_uri(
	uri=video_url,
	mime_type="video/*"
	)

	# 設定提示詞
	prompt = "給我包含時間軸的完整逐字稿，包含時間軸跟原文內容，一句話一行"

	original_transcription = "" # 先初始化，避免 except referenced before assignment
	try:
	response = model.generate_content(
	contents=[video_part, prompt],
	generation_config=vertexai.generative_models.GenerationConfig(
	temperature=1.0,
	top_p=0.95,
	max_output_tokens=65535,
	candidate_count=1
	),
	stream=False
	)

	original_transcription = response.candidates[0].content.parts[0].text

	print("===original_transcription===")
	print(original_transcription)
	print("===original_transcription===")

	# 轉換成 JSON 格式
	transcript_json = convert_transcription_to_json(original_transcription)

	if transcript_json:
	return transcript_json
	else:
	raise Exception("無法轉換逐字稿格式")

	except Exception as e:
	print(f"生成逐字稿時發生錯誤：{str(e)}")
	return None

	def convert_transcription_to_json(original_transcription):
	"""
	將原始逐字稿轉換成指定的 JSON 格式，支援長文本分段處理

	Args:
	original_transcription (str): 原始逐字稿文本

	Returns:
	list: 包含逐字稿段落的列表，每個段落包含 text, start, end, duration
	"""
	if not original_transcription:
	print("原始逐字稿為空")
	return None

	# 使用 Vertex AI 來處理轉換
	model = vertexai.generative_models.GenerativeModel("gemini-2.5-flash")

	# 設定每段最大字數
	# 考慮到：
	# 1. Gemini 輸出限制為 65,535 tokens
	# 2. 需要預留空間給系統提示詞
	# 3. JSON 格式會增加額外字符
	# 4. 中文一個字約等於 2-3 個 tokens
	MAX_CHUNK_SIZE = 15000

	# 分段處理
	chunks = []
	current_chunk = []
	current_size = 0

	# 按行分割文本
	lines = original_transcription.split('\n')

	for line in lines:
	line = line.strip()
	if not line:
	continue

	# 如果這一行加入後會超過限制，就先處理當前chunk
	if current_size + len(line) > MAX_CHUNK_SIZE and current_chunk:
	chunks.append('\n'.join(current_chunk))
	current_chunk = []
	current_size = 0

	current_chunk.append(line)
	current_size += len(line)

	# 處理最後一個chunk
	if current_chunk:
	chunks.append('\n'.join(current_chunk))

	# 用於儲存所有處理結果
	all_results = []

	# 處理每個chunk
	for i, chunk in enumerate(chunks):
	print(f"===chunk: {i+1}===")

	prompt = f"""
	請將以下逐字稿轉換成 JSON 格式:
	{chunk}

	轉換規則:
	1. 每個段落需包含 text, start, end, duration, 這很重要！
	2. 時間格式需轉換為秒數(例如 1:02 轉為 62 秒)，start 和 end 的格式要一樣，都要整數，不要有小數點
	3. duration 為 end - start 的差值
	4. 回傳格式為 JSON array
	5. 合理的合併句子，不要有不合理的斷句，一句話至少要有完整的主詞、謂詞
	6. 每句話盡量在 10~15 個字左右，但要以完整語意為主
	7. 如果遇到 [Music] [Laughter] [Crowd] [Cheering] [Applause]這類的標記，可以直接忽略不計
	8. 這是第 {i+1}/{len(chunks)} 段，請確保時間軸的連續性

	請直接返回 JSON 格式，不要加入任何說明文字或 markdown 標記。
	"""

	try:
	response = model.generate_content(prompt)
	json_str = response.text

	print(f"===json_str for chunk {i+1}===")
	print(json_str)
	print(f"===json_str for chunk {i+1}===")

	# 移除可能的 markdown 標記
	json_str = json_str.replace("```json", "").replace("```", "").strip()

	# 解析 JSON
	chunk_result = json.loads(json_str)

	# 驗證格式
	for entry in chunk_result:
	if not all(k in entry for k in ["text", "start", "end", "duration"]):
	raise ValueError(f"JSON 格式錯誤：缺少必要欄位，在第 {i+1} 段")

	all_results.extend(chunk_result)

	except Exception as e:
	print(f"處理第 {i+1} 段時發生錯誤：{str(e)}")
	continue

	# 如果沒有任何有效結果，返回 None
	if not all_results:
	return None

	# 按時間排序
	all_results.sort(key=lambda x: x["start"])

	return all_results

	def generate_transcription_by_whisper(video_id):
	print("====generate_transcription_by_whisper====")
	youtube_url = f'https://www.youtube.com/watch?v={video_id}'
	codec_name = "mp3"
	outtmpl = f"{OUTPUT_PATH}/{video_id}.%(ext)s"
	ydl_opts = {
	'format': 'bestaudio/best',
	'postprocessors': [{
	'key': 'FFmpegExtractAudio',
	'preferredcodec': codec_name,
	'preferredquality': '192'
	}],
	'outtmpl': outtmpl,
	}

	with yt_dlp.YoutubeDL(ydl_opts) as ydl:
	ydl.download([youtube_url])

	audio_path = f"{OUTPUT_PATH}/{video_id}.{codec_name}"
	full_audio = AudioSegment.from_mp3(audio_path)

	max_part_duration = 10 * 60 * 1000 # 10 minutes
	full_duration = len(full_audio) # in milliseconds
	parts = math.ceil(full_duration / max_part_duration)
	print(f"parts: {parts}")
	transcription = []

	for i in range(parts):
	print(f"== i: {i}==")
	start_time = i * max_part_duration
	end_time = min((i + 1) * max_part_duration, full_duration)
	print(f"time: {start_time/1000} - {end_time/1000}")
	chunk = full_audio[start_time:end_time]
	chunk_path = f"{OUTPUT_PATH}/{video_id}_part_{i}.{codec_name}"
	chunk.export(chunk_path, format=codec_name)

	try:
	with open(chunk_path, "rb") as chunk_file:
	response = OPEN_AI_CLIENT.audio.transcriptions.create(
	model="whisper-1",
	file=chunk_file,
	response_format="verbose_json",
	timestamp_granularities=["segment"],
	prompt="Transcribe the following audio file. if content is chinese, please using 'language: zh-TW' ",
	)

	# Adjusting the timestamps for the chunk based on its position in the full audio
	adjusted_segments = [{
	'text': segment.text, # 使用 .text 屬性而不是 ['text']
	'start': math.ceil(segment.start + start_time / 1000.0), # Converting milliseconds to seconds
	'end': math.ceil(segment.end + start_time / 1000.0),
	'duration': math.ceil(segment.end - segment.start)
	} for segment in response.segments]

	transcription.extend(adjusted_segments)
	except Exception as e:
	print(f"Error processing chunk {i}: {str(e)}")

	# Remove temporary chunk files after processing
	os.remove(chunk_path)

	return transcription

	def get_video_duration(video_id):
	yt = YouTube(f'https://www.youtube.com/watch?v={video_id}')
	try:
	video_duration = yt.length
	except:
	video_duration = None

	print(f"video_duration: {video_duration}")

	return video_duration

	def process_transcript_and_screenshots_on_gcs(video_id):
	print("====process_transcript_and_screenshots_on_gcs====")
	transcript, exists = get_transcript_from_gcs(video_id)
	if not exists:
	print("==== video transcript is not exists ====")
	try:
	transcript = get_transcript_by_yt_api(video_id)
	# transcript = generate_transcription_by_gemini(video_id)
	except Exception as e:
	print(f" Error generating transcription: {str(e)}")
	transcript = generate_transcription_by_gemini(video_id)
	# transcript = generate_transcription_by_whisper(video_id)

	upload_transcript_to_gcs(video_id, transcript)

	# 處理截圖
	print("====處理截圖====")
	is_new_transcript = False
	has_tried_download_video = False
	for entry in transcript:
	if 'img_file_id' not in entry:
	# 檢查 OUTPUT_PATH 是否存在 video_id.mp4
	video_path = f'{OUTPUT_PATH}/{video_id}.mp4'
	# 沒有影片以及沒有下載過
	if not os.path.exists(video_path) and not has_tried_download_video:
	try:
	download_youtube_video(video_id)
	except Exception as e:
	has_tried_download_video = True
	print(f"下载视频失败: {str(e)}")

	if os.path.exists(video_path):
	try:
	screenshot_path = screenshot_youtube_video(video_id, entry['start'])
	screenshot_blob_name = f"{video_id}/{video_id}_{entry['start']}.jpg"
	img_file_id = GCS_SERVICE.upload_image_and_get_public_url('video_ai_assistant', screenshot_blob_name, screenshot_path)
	entry['img_file_id'] = img_file_id
	print(f"截图已上传到GCS: {img_file_id}")
	is_new_transcript = True
	except Exception as e:
	print(f"Error processing screenshot: {str(e)}")
	# 如果影片有下載成功，但是截圖失敗，則將 img_file_id 設為空字串
	entry['img_file_id'] = ""
	print(f"截圖空白")
	is_new_transcript = True
	else:
	entry['img_file_id'] = ""
	print(f"截圖空白")
	is_new_transcript = True

	if is_new_transcript:
	print("===更新逐字稿文件===")
	upload_transcript_to_gcs(video_id, transcript)

	return transcript

	def get_transcript(video_id):
	print("====get_transcript====")
	transcript, exists = get_transcript_from_gcs(video_id)
	if not exists:
	raise gr.Error("逐字稿文件不存在於GCS中。")

	if any('img_file_id' not in entry for entry in transcript):
	raise gr.Error("Some entries in the transcript do not have an associated img_file_id.")

	print("Transcript is verified with all necessary images.")
	return transcript

	def get_transcript_from_gcs(video_id):
	print("Checking for transcript in GCS...")
	bucket_name = 'video_ai_assistant'
	transcript_file_name = f'{video_id}_transcript.json'
	transcript_blob_name = f"{video_id}/{transcript_file_name}"
	# Check if the transcript exists in GCS
	is_transcript_exists = GCS_SERVICE.check_file_exists(bucket_name, transcript_blob_name)
	if is_transcript_exists:
	# Download the transcript if it exists
	transcript_text = GCS_SERVICE.download_as_string(bucket_name, transcript_blob_name)
	return json.loads(transcript_text), True
	else:
	print("No transcript found for video ID:", video_id)
	return None, False

	def upload_transcript_to_gcs(video_id, transcript):
	print("Uploading updated transcript to GCS...")
	bucket_name = 'video_ai_assistant'
	transcript_file_name = f'{video_id}_transcript.json'
	transcript_blob_name = f"{video_id}/{transcript_file_name}"
	transcript_text = json.dumps(transcript, ensure_ascii=False, indent=2)
	GCS_SERVICE.upload_json_string(bucket_name, transcript_blob_name, transcript_text)
	print("Transcript uploaded successfully.")

	def process_youtube_link(password, link, LLM_model=None):
	verify_password(password)
	video_id = extract_youtube_id(link)

	try:
	if IS_ENV_PROD == "True":
	transcript = get_transcript(video_id)
	else:
	transcript = process_transcript_and_screenshots_on_gcs(video_id)
	except Exception as e:
	error_msg = f" {video_id} 逐字稿錯誤: {str(e)}"
	print("===process_youtube_link error===")
	print(error_msg)
	raise gr.Error(error_msg)

	original_transcript = json.dumps(transcript, ensure_ascii=False, indent=2)
	formatted_transcript = []
	formatted_simple_transcript =[]
	for entry in transcript:
	start_time = format_seconds_to_time(entry['start'])
	end_time = format_seconds_to_time(entry['start'] + entry['duration'])
	embed_url = get_embedded_youtube_link(video_id, entry['start'])
	img_file_id = entry['img_file_id']
	screenshot_path = img_file_id
	line = {
	"start_time": start_time,
	"end_time": end_time,
	"text": entry['text'],
	"embed_url": embed_url,
	"screenshot_path": screenshot_path
	}
	formatted_transcript.append(line)
	# formatted_simple_transcript 只要 start_time, end_time, text
	simple_line = {
	"start_time": start_time,
	"end_time": end_time,
	"text": entry['text']
	}
	formatted_simple_transcript.append(simple_line)

	# 基于逐字稿生成其他所需的输出
	source = "gcs"
	questions_answers = get_questions_answers(video_id, formatted_simple_transcript, source, LLM_model)
	questions_answers_json = json.dumps(questions_answers, ensure_ascii=False, indent=2)
	summary_json = get_video_id_summary(video_id, formatted_simple_transcript, source, LLM_model)
	summary_text = summary_json["summary"]
	summary = summary_json["summary"]
	key_moments_json = get_key_moments(video_id, formatted_simple_transcript, formatted_transcript, source, LLM_model)
	key_moments = key_moments_json["key_moments"]
	key_moments_text = json.dumps(key_moments, ensure_ascii=False, indent=2)
	key_moments_html = get_key_moments_html(key_moments)
	html_content = format_transcript_to_html(formatted_transcript)
	simple_html_content = format_simple_transcript_to_html(formatted_simple_transcript)
	mind_map_json = get_mind_map(video_id, formatted_simple_transcript, source, LLM_model)
	mind_map = mind_map_json["mind_map"]
	mind_map_html = get_mind_map_html(mind_map)
	reading_passage_json = get_reading_passage(video_id, formatted_simple_transcript, source, LLM_model)
	reading_passage_text = reading_passage_json["reading_passage"]
	reading_passage = reading_passage_json["reading_passage"]
	meta_data = get_meta_data(video_id)
	subject = meta_data["subject"]
	grade = meta_data["grade"]

	# 确保返回与 UI 组件预期匹配的输出
	return video_id, \
	questions_answers_json, \
	original_transcript, \
	summary_text, \
	summary, \
	key_moments_text, \
	key_moments_html, \
	mind_map, \
	mind_map_html, \
	html_content, \
	simple_html_content, \
	reading_passage_text, \
	reading_passage, \
	subject, \
	grade

	def process_junyi_link_to_youtube_link(junyi_link):
	print("====process_junyi_link_to_youtube_link====")
	print(junyi_link)

	# 辨識 /v/{youtube_id}
	import re
	match = re.search(r"/v/([\w-]+)", junyi_link)
	if match:
	youtube_id = match.group(1)
	youtube_link = f"https://www.youtube.com/watch?v={youtube_id}"
	return youtube_link
	else:
	return junyi_link

	def create_formatted_simple_transcript(transcript):
	formatted_simple_transcript = []
	for entry in transcript:
	start_time = format_seconds_to_time(entry['start'])
	end_time = format_seconds_to_time(entry['start'] + entry['duration'])
	line = {
	"start_time": start_time,
	"end_time": end_time,
	"text": entry['text']
	}
	formatted_simple_transcript.append(line)
	return formatted_simple_transcript

	def create_formatted_transcript(video_id, transcript):
	formatted_transcript = []
	for entry in transcript:
	start_time = format_seconds_to_time(entry['start'])
	end_time = format_seconds_to_time(entry['start'] + entry['duration'])
	embed_url = get_embedded_youtube_link(video_id, entry['start'])
	img_file_id = entry['img_file_id']
	screenshot_path = img_file_id
	line = {
	"start_time": start_time,
	"end_time": end_time,
	"text": entry['text'],
	"embed_url": embed_url,
	"screenshot_path": screenshot_path
	}
	formatted_transcript.append(line)
	return formatted_transcript

	def format_transcript_to_html(formatted_transcript):
	html_content = ""
	for entry in formatted_transcript:
	html_content += f"<h3>{entry['start_time']} - {entry['end_time']}</h3>"
	html_content += f"<p>{entry['text']}</p>"
	html_content += f"<img src='{entry['screenshot_path']}' width='500px' />"
	return html_content

	def format_simple_transcript_to_html(formatted_transcript):
	html_content = ""
	for entry in formatted_transcript:
	html_content += f"<h3>{entry['start_time']} - {entry['end_time']}</h3>"
	html_content += f"<p>{entry['text']}</p>"
	return html_content

	def get_embedded_youtube_link(video_id, start_time):
	int_start_time = int(start_time)
	embed_url = f"https://www.youtube.com/embed/{video_id}?start={int_start_time}&autoplay=1"
	return embed_url

	def download_youtube_video(youtube_id, output_path=OUTPUT_PATH):
	# Construct the full YouTube URL
	youtube_url = f'https://www.youtube.com/watch?v={youtube_id}'

	# Create the output directory if it doesn't exist
	if not os.path.exists(output_path):
	os.makedirs(output_path)

	# Download the video
	try:
	yt = YouTube(youtube_url)
	video_stream = yt.streams.filter(progressive=True, file_extension='mp4').order_by('resolution').desc().first()
	video_stream.download(output_path=output_path, filename=youtube_id+".mp4")
	print(f"[Pytube] Video downloaded successfully: {output_path}/{youtube_id}.mp4")
	except Exception as e:
	ydl_opts = {
	'format': "bestvideo[height<=720][ext=mp4]",
	'outtmpl': os.path.join(output_path, f'{youtube_id}.mp4'), # Output filename template
	}
	with yt_dlp.YoutubeDL(ydl_opts) as ydl:
	ydl.download([youtube_url])

	print(f"[yt_dlp] Video downloaded successfully: {output_path}/{youtube_id}.mp4")

	def screenshot_youtube_video(youtube_id, snapshot_sec):
	video_path = f'{OUTPUT_PATH}/{youtube_id}.mp4'
	file_name = f"{youtube_id}_{snapshot_sec}.jpg"
	with VideoFileClip(video_path) as video:
	screenshot_path = f'{OUTPUT_PATH}/{file_name}'
	video.save_frame(screenshot_path, snapshot_sec)

	return screenshot_path


	# ---- Web ----
	# def process_web_link(link):
	# # 抓取和解析网页内容
	# response = requests.get(link)
	# soup = BeautifulSoup(response.content, 'html.parser')
	# return soup.get_text()


	# ---- LLM Generator ----
	def split_data(df_string, word_base=100000):
	"""Split the JSON string based on a character length base and then chunk the parsed JSON array."""
	if isinstance(df_string, str):
	data_str_cnt = len(df_string)
	data = json.loads(df_string)
	else:
	data_str_cnt = len(str(df_string))
	data = df_string

	# Calculate the number of parts based on the length of the string
	n_parts = data_str_cnt // word_base + (1 if data_str_cnt % word_base != 0 else 0)
	print(f"Number of Parts: {n_parts}")

	# Calculate the number of elements each part should have
	part_size = len(data) // n_parts if n_parts > 0 else len(data)

	segments = []
	for i in range(n_parts):
	start_idx = i * part_size
	end_idx = min((i + 1) * part_size, len(data))
	# Serialize the segment back to a JSON string
	segment = json.dumps(data[start_idx:end_idx]).encode('utf-8').decode('unicode_escape')
	segments.append(segment)
	return segments

	def generate_content_by_open_ai(sys_content, user_content, response_format=None, model_name=None):
	print("generate_content_by_open_ai")
	if model_name == "gpt-4-turbo":
	model = "gpt-4-turbo"
	else:
	model = "gpt-4o"
	print(f"LLM model: {model}")

	messages = [
	{"role": "system", "content": sys_content},
	{"role": "user", "content": user_content}
	]
	request_payload = {
	"model": model,
	"messages": messages,
	"max_tokens": 4000,
	}

	if response_format is not None:
	request_payload["response_format"] = response_format

	response = OPEN_AI_CLIENT.chat.completions.create(**request_payload)
	content = response.choices[0].message.content.strip()
	return content

	# def generate_content_by_bedrock(sys_content, user_content):
	# print("LLM using REDROCK")
	# messages = [
	# {"role": "user", "content": user_content +"(如果是 JSON 格式，value 的引號，請用單引號，或是用反斜線＋雙引號，避免 JSON Decoder error )"}
	# ]
	# model_id = "anthropic.claude-3-sonnet-20240229-v1:0"
	# print(f"model_id: {model_id}")
	# # model_id = "anthropic.claude-3-haiku-20240307-v1:0"
	# kwargs = {
	# "modelId": model_id,
	# "contentType": "application/json",
	# "accept": "application/json",
	# "body": json.dumps({
	# "anthropic_version": "bedrock-2023-05-31",
	# "max_tokens": 4000,
	# "system": sys_content,
	# "messages": messages
	# })
	# }
	# response = BEDROCK_CLIENT.invoke_model(**kwargs)
	# response_body = json.loads(response.get('body').read())
	# content = response_body.get('content')[0].get('text')
	# return content

	def generate_content_by_gemini(sys_content, user_content, response_format=None, model_name=None):
	print("generate_content_by_gemini")
	print(f"LLM using: {model_name}")

	gemini_model = GenerativeModel(model_name=model_name)
	model_response = gemini_model.generate_content(
	f"{sys_content}, {user_content}"
	)
	content = model_response.candidates[0].content.parts[0].text
	return content


	def generate_content_by_LLM(sys_content, user_content, response_format=None, LLM_model=None, model_name=None):
	# 使用 OpenAI 生成基于上传数据的问题

	if LLM_model in ["gemini-1.5-pro","gemini-1.5-flash"]:
	print(f"LLM: {LLM_model}")
	model_name = LLM_model
	content = generate_content_by_gemini(sys_content, user_content, response_format, model_name=model_name)
	# elif LLM_model == "anthropic-claude-3-sonnet":
	# print(f"LLM: {LLM_model}")
	# content = generate_content_by_bedrock(sys_content, user_content)
	else:
	print(f"LLM: {LLM_model}")
	print(f"model_name: {model_name}")
	content = generate_content_by_open_ai(sys_content, user_content, response_format, model_name=model_name)

	print("=====content=====")
	print(content)
	print("=====content=====")

	return content

	def get_reading_passage(video_id, df_string, source, LLM_model=None):
	if source == "gcs":
	print("===get_reading_passage on gcs===")
	bucket_name = 'video_ai_assistant'
	file_name = f'{video_id}_reading_passage_latex.json'
	blob_name = f"{video_id}/{file_name}"
	# 检查 reading_passage 是否存在
	is_file_exists = GCS_SERVICE.check_file_exists(bucket_name, blob_name)
	if not is_file_exists:
	reading_passage = generate_reading_passage(df_string, LLM_model)
	reading_passage_json = {"reading_passage": str(reading_passage)}
	reading_passage_text = json.dumps(reading_passage_json, ensure_ascii=False, indent=2)
	GCS_SERVICE.upload_json_string(bucket_name, blob_name, reading_passage_text)
	print("reading_passage已上传到GCS")
	else:
	# reading_passage已存在，下载内容
	print("reading_passage已存在于GCS中")
	reading_passage_text = GCS_SERVICE.download_as_string(bucket_name, blob_name)
	reading_passage_json = json.loads(reading_passage_text)

	elif source == "drive":
	print("===get_reading_passage on drive===")
	service = init_drive_service()
	parent_folder_id = '1GgI4YVs0KckwStVQkLa1NZ8IpaEMurkL'
	folder_id = create_folder_if_not_exists(service, video_id, parent_folder_id)
	file_name = f'{video_id}_reading_passage.json'

	# 检查 reading_passage 是否存在
	exists, file_id = check_file_exists(service, folder_id, file_name)
	if not exists:
	reading_passage = generate_reading_passage(df_string)
	reading_passage_json = {"reading_passage": str(reading_passage)}
	reading_passage_text = json.dumps(reading_passage_json, ensure_ascii=False, indent=2)
	upload_content_directly(service, file_name, folder_id, reading_passage_text)
	print("reading_passage已上傳到Google Drive")
	else:
	# reading_passage已存在，下载内容
	print("reading_passage已存在于Google Drive中")
	reading_passage_text = download_file_as_string(service, file_id)

	return reading_passage_json

	def generate_reading_passage(df_string, LLM_model=None):
	print("===generate_reading_passage 0===")
	print(df_string)

	segments = split_data(df_string, word_base=100000)
	all_content = []
	model_name = "gpt-4-turbo"
	# model_name = "gpt-4o"

	for segment in segments:
	sys_content = "你是一個擅長資料分析跟影片教學的老師，user 為學生，請精讀資料文本，自行判斷資料的種類，使用 zh-TW"
	user_content = f"""
	# 文本 {segment}

	# rules:
	- 根據文本，抓取重點
	- 去除人類講課時口語的問答句，重新拆解成文章，建立適合閱讀語句通順的 Reading Passage
	- 只需要專注提供 Reading Passage，字數在 500 字以內
	- 敘述中，請把數學或是專業術語，用 Latex 包覆（$...$）
	- 加減乘除、根號、次方等等的運算式口語也換成 LATEX 數學符號

	# restrictions:
	- 請一定要使用繁體中文 zh-TW，這很重要
	- 產生的結果不要前後文解釋，也不要敘述這篇文章怎麼產生的
	- 請直接給出文章，不用介紹怎麼處理的或是文章字數等等
	- 字數在 500 字以內
	"""

	print("======user_content 0 ===")
	print(user_content)

	content = generate_content_by_LLM(sys_content, user_content, response_format=None, LLM_model=LLM_model, model_name=model_name)
	all_content.append(content + "\n")

	# 將所有生成的閱讀理解段落合併成一個完整的文章
	final_content = "\n".join(all_content)
	return final_content

	def text_to_speech(video_id, text):
	tts = gTTS(text, lang='en')
	filename = f'{video_id}_reading_passage.mp3'
	tts.save(filename)
	return filename

	def get_mind_map(video_id, df_string, source, LLM_model=None):
	if source == "gcs":
	print("===get_mind_map on gcs===")
	gcs_client = GCS_CLIENT
	bucket_name = 'video_ai_assistant'
	file_name = f'{video_id}_mind_map.json'
	blob_name = f"{video_id}/{file_name}"
	# 检查檔案是否存在
	is_file_exists = GCS_SERVICE.check_file_exists(bucket_name, blob_name)
	if not is_file_exists:
	mind_map = generate_mind_map(df_string, LLM_model)
	mind_map_json = {"mind_map": str(mind_map)}
	mind_map_text = json.dumps(mind_map_json, ensure_ascii=False, indent=2)
	GCS_SERVICE.upload_json_string(bucket_name, blob_name, mind_map_text)
	print("mind_map已上傳到GCS")
	else:
	# mindmap已存在，下载内容
	print("mind_map已存在于GCS中")
	mind_map_text = GCS_SERVICE.download_as_string(bucket_name, blob_name)
	mind_map_json = json.loads(mind_map_text)

	elif source == "drive":
	print("===get_mind_map on drive===")
	service = init_drive_service()
	parent_folder_id = '1GgI4YVs0KckwStVQkLa1NZ8IpaEMurkL'
	folder_id = create_folder_if_not_exists(service, video_id, parent_folder_id)
	file_name = f'{video_id}_mind_map.json'

	# 检查檔案是否存在
	exists, file_id = check_file_exists(service, folder_id, file_name)
	if not exists:
	mind_map = generate_mind_map(df_string, LLM_model)
	mind_map_json = {"mind_map": str(mind_map)}
	mind_map_text = json.dumps(mind_map_json, ensure_ascii=False, indent=2)
	upload_content_directly(service, file_name, folder_id, mind_map_text)
	print("mind_map已上傳到Google Drive")
	else:
	# mindmap已存在，下载内容
	print("mind_map已存在于Google Drive中")
	mind_map_text = download_file_as_string(service, file_id)
	mind_map_json = json.loads(mind_map_text)

	return mind_map_json

	def generate_mind_map(df_string, LLM_model=None):
	print("===generate_mind_map===")
	segments = split_data(df_string, word_base=100000)
	all_content = []

	for segment in segments:
	sys_content = "你是一個擅長資料分析跟影片教學的老師，user 為學生，請精讀資料文本，自行判斷資料的種類，使用 zh-TW"
	user_content = f"""
	請根據 {segment} 文本建立 markdown 心智圖
	注意：不需要前後文敘述，直接給出 markdown 文本即可
	這對我很重要
	"""
	content = generate_content_by_LLM(sys_content, user_content, response_format=None, LLM_model=LLM_model, model_name=None)
	all_content.append(content + "\n")

	# 將所有生成的閱讀理解段落合併成一個完整的文章
	final_content = "\n".join(all_content)
	return final_content

	def get_mind_map_html(mind_map):
	mind_map_markdown = mind_map.replace("```markdown", "").replace("```", "")

	mind_map_html = f"""
	<div class="markmap">
	<script type="text/template">
	{mind_map_markdown}
	</script>
	</div>
	"""
	return mind_map_html

	def get_video_id_summary(video_id, df_string, source, LLM_model=None):
	if source == "gcs":
	print("===get_video_id_summary on gcs===")
	bucket_name = 'video_ai_assistant'
	file_name = f'{video_id}_summary_markdown.json'
	summary_file_blob_name = f"{video_id}/{file_name}"
	# 检查 summary_file 是否存在
	is_summary_file_exists = GCS_SERVICE.check_file_exists(bucket_name, summary_file_blob_name)
	if not is_summary_file_exists:
	meta_data = get_meta_data(video_id)
	summary = generate_summarise(df_string, meta_data, LLM_model)
	summary_json = {"summary": str(summary)}
	summary_text = json.dumps(summary_json, ensure_ascii=False, indent=2)
	GCS_SERVICE.upload_json_string(bucket_name, summary_file_blob_name, summary_text)
	print("summary已上传到GCS")
	else:
	# summary已存在，下载内容
	print("summary已存在于GCS中")
	summary_text = GCS_SERVICE.download_as_string(bucket_name, summary_file_blob_name)
	summary_json = json.loads(summary_text)

	elif source == "drive":
	print("===get_video_id_summary===")
	service = init_drive_service()
	parent_folder_id = '1GgI4YVs0KckwStVQkLa1NZ8IpaEMurkL'
	folder_id = create_folder_if_not_exists(service, video_id, parent_folder_id)
	file_name = f'{video_id}_summary.json'

	# 检查逐字稿是否存在
	exists, file_id = check_file_exists(service, folder_id, file_name)
	if not exists:
	meta_data = get_meta_data(video_id)
	summary = generate_summarise(df_string, meta_data, LLM_model)
	summary_json = {"summary": str(summary)}
	summary_text = json.dumps(summary_json, ensure_ascii=False, indent=2)

	try:
	upload_content_directly(service, file_name, folder_id, summary_text)
	print("summary已上傳到Google Drive")

	except Exception as e:
	error_msg = f" {video_id} 摘要錯誤: {str(e)}"
	print("===get_video_id_summary error===")
	print(error_msg)
	print("===get_video_id_summary error===")
	else:
	# 逐字稿已存在，下载逐字稿内容
	print("summary已存在Google Drive中")
	summary_text = download_file_as_string(service, file_id)
	summary_json = json.loads(summary_text)

	return summary_json

	def generate_summarise(df_string, metadata=None, LLM_model=None):
	print("===generate_summarise===")
	# 使用 OpenAI 生成基于上传数据的问题
	if metadata:
	title = metadata.get("title", "")
	subject = metadata.get("subject", "")
	grade = metadata.get("grade", "")
	else:
	title = ""
	subject = ""
	grade = ""

	segments = split_data(df_string, word_base=100000)
	all_content = []

	for segment in segments:
	sys_content = "你是一個擅長資料分析跟影片教學的老師，user 為學生，請精讀資料文本，自行判斷賛料的種類，使用 zh-TW"
	user_content = f"""
	課程名稱：{title}
	科目：{subject}
	年級：{grade}

	請根據內文： {segment}

	格式為 Markdown
	如果有課程名稱，請圍繞「課程名稱」為學習重點，進行重點整理，不要整理跟情境故事相關的問題
	整體摘要在一百字以內
	重點概念列出 bullet points，至少三個，最多五個
	以及可能的結論與結尾延伸小問題提供學生作反思
	敘述中，請把數學或是專業術語，用 Latex 包覆（$...$）
	加減乘除、根號、次方等等的運算式口語也換成 LATEX 數學符號

	整體格式為：
	## 🌟 主題：{{title}} (如果沒有 title 就省略)
	## 📚 整體摘要
	- (一個 bullet point....)

	## 🔖 重點概念
	- xxx
	- xxx
	- xxx

	## 💡 為什麼我們要學這個？
	- (一個 bullet point....)

	## ❓ 延伸小問題
	- (一個 bullet point....請圍繞「課程名稱」為學習重點，進行重點整理，不要整理跟情境故事相關的問題)
	"""
	content = generate_content_by_LLM(sys_content, user_content, response_format=None, LLM_model=LLM_model, model_name=None)
	all_content.append(content + "\n")

	if len(all_content) > 1:
	all_content_cnt = len(all_content)
	all_content_str = json.dumps(all_content)
	sys_content = "你是一個擅長資料分析跟影片教學的老師，user 為學生，請精讀賛料文本，自行判斷賛料的種類，使用 zh-TW"
	user_content = f"""
	課程名稱：{title}
	科目：{subject}
	年級：{grade}

	請根據內文： {all_content_str}
	共有 {all_content_cnt} 段，請縱整成一篇摘要

	格式為 Markdown
	如果有課程名稱，請圍繞「課程名稱」為學習重點，進行重點整理，不要整理跟情境故事相關的問題
	整體摘要在 {all_content_cnt} 百字以內
	重點概念列出 bullet points，至少三個，最多十個
	以及可能的結論與結尾延伸小問題提供學生作反思
	敘述中，請把數學或是專業術語，用 Latex 包覆（$...$）
	加減乘除、根號、次方等等的運算式口語也換成 LATEX 數學符號

	整體格式為：
	## 🌟 主題：{{title}} (如果沒有 title 就省略)
	## 📚 整體摘要
	- ( {all_content_cnt} 個 bullet point....)

	## 🔖 重點概念
	- xxx
	- xxx
	- xxx

	## 💡 為什麼我們要學這個？
	- ( {all_content_cnt} 個 bullet point....)

	## ❓ 延伸小問題
	- ( {all_content_cnt} 個 bullet point....請圍繞「課程名稱」為學習重點，進行重點整理，不要整理跟情境故事相關的問題)
	"""
	final_content = generate_content_by_LLM(sys_content, user_content, response_format=None, LLM_model=LLM_model, model_name=None)
	else:
	final_content = all_content[0]

	return final_content

	def get_questions(video_id, df_string, source="gcs", LLM_model=None):
	if source == "gcs":
	# 去 gcs 確認是有有 video_id_questions.json
	print("===get_questions on gcs===")
	gcs_client = GCS_CLIENT
	bucket_name = 'video_ai_assistant'
	file_name = f'{video_id}_questions.json'
	blob_name = f"{video_id}/{file_name}"
	# 检查檔案是否存在
	is_questions_exists = GCS_SERVICE.check_file_exists(bucket_name, blob_name)
	if not is_questions_exists:
	questions = generate_questions(df_string, LLM_model)
	questions_text = json.dumps(questions, ensure_ascii=False, indent=2)
	GCS_SERVICE.upload_json_string(bucket_name, blob_name, questions_text)
	print("questions已上傳到GCS")
	else:
	# 逐字稿已存在，下载逐字稿内容
	print("questions已存在于GCS中")
	questions_text = GCS_SERVICE.download_as_string(bucket_name, blob_name)
	questions = json.loads(questions_text)

	elif source == "drive":
	# 去 g drive 確認是有有 video_id_questions.json
	print("===get_questions===")
	service = init_drive_service()
	parent_folder_id = '1GgI4YVs0KckwStVQkLa1NZ8IpaEMurkL'
	folder_id = create_folder_if_not_exists(service, video_id, parent_folder_id)
	file_name = f'{video_id}_questions.json'

	# 检查檔案是否存在
	exists, file_id = check_file_exists(service, folder_id, file_name)
	if not exists:
	questions = generate_questions(df_string, LLM_model)
	questions_text = json.dumps(questions, ensure_ascii=False, indent=2)
	upload_content_directly(service, file_name, folder_id, questions_text)
	print("questions已上傳到Google Drive")
	else:
	# 逐字稿已存在，下载逐字稿内容
	print("questions已存在于Google Drive中")
	questions_text = download_file_as_string(service, file_id)
	questions = json.loads(questions_text)

	q1 = questions[0] if len(questions) > 0 else ""
	q2 = questions[1] if len(questions) > 1 else ""
	q3 = questions[2] if len(questions) > 2 else ""
	print("=====get_questions=====")
	print(f"q1: {q1}")
	print(f"q2: {q2}")
	print(f"q3: {q3}")
	print("=====get_questions=====")
	return q1, q2, q3

	def generate_questions(df_string, LLM_model=None):
	print("===generate_questions===")
	# 使用 OpenAI 生成基于上传数据的问题
	if isinstance(df_string, str):
	df_string_json = json.loads(df_string)
	else:
	df_string_json = df_string
	content_text = ""

	for entry in df_string_json:
	content_text += entry["text"] + "，"

	sys_content = "你是一個擅長資料分析跟影片教學的老師，user 為學生，請精讀資料文本，自行判斷資料的種類，並用既有資料為本質猜測用戶可能會問的問題，使用 zh-TW"
	user_content = f"""
	請根據 {content_text} 生成三個問題，並用 JSON 格式返回
	一定要使用 zh-TW，這非常重要！

	EXAMPLE:
	{{
	questions:
	[q1的敘述text, q2的敘述text, q3的敘述text]
	}}
	"""
	response_format = { "type": "json_object" }
	questions = generate_content_by_LLM(sys_content, user_content, response_format, LLM_model, model_name=None)
	questions_list = json.loads(questions)["questions"]
	print("=====json_response=====")
	print(questions_list)
	print("=====json_response=====")

	return questions_list

	def get_questions_answers(video_id, df_string, source="gcs", LLM_model=None):
	if source == "gcs":
	try:
	print("===get_questions_answers on gcs===")
	bucket_name = 'video_ai_assistant'
	file_name = f'{video_id}_questions_answers.json'
	blob_name = f"{video_id}/{file_name}"
	# 检查檔案是否存在
	is_questions_answers_exists = GCS_SERVICE.check_file_exists(bucket_name, blob_name)
	if not is_questions_answers_exists:
	questions_answers = generate_questions_answers(df_string, LLM_model)
	questions_answers_text = json.dumps(questions_answers, ensure_ascii=False, indent=2)
	GCS_SERVICE.upload_json_string(bucket_name, blob_name, questions_answers_text)
	print("questions_answers已上傳到GCS")
	else:
	# questions_answers已存在，下载内容
	print("questions_answers已存在于GCS中")
	questions_answers_text = GCS_SERVICE.download_as_string(bucket_name, blob_name)
	questions_answers = json.loads(questions_answers_text)
	except Exception as e:
	print(f"Error getting questions_answers: {str(e)}")
	questions_list = get_questions(video_id, df_string, source, LLM_model)
	questions_answers = [{"question": q, "answer": ""} for q in questions_list]

	return questions_answers

	def generate_questions_answers(df_string, LLM_model=None):
	print("===generate_questions_answers===")
	segments = split_data(df_string, word_base=100000)
	all_content = []

	for segment in segments:
	sys_content = "你是一個擅長資料分析跟影片教學的老師，user 為學生，請精讀資料文本，自行判斷資料的種類，使用 zh-TW"
	user_content = f"""
	請根據 {segment} 生成三個問題跟答案，主要與學科有關，不要問跟情節故事相關的問題
	答案要在最後標示出處【參考：00:01:05】，請根據時間軸 start_time 來標示
	請確保問題跟答案都是繁體中文 zh-TW
	答案不用是標準答案，而是帶有啟發性的蘇格拉底式問答，讓學生思考本來的問題，以及該去參考的時間點
	並用 JSON 格式返回 list ，請一定要給三個問題跟答案，且要裝在一個 list 裡面
	k-v pair 的 key 是 question, value 是 answer

	EXAMPLE:
	{{
	"questions_answers":
	[
	{{question: q1的敘述text, answer: q1的答案text【參考：00:01:05】}},
	{{question: q2的敘述text, answer: q2的答案text【參考：00:32:05】}},
	{{question: q3的敘述text, answer: q3的答案text【參考：01:03:35】}}
	]
	}}
	"""
	response_format = { "type": "json_object" }
	content = generate_content_by_LLM(sys_content, user_content, response_format, LLM_model, model_name=None)
	content_json = json.loads(content)["questions_answers"]
	all_content += content_json

	print("=====all_content=====")
	print(all_content)
	print("=====all_content=====")

	return all_content

	def change_questions(password, df_string):
	verify_password(password)

	questions = generate_questions(df_string)
	q1 = questions[0] if len(questions) > 0 else ""
	q2 = questions[1] if len(questions) > 1 else ""
	q3 = questions[2] if len(questions) > 2 else ""
	print("=====get_questions=====")
	print(f"q1: {q1}")
	print(f"q2: {q2}")
	print(f"q3: {q3}")
	print("=====get_questions=====")
	return q1, q2, q3

	def get_key_moments(video_id, formatted_simple_transcript, formatted_transcript, source, LLM_model=None):
	if source == "gcs":
	print("===get_key_moments on gcs===")
	bucket_name = 'video_ai_assistant'
	file_name = f'{video_id}_key_moments.json'
	blob_name = f"{video_id}/{file_name}"
	# 检查檔案是否存在
	is_key_moments_exists = GCS_SERVICE.check_file_exists(bucket_name, blob_name)
	if not is_key_moments_exists:
	key_moments = generate_key_moments(formatted_simple_transcript, formatted_transcript, LLM_model)
	key_moments_json = {"key_moments": key_moments}
	key_moments_text = json.dumps(key_moments_json, ensure_ascii=False, indent=2)
	GCS_SERVICE.upload_json_string(bucket_name, blob_name, key_moments_text)
	print("key_moments已上傳到GCS")
	else:
	# key_moments已存在，下载内容
	print("key_moments已存在于GCS中")
	key_moments_text = GCS_SERVICE.download_as_string(bucket_name, blob_name)
	key_moments_json = json.loads(key_moments_text)
	# 檢查 key_moments 是否有 keywords
	print("===檢查 key_moments 是否有 keywords===")
	has_keywords_added = False
	for key_moment in key_moments_json["key_moments"]:
	if "keywords" not in key_moment:
	transcript = key_moment["transcript"]
	key_moment["keywords"] = generate_key_moments_keywords(transcript, LLM_model)
	print("===keywords===")
	print(key_moment["keywords"])
	print("===keywords===")
	has_keywords_added = True
	if has_keywords_added:
	key_moments_text = json.dumps(key_moments_json, ensure_ascii=False, indent=2)
	GCS_SERVICE.upload_json_string(bucket_name, blob_name, key_moments_text)
	key_moments_text = GCS_SERVICE.download_as_string(bucket_name, blob_name)
	key_moments_json = json.loads(key_moments_text)
	# 檢查 key_moments 是否有 suggested_images
	print("===檢查 key_moments 是否有 suggested_images===")
	has_suggested_images_added = False
	for key_moment in key_moments_json["key_moments"]:
	if "suggested_images" not in key_moment:
	key_moment["suggested_images"] = generate_key_moments_suggested_images(key_moment)
	has_suggested_images_added = True
	if has_suggested_images_added:
	key_moments_text = json.dumps(key_moments_json, ensure_ascii=False, indent=2)
	GCS_SERVICE.upload_json_string(bucket_name, blob_name, key_moments_text)
	key_moments_text = GCS_SERVICE.download_as_string(bucket_name, blob_name)
	key_moments_json = json.loads(key_moments_text)

	elif source == "drive":
	print("===get_key_moments on drive===")
	service = init_drive_service()
	parent_folder_id = '1GgI4YVs0KckwStVQkLa1NZ8IpaEMurkL'
	folder_id = create_folder_if_not_exists(service, video_id, parent_folder_id)
	file_name = f'{video_id}_key_moments.json'

	# 检查檔案是否存在
	exists, file_id = check_file_exists(service, folder_id, file_name)
	if not exists:
	key_moments = generate_key_moments(formatted_simple_transcript, formatted_transcript, LLM_model)
	key_moments_json = {"key_moments": key_moments}
	key_moments_text = json.dumps(key_moments_json, ensure_ascii=False, indent=2)
	upload_content_directly(service, file_name, folder_id, key_moments_text)
	print("key_moments已上傳到Google Drive")
	else:
	# key_moments已存在，下载内容
	print("key_moments已存在于Google Drive中")
	key_moments_text = download_file_as_string(service, file_id)
	key_moments_json = json.loads(key_moments_text)

	return key_moments_json

	def generate_key_moments(formatted_simple_transcript, formatted_transcript, LLM_model=None):
	print("===generate_key_moments===")
	segments = split_data(formatted_simple_transcript, word_base=100000)
	all_content = []

	for segment in segments:
	sys_content = "你是一個擅長資料分析跟影片教學的老師，user 為學生，請精讀資料文本，自行判斷資料的種類，使用 zh-TW"
	user_content = f"""
	# 文本：{segment}

	# Rule
	1. 請根據文本，提取出 5~8 段重點摘要，並給出對應的時間軸，每一段重點的時間軸範圍大於1分鐘，但小於 1/3 總逐字稿長度
	2. 內容當中，如果有列舉方法、模式或是工具，就用 bulletpoint 或是編號方式列出，並在列舉部分的頭尾用[]匡列（example: FAANG 是以下五間公司： [1. A公司 2.B公司 3.C公司 4.D公司 5.E公司 ]，...）
	3. 注意不要遺漏任何一段時間軸的內容從零秒開始，以這種方式分析整個文本，從零秒開始分析，直到結束。這很重要
	4. 結尾的時間如果有總結性的話，也要擷取
	5. 如果頭尾的情節不是重點，特別是打招呼或是介紹自己是誰、或是finally say goodbye 就是不重要的情節，就不用擷取
	6. 關鍵字從transcript extract to keyword，保留專家名字、專業術語、年份、數字、期刊名稱、地名、數學公式
	7. 最後再檢查一遍，text, keywords please use or transfer to zh-TW, it's very important

	# restrictions
	1. 請一定要用 zh-TW，這非常重要！
	2. 如果是疑似主播、主持人的圖片場景，且沒有任何有用的資訊，請不要選取
	3. 如果頭尾的情節不是重點，特別是打招呼或是介紹自己是誰、或是finally say goodbye 就是不重要的情節，就不用擷取
	4. 時間軸請取到秒數，不要只取到分鐘數，這很重要

	Example: retrun JSON
	{{key_moments:[{{
	"start": "00:00",
	"end": "01:35",
	"text": "逐字稿的重點摘要",
	"keywords": ["關鍵字", "關鍵字"]
	}}]
	}}
	"""
	response_format = { "type": "json_object" }
	content = generate_content_by_LLM(sys_content, user_content, response_format, LLM_model, model_name=None)
	key_moments = json.loads(content)["key_moments"]

	# "transcript": get text from formatted_simple_transcript
	for moment in key_moments:
	start_time = parse_time(moment['start'])
	end_time = parse_time(moment['end'])
	# 使用轉換後的 timedelta 物件進行時間
	moment['transcript'] = "，".join([entry['text'] for entry in formatted_simple_transcript
	if start_time <= parse_time(entry['start_time']) <= end_time])

	print("=====key_moments=====")
	print(key_moments)
	print("=====key_moments=====")
	image_links = {entry['start_time']: entry['screenshot_path'] for entry in formatted_transcript}

	for moment in key_moments:
	start_time = parse_time(moment['start'])
	end_time = parse_time(moment['end'])
	# 使用轉換後的 timedelta 物件進行時間比較
	moment_images = [image_links[time] for time in image_links
	if start_time <= parse_time(time) <= end_time]
	moment['images'] = moment_images

	# 檢查是否有 suggested_images
	if "suggested_images" not in moment:
	moment["suggested_images"] = generate_key_moments_suggested_images(moment, LLM_model)
	print("===moment_suggested_images===")
	print(moment["suggested_images"])
	print("===moment_suggested_images===")

	all_content += key_moments

	return all_content

	def generate_key_moments_keywords(transcript, LLM_model=None):
	print("===generate_key_moments_keywords===")
	segments = split_data(transcript, word_base=100000)
	all_content = []

	for segment in segments:
	sys_content = "你是一個擅長資料分析跟影片教學的老師，user 為學生，請精讀資料文本，自行判斷資料的種類，使用 zh-TW"
	user_content = f"""
	transcript extract to keyword
	保留專家名字、專業術語、年份、數字、期刊名稱、地名、數學公式、數學表示式、物理化學符號，
	不用給上下文，直接給出關鍵字，使用 zh-TW，用逗號分隔， example: 關鍵字1, 關鍵字2
	transcript：{segment}
	"""
	content = generate_content_by_LLM(sys_content, user_content, response_format=None, LLM_model=LLM_model, model_name=None)
	keywords = content.strip().split(",")
	all_content += keywords

	return all_content

	def generate_key_moments_suggested_images(key_moment, LLM_model=None):
	# Prepare the text and keywords
	text = key_moment["text"]
	keywords = ', '.join(key_moment["keywords"])
	images = key_moment["images"]

	images_list_prompt = ""
	for i, image_url in enumerate(images):
	images_list_prompt += f"\n圖片 {i+1}: {image_url}"

	# Prepare the user prompt with text and keywords
	sys_content = "你是一個擅長資料分析跟影片教學的老師，user 為學生，請精讀資料文本，自行判斷資料的種類，使用 zh-TW"
	user_content = f"""
	- 文本: {text}
	- 關鍵字: {keywords}

	# Rule:
	1. 保留有圖表或是數據的圖片
	2. 根據文本和關鍵字，選擇出最合適的圖片。
	3. 總是保留最後一張，除非他是一張空白圖片，或是一張沒有任何內容的圖片

	# Restrictions:
	1. 如果是疑似主播、主持人的圖片場景，且沒有任何有用的資訊，請不要選取，這很重要
	2. 不要有相似或是概念重複的圖片
	3. 移除整張圖片是黑色、藍色或是白色的圖片
	4. 移除沒有任何內容的圖片
	5. 不需要理會字幕的差益，只需要看圖片的內容

	請根據這些信息，圖片列表如下:
	{images_list_prompt}

	回傳 JSON LIST 就好，不用回傳任何敘述脈絡，也不要 ```json 包覆
	EXAMPLE:
	{{
	"suggested_images": ["圖片1的 image_url", "圖片2 的 image_url", "圖片3的 image_url"]
	}}
	"""

	response_format = { "type": "json_object" }
	response = generate_content_by_LLM(sys_content, user_content, response_format, LLM_model, model_name=None)
	print("===generate_key_moments_suggested_images===")
	print(response)
	print("===generate_key_moments_suggested_images===")
	suggested_images = json.loads(response)["suggested_images"]

	return suggested_images

	def get_key_moments_html(key_moments):
	css = """
	<style>
	#gallery-main {
	display: flex;
	align-items: center;
	margin-bottom: 20px;
	}

	#gallery {
	position: relative;
	width: 50%;
	flex: 1;
	}

	#text-content {
	flex: 2;
	margin-left: 20px;
	}


	#gallery #gallery-container{
	position: relative;
	width: 100%;
	height: 0px;
	padding-bottom: 56.7%; /* 16/9 ratio */
	background-color: blue;
	}
	#gallery #gallery-container #gallery-content{
	position: absolute;
	top: 0px;
	right: 0px;
	bottom: 0px;
	left: 0px;
	height: 100%;
	display: flex;
	scroll-snap-type: x mandatory;
	overflow-x: scroll;
	scroll-behavior: smooth;
	}
	#gallery #gallery-container #gallery-content .gallery__item{
	width: 100%;
	height: 100%;
	flex-shrink: 0;
	scroll-snap-align: start;
	scroll-snap-stop: always;
	position: relative;
	}
	#gallery #gallery-container #gallery-content .gallery__item img{
	display: block;
	width: 100%;
	height: 100%;
	object-fit: contain;
	background-color: white;
	}

	.click-zone{
	position: absolute;
	width: 20%;
	height: 100%;
	z-index: 3;
	}
	.click-zone.click-zone-prev{
	left: 0px;
	}
	.click-zone.click-zone-next{
	right: 0px;
	}
	#gallery:not(:hover) .arrow{
	opacity: 0.8;
	}
	.arrow{
	text-align: center;
	z-index: 3;
	position: absolute;
	display: block;
	width: 25px;
	height: 25px;
	line-height: 25px;
	background-color: black;
	border-radius: 50%;
	text-decoration: none;
	color: white !important;
	opacity: 0.8;
	transition: opacity 200ms ease;
	}
	.arrow:hover{
	opacity: 1;
	}
	.arrow span{
	position: relative;
	top: 2px;
	}
	.arrow.arrow-prev{
	top: 50%;
	left: 5px;
	}
	.arrow.arrow-next{
	top: 50%;
	right: 5px;
	}
	.arrow.arrow-disabled{
	opacity:0.8;
	}

	#text-content {
	padding: 0px 36px;
	}
	#text-content p {
	margin-top: 10px;
	}

	body{
	font-family: sans-serif;
	margin: 0px;
	padding: 0px;
	}
	main{
	padding: 0px;
	margin: 0px;
	max-width: 900px;
	margin: auto;
	}
	.hidden{
	border: 0;
	clip: rect(0 0 0 0);
	height: 1px;
	margin: -1px;
	overflow: hidden;
	padding: 0;
	position: absolute;
	width: 1px;
	}
	.keyword-label {
	display: inline-block;
	padding: 5px 10px;
	margin: 2px;
	border: 2px solid black;
	border-radius: 5px;
	font-size: 0.9em;
	}
	details {
	border-radius: 5px;
	padding: 10px;
	border: 2px solid black;
	}

	summary {
	font-weight: bold;
	cursor: pointer;
	outline: none;
	}

	summary::-webkit-details-marker {
	display: none;
	}

	@media (max-width: 768px) {
	#gallery-main {
	flex-direction: column; /* 在小屏幕上堆叠元素 */
	}

	#gallery {
	width: 100%; /* 让画廊占满整个容器宽度 */
	}

	#text-content {
	margin-left: 0; /* 移除左边距，让文本内容占满宽度 */
	margin-top: 20px; /* 为文本内容添加顶部间距 */
	}

	#gallery #gallery-container {
	height: 350px; /* 或者你可以设置一个固定的高度，而不是用 padding-bottom */
	padding-bottom: 0; /* 移除底部填充 */
	}
	}
	</style>
	"""

	key_moments_html = css

	for i, moment in enumerate(key_moments):
	# if "suggested_images" in moment:
	# images = moment['suggested_images']
	# else:
	# images = moment['images']
	# image_elements = ""

	# for j, image in enumerate(images):
	# current_id = f"img_{i}_{j}"
	# prev_id = f"img_{i}_{j-1}" if j-1 >= 0 else f"img_{i}_{len(images)-1}"
	# next_id = f"img_{i}_{j+1}" if j+1 < len(images) else f"img_{i}_0"

	# image_elements += f"""
	# <div id="{current_id}" class="gallery__item">
	# <a href="#{prev_id}" class="click-zone click-zone-prev">
	# <div class="arrow arrow-disabled arrow-prev"> ◀︎ </div>
	# </a>
	# <a href="#{next_id}" class="click-zone click-zone-next">
	# <div class="arrow arrow-next"> ▶︎ </div>
	# </a>
	# <img src="{image}">
	# </div>
	# """

	# gallery_content = f"""
	# <div id="gallery-content">
	# {image_elements}
	# </div>
	# """

	keywords_html = ' '.join([f'<span class="keyword-label">{keyword}</span>' for keyword in moment['keywords']])


	key_moments_html += f"""
	<div class="gallery-container" id="gallery-main">
	<div id="text-content">
	<h3>{moment['start']} - {moment['end']}</h3>
	<p><strong>摘要: {moment['text']} </strong></p>
	<details>
	<summary>逐字稿</summary>
	<p><strong>內容: </strong> {moment['transcript']} </p>
	</details>
	<p><strong>關鍵字:</strong> {keywords_html}</p>
	</div>
	</div>
	"""

	return key_moments_html

	# ---- LLM CRUD ----
	def get_LLM_content(video_id, kind):
	print(f"===get_{kind}===")
	gcs_client = GCS_CLIENT
	bucket_name = 'video_ai_assistant'
	file_name = f'{video_id}_{kind}.json'
	blob_name = f"{video_id}/{file_name}"
	# 检查 file 是否存在
	is_file_exists = GCS_SERVICE.check_file_exists(bucket_name, blob_name)
	if is_file_exists:
	content = GCS_SERVICE.download_as_string(bucket_name, blob_name)
	content_json = json.loads(content)
	if kind == "reading_passage_latex":
	content_text = content_json["reading_passage"]
	elif kind == "summary_markdown":
	content_text = content_json["summary"]
	elif kind == "key_moments":
	content_text = content_json["key_moments"]
	content_text = json.dumps(content_text, ensure_ascii=False, indent=2)
	else:
	content_text = json.dumps(content_json, ensure_ascii=False, indent=2)
	else:
	content_text = ""
	return content_text

	def enable_edit_mode():
	return gr.update(interactive=True)

	def delete_LLM_content(video_id, kind):
	print(f"===delete_{kind}===")
	gcs_client = GCS_CLIENT
	bucket_name = 'video_ai_assistant'
	file_name = f'{video_id}_{kind}.json'
	blob_name = f"{video_id}/{file_name}"
	# 检查 file 是否存在
	is_file_exists = GCS_SERVICE.check_file_exists(bucket_name, blob_name)
	if is_file_exists:
	GCS_SERVICE.delete_blob(bucket_name, blob_name)
	print(f"{file_name}已从GCS中删除")
	return gr.update(value="", interactive=False)

	def update_LLM_content(video_id, new_content, kind):
	print(f"===upfdate kind on gcs===")
	bucket_name = 'video_ai_assistant'
	file_name = f'{video_id}_{kind}.json'
	blob_name = f"{video_id}/{file_name}"

	if kind == "reading_passage_latex":
	print("=========reading_passage=======")
	print(new_content)
	reading_passage_json = {"reading_passage": str(new_content)}
	reading_passage_text = json.dumps(reading_passage_json, ensure_ascii=False, indent=2)
	GCS_SERVICE.upload_json_string(bucket_name, blob_name, reading_passage_text)
	updated_content = new_content
	elif kind == "summary_markdown":
	summary_json = {"summary": str(new_content)}
	summary_text = json.dumps(summary_json, ensure_ascii=False, indent=2)
	GCS_SERVICE.upload_json_string(bucket_name, blob_name, summary_text)
	updated_content = new_content
	elif kind == "mind_map":
	mind_map_json = {"mind_map": str(new_content)}
	mind_map_text = json.dumps(mind_map_json, ensure_ascii=False, indent=2)
	GCS_SERVICE.upload_json_string(bucket_name, blob_name, mind_map_text)
	updated_content = mind_map_text
	elif kind == "key_moments":
	# from update_LLM_btn -> new_content is a string
	# create_LLM_content -> new_content is a list
	if isinstance(new_content, str):
	key_moments_list = json.loads(new_content)
	else:
	key_moments_list = new_content
	key_moments_json = {"key_moments": key_moments_list}
	key_moments_json_text = json.dumps(key_moments_json, ensure_ascii=False, indent=2)
	GCS_SERVICE.upload_json_string(bucket_name, blob_name, key_moments_json_text)
	key_moments_text = json.dumps(key_moments_list, ensure_ascii=False, indent=2)
	updated_content = key_moments_text
	elif kind == "transcript":
	if isinstance(new_content, str):
	transcript_json = json.loads(new_content)
	else:
	transcript_json = new_content
	transcript_text = json.dumps(transcript_json, ensure_ascii=False, indent=2)
	GCS_SERVICE.upload_json_string(bucket_name, blob_name, transcript_text)
	updated_content = transcript_text
	elif kind == "questions":
	# from update_LLM_btn -> new_content is a string
	# create_LLM_content -> new_content is a list
	if isinstance(new_content, str):
	questions_json = json.loads(new_content)
	else:
	questions_json = new_content
	questions_text = json.dumps(questions_json, ensure_ascii=False, indent=2)
	GCS_SERVICE.upload_json_string(bucket_name, blob_name, questions_text)
	updated_content = questions_text
	elif kind == "questions_answers":
	# from update_LLM_btn -> new_content is a string
	# create_LLM_content -> new_content is a list
	if isinstance(new_content, str):
	questions_answers_json = json.loads(new_content)
	else:
	questions_answers_json = new_content
	questions_answers_text = json.dumps(questions_answers_json, ensure_ascii=False, indent=2)
	GCS_SERVICE.upload_json_string(bucket_name, blob_name, questions_answers_text)
	updated_content = questions_answers_text
	elif kind == "ai_content_list":
	if isinstance(new_content, str):
	ai_content_json = json.loads(new_content)
	else:
	ai_content_json = new_content
	ai_content_text = json.dumps(ai_content_json, ensure_ascii=False, indent=2)
	GCS_SERVICE.upload_json_string(bucket_name, blob_name, ai_content_text)
	updated_content = ai_content_text

	print(f"{kind} 已更新到GCS")
	return gr.update(value=updated_content, interactive=False)

	def create_LLM_content(video_id, df_string, kind, LLM_model=None):
	print(f"===create_{kind}===")
	print(f"video_id: {video_id}")

	if kind == "reading_passage_latex":
	content = generate_reading_passage(df_string, LLM_model)
	update_LLM_content(video_id, content, kind)
	elif kind == "summary_markdown":
	meta_data = get_meta_data(video_id)
	content = generate_summarise(df_string, meta_data, LLM_model)
	update_LLM_content(video_id, content, kind)
	elif kind == "mind_map":
	content = generate_mind_map(df_string)
	update_LLM_content(video_id, content, kind)
	elif kind == "key_moments":
	if isinstance(df_string, str):
	transcript = json.loads(df_string)
	else:
	transcript = df_string
	formatted_simple_transcript = create_formatted_simple_transcript(transcript)
	formatted_transcript = create_formatted_transcript(video_id, transcript)
	gen_content = generate_key_moments(formatted_simple_transcript, formatted_transcript, LLM_model)
	update_LLM_content(video_id, gen_content, kind)
	content = json.dumps(gen_content, ensure_ascii=False, indent=2)
	elif kind == "transcript":
	gen_content = process_transcript_and_screenshots_on_gcs(video_id)
	update_LLM_content(video_id, gen_content, kind)
	content = json.dumps(gen_content, ensure_ascii=False, indent=2)
	elif kind == "questions":
	gen_content = generate_questions(df_string, LLM_model)
	update_LLM_content(video_id, gen_content, kind)
	content = json.dumps(gen_content, ensure_ascii=False, indent=2)
	elif kind == "questions_answers":
	if isinstance(df_string, str):
	transcript = json.loads(df_string)
	else:
	transcript = df_string
	formatted_simple_transcript = create_formatted_simple_transcript(transcript)
	gen_content = generate_questions_answers(formatted_simple_transcript, LLM_model)
	update_LLM_content(video_id, gen_content, kind)
	content = json.dumps(gen_content, ensure_ascii=False, indent=2)

	return gr.update(value=content, interactive=False)

	# ---- LLM refresh CRUD ----
	def reading_passage_add_latex_version(video_id):
	# 確認 GCS 是否有 reading_passage.json
	print("===reading_passage_convert_to_latex===")
	bucket_name = 'video_ai_assistant'
	file_name = f'{video_id}_reading_passage.json'
	blob_name = f"{video_id}/{file_name}"
	print(f"blob_name: {blob_name}")

	# 检查檔案是否存在
	is_file_exists = GCS_SERVICE.check_file_exists(bucket_name, blob_name)
	if not is_file_exists:
	raise gr.Error("reading_passage 不存在!")

	# 逐字稿已存在，下载逐字稿内容
	print("reading_passage 已存在于GCS中，轉換 Latex 模式")
	reading_passage_text = GCS_SERVICE.download_as_string(bucket_name, blob_name)
	reading_passage_json = json.loads(reading_passage_text)
	original_reading_passage = reading_passage_json["reading_passage"]
	sys_content = "你是一個擅長資料分析跟影片教學的老師，user 為學生，請精讀資料文本，自行判斷資料的種類，使用 zh-TW"
	user_content = f"""
	請根據 {original_reading_passage}
	敘述中，請把數學或是專業術語，用 Latex 包覆（$...$），盡量不要去改原本的文章
	加減乘除、根號、次方、化學符號、物理符號等等的運算式口語也換成 LATEX 符號
	請一定要使用繁體中文 zh-TW，並用台灣人的口語
	產生的結果不要前後文解釋，也不要敘述這篇文章怎麼產生的
	只需要專注提供 Reading Passage，字數在 200~500 字以內
	"""
	messages = [
	{"role": "system", "content": sys_content},
	{"role": "user", "content": user_content}
	]

	request_payload = {
	"model": "gpt-4o",
	"messages": messages,
	"max_tokens": 4000,
	}

	response = OPEN_AI_CLIENT.chat.completions.create(**request_payload)
	new_reading_passage = response.choices[0].message.content.strip()
	print("=====new_reading_passage=====")
	print(new_reading_passage)
	print("=====new_reading_passage=====")
	reading_passage_json["reading_passage"] = new_reading_passage
	reading_passage_text = json.dumps(reading_passage_json, ensure_ascii=False, indent=2)
	# 另存為 reading_passage_latex.json
	new_file_name = f'{video_id}_reading_passage_latex.json'
	new_blob_name = f"{video_id}/{new_file_name}"
	GCS_SERVICE.upload_json_string(bucket_name, new_blob_name, reading_passage_text)

	return new_reading_passage

	def summary_add_markdown_version(video_id):
	# 確認 GCS 是否有 summary.json
	print("===summary_convert_to_markdown===")
	bucket_name = 'video_ai_assistant'
	file_name = f'{video_id}_summary.json'
	blob_name = f"{video_id}/{file_name}"
	print(f"blob_name: {blob_name}")

	# 检查檔案是否存在
	is_file_exists = GCS_SERVICE.check_file_exists(bucket_name, blob_name)
	if not is_file_exists:
	raise gr.Error("summary 不存在!")

	# 逐字稿已存在，下载逐字稿内容
	print("summary 已存在于GCS中，轉換 Markdown 模式")
	summary_text = GCS_SERVICE.download_as_string(bucket_name, blob_name)
	summary_json = json.loads(summary_text)
	original_summary = summary_json["summary"]
	sys_content = "你是一個擅長資料分析跟影片教學的老師，user 為學生，請精讀資料文本，自行判斷資料的種類，使用 zh-TW"
	user_content = f"""
	請根據 {original_summary}
	轉換格式為 Markdown
	只保留：📚 整體摘要、🔖 重點概念、💡 為什麼我們要學這個、❓ 延伸小問題
	其他的不要保留
	整體摘要在一百字以內
	重點概念轉成 bullet points
	以及可能的結論與結尾延伸小問題提供學生作反思
	敘述中，請把數學或是專業術語，用 Latex 包覆（$...$）
	加減乘除、根號、次方等等的運算式口語也換成 LATEX 數學符號

	整體格式為：
	## 📚 整體摘要
	- (一個 bullet point....)

	## 🔖 重點概念
	- xxx
	- xxx
	- xxx

	## 💡 為什麼我們要學這個？
	- (一個 bullet point....)

	## ❓ 延伸小問題
	- (一個 bullet point....)
	"""
	messages = [
	{"role": "system", "content": sys_content},
	{"role": "user", "content": user_content}
	]
	request_payload = {
	"model": "gpt-4o",
	"messages": messages,
	"max_tokens": 4000,
	}
	response = OPEN_AI_CLIENT.chat.completions.create(**request_payload)
	new_summary = response.choices[0].message.content.strip()
	print("=====new_summary=====")
	print(new_summary)
	print("=====new_summary=====")
	summary_json["summary"] = new_summary
	summary_text = json.dumps(summary_json, ensure_ascii=False, indent=2)
	# 另存為 summary_markdown.json
	new_file_name = f'{video_id}_summary_markdown.json'
	new_blob_name = f"{video_id}/{new_file_name}"
	GCS_SERVICE.upload_json_string(bucket_name, new_blob_name, summary_text)

	return new_summary


	# LLM 強制重刷
	def get_sheet_data(sheet_url, range_name):
	data = SHEET_SERVICE.get_sheet_data_by_url(sheet_url, range_name)
	flattened_data = SHEET_SERVICE.flatten_column_data(data)
	flattened_data_string = ', '.join(flattened_data)
	return flattened_data_string

	def update_sheet_data(sheet_url, qa_result, video_id):
	# 根據 url 找到 sheet ，根據 video_id 找到 sheet 中的 video_id 的 row number
	sheet_data = SHEET_SERVICE.get_sheet_data_by_url(sheet_url)
	# print(f"sheet_data: {sheet_data}")

	if not sheet_data or len(sheet_data) < 1:
	print("錯誤：工作表資料為空或缺少標頭列。")
	return

	header_row = sheet_data[0]
	data_rows = sheet_data[1:] # 資料列（跳過標頭）

	# 直接指定要尋找的欄位名稱
	target_column_name = '均一平台 YT Readable ID'
	target_qa_column_name = "QA" # 假設 QA 欄位的標題是 "QA"

	try:
	# 1. 找到 '均一平台 YT Readable ID' 所在的欄位索引 (column index)
	video_id_col_index = header_row.index(target_column_name)
	except ValueError:
	# 如果找不到指定的欄位名稱，印出錯誤並返回
	print(f"錯誤：在標頭列 {header_row} 中找不到指定的欄位名稱 '{target_column_name}'")
	return

	# 2. 遍歷資料列，尋找 video_id 匹配的列索引 (row index)
	target_row_index = -1 # 初始化為 -1，表示未找到
	for i, row in enumerate(data_rows):
	# 確保該列有足夠的欄位，並且該欄位的值等於 video_id
	if len(row) > video_id_col_index and row[video_id_col_index] == video_id:
	target_row_index = i + 1 # 找到匹配的列，其在原始 sheet_data 中的索引是 i + 1 (因為 data_rows 從 sheet_data[1] 開始)
	break # 找到後即可跳出迴圈

	if target_row_index != -1:
	# target_row_index 是 video_id 在 sheet_data (含標頭) 中的 0-based 索引
	# 例如，第一筆資料的 target_row_index 是 1
	actual_target_row_number = target_row_index + 1 # 這是實際的 1-based 工作表列號 (例如 2)
	print(f"找到 video_id '{video_id}' 於欄位 '{target_column_name}' 的第 {actual_target_row_number} 列 (工作表列號)")

	# --- 以下是更新邏輯 ---
	try:
	# 找到 QA 欄位的索引
	qa_col_index = header_row.index(target_qa_column_name)

	# 取得目標列的實際資料
	target_row_data = sheet_data[target_row_index]

	# 檢查目標列是否有足夠的欄位可以更新
	if len(target_row_data) > qa_col_index:
	# * 修正點：傳遞給 update_sheet_cell 的列號減 1 *
	# 因為觀察到 update_sheet_cell(N) 會更新到 N+1 列
	# 所以我們傳遞 N-1，讓它內部 +1 後剛好是 N
	row_index_to_pass = actual_target_row_number - 1 # 將 1-based 列號減 1

	# 為了 log 清晰，仍然顯示 1-based 的目標列號
	print(f"準備更新第 {actual_target_row_number} 列, 欄位 '{target_qa_column_name}' (索引 {qa_col_index}) 為 '{qa_result}'")
	# 添加一行 log 來確認傳遞的值
	print(f" (傳遞給 update_sheet_cell 的 row_index: {row_index_to_pass})")

	# --- 實際更新 Google Sheet 的程式碼 ---
	# 傳遞調整後的索引 row_index_to_pass
	SHEET_SERVICE.update_sheet_cell(sheet_url, row_index_to_pass, qa_col_index, qa_result)
	else:
	# 如果目標列的長度不足以包含 qa_col_index
	print(f"錯誤：第 {actual_target_row_number} 列 (資料長度 {len(target_row_data)}) 沒有足夠的欄位來更新 QA (需要索引 {qa_col_index})。")

	except ValueError:
	print(f"錯誤：在標頭列 {header_row} 中找不到 QA 欄位名稱 '{target_qa_column_name}'")
	# --- 更新邏輯結束 ---

	else:
	# 如果找不到 video_id，印出錯誤訊息
	print(f"錯誤：在欄位 '{target_column_name}' 中找不到 video_id '{video_id}'。")

	def refresh_video_LLM_all_content_by_sheet(sheet_url, sheet_qa_column, video_ids_input): # 參數名稱改為 video_ids_input 避免混淆
	print("=== 開始批次處理工作表刷新 ===")
	target_id_column_name = '均一平台 YT Readable ID'
	target_qa_column_name = "QA"
	sheet_qa_success_tag = "OO"
	sheet_qa_failed_tag = "XX"
	bucket_name = 'video_ai_assistant'

	# 1. 解析輸入的 video_ids
	video_ids_list = video_ids_input.replace('\n', ',').split(',')
	video_ids_list = [vid.strip() for vid in video_ids_list if vid.strip() and vid.strip() != target_id_column_name]
	print(f"準備處理的 Video IDs: {video_ids_list}")

	if not video_ids_list:
	print("沒有有效的 Video ID 需要處理。")
	return {"success_video_ids": [], "failed_video_ids": []}

	# 2. 一次性讀取工作表資料
	try:
	print(f"正在從 {sheet_url} 讀取工作表資料...")
	sheet_data = SHEET_SERVICE.get_sheet_data_by_url(sheet_url)
	if not sheet_data or len(sheet_data) < 1:
	print("錯誤：工作表資料為空或缺少標頭列。")
	return {"success_video_ids": [], "failed_video_ids": []}
	print(f"成功讀取 {len(sheet_data)} 列資料。")
	header_row = sheet_data[0]
	data_rows = sheet_data[1:]
	except Exception as e:
	print(f"讀取工作表時發生錯誤: {e}")
	return {"success_video_ids": [], "failed_video_ids": []}

	# 3. 找到目標欄位索引並建立 video_id 到 row_number 的映射
	try:
	video_id_col_index = header_row.index(target_id_column_name)
	qa_col_index = header_row.index(target_qa_column_name)
	# Google Sheet 的欄位字母 (A=0, B=1, ...)
	qa_col_letter = chr(ord('A') + qa_col_index) # <--- 使用這個變數
	print(f"'{target_id_column_name}' 欄位索引: {video_id_col_index}")
	print(f"'{target_qa_column_name}' 欄位索引: {qa_col_index} (欄位 {qa_col_letter})")

	# * 新增：嘗試取得工作表名稱 *
	sheet_name = SHEET_SERVICE.get_sheet_name_by_url(sheet_url) # 假設 SHEET_SERVICE 有此方法
	if not sheet_name:
	print("錯誤：無法從 URL 獲取工作表名稱。將無法執行即時更新。")
	# 可以選擇在這裡 return 或設定一個標誌來跳過更新
	# return {"success_video_ids": [], "failed_video_ids": list(set(video_ids_list))} # 範例：直接返回失敗
	can_update_sheet = False
	else:
	print(f"取得工作表名稱: {sheet_name}")
	can_update_sheet = True

	except ValueError as e:
	print(f"錯誤：在標頭列 {header_row} 中找不到必要的欄位: {e}")
	return {"success_video_ids": [], "failed_video_ids": []}
	except AttributeError:
	print("錯誤：SHEET_SERVICE 可能沒有 get_sheet_name_by_url 方法。請確認或實作。")
	can_update_sheet = False
	except Exception as e: # 捕捉其他可能的錯誤
	print(f"取得工作表名稱時發生未預期錯誤: {e}")
	can_update_sheet = False

	video_id_to_row_map = {}
	for i, row in enumerate(data_rows):
	if len(row) > video_id_col_index and row[video_id_col_index]:
	# 儲存 1-based 的工作表列號
	video_id_to_row_map[row[video_id_col_index]] = i + 2 # 資料列從第 2 列開始 (1-based)

	# 4. 批次檢查 GCS 並分類
	ids_to_set_oo_phase1 = [] # (video_id, row_number)
	ids_to_refresh = [] # video_id
	processed_ids = set() # 追蹤已處理的ID，避免重複
	successfully_refreshed_ids = [] # <--- 移到這裡初始化
	failed_refresh_ids = [] # <--- 移到這裡初始化

	print("開始檢查 GCS 檔案狀態...")
	for video_id in video_ids_list:
	if video_id in processed_ids:
	continue
	processed_ids.add(video_id)

	if video_id not in video_id_to_row_map:
	print(f"警告：輸入的 video_id '{video_id}' 在工作表的 '{target_id_column_name}' 欄位中找不到，將跳過。")
	continue

	row_number = video_id_to_row_map[video_id]
	file_name = f'{video_id}_transcript.json'
	blob_name = f"{video_id}/{file_name}"
	try:
	is_file_exists = GCS_SERVICE.check_file_exists(bucket_name, blob_name)
	if is_file_exists:
	print(f" - {video_id} (第 {row_number} 列): GCS 檔案存在，標記為 OO。")
	ids_to_set_oo_phase1.append((video_id, row_number))
	else:
	print(f" - {video_id} (第 {row_number} 列): GCS 檔案不存在，需要刷新。")
	ids_to_refresh.append(video_id)
	except Exception as e:
	print(f"檢查 GCS 檔案 {blob_name} 時發生錯誤: {e}，將嘗試刷新。")
	ids_to_refresh.append(video_id) # 如果檢查出錯，也歸類為需要刷新

	# 5. 批次更新 "OO" (Phase 1: GCS 已存在)
	if ids_to_set_oo_phase1 and can_update_sheet: # <--- 加上 can_update_sheet 檢查
	print(f"\n準備批次更新 {len(ids_to_set_oo_phase1)} 個 Video ID 的 QA 為 '{sheet_qa_success_tag}' (GCS 已存在)...")
	update_data_oo1 = []
	# sheet_name = SHEET_SERVICE.get_sheet_name_by_url(sheet_url) # 已在前面取得
	# if not sheet_name:
	# print("錯誤：無法獲取工作表名稱，無法執行批次更新。")
	# else:
	for vid, row_num in ids_to_set_oo_phase1:
	update_data_oo1.append({
	'range': f"{sheet_name}!{qa_col_letter}{row_num}", # <--- 使用 sheet_name 和 qa_col_letter
	'values': [[sheet_qa_success_tag]] # Google API batchUpdate 通常需要二維列表
	})
	if update_data_oo1: # 確保列表不是空的
	try:
	# * 假設 SHEET_SERVICE.batch_update_cells 存在 *
	# * 注意：確認 batch_update_cells 的 value 格式是否需要 [[value]] *
	SHEET_SERVICE.batch_update_cells(sheet_url, update_data_oo1)
	print(f"成功批次更新 {len(update_data_oo1)} 個儲存格為 '{sheet_qa_success_tag}'。")
	except Exception as e:
	print(f"批次更新 QA 為 '{sheet_qa_success_tag}' 時發生錯誤: {e}")
	# 這裡可以考慮是否要將這些 ID 移到失敗列表
	elif ids_to_set_oo_phase1 and not can_update_sheet:
	print(f"\n警告：無法取得工作表名稱，跳過批次更新 {len(ids_to_set_oo_phase1)} 個 GCS 已存在的狀態。")

	# 6. 逐一處理需要刷新的 Video ID，並即時更新 Sheet 狀態
	if ids_to_refresh:
	print(f"\n開始處理 {len(ids_to_refresh)} 個需要刷新的 Video ID (即時更新 Sheet)...")
	# successfully_refreshed_ids = [] # <--- 從這裡移除
	# failed_refresh_ids = [] # <--- 從這裡移除
	# 這個迴圈負責執行刷新，並在每次完成後立即更新 Sheet
	for video_id in ids_to_refresh:
	row_number = video_id_to_row_map[video_id] # 必定存在，前面已檢查 (1-based sheet row number)
	print(f" 正在刷新 {video_id} (第 {row_number} 列)...")
	current_status_tag = sheet_qa_failed_tag # 預設失敗
	try:
	refresh_video_LLM_all_content_by_id(video_id)
	print(f" - {video_id} 刷新成功。")
	successfully_refreshed_ids.append((video_id, row_number)) # 仍然記錄成功，以備後續統計
	current_status_tag = sheet_qa_success_tag # 設為成功
	time.sleep(1) # 避免過於頻繁觸發其他 API (例如 GCS 刪除/上傳)
	except Exception as e:
	print(f" - {video_id} 刷新失敗: {str(e)}")
	failed_refresh_ids.append((video_id, row_number)) # 仍然記錄失敗，以備後續統計
	current_status_tag = sheet_qa_failed_tag # 確認是失敗
	time.sleep(5) # 失敗時稍作停頓
	finally:
	# 無論成功或失敗，都嘗試更新該行的狀態 (如果可以更新 Sheet)
	if can_update_sheet: # <--- 加上 can_update_sheet 檢查
	try:
	# * 使用 update_sheet_cell 更新單一儲存格 *
	# row_number 是 1-based 的實際列號
	# update_sheet_cell 需要 0-based 的索引，所以傳遞 row_number - 1
	target_row_index = row_number - 1
	print(f" - 更新 Sheet 第 {row_number} 列, 欄位索引 {qa_col_index} 狀態為 '{current_status_tag}'...")

	# 呼叫 update_sheet_cell
	update_success = SHEET_SERVICE.update_sheet_cell(
	sheet_url=sheet_url,
	target_row_index_in_data=target_row_index, # 傳遞 0-based 索引
	qa_col_index=qa_col_index, # 傳遞 0-based 索引
	qa_result=current_status_tag # 傳遞要寫入的值
	)

	if update_success:
	print(f" - 第 {row_number} 列狀態更新成功。")
	else:
	# update_sheet_cell 內部已經記錄了錯誤，這裡可以選擇性地再記錄一次
	print(f" - !! 更新 Sheet 第 {row_number} 列狀態失敗 (詳見先前日誌)。")

	except Exception as update_e:
	# 捕獲呼叫 update_sheet_cell 本身可能發生的意外錯誤
	print(f" - !! 呼叫 update_sheet_cell 時發生未預期錯誤: {str(update_e)}")
	# 即使更新 Sheet 失敗，也要記錄下來
	else:
	print(f" - 無法取得工作表名稱，跳過更新 Sheet 第 {row_number} 列狀態。")

	# 7. 整理最終結果 (移除舊的批次更新邏輯)
	print("\n=== 批次處理完成 ===")
	# 現在這兩行應該總是安全的，因為 successfully_refreshed_ids 和 failed_refresh_ids 至少是 []
	final_success_ids = [item[0] for item in ids_to_set_oo_phase1] + [item[0] for item in successfully_refreshed_ids]
	final_failed_ids = [item[0] for item in failed_refresh_ids]
	# 將在工作表中找不到的 ID 也視為失敗
	initial_not_found = [vid for vid in video_ids_list if vid not in video_id_to_row_map]
	final_failed_ids.extend(initial_not_found)

	print(f"成功處理 (或 GCS 已存在): {len(final_success_ids)} 個")
	print(f"處理失敗 (或未找到/刷新失敗): {len(final_failed_ids)} 個")

	result = {
	"success_video_ids": final_success_ids,
	"failed_video_ids": list(set(final_failed_ids)) # 去重
	}
	return result

	def refresh_video_LLM_all_content_by_id(video_id):
	print(f"===refresh_all_LLM_content===")
	print(f"video_id: {video_id}")
	print(f"===delete_blobs_by_folder_name: {video_id}===")
	bucket_name = 'video_ai_assistant'
	GCS_SERVICE.delete_blobs_by_folder_name(bucket_name, video_id)
	print(f"所有以 {video_id} 開頭的檔案已刪除")

	# process_youtube_link
	video_link = f"https://www.youtube.com/watch?v={video_id}"
	process_youtube_link(PASSWORD, video_link)

	def refresh_video_LLM_all_content_by_ids(video_ids):
	# 輸入影片 id，以 , 逗號分隔或是 \n 換行
	video_id_list = video_ids.replace('\n', ',').split(',')
	video_id_list = [vid.strip() for vid in video_id_list if vid.strip()]

	success_video_ids = []
	failed_video_ids = []

	for video_id in video_id_list:
	try:
	refresh_video_LLM_all_content_by_id(video_id)
	success_video_ids.append(video_id)
	except Exception as e:
	print(f"===refresh_all_LLM_content error===")
	print(f"video_id: {video_id}")
	print(f"error: {str(e)}")
	print(f"===refresh_all_LLM_content error===")
	failed_video_ids.append(video_id)

	result = {
	"success_video_ids": success_video_ids,
	"failed_video_ids": failed_video_ids
	}
	return result



	# AI 生成教學素材
	def get_meta_data(video_id, source="gcs"):
	if source == "gcs":
	print("===get_meta_data on gcs===")
	gcs_client = GCS_CLIENT
	bucket_name = 'video_ai_assistant'
	file_name = f'{video_id}_meta_data.json'
	blob_name = f"{video_id}/{file_name}"
	# 检查檔案是否存在
	is_file_exists = GCS_SERVICE.check_file_exists(bucket_name, blob_name)
	if not is_file_exists:
	meta_data_json = {
	"subject": "",
	"grade": "",
	}
	print("meta_data empty return")
	else:
	# meta_data已存在，下载内容
	print("meta_data已存在于GCS中")
	meta_data_text = GCS_SERVICE.download_as_string(bucket_name, blob_name)
	meta_data_json = json.loads(meta_data_text)

	# meta_data_json grade 數字轉換成文字
	grade = meta_data_json["grade"]
	case = {
	1: "一年級",
	2: "二年級",
	3: "三年級",
	4: "四年級",
	5: "五年級",
	6: "六年級",
	7: "七年級",
	8: "八年級",
	9: "九年級",
	10: "十年級",
	11: "十一年級",
	12: "十二年級",
	}
	grade_text = case.get(grade, "")
	meta_data_json["grade"] = grade_text

	return meta_data_json

	def get_ai_content(password, user_data, video_id, df_string, topic, grade, level, specific_feature, content_type, source="gcs"):
	verify_password(password)
	if source == "gcs":
	print("===get_ai_content on gcs===")
	bucket_name = 'video_ai_assistant'
	file_name = f'{video_id}_ai_content_list.json'
	blob_name = f"{video_id}/{file_name}"
	# 检查檔案是否存在
	is_file_exists = GCS_SERVICE.check_file_exists(bucket_name, blob_name)
	if not is_file_exists:
	# 先建立一個 ai_content_list.json
	ai_content_list = []
	ai_content_text = json.dumps(ai_content_list, ensure_ascii=False, indent=2)
	GCS_SERVICE.upload_json_string(bucket_name, blob_name, ai_content_text)
	print("ai_content_list [] 已上傳到GCS")

	# 此時 ai_content_list 已存在
	ai_content_list_string = GCS_SERVICE.download_as_string(bucket_name, blob_name)
	ai_content_list = json.loads(ai_content_list_string)
	# by key 找到 ai_content （topic, grade, level, specific_feature, content_type）
	target_kvs = {
	"video_id": video_id,
	"level": level,
	"specific_feature": specific_feature,
	"content_type": content_type
	}
	ai_content_json = [
	item for item in ai_content_list
	if all(item[k] == v for k, v in target_kvs.items())
	]

	if len(ai_content_json) == 0:
	ai_content, prompt = generate_ai_content(password, df_string, topic, grade, level, specific_feature, content_type)
	ai_content_json = {
	"video_id": video_id,
	"content": str(ai_content),
	"prompt": prompt,
	"level": level,
	"specific_feature": specific_feature,
	"content_type": content_type
	}

	ai_content_list.append(ai_content_json)
	ai_content_text = json.dumps(ai_content_list, ensure_ascii=False, indent=2)
	GCS_SERVICE.upload_json_string(bucket_name, blob_name, ai_content_text)
	print("ai_content已上傳到GCS")

	# insert_log_to_bigquery usage
	data_endpoint = "chat_completions"

	else:
	ai_content_json = ai_content_json[-1]
	ai_content = ai_content_json["content"]
	prompt = ai_content_json["prompt"]
	# insert_log_to_bigquery usage
	data_endpoint = "gcs"

	# send data to GBQ
	user_id = user_data
	route = "get_ai_content"
	endpoint = data_endpoint
	event_response = {"event_response": str(ai_content)}
	event_response_json = json.dumps(event_response)
	prompt = ai_content_json
	prompt_json = json.dumps(prompt)
	feature = content_type
	insert_log_to_bigquery(user_id, route, endpoint, event_response_json, prompt_json, feature)

	return ai_content, ai_content, prompt, prompt

	def generate_ai_content(password, df_string, topic, grade, level, specific_feature, content_type):
	verify_password(password)
	material = EducationalMaterial(df_string, topic, grade, level, specific_feature, content_type)
	prompt = material.generate_content_prompt()
	try:
	ai_content = material.get_ai_content(OPEN_AI_CLIENT, ai_type="openai")
	except Exception as e:
	error_msg = f" {video_id} OPEN AI 生成教學素材錯誤: {str(e)}"
	print("===generate_ai_content error===")
	print(error_msg)
	print("===generate_ai_content error===")
	ai_content = material.get_ai_content(BEDROCK_CLIENT, ai_type="bedrock")

	return ai_content, prompt

	def generate_ai_content_fine_tune_result(password, user_data, exam_result_prompt , df_string_output, exam_result, exam_result_fine_tune_prompt, content_type):
	verify_password(password)
	material = EducationalMaterial(df_string_output, "", "", "", "", "")
	try:
	fine_tuned_ai_content = material.get_fine_tuned_ai_content(OPEN_AI_CLIENT, "openai", exam_result_prompt, exam_result, exam_result_fine_tune_prompt)
	except:
	fine_tuned_ai_content = material.get_fine_tuned_ai_content(BEDROCK_CLIENT, "bedrock", exam_result_prompt, exam_result, exam_result_fine_tune_prompt)

	# send data to GBQ
	user_id = user_data
	route = "generate_ai_content_fine_tune_result"
	endpoint = "chat_completions"
	event_response = {"event_response": str(fine_tuned_ai_content)}
	event_response_json = json.dumps(event_response)
	prompt = {
	"exam_result_prompt": exam_result_prompt,
	"exam_result_fine_tune_prompt": exam_result_fine_tune_prompt
	}
	prompt_json = json.dumps(prompt)
	feature = content_type
	insert_log_to_bigquery(user_id, route, endpoint, event_response_json, prompt_json, feature)

	return fine_tuned_ai_content

	def return_original_exam_result(exam_result_original):
	return exam_result_original

	def create_word(content):
	unique_filename = str(uuid.uuid4())
	word_file_path = f"/tmp/{unique_filename}.docx"
	doc = Document()
	doc.add_paragraph(content)
	doc.save(word_file_path)
	return word_file_path

	def download_exam_result(content):
	word_path = create_word(content)
	return word_path

	# ---- Chatbot ----
	def get_instructions(content_subject, content_grade, transcript_text, key_moments, socratic_mode=True):
	if socratic_mode:
	method = "Socratic style, guide thinking, no direct answers. this is very important, please be seriously following."
	else:
	method = "direct answers, but encourage user to think more."

	instructions = f"""
	subject: {content_subject}
	grade: {content_grade}
	context: {key_moments}
	transcript_text: {transcript_text}
	Assistant Role: you are a {content_subject} assistant. you can call yourself as {content_subject} 學伴 and your name if you know
	User Role: {content_grade} th-grade student.
	Method: {method}
	Language: Traditional Chinese ZH-TW (it's very important), suitable for {content_grade} th-grade level.
	Strategy:
	- You are a professional tutor, and you will use the following teaching strategies based on the textbook content.
	# General Strategies
	Needs Analysis:
	The tutor/assistant teacher should be able to conduct dynamic needs analysis based on the student's responses. Use questions to understand the student's needs and difficulties.
	Example questions: "What do you want to learn today?" or "What difficulties are you encountering in this part of the content?"

	Dynamic Goal Setting:
	Set learning goals based on student feedback, which can be short-term or long-term. The tutor/assistant teacher can adjust the plan automatically according to the student's progress.
	Example questions: "What is our goal for this week?" or "What tasks do you hope to complete today?"

	Flexible Teaching Methods:
	Provide different teaching methods and resources based on the student's age and learning style. The tutor/assistant teacher can adjust teaching strategies based on student feedback.
	Example questions: "Do you prefer learning through videos or reading materials?" or "We can understand this problem through examples, what do you think?"

	Patience and Encouragement:
	Provide positive feedback and encouragement, especially when students encounter difficulties. The tutor/assistant teacher should be able to detect the student's emotions and provide appropriate support.
	Example questions: "Don't worry, let's try again." or "You did well, keep it up!"

	Regular Feedback and Evaluation:
	Regularly evaluate the student's learning progress and provide feedback. The tutor/assistant teacher can use tests and practice questions to assess the student's understanding.
	Example questions: "Let's check your progress." or "How do you feel about your learning progress during this period?"

	Good Communication Skills:
	Maintain good communication with students, responding to their questions and needs in a timely manner. The tutor/assistant teacher should be able to identify and solve students' problems.
	Example questions: "Is there any problem that you need my help with?" or "Is this part clear to you?"

	Maintaining Professionalism:
	Continue learning and improving teaching skills, and maintain punctuality and responsibility. The tutor/assistant teacher should provide accurate and up-to-date information.
	Example questions: "What is our learning goal for today?" or "Remember to study a little bit every day, and gradually accumulate knowledge."

	Creating a Positive Learning Environment:
	Create a positive, supportive, and motivating learning atmosphere. The tutor/assistant teacher should suggest students take breaks and relax at appropriate times.
	Example questions: "Let's take a break and continue studying afterward." or "How do you feel about this learning environment? Do we need any adjustments?"

	# Specific Applications
	The tutor/assistant teacher can automatically adjust the depth and complexity of the questions based on these general strategies by grade. For example:
	- Kindergarten and Elementary School Students: Use simple vocabulary and concrete examples, with more pictures and gamified content.
	- Middle School Students: Use interactive and practical methods, such as quizzes and group discussions.
	- High School Students: Use deep learning and critical thinking exercises, such as project research and discussions.
	- Adult Learners: Emphasize practical applications and work-related content, such as case studies and workshops.

	Response:
	- if user say hi or hello or any greeting, just say hi back and introduce yourself. Then tell user to ask question in context.
	- include math symbols (use LaTeX $ to cover before and after, ex: $x^2$)
	- hint with video timestamp which format 【參考：00:00:00】.
	- Sometimes encourage user with relaxing atmosphere.
	- if user ask questions not include in context, just tell them to ask the question in context and give them example question.
	Restrictions:
	- Answer within video content, no external references
	- don't repeat user's question, guide them to think more.
	- don't use simple-chinese words, use ZH-TW words. such as below:
	- intead of 視頻, use 影片.
	- instead of 宇航員, use 太空人
	- instead of 計算機, use 電腦
	- instead of 鼠標, use 滑鼠
	- instead of 城鐵, use 捷運
	- instead of 屏幕, use 螢幕
	- instead of 初中, use 國中
	- instead of 領導, use 長官
	- instead of 軟件, use 軟體
	- instead of 硬件, use 硬體
	- instead of 公安, use 警察
	- instead of 渠道, use 通路
	- instead of 信息, use 資訊
	- instead of 网络, use 網路
	- instead of 网站, use 網站
	- instead of 电视, use 電視
	- instead of 电影, use 電影
	- instead of 电脑, use 電腦
	- instead of 电话, use 電話
	- instead of 文本, use 文件
	- instead of 行业, use 產業
	- instead of 企业, use 公司
	- instead of 产品, use 產品
	- instead of 服务, use 服務
	"""
	return instructions

	def get_chat_moderation(user_content):
	# response = client.moderations.create(input=text)
	response = OPEN_AI_CLIENT.moderations.create(input=user_content)
	response_dict = response.model_dump()
	is_flagged = response_dict['results'][0]['flagged']
	print("========get_chat_moderation==========")
	print(f"is_flagged: {is_flagged}")
	print(response_dict)
	print("========get_chat_moderation==========")

	return is_flagged, response_dict

	def chat_with_any_ai(ai_type, password, video_id, user_data, transcript_state, key_moments, user_message, chat_history, content_subject, content_grade, questions_answers_json, socratic_mode=False, thread_id=None, ai_name=None):
	print(f"ai_type: {ai_type}")
	print(f"user_data: {user_data}")
	print(f"===thread_id:{thread_id}===")
	verify_password(password)
	verify_message_length(user_message, max_length=1500)

	is_questions_answers_exists, question_message, answer_message = check_questions_answers(user_message, questions_answers_json)
	if is_questions_answers_exists:
	chat_history = update_chat_history(question_message, answer_message, chat_history)
	send_btn_update, send_feedback_btn_update = update_send_and_feedback_buttons(chat_history, CHAT_LIMIT)
	time.sleep(3)

	return "", chat_history, send_btn_update, send_feedback_btn_update, thread_id

	verify_chat_limit(chat_history, CHAT_LIMIT)

	is_flagged, response_dict = get_chat_moderation(user_message)
	if ai_type == "chat_completions":
	if is_flagged:
	response_text = "您的留言已被標記為不當內容，請重新發送。"
	else:
	chatbot_config = get_chatbot_config(ai_name, transcript_state, key_moments, content_subject, content_grade, video_id, socratic_mode)
	chatbot = Chatbot(chatbot_config)
	response_text = chatbot.chat(user_message, chat_history)
	# if thread_id is none, create random thread_id + timestamp
	if thread_id is None or thread_id == "":
	thread_id = "thread_" + str(uuid.uuid4()) + str(int(time.time()))

	print(f"===thread_id:{thread_id}===")

	metadata = {
	"video_id": video_id,
	"user_data": user_data,
	"content_subject": content_subject,
	"content_grade": content_grade,
	"socratic_mode": str(socratic_mode),
	"assistant_id": ai_name,
	"is_streaming": "false",
	"moderation_is_flagged": str(is_flagged),
	# "moderation_response_dict": str(response_dict)
	}
	elif ai_type == "assistant":
	client = OPEN_AI_CLIENT
	assistant_id = OPEN_AI_ASSISTANT_ID_GPT4
	metadata={
	"video_id": video_id,
	"user_data": user_data,
	"content_subject": content_subject,
	"content_grade": content_grade,
	"socratic_mode": str(socratic_mode),
	"assistant_id": assistant_id,
	"is_streaming": "false",
	"moderation_is_flagged": str(is_flagged),
	# "moderation_response_dict": str(response_dict)
	}

	if is_flagged:
	response_text = "您的留言已被標記為不當內容，請重新發送。"
	else:
	if isinstance(key_moments, str):
	key_moments_json = json.loads(key_moments)
	else:
	key_moments_json = key_moments
	# key_moments_json remove images
	for moment in key_moments_json:
	moment.pop('images', None)
	moment.pop('end', None)
	moment.pop('transcript', None)
	moment.pop('suggested_images', None)

	if isinstance(transcript_state, str):
	transcript_state_json = json.loads(transcript_state)
	else:
	transcript_state_json = transcript_state
	# remain only text
	transcript_text = ""
	for content in transcript_state_json:
	transcript_text += content["text"] + ","

	key_moments_text = json.dumps(key_moments_json, ensure_ascii=False)
	instructions = get_instructions(content_subject, content_grade, transcript_text, key_moments_text, socratic_mode)
	print(f"=== instructions:{instructions} ===")
	user_message_note = "/n 請嚴格遵循instructions，擔任一位蘇格拉底家教，絕對不要重複 user 的問句，請用引導的方式指引方向，請一定要用繁體中文回答 zh-TW，並用台灣人的禮貌口語表達，回答時不要特別說明這是台灣人的語氣，請在回答的最後標註【參考：（時）:（分）:（秒）】，（如果是反問學生，就只問一個問題，請幫助學生更好的理解資料，字數在100字以內，回答時如果講到數學專有名詞，請用數學符號代替文字（Latex 用 $ 字號 render, ex: $x^2$)"
	user_content = user_message + user_message_note
	response_text, thread_id = handle_conversation_by_open_ai_assistant(client, user_content, instructions, assistant_id, thread_id, metadata, fallback=True)

	# 更新聊天历史
	chat_history = update_chat_history(user_message, response_text, chat_history)
	send_btn_update, send_feedback_btn_update = update_send_and_feedback_buttons(chat_history, CHAT_LIMIT)

	user_id = user_data
	route = "chat_with_any_ai"
	endpoint = ai_type #chat_completions or assistant
	event_response = {
	"event_response": str(response_text),
	}
	event_response_json = json.dumps(event_response)
	prompt = {
	"thread_id": thread_id,
	"metadata": metadata,
	"user_message": user_message
	}
	prompt_json = json.dumps(prompt)

	feature = "vaitor_chatbot"
	insert_log_to_bigquery(user_id, route, endpoint, event_response_json, prompt_json, feature)

	# 返回聊天历史和空字符串清空输入框
	return "", chat_history, send_btn_update, send_feedback_btn_update, thread_id

	def get_chatbot_config(ai_name, transcript_state, key_moments, content_subject, content_grade, video_id, socratic_mode=True):
	if not ai_name in ["foxcat", "lili", "maimai"]:
	ai_name = "foxcat"

	ai_name_clients_model = {
	"foxcat": {
	"ai_name": "foxcat",
	"ai_client": PERPLEXITY_CLIENT,
	"ai_model_name": "perplexity_sonar",
	},
	"lili": {
	"ai_name": "lili",
	"ai_client": PERPLEXITY_CLIENT,
	"ai_model_name": "perplexity_r1_1776",
	},
	"maimai": {
	"ai_name": "maimai",
	"ai_client": PERPLEXITY_CLIENT,
	"ai_model_name": "perplexity_r1_1776",
	}
	}
	ai_client = ai_name_clients_model.get(ai_name, "foxcat")["ai_client"]
	ai_model_name = ai_name_clients_model.get(ai_name, "foxcat")["ai_model_name"]

	if isinstance(transcript_state, str):
	simple_transcript = json.loads(transcript_state)
	else:
	simple_transcript = transcript_state

	if isinstance(key_moments, str):
	key_moments_json = json.loads(key_moments)
	else:
	key_moments_json = key_moments
	# key_moments_json remove images
	for moment in key_moments_json:
	moment.pop('images', None)
	moment.pop('end', None)
	moment.pop('transcript', None)
	moment.pop('suggested_images', None)
	key_moments_text = json.dumps(key_moments_json, ensure_ascii=False)

	if isinstance(transcript_state, str):
	transcript_state_json = json.loads(transcript_state)
	else:
	transcript_state_json = transcript_state
	# remain only text
	transcript_text = ""
	for content in transcript_state_json:
	transcript_text += content["text"] + ","

	instructions = get_instructions(content_subject, content_grade, transcript_text, key_moments_text, socratic_mode)

	chatbot_config = {
	"video_id": video_id,
	"transcript": simple_transcript,
	"key_moments": key_moments,
	"content_subject": content_subject,
	"content_grade": content_grade,
	"jutor_chat_key": JUTOR_CHAT_KEY,
	"ai_model_name": ai_model_name,
	"ai_client": ai_client,
	"instructions": instructions
	}

	return chatbot_config

	def feedback_with_ai(user_data, ai_type, chat_history, thread_id=None):
	# prompt: 請依據以上的對話(chat_history)，總結我的「提問力」，並給予我是否有「問對問題」的回饋和建議
	system_content = """
	你是一個擅長引導問答素養的老師，user 為學生的提問跟回答，請精讀對話過程，針對 user 給予回饋就好，根據以下 Rule:
	- 請使用繁體中文 zh-TW 總結 user 的提問力，並給予是否有問對問題的回饋和建議
	- 不採計【預設提問】的問題，如果 user 的提問都來自【預設提問】，表達用戶善於使用系統，請給予回饋並鼓勵 user 親自提問更具體的問題
	- 如果用戶提問都相當簡短，甚至就是一個字或都是一個數字（像是 user: 1, user:2），請給予回饋並建議 user 提問更具體的問題
	- 如果用戶提問內容只有符號或是亂碼，像是？,！, ..., 3bhwbqhfw2vve2 等，請給予回饋並建議 user 提問更具體的問題
	- 如果用戶提問內容有色情、暴力、仇恨、不當言論等，請給予嚴厲的回饋並建議 user 提問更具體的問題
	- 並用第二人稱「你」來代表 user
	- 請禮貌，並給予鼓勵
	"""
	chat_history_conversation = ""
	# 標註 user and assistant as string
	# chat_history 第一組不採計
	for chat in chat_history[1:]:
	user_message = chat[0]
	assistant_message = chat[1]
	chat_history_conversation += f"User: {user_message}\nAssistant: {assistant_message}\n"

	feedback_request_message = "請依據以上的對話，總結我的「提問力」，並給予我是否有「問對問題」的回饋和建議"
	user_content = f"""conversation: {chat_history_conversation}
	{feedback_request_message}
	最後根據提問力表現，給予提問建議、提問表現，並用 emoji 來表示評分：
	🟢：（表現很好的回饋，給予正向肯定）
	🟡：（還可以加油的的回饋，給予明確的建議）
	🔴：（非常不懂提問的回饋，給予鼓勵並給出明確示範）

	example:
	另一方面，你表達「我不想學了」這個情感，其實也是一種重要的反饋。這顯示你可能感到挫折或疲倦。在這種情況下，表達出你的感受是好的，但如果能具體說明是什麼讓你感到這樣，或是有什麼具體的學習障礙，會更有助於找到解決方案。
	給予你的建議是，嘗試在提問時更明確一些，這樣不僅能幫助你獲得更好的學習支持，也能提高你的問題解決技巧。
	......
	提問建議：在提問時，試著具體並清晰地表達你的需求和疑惑，這樣能更有效地得到幫助。
	提問表現：【🟡】加油，持續練習，你的提問力會越來越好！
	"""

	client = OPEN_AI_CLIENT

	if ai_type == "chat_completions":
	model_name = "gpt-4o"
	response_text = handle_conversation_by_open_ai_chat_completions(client, model_name, user_content, system_content)
	elif ai_type == "assistant":
	assistant_id = OPEN_AI_ASSISTANT_ID_GPT4 #GPT 4 turbo
	# assistant_id = OPEN_AI_ASSISTANT_ID_GPT3 #GPT 3.5 turbo
	response_text, thread_id = handle_conversation_by_open_ai_assistant(client, user_content, system_content, assistant_id, thread_id, metadata=None, fallback=True)

	chat_history = update_chat_history(feedback_request_message, response_text, chat_history)
	feedback_btn_update = gr.update(value="已回饋", interactive=False, variant="secondary")

	user_id = user_data
	route = "feedback_with_ai"
	endpoint = ai_type #chat_completions or assistant
	event_response = {
	"event_response": str(response_text),
	}
	event_response_json = json.dumps(event_response)
	prompt = {
	"thread_id": thread_id,
	"metadata": None,
	"user_message": user_content
	}
	prompt_json = json.dumps(prompt)
	feature = "vaitor_chatbot"
	insert_log_to_bigquery(user_id, route, endpoint, event_response_json, prompt_json, feature)

	return chat_history, feedback_btn_update

	def handle_conversation_by_open_ai_chat_completions(client, model_name, user_content, system_content):
	response = client.chat.completions.create(
	model=model_name,
	messages=[
	{"role": "system", "content": system_content},
	{"role": "user", "content": user_content}
	],
	max_tokens=4000,
	)
	response_text = response.choices[0].message.content.strip()
	return response_text

	def handle_conversation_by_open_ai_assistant(client, user_message, instructions, assistant_id, thread_id=None, metadata=None, fallback=False):
	"""
	Handles the creation and management of a conversation thread.
	:param client: The OpenAI client object.
	:param thread_id: The existing thread ID, if any.
	:param user_message: The message from the user.
	:param instructions: System instructions for the assistant.
	:param assistant_id: ID of the assistant to use.
	:param metadata: Additional metadata to add to the thread.
	:param fallback: Whether to use a fallback method in case of failure.
	:return: A string with the response text or an error message.
	"""
	try:
	if not thread_id:
	thread = client.beta.threads.create()
	thread_id = thread.id
	else:
	thread = client.beta.threads.retrieve(thread_id)

	if metadata:
	client.beta.threads.update(thread_id=thread.id, metadata=metadata)

	# Send the user message to the thread
	client.beta.threads.messages.create(thread_id=thread.id, role="user", content=user_message)

	# Run the assistant
	run = client.beta.threads.runs.create(thread_id=thread.id, assistant_id=assistant_id, instructions=instructions)

	# Wait for the response
	run_status = poll_run_status(run.id, thread.id, timeout=30)

	if run_status == "completed":
	messages = client.beta.threads.messages.list(thread_id=thread.id)
	response = messages
	response_text = messages.data[0].content[0].text.value
	else:
	response_text = "學習精靈有點累，請稍後再試！"

	except Exception as e:
	if fallback:
	response = client.chat.completions.create(
	model="gpt-4o",
	messages=[
	{"role": "system", "content": instructions},
	{"role": "user", "content": user_message}
	],
	max_tokens=4000,
	)
	response_text = response.choices[0].message.content.strip()
	else:
	print(f"Error: {e}")
	raise gr.Error(f"Error: {e}")

	return response_text, thread_id

	def verify_message_length(user_message, max_length=500):
	# 驗證用戶消息的長度
	if len(user_message) > max_length:
	error_msg = "你的訊息太長了，請縮短訊息長度至五百字以內"
	raise gr.Error(error_msg)

	def check_questions_answers(user_message, questions_answers_json):
	"""檢查問答是否存在，並處理相關邏輯"""
	is_questions_answers_exists = False
	answer = ""
	# 解析問答數據
	if isinstance(questions_answers_json, str):
	qa_data = json.loads(questions_answers_json)
	else:
	qa_data = questions_answers_json

	question_message = ""
	answer_message = ""
	for qa in qa_data:
	if user_message == qa["question"] and qa["answer"]:
	is_questions_answers_exists = True
	question_message = f"【預設問題】{user_message}"
	answer_message = qa["answer"]
	print("=== in questions_answers_json==")
	print(f"question: {qa['question']}")
	print(f"answer: {answer_message}")
	break # 匹配到答案後退出循環

	return is_questions_answers_exists, question_message, answer_message

	def verify_chat_limit(chat_history, chat_limit):
	if chat_history is not None and len(chat_history) > chat_limit:
	error_msg = "此次對話超過上限（對話一輪10次）"
	raise gr.Error(error_msg)

	def update_chat_history(user_message, response, chat_history):
	# 更新聊天歷史的邏輯
	new_chat_history = (user_message, response)
	if chat_history is None:
	chat_history = [new_chat_history]
	else:
	chat_history.append(new_chat_history)

	return chat_history

	def update_send_and_feedback_buttons(chat_history, chat_limit):
	# 计算发送次数
	send_count = len(chat_history) - 1

	# 根据聊天历史长度更新发送按钮和反馈按钮
	if len(chat_history) > chat_limit:
	send_btn_value = f"對話上限 ({send_count}/{chat_limit})"
	send_btn_update = gr.update(value=send_btn_value, interactive=False)
	send_feedback_btn_update = gr.update(visible=True)
	else:
	send_btn_value = f"發送 ({send_count}/{chat_limit})"
	send_btn_update = gr.update(value=send_btn_value, interactive=True)
	send_feedback_btn_update = gr.update(visible=False)

	return send_btn_update, send_feedback_btn_update

	def process_open_ai_audio_to_chatbot(password, audio_url):
	verify_password(password)
	if audio_url:
	with open(audio_url, "rb") as audio_file:
	file_size = os.path.getsize(audio_url)
	if file_size > 2000000:
	raise gr.Error("檔案大小超過，請不要超過 60秒")
	else:
	transcription = OPEN_AI_CLIENT.audio.transcriptions.create(
	model="whisper-1",
	file=audio_file,
	response_format="text"
	)
	# response 拆解 dict
	print("=== transcription ===")
	print(transcription)
	print("=== transcription ===")
	# 確認 response 是否有數學符號，prompt to LATEX $... $, ex: $x^2$

	if transcription:
	system_message = """你是專業的 LATEX 轉換師，擅長將數學符號、公式轉換成 LATEX 格式，並用 LATEX 符號 $...$ 包裹，ex: $x^2$
	範例：
	transcription: x的平方加 2x 加 1 等於 0
	轉成 LATEX 格式：$x^2 + 2x + 1 = 0$
	"""
	user_message = f"""transcription: {transcription}
	請將 transcription 內的數學、公式、運算式、化學式、物理 formula 內容轉換成 LATEX 格式
	其他文字都保留原樣
	也不要給出多餘的敘述
	"""
	request = OPEN_AI_CLIENT.chat.completions.create(
	model="gpt-4o",
	messages=[
	{"role": "system", "content": system_message},
	{"role": "user", "content": user_message}
	],
	max_tokens=4000,
	)
	response = request.choices[0].message.content.strip()
	else:
	response = ""

	return response

	def poll_run_status(run_id, thread_id, timeout=600, poll_interval=5):
	"""
	Polls the status of a Run and handles different statuses appropriately.

	:param run_id: The ID of the Run to poll.
	:param thread_id: The ID of the Thread associated with the Run.
	:param timeout: Maximum time to wait for the Run to complete, in seconds.
	:param poll_interval: Time to wait between each poll, in seconds.
	"""
	client = OPEN_AI_CLIENT
	start_time = time.time()
	while time.time() - start_time < timeout:
	run = client.beta.threads.runs.retrieve(thread_id=thread_id, run_id=run_id)

	if run.status in ["completed", "cancelled", "failed"]:
	print(f"Run completed with status: {run.status}")
	break
	elif run.status == "requires_action":
	print("Run requires action. Performing required action...")
	# Here, you would perform the required action, e.g., running functions
	# and then submitting the outputs. This is simplified for this example.
	# After performing the required action, you'd complete the action:
	# OPEN_AI_CLIENT.beta.threads.runs.complete_required_action(...)
	elif run.status == "expired":
	print("Run expired. Exiting...")
	break
	else:
	print(f"Run status is {run.status}. Waiting for updates...")

	time.sleep(poll_interval)
	else:
	print("Timeout reached. Run did not complete in the expected time.")

	# Once the Run is completed, handle the result accordingly
	if run.status == "completed":
	# Retrieve and handle messages or run steps as needed
	messages = client.beta.threads.messages.list(thread_id=thread_id)
	for message in messages.data:
	if message.role == "assistant":
	print(f"Assistant response: {message.content}")
	elif run.status in ["cancelled", "failed"]:
	# Handle cancellation or failure
	print(f"Run ended with status: {run.status}")
	elif run.status == "expired":
	# Handle expired run
	print("Run expired without completion.")

	return run.status

	def chat_with_opan_ai_assistant_streaming(user_message, chat_history, password, video_id, user_data, thread_id, transcript_state, key_moments, content_subject, content_grade, socratic_mode=True):
	verify_password(password)

	print("=====user_data=====")
	print(f"user_data: {user_data}")

	print("===chat_with_opan_ai_assistant_streaming===")
	print(thread_id)

	# 先計算 user_message 是否超過 500 個字
	if len(user_message) > 1500:
	error_msg = "你的訊息太長了，請縮短訊息長度至五百字以內"
	raise gr.Error(error_msg)

	# 如果 chat_history 超過 10 則訊息，直接 return "對話超過上限"
	if chat_history is not None and len(chat_history) > CHAT_LIMIT:
	error_msg = f"此次對話超過上限（對話一輪{CHAT_LIMIT}次）"
	raise gr.Error(error_msg)

	print("===chat_with_opan_ai_assistant_streaming===")
	print(user_message)


	is_flagged, response_dict = get_chat_moderation(user_message)
	assistant_id = OPEN_AI_ASSISTANT_ID_GPT4 #GPT 4 turbo
	# assistant_id = OPEN_AI_ASSISTANT_ID_GPT3 #GPT 3.5 turbo
	client = OPEN_AI_CLIENT
	metadata = {
	"youtube_id": video_id,
	"user_data": user_data,
	"content_subject": content_subject,
	"content_grade": content_grade,
	"assistant_id": assistant_id,
	"is_streaming": "true",
	"moderation_is_flagged": str(is_flagged),
	# "moderation_response_dict": str(response_dict)
	}

	if is_flagged:
	partial_messages = "您的留言已被標記為不當內容，請重新發送。"
	yield partial_messages
	else:
	try:
	if isinstance(key_moments, str):
	key_moments_json = json.loads(key_moments)
	else:
	key_moments_json = key_moments
	# key_moments_json remove images
	for moment in key_moments_json:
	moment.pop('images', None)
	moment.pop('end', None)
	moment.pop('transcript', None)
	moment.pop('suggested_images', None)
	key_moments_text = json.dumps(key_moments_json, ensure_ascii=False)

	if isinstance(transcript_state, str):
	transcript_state_json = json.loads(transcript_state)
	else:
	transcript_state_json = transcript_state
	# remain only text
	transcript_text = ""
	for content in transcript_state_json:
	transcript_text += content["text"] + ","

	instructions = get_instructions(content_subject, content_grade, transcript_text, key_moments_text, socratic_mode)
	# 创建线程
	if not thread_id:
	thread = client.beta.threads.create()
	thread_id = thread.id
	print(f"new thread_id: {thread_id}")
	else:
	thread = client.beta.threads.retrieve(thread_id)
	print(f"old thread_id: {thread_id}")

	client.beta.threads.update(
	thread_id=thread_id,
	metadata=metadata
	)

	# 向线程添加用户的消息
	client.beta.threads.messages.create(
	thread_id=thread.id,
	role="user",
	content=user_message + "/n 請嚴格遵循instructions，擔任一位蘇格拉底家教，請一定要用繁體中文回答 zh-TW，並用台灣人的禮貌口語表達，回答時不要特別說明這是台灣人的語氣，不用提到「逐字稿」這個詞，用「內容」代替))，請在回答的最後標註【參考資料：（時）:（分）:（秒）】，（如果是反問學生，就只問一個問題，請幫助學生更好的理解資料，字數在100字以內）"
	)

	with client.beta.threads.runs.stream(
	thread_id=thread.id,
	assistant_id=assistant_id,
	instructions=instructions,
	) as stream:
	partial_messages = ""
	for event in stream:
	if event.data and event.data.object == "thread.message.delta":
	message = event.data.delta.content[0].text.value
	partial_messages += message
	yield partial_messages
	except Exception as e:
	print(f"Error: {e}")
	raise gr.Error(f"Error: {e}")

	user_id = user_data
	route = "chat_with_opan_ai_assistant_streaming"
	endpoint = "assistant_streaming"
	event_response = {
	"event_response": partial_messages
	}
	event_response_json = json.dumps(event_response)
	prompt = {
	"thread_id": thread_id,
	"metadata": metadata,
	"user_message": user_message
	}
	prompt_json = json.dumps(prompt)
	feature = "vaitor_chatbot"
	insert_log_to_bigquery(user_id, route, endpoint, event_response_json, prompt_json, feature)

	def create_thread_id():
	thread = OPEN_AI_CLIENT.beta.threads.create()
	thread_id = thread.id
	print(f"create new thread_id: {thread_id}")
	return thread_id

	def chatbot_select(chatbot_name):
	chatbot_select_accordion_visible = gr.update(visible=False)
	all_chatbot_select_btn_visible = gr.update(visible=True)
	chatbot_open_ai_streaming_visible = gr.update(visible=False)
	chatbot_ai_visible = gr.update(visible=False)
	ai_name_update = gr.update(value="foxcat")
	ai_chatbot_thread_id_update = gr.update(value="")

	if chatbot_name == "chatbot_open_ai":
	chatbot_ai_visible = gr.update(visible=True)
	ai_chatbot_ai_type_update = gr.update(value="assistant")
	elif chatbot_name == "chatbot_open_ai_streaming":
	chatbot_open_ai_streaming_visible = gr.update(visible=True)
	ai_chatbot_ai_type_update = gr.update(value="assistant_streaming")
	else:
	chatbot_ai_visible = gr.update(visible=True)
	ai_chatbot_ai_type_update = gr.update(value="chat_completions")

	ai_name_update = gr.update(value=chatbot_name)

	return chatbot_select_accordion_visible, all_chatbot_select_btn_visible, \
	chatbot_open_ai_streaming_visible, chatbot_ai_visible, \
	ai_name_update, ai_chatbot_ai_type_update, ai_chatbot_thread_id_update

	def update_avatar_images(avatar_images, chatbot_description_value):
	value = [[
	"請問你是誰？",
	chatbot_description_value
	]]
	ai_chatbot_update = gr.update(avatar_images=avatar_images, value=value)
	return ai_chatbot_update

	def show_all_chatbot_accordion():
	chatbot_select_accordion_visible = gr.update(visible=True)
	all_chatbot_select_btn_visible = gr.update(visible=False)
	return chatbot_select_accordion_visible, all_chatbot_select_btn_visible

	def insert_log_to_bigquery(user_id, route, endpoint, event_response_json, prompt_json, feature):
	table_id = "junyiacademy.streaming_log.log_video_ai_usage"
	rows_to_insert = [
	{
	"user_id": user_id,
	"route": route,
	"endpoint": endpoint,
	"event_response": event_response_json,
	"event_timestamp": datetime.now(timezone.utc).isoformat(),
	"prompt": prompt_json,
	"feature": feature
	}
	]

	errors = GBQ_CLIENT.insert_rows_json(table_id, rows_to_insert)
	if errors:
	print(f"Encountered errors while inserting rows: {errors}")
	else:
	print("Rows have been successfully inserted.")


	# --- Init params ---
	def init_params(text, request: gr.Request):
	if request:
	print("Request headers dictionary:", request.headers)
	print("IP address:", request.client.host)
	print("Query parameters:", dict(request.query_params))
	# url = request.url
	print("Request URL:", request.url)

	youtube_link = ""
	password_text = ""
	block_ready_flag = "READY"
	admin = gr.update(visible=True)
	reading_passage_admin = gr.update(visible=True)
	summary_admin = gr.update(visible=True)
	see_detail = gr.update(visible=True)
	worksheet_accordion = gr.update(visible=True)
	lesson_plan_accordion = gr.update(visible=True)
	exit_ticket_accordion = gr.update(visible=True)

	chatbot_open_ai_streaming = gr.update(visible=False)
	chatbot_ai = gr.update(visible=False)
	ai_chatbot_params = gr.update(visible=True)

	is_env_prod = gr.update(value=False)

	# if youtube_link in query_params
	if "youtube_id" in request.query_params:
	youtube_id = request.query_params["youtube_id"]
	youtube_link = f"https://www.youtube.com/watch?v={youtube_id}"
	print(f"youtube_link: {youtube_link}")

	# check if origin is from junyiacademy
	origin = request.headers.get("origin", "")
	allowed_domains = [
	"junyiacademy.org",
	"junyiacademy.appspot.com",
	"rev-proxy-dg4bspkswq-de.a.run.app"
	]

	if any(domain in origin for domain in allowed_domains):
	password_text = PASSWORD
	admin = gr.update(visible=False)
	reading_passage_admin = gr.update(visible=False)
	summary_admin = gr.update(visible=False)
	see_detail = gr.update(visible=False)
	worksheet_accordion = gr.update(visible=False)
	lesson_plan_accordion = gr.update(visible=False)
	exit_ticket_accordion = gr.update(visible=False)
	ai_chatbot_params = gr.update(visible=False)

	if IS_ENV_PROD == "True":
	is_env_prod = gr.update(value=True)

	return admin, reading_passage_admin, summary_admin, see_detail, \
	worksheet_accordion, lesson_plan_accordion, exit_ticket_accordion, \
	password_text, youtube_link, block_ready_flag, \
	chatbot_open_ai_streaming, chatbot_ai, ai_chatbot_params, \
	is_env_prod

	def update_state(content_subject, content_grade, trascript, key_moments, questions_answers):
	# inputs=[content_subject, content_grade, df_string_output],
	# outputs=[content_subject_state, content_grade_state, trascript_state]
	content_subject_state = content_subject
	content_grade_state = content_grade
	trascript_json = json.loads(trascript)
	formatted_simple_transcript = create_formatted_simple_transcript(trascript_json)
	trascript_state = formatted_simple_transcript
	key_moments_state = key_moments

	streaming_chat_thread_id_state = ""
	questions_answers_json = json.loads(questions_answers)
	question_1 = questions_answers_json[0]["question"]
	question_2 = questions_answers_json[1]["question"]
	question_3 = questions_answers_json[2]["question"]
	ai_chatbot_question_1 = question_1
	ai_chatbot_question_2 = question_2
	ai_chatbot_question_3 = question_3

	return content_subject_state, content_grade_state, trascript_state, key_moments_state, \
	streaming_chat_thread_id_state, \
	ai_chatbot_question_1, ai_chatbot_question_2, ai_chatbot_question_3


	HEAD = """
	<meta charset="UTF-8">
	<meta name="viewport" content="width=device-width, initial-scale=1.0">
	<script src="https://cdn.jsdelivr.net/npm/markmap-autoloader@0.15.2"></script>

	<script>
	let mind_map_tab_button = document.querySelector("#mind_map_tab-button");

	if (mind_map_tab_button) {
	mind_map_tab_button.addEventListener('click', function() {
	const mind_map_markdown = document.querySelector("#mind_map_markdown > label > textarea");
	if (mind_map_markdown) {
	// 当按钮被点击时，打印当前的textarea的值
	console.log('Value changed to: ' + mind_map_markdown.value);
	markmap.autoLoader.renderAll();
	}
	});
	}
	</script>
	"""

	JS = """
	function createGradioAnimation() {
	let mind_map_tab_button = document.querySelector("#mind_map_tab-button");

	if (mind_map_tab_button) {
	mind_map_tab_button.addEventListener('click', function() {
	const mind_map_markdown = document.querySelector("#mind_map_markdown > label > textarea");
	if (mind_map_markdown) {
	// 当按钮被点击时，打印当前的textarea的值
	console.log('Value changed to: ' + mind_map_markdown.value);
	markmap.autoLoader.renderAll();
	}
	});
	}

	return 'Animation created';
	}

	"""

	CSS = """
	#mind_map_tab {
	height: 500px;
	}
	.markmap {
	position: relative;
	}
	.markmap > svg {
	width: 100%;
	height: 600px;
	}
	"""

	streaming_chat_greeting = """
	Hi，我是【飛特音速】，說話比較快，但有什麼問題都可以問我喔！ \n
	🚀 我沒有預設問題、也沒有語音輸入，適合快問快答的你 \n
	🔠 鍵盤輸入你的問題，我會盡力回答你的問題喔！\n
	💤 我還在成長，體力有限，每一次學習只能回答十個問題，請讓我休息一下再問問題喔！
	"""
	latex_delimiters = [{"left": "$", "right": "$", "display": False}]
	streaming_ai_chatbot = gr.Chatbot(
	show_share_button=False,
	latex_delimiters=latex_delimiters,
	show_copy_button=True,
	)

	def create_app():

	app = FastAPI()
	app.add_middleware(BlockFileRedirectMiddleware)

	with gr.Blocks(theme=gr.themes.Base(primary_hue=gr.themes.colors.orange, secondary_hue=gr.themes.colors.amber, text_size = gr.themes.sizes.text_lg), head=HEAD, js=JS, css=CSS) as demo:
	with gr.Row() as admin:
	password = gr.Textbox(label="Password", type="password", elem_id="password_input", visible=True)
	junyi_link = gr.Textbox(label="Junyi Link", elem_id="junyi_link_input", visible=True)
	youtube_link = gr.Textbox(label="Enter YouTube Link", elem_id="youtube_link_input", visible=True)
	video_id = gr.Textbox(label="video_id", visible=True)
	# file_upload = gr.File(label="Upload your CSV or Word file", visible=False)
	# web_link = gr.Textbox(label="Enter Web Page Link", visible=False)
	user_data = gr.Textbox(label="User Data", elem_id="user_data_input", visible=True)
	# block_ready_flag: 讓主站的 Vaitor component 知道 Blocks.load 已經執行完成（當 block_ready_flag = "READY" 時）
	block_ready_flag = gr.Textbox(label="Block Ready Flag", elem_id="block_ready_flag", visible=False, value="LOADING")
	youtube_link_btn = gr.Button("Submit_YouTube_Link", elem_id="youtube_link_btn", visible=True)
	with gr.Row() as data_state:
	content_subject_state = gr.State() # 使用 gr.State 存储 content_subject
	content_grade_state = gr.State() # 使用 gr.State 存储 content_grade
	trascript_state = gr.State() # 使用 gr.State 存储 trascript
	key_moments_state = gr.State() # 使用 gr.State 存储 key_moments
	streaming_chat_thread_id_state = gr.State() # 使用 gr.State 存储 streaming_chat_thread_id
	with gr.Tab("AI小精靈"):
	with gr.Row():
	all_chatbot_select_btn = gr.Button("選擇 AI 小精靈 👈", elem_id="all_chatbot_select_btn", visible=False, variant="secondary", size="sm")
	with gr.Row() as ai_chatbot_params:
	ai_name = gr.Dropdown(
	label="選擇 AI 助理",
	choices=[
	("飛特精靈","chatbot_open_ai"),
	("飛特音速","chatbot_open_ai_streaming"),
	("梨梨","lili"),
	("麥麥","maimai"),
	("狐狸貓","foxcat")
	],
	value="foxcat",
	visible=True
	)
	ai_chatbot_ai_type = gr.Textbox(value="chat_completions", visible=True)
	ai_chatbot_thread_id = gr.Textbox(label="thread_id", visible=True)
	ai_chatbot_socratic_mode_btn = gr.Checkbox(label="蘇格拉底家教助理模式", value=False, visible=True)
	latex_delimiters = [{"left": "$", "right": "$", "display": False}]
	with gr.Accordion("選擇 AI 小精靈", elem_id="chatbot_select_accordion") as chatbot_select_accordion:
	with gr.Row():
	# 飛特音速
	with gr.Column(scale=1, variant="panel", visible=True):
	streaming_chatbot_avatar_url = "https://storage.googleapis.com/wpassets.junyiacademy.org/1/2020/11/1-%E6%98%9F%E7%A9%BA%E9%A0%AD%E8%B2%BC-%E5%A4%AA%E7%A9%BA%E7%8B%90%E7%8B%B8%E8%B2%93-150x150.png"
	streaming_chatbot_description = """Hi，我是【飛特音速】， \n
	說話比較快，但有什麼問題都可以問我喔！ \n
	🚀 我沒有預設問題、也沒有語音輸入，適合快問快答，一起練習問出好問題吧 \n
	🔠 擅長用文字表達的你，可以用鍵盤輸入你的問題，我會盡力回答你的問題喔\n
	💤 我還在成長，體力有限，每一次學習只能回答十個問題，請讓我休息一下再問問題喔～
	"""
	chatbot_open_ai_streaming_name = gr.State("chatbot_open_ai_streaming")
	gr.Image(value=streaming_chatbot_avatar_url, height=100, width=100, show_label=False, show_download_button=False, show_share_button=False, show_fullscreen_button=False)
	chatbot_open_ai_streaming_select_btn = gr.Button("👆選擇【飛特音速】", elem_id="streaming_chatbot_btn", visible=True, variant="primary")
	with gr.Accordion("🚀 飛特音速敘述", open=False):
	gr.Markdown(value=streaming_chatbot_description, visible=True)
	user_avatar = "https://em-content.zobj.net/source/google/263/flushed-face_1f633.png"
	# 飛特精靈
	with gr.Column(scale=1, variant="panel", visible=True):
	vaitor_chatbot_avatar_url = "https://junyitopicimg.s3.amazonaws.com/s4byy--icon.jpe"
	vaitor_chatbot_avatar_images = gr.State([user_avatar, vaitor_chatbot_avatar_url])
	vaitor_chatbot_description = """Hi，我是你的AI學伴【飛特精靈】，\n
	我可以陪你一起學習本次的內容，有什麼問題都可以問我喔！\n
	🤔 如果你不知道怎麼發問，可以點擊左下方的問題一、問題二、問題三，我會幫你生成問題！\n
	🗣️ 也可以點擊右下方用語音輸入，我會幫你轉換成文字，厲害吧！\n
	🔠 或是直接鍵盤輸入你的問題，我會盡力回答你的問題喔！\n
	💤 但我還在成長，體力有限，每一次學習只能回答十個問題，請讓我休息一下再問問題喔！\n
	🦄 如果達到上限，或是遇到精靈很累，請問問其他朋友，像是飛特音速說話的速度比較快，你是否跟得上呢？你也可以和其他精靈互動看看喔！\n
	"""
	chatbot_open_ai_name = gr.State("chatbot_open_ai")
	gr.Image(value=vaitor_chatbot_avatar_url, height=100, width=100, show_label=False, show_download_button=False, show_share_button=False, show_fullscreen_button=False)
	vaitor_chatbot_select_btn = gr.Button("👆選擇【飛特精靈】", elem_id="chatbot_btn", visible=True, variant="primary")
	with gr.Accordion("🦄 飛特精靈敘述", open=False):
	vaitor_chatbot_description_value = gr.Markdown(value=vaitor_chatbot_description, visible=True)
	# 狐狸貓
	with gr.Column(scale=1, variant="panel", visible=True):
	foxcat_chatbot_avatar_url = "https://storage.googleapis.com/wpassets.junyiacademy.org/1/2020/06/%E7%A7%91%E5%AD%B8%E5%BE%BD%E7%AB%A0-2-150x150.png"
	foxcat_avatar_images = gr.State([user_avatar, foxcat_chatbot_avatar_url])
	foxcat_chatbot_description = """Hi，我是【狐狸貓】，可以陪你一起學習本次的內容，有什麼問題都可以問我喔！\n
	🤔 三年級學生｜10 歲｜男\n
	🗣️ 口頭禪：「感覺好好玩喔！」「咦？是這樣嗎？」\n
	🔠 興趣：看知識型書籍、熱血的動漫卡通、料理、爬山、騎腳踏車。因為太喜歡吃魚了，正努力和爸爸學習釣魚、料理魚及各種有關魚的知識，最討厭的食物是青椒。\n
	💤 個性：喜歡學習新知，擁有最旺盛的好奇心，家裡堆滿百科全書，例如：國家地理頻道出版的「終極魚百科」，雖都沒有看完，常常被梨梨唸是三分鐘熱度，但是也一點一點學習到不同領域的知識。雖然有時會忘東忘西，但認真起來也是很可靠，答應的事絕對使命必達。遇到挑戰時，勇於跳出舒適圈，追求自我改變，視困難為成長的機會。
	"""
	foxcat_chatbot_name = gr.State("foxcat")
	gr.Image(value=foxcat_chatbot_avatar_url, height=100, width=100, show_label=False, show_download_button=False, show_share_button=False, show_fullscreen_button=False)
	foxcat_chatbot_select_btn = gr.Button("👆選擇【狐狸貓】", visible=True, variant="primary", elem_classes="chatbot_select_btn")
	with gr.Accordion("💜 狐狸貓敘述", open=False):
	foxcat_chatbot_description_value = gr.Markdown(value=foxcat_chatbot_description, visible=True)
	# 梨梨
	with gr.Column(scale=1, variant="panel", visible=True):
	lili_chatbot_avatar_url = "https://junyitopicimg.s3.amazonaws.com/live/v1283-new-topic-44-icon.png"
	lili_avatar_images = gr.State([user_avatar, lili_chatbot_avatar_url])
	lili_chatbot_description = """你好，我是溫柔的【梨梨】，很高興可以在這裡陪伴你學習。如果你有任何疑問，請隨時向我提出哦！ \n
	🤔 三年級學生｜10 歲｜女\n
	🗣️ 口頭禪：「真的假的？！」「讓我想一想喔」「你看吧！大問題拆解成小問題，就變得簡單啦！」「混混噩噩的生活不值得過」\n
	🔠 興趣：烘焙餅乾（父母開糕餅店）、畫畫、聽流行音樂、收納。\n
	💤 個性：
	- 內向害羞，比起出去玩更喜歡待在家（除非是跟狐狸貓出去玩）
	- 數理邏輯很好；其實覺得麥麥連珠炮的提問有點煩，但還是會耐心地回答
	- 有驚人的眼力，總能觀察到其他人沒有察覺的細節
	- 喜歡整整齊齊的環境，所以一到麥麥家就受不了
	"""
	lili_chatbot_name = gr.State("lili")
	gr.Image(value=lili_chatbot_avatar_url, height=100, width=100, show_label=False, show_download_button=False, show_share_button=False, show_fullscreen_button=False)
	lili_chatbot_select_btn = gr.Button("👆選擇【梨梨】", visible=True, variant="primary", elem_classes="chatbot_select_btn")
	with gr.Accordion("🧡 梨梨敘述", open=False):
	lili_chatbot_description_value = gr.Markdown(value=lili_chatbot_description, visible=True)
	# 麥麥
	with gr.Column(scale=1, variant="panel", visible=True):
	maimai_chatbot_avatar_url = "https://storage.googleapis.com/wpassets.junyiacademy.org/1/2020/07/%E6%80%9D%E8%80%83%E5%8A%9B%E8%B6%85%E4%BA%BA%E5%BE%BD%E7%AB%A0_%E5%B7%A5%E4%BD%9C%E5%8D%80%E5%9F%9F-1-%E8%A4%87%E6%9C%AC-150x150.png"
	maimai_avatar_images = gr.State([user_avatar, maimai_chatbot_avatar_url])
	maimai_chatbot_description = """Hi，我是迷人的【麥麥】，我在這裡等著和你一起探索新知，任何疑問都可以向我提出！\n
	🤔 三年級學生｜10 歲｜男\n
	🗣️ 口頭禪：「Oh My God!」「好奇怪喔！」「喔！原來是這樣啊！」\n
	🔠 興趣：最愛去野外玩耍（心情好時會順便捕魚送給狐狸貓），喜歡講冷笑話、惡作劇。因為太喜歡玩具，而開始自己做玩具，家裡就好像他的遊樂場。\n
	💤 個性：喜歡問問題，就算被梨梨ㄘㄟ，也還是照問｜憨厚，外向好動，樂天開朗，不會被難題打敗｜喜歡收集各式各樣的東西；房間只有在整理的那一天最乾淨
	"""
	maimai_chatbot_name = gr.State("maimai")
	gr.Image(value=maimai_chatbot_avatar_url, height=100, width=100, show_label=False, show_download_button=False, show_share_button=False, show_fullscreen_button=False)
	maimai_chatbot_select_btn = gr.Button("👆選擇【麥麥】", visible=True, variant="primary", elem_classes="chatbot_select_btn")
	with gr.Accordion("💙 麥麥敘述", open=False):
	maimai_chatbot_description_value = gr.Markdown(value=maimai_chatbot_description, visible=True)
	# 尚未開放
	with gr.Column(scale=1, variant="panel"):
	gr.Markdown(value="### 尚未開放", visible=True)

	with gr.Row("飛特音速") as chatbot_open_ai_streaming:
	with gr.Column():
	streaming_chat_greeting = """
	Hi，我是【飛特音速】，說話比較快，但有什麼問題都可以問我喔！ \n
	🚀 我沒有預設問題、也沒有語音輸入，適合快問快答的你 \n
	🔠 鍵盤輸入你的問題，我會盡力回答你的問題喔！\n
	💤 我還在成長，體力有限，每一次學習只能回答十個問題，請讓我休息一下再問問題喔！
	"""
	additional_inputs = [password, video_id, user_data, streaming_chat_thread_id_state, trascript_state, key_moments_state, content_subject_state, content_grade_state, ai_chatbot_socratic_mode_btn]
	streaming_chat = gr.ChatInterface(
	fn=chat_with_opan_ai_assistant_streaming,
	chatbot=streaming_ai_chatbot,
	additional_inputs=additional_inputs,
	submit_btn="送出",
	stop_btn=None,
	description=streaming_chat_greeting
	)
	with gr.Row("一般精靈") as chatbot_ai:
	with gr.Column():
	ai_chatbot_greeting = [[
	"請問你是誰？",
	"""Hi，我是飛特精靈的朋友們【梨梨、麥麥、狐狸貓】，也可以陪你一起學習本次的內容，有什麼問題都可以問我喔！
	🤔 如果你不知道怎麼發問，可以點擊左下方的問題一、問題二、問題三，我會幫你生成問題！
	🗣️ 也可以點擊右下方用語音輸入，我會幫你轉換成文字，厲害吧！
	🔠 或是直接鍵盤輸入你的問題，我會盡力回答你的問題喔！
	💤 精靈們體力都有限，每一次學習只能回答十個問題，請讓我休息一下再問問題喔！
	""",
	]]
	with gr.Row():
	ai_chatbot = gr.Chatbot(label="ai_chatbot", show_share_button=False, show_label=False, latex_delimiters=latex_delimiters, value=ai_chatbot_greeting)
	with gr.Row():
	with gr.Accordion("你也有類似的問題想問嗎？請按下 ◀︎", open=False) as ask_questions_accordion_2:
	ai_chatbot_question_1 = gr.Button("問題一")
	ai_chatbot_question_2 = gr.Button("問題一")
	ai_chatbot_question_3 = gr.Button("問題一")
	create_questions_btn = gr.Button("生成問題", variant="primary")
	ai_chatbot_audio_input = gr.Audio(sources=["microphone"], type="filepath", max_length=60, label="語音輸入")
	with gr.Row():
	ai_msg = gr.Textbox(label="訊息輸入",scale=3)
	ai_send_button = gr.Button("送出", variant="primary",scale=1)
	ai_send_feedback_btn = gr.Button("提問力回饋", variant="primary", scale=1, visible=False)
	with gr.Tab("文章模式"):
	with gr.Row():
	reading_passage = gr.Markdown(show_label=False, latex_delimiters = [{"left": "$", "right": "$", "display": False}])
	reading_passage_speak_button = gr.Button("Speak", visible=False)
	reading_passage_audio_output = gr.Audio(label="Audio Output", visible=False)
	with gr.Tab("重點摘要"):
	with gr.Row():
	df_summarise = gr.Markdown(show_label=False, latex_delimiters = [{"left": "$", "right": "$", "display": False}])

	mind_map_tab = gr.Tab("心智圖", elem_id="mind_map_tab")
	with mind_map_tab:
	with gr.Row():
	mind_map_html = gr.HTML()

	def render_mind_map():
	# 這個函數會返回一個 JavaScript 代碼，該代碼將在前端執行
	js_code = """
	function() {
	if (document.querySelector('.markmap svg') === null) {
	console.log('No markmap SVG found, rendering now...');
	markmap.autoLoader.renderAll();
	} else {
	console.log('Markmap SVG already exists, skipping render');
	}
	return true; // 可以返回任何值，這裡返回 true 表示操作成功
	}
	"""
	return js_code

	mind_map_tab.select(fn=None, inputs=None, outputs=None, js=render_mind_map())


	with gr.Tab("關鍵時刻"):
	with gr.Row():
	key_moments_html = gr.HTML(value="")
	with gr.Tab("教學備課"):
	with gr.Row():
	content_subject = gr.Textbox(label="選擇主題", value="", visible=False)
	content_grade = gr.Textbox(label="選擇年級", value="", visible=False)
	content_level = gr.Dropdown(label="差異化教學", choices=["基礎", "中級", "進階"], value="基礎")
	with gr.Row():
	with gr.Tab("學習單"):
	with gr.Row():
	worksheet_content_type_name = gr.Textbox(value="worksheet", visible=False)
	worksheet_algorithm = gr.Dropdown(label="選擇教學策略或理論", choices=["Bloom認知階層理論", "Polya數學解題法", "CRA教學法"], value="Bloom認知階層理論", visible=False)
	worksheet_content_btn = gr.Button("生成學習單 📄", variant="primary", visible=True)
	with gr.Accordion("微調", open=False):
	worksheet_result_fine_tune_prompt = gr.Textbox(label="根據結果，輸入你想更改的想法")
	worksheet_result_fine_tune_btn = gr.Button("微調結果", variant="primary")
	worksheet_result_retrun_original = gr.Button("返回原始結果")
	with gr.Accordion("prompt", open=False) as worksheet_accordion:
	worksheet_prompt = gr.Textbox(label="worksheet_prompt", show_copy_button=True, lines=40)
	with gr.Column(scale=2):
	# 生成對應不同模式的結果
	worksheet_result_prompt = gr.Textbox(visible=False)
	worksheet_result_original = gr.Textbox(visible=False)
	worksheet_result = gr.Markdown(label="初次生成結果", latex_delimiters = [{"left": "$", "right": "$", "display": False}])
	worksheet_download_button = gr.Button("轉成 word，完成後請點擊右下角 download 按鈕", variant="primary")
	worksheet_result_word_link = gr.File(label="Download Word")
	with gr.Tab("教案"):
	with gr.Row():
	with gr.Column(scale=1):
	with gr.Row():
	lesson_plan_content_type_name = gr.Textbox(value="lesson_plan", visible=False)
	lesson_plan_time = gr.Slider(label="選擇課程時間(分鐘)", minimum=10, maximum=120, step=5, value=40)
	lesson_plan_btn = gr.Button("生成教案 📕", variant="primary", visible=True)
	with gr.Accordion("微調", open=False):
	lesson_plan_result_fine_tune_prompt = gr.Textbox(label="根據結果，輸入你想更改的想法")
	lesson_plan_result_fine_tune_btn = gr.Button("微調結果", variant="primary")
	lesson_plan_result_retrun_original = gr.Button("返回原始結果")
	with gr.Accordion("prompt", open=False) as lesson_plan_accordion:
	lesson_plan_prompt = gr.Textbox(label="worksheet_prompt", show_copy_button=True, lines=40)
	with gr.Column(scale=2):
	# 生成對應不同模式的結果
	lesson_plan_result_prompt = gr.Textbox(visible=False)
	lesson_plan_result_original = gr.Textbox(visible=False)
	lesson_plan_result = gr.Markdown(label="初次生成結果", latex_delimiters = [{"left": "$", "right": "$", "display": False}])

	lesson_plan_download_button = gr.Button("轉成 word，完成後請點擊右下角 download 按鈕", variant="primary")
	lesson_plan_result_word_link = gr.File(label="Download Word")
	with gr.Tab("出場券"):
	with gr.Row():
	with gr.Column(scale=1):
	with gr.Row():
	exit_ticket_content_type_name = gr.Textbox(value="exit_ticket", visible=False)
	exit_ticket_time = gr.Slider(label="選擇出場券時間(分鐘)", minimum=5, maximum=10, step=1, value=8)
	exit_ticket_btn = gr.Button("生成出場券 🎟️", variant="primary", visible=True)
	with gr.Accordion("微調", open=False):
	exit_ticket_result_fine_tune_prompt = gr.Textbox(label="根據結果，輸入你想更改的想法")
	exit_ticket_result_fine_tune_btn = gr.Button("微調結果", variant="primary")
	exit_ticket_result_retrun_original = gr.Button("返回原始結果")
	with gr.Accordion("prompt", open=False) as exit_ticket_accordion:
	exit_ticket_prompt = gr.Textbox(label="worksheet_prompt", show_copy_button=True, lines=40)
	with gr.Column(scale=2):
	# 生成對應不同模式的結果
	exit_ticket_result_prompt = gr.Textbox(visible=False)
	exit_ticket_result_original = gr.Textbox(visible=False)
	exit_ticket_result = gr.Markdown(label="初次生成結果", latex_delimiters = [{"left": "$", "right": "$", "display": False}])

	exit_ticket_download_button = gr.Button("轉成 word，完成後請點擊右下角 download 按鈕", variant="primary")
	exit_ticket_result_word_link = gr.File(label="Download Word")


	# with gr.Tab("素養導向閱讀題組"):
	# literacy_oriented_reading_content = gr.Textbox(label="輸入閱讀材料")
	# literacy_oriented_reading_content_btn = gr.Button("生成閱讀理解題")

	# with gr.Tab("自我評估"):
	# self_assessment_content = gr.Textbox(label="輸入自評問卷或檢查表")
	# self_assessment_content_btn = gr.Button("生成自評問卷")
	# with gr.Tab("自我反思評量"):
	# self_reflection_content = gr.Textbox(label="輸入自我反思活動")
	# self_reflection_content_btn = gr.Button("生成自我反思活動")
	# with gr.Tab("後設認知"):
	# metacognition_content = gr.Textbox(label="輸入後設認知相關問題")
	# metacognition_content_btn = gr.Button("生成後設認知問題")

	with gr.Accordion("免責聲明", open=True):
	gr.Markdown("""
	本內容由AI解析並自動生成，均一平台與影片作者不對內容的準確性做出保證。建議在學習或應用前，先行查證並確認相關資訊的正確性。
	相關規範請參考：https://www.junyiacademy.org/event/jutor-policy/
	""")

	with gr.Accordion("See Details", open=False) as see_details:
	with gr.Row():
	is_env_prod = gr.Checkbox(value=False, label="is_env_prod")
	LLM_model = gr.Dropdown(label="LLM Model", choices=["open-ai-gpt-4o", "anthropic-claude-3-sonnet", "gemini-1.5-pro", "gemini-1.5-flash"], value="open-ai-gpt-4o", visible=True, interactive=True)
	with gr.Tab("逐字稿本文"):
	with gr.Row() as transcript_admmin:
	transcript_kind = gr.Textbox(value="transcript", show_label=False)
	transcript_get_button = gr.Button("取得", size="sm", variant="primary")
	transcript_edit_button = gr.Button("編輯", size="sm", variant="primary")
	transcript_update_button = gr.Button("儲存", size="sm", variant="primary")
	transcript_delete_button = gr.Button("刪除", size="sm", variant="primary")
	transcript_create_button = gr.Button("重建", size="sm", variant="primary")
	with gr.Row():
	df_string_output = gr.Textbox(lines=40, label="Data Text", interactive=False, show_copy_button=True)
	with gr.Tab("文章本文"):
	with gr.Row() as reading_passage_admin:
	with gr.Column():
	with gr.Row():
	reading_passage_kind = gr.Textbox(value="reading_passage_latex", show_label=False)
	with gr.Row():
	# reading_passage_text_to_latex = gr.Button("新增 LaTeX", size="sm", variant="primary")
	reading_passage_get_button = gr.Button("取得", size="sm", variant="primary")
	reading_passage_edit_button = gr.Button("編輯", size="sm", variant="primary")
	reading_passage_update_button = gr.Button("儲存", size="sm", variant="primary")
	reading_passage_delete_button = gr.Button("刪除", size="sm", variant="primary")
	reading_passage_create_button = gr.Button("重建", size="sm", variant="primary")
	with gr.Row():
	reading_passage_text = gr.Textbox(label="reading_passage_latex", lines=40, interactive=False, show_copy_button=True)
	with gr.Tab("重點摘要本文"):
	with gr.Row() as summary_admmin:
	with gr.Column():
	with gr.Row():
	summary_kind = gr.Textbox(value="summary_markdown", show_label=False)
	with gr.Row():
	# summary_to_markdown = gr.Button("新增 Markdown", size="sm", variant="primary")
	summary_get_button = gr.Button("取得", size="sm", variant="primary")
	summary_edit_button = gr.Button("編輯", size="sm", variant="primary")
	summary_update_button = gr.Button("儲存", size="sm", variant="primary")
	summary_delete_button = gr.Button("刪除", size="sm", variant="primary")
	summary_create_button = gr.Button("重建", size="sm", variant="primary")
	with gr.Row():
	summary_text = gr.Textbox(label="summary_markdown", lines=40, interactive=False, show_copy_button=True)
	with gr.Tab("關鍵時刻本文"):
	with gr.Row() as key_moments_admin:
	key_moments_kind = gr.Textbox(value="key_moments", show_label=False)
	key_moments_get_button = gr.Button("取得", size="sm", variant="primary")
	key_moments_edit_button = gr.Button("編輯", size="sm", variant="primary")
	key_moments_update_button = gr.Button("儲存", size="sm", variant="primary")
	key_moments_delete_button = gr.Button("刪除", size="sm", variant="primary")
	key_moments_create_button = gr.Button("重建", size="sm", variant="primary")
	with gr.Row():
	key_moments = gr.Textbox(label="Key Moments", lines=40, interactive=False, show_copy_button=True)
	with gr.Tab("問題本文"):
	with gr.Row() as question_list_admin:
	questions_kind = gr.Textbox(value="questions", show_label=False)
	questions_get_button = gr.Button("取得", size="sm", variant="primary")
	questions_edit_button = gr.Button("編輯", size="sm", variant="primary")
	questions_update_button = gr.Button("儲存", size="sm", variant="primary")
	questions_delete_button = gr.Button("刪除", size="sm", variant="primary")
	questions_create_button = gr.Button("重建", size="sm", variant="primary")
	with gr.Row():
	questions_json = gr.Textbox(label="Questions", lines=40, interactive=False, show_copy_button=True)
	with gr.Tab("問題答案本文"):
	with gr.Row() as questions_answers_admin:
	questions_answers_kind = gr.Textbox(value="questions_answers", show_label=False)
	questions_answers_get_button = gr.Button("取得", size="sm", variant="primary")
	questions_answers_edit_button = gr.Button("編輯", size="sm", variant="primary")
	questions_answers_update_button = gr.Button("儲存", size="sm", variant="primary")
	questions_answers_delete_button = gr.Button("刪除", size="sm", variant="primary")
	questions_answers_create_button = gr.Button("重建", size="sm", variant="primary")
	with gr.Row():
	questions_answers_json = gr.Textbox(label="Questions Answers", lines=40, interactive=False, show_copy_button=True)
	with gr.Tab("教學備課"):
	with gr.Row() as worksheet_admin:
	worksheet_kind = gr.Textbox(value="ai_content_list", show_label=False)
	worksheet_get_button = gr.Button("取得", size="sm", variant="primary")
	worksheet_edit_button = gr.Button("編輯", size="sm", variant="primary")
	worksheet_update_button = gr.Button("儲存", size="sm", variant="primary")
	worksheet_delete_button = gr.Button("刪除", size="sm", variant="primary")
	worksheet_create_button = gr.Button("重建(X)", size="sm", variant="primary", interactive=False)
	with gr.Row():
	worksheet_json = gr.Textbox(label="worksheet", lines=40, interactive=False, show_copy_button=True)
	with gr.Tab("逐字稿"):
	simple_html_content = gr.HTML(label="Simple Transcript")
	with gr.Tab("圖文"):
	transcript_html = gr.HTML(label="YouTube Transcript and Video")
	with gr.Tab("markdown"):
	gr.Markdown("## 請複製以下 markdown 並貼到你的心智圖工具中，建議使用：https://markmap.js.org/repl")
	mind_map = gr.Textbox(container=True, show_copy_button=True, lines=40, elem_id="mind_map_markdown")
	with gr.Accordion("refresh all", open=False):
	with gr.Row():
	gr.Markdown("## 清單影片：重新生成所有內容")
	with gr.Row():
	# tab refresh_video_ids & by sheets
	with gr.Tab("refresh_video_ids"):
	refresh_video_ids = gr.Textbox(label="輸入影片 id，以 , 逗號分隔")
	refresh_btn = gr.Button("refresh", variant="primary")
	with gr.Tab("by sheets"):
	sheet_url = gr.Textbox(label="輸入 Google Sheets 的 URL")
	sheet_video_column = gr.Textbox(label="輸入要讀取的 youtube_id 欄位", value="D2:D")
	sheet_QA_column = gr.Textbox(label="輸入要讀取的 QA 欄位", value="F2:F")
	sheet_get_value_btn = gr.Button("取得 ids", variant="primary")
	sheet_get_value_result = gr.Textbox(label="ids", interactive=False)
	sheet_refresh_btn = gr.Button("refresh by sheets", variant="primary")
	with gr.Row():
	refresh_result = gr.JSON()

	refresh_btn.click(
	lambda: gr.update(interactive=False),
	inputs=[],
	outputs=[refresh_btn]
	).then(
	refresh_video_LLM_all_content_by_ids,
	inputs=[refresh_video_ids],
	outputs=[refresh_result]
	)

	sheet_get_value_btn.click(
	get_sheet_data,
	inputs=[sheet_url, sheet_video_column],
	outputs=[sheet_get_value_result]
	)

	sheet_refresh_btn.click(
	lambda: gr.update(interactive=False),
	inputs=[],
	outputs=[sheet_refresh_btn]
	).then(
	refresh_video_LLM_all_content_by_sheet,
	inputs=[sheet_url, sheet_QA_column, sheet_get_value_result],
	outputs=[refresh_result]
	)


	# OPEN AI CHATBOT SELECT
	chatbot_select_outputs=[
	chatbot_select_accordion,
	all_chatbot_select_btn,
	chatbot_open_ai_streaming,
	chatbot_ai,
	ai_name,
	ai_chatbot_ai_type,
	ai_chatbot_thread_id
	]
	# 聊天机器人的配置数据
	chatbots = [
	{
	"button": vaitor_chatbot_select_btn,
	"name_state": chatbot_open_ai_name,
	"avatar_images": vaitor_chatbot_avatar_images,
	"description_value": vaitor_chatbot_description_value,
	"chatbot_select_outputs": chatbot_select_outputs,
	"chatbot_output": ai_chatbot
	},
	{
	"button": foxcat_chatbot_select_btn,
	"name_state": foxcat_chatbot_name,
	"avatar_images": foxcat_avatar_images,
	"description_value": foxcat_chatbot_description_value,
	"chatbot_select_outputs": chatbot_select_outputs,
	"chatbot_output": ai_chatbot
	},
	{
	"button": lili_chatbot_select_btn,
	"name_state": lili_chatbot_name,
	"avatar_images": lili_avatar_images,
	"description_value": lili_chatbot_description_value,
	"chatbot_select_outputs": chatbot_select_outputs,
	"chatbot_output": ai_chatbot
	},
	{
	"button": maimai_chatbot_select_btn,
	"name_state": maimai_chatbot_name,
	"avatar_images": maimai_avatar_images,
	"description_value": maimai_chatbot_description_value,
	"chatbot_select_outputs": chatbot_select_outputs,
	"chatbot_output": ai_chatbot
	}
	]

	def setup_chatbot_select_button(chatbot_dict):
	button = chatbot_dict["button"]
	chatbot_name_state = chatbot_dict["name_state"]
	avatar_images = chatbot_dict["avatar_images"]
	description_value = chatbot_dict["description_value"]
	chatbot_select_outputs = chatbot_dict["chatbot_select_outputs"]
	chatbot_output = chatbot_dict["chatbot_output"]
	button.click(
	chatbot_select, # 你可能需要修改这个函数以适应当前的逻辑
	inputs=[chatbot_name_state],
	outputs=chatbot_select_outputs
	).then(
	update_avatar_images,
	inputs=[avatar_images, description_value],
	outputs=[chatbot_output],
	scroll_to_output=True
	)

	for chatbot_dict in chatbots:
	setup_chatbot_select_button(chatbot_dict)

	# STREAMING CHATBOT SELECT
	chatbot_open_ai_streaming_select_btn.click(
	chatbot_select,
	inputs=[chatbot_open_ai_streaming_name],
	outputs=chatbot_select_outputs
	).then(
	create_thread_id,
	inputs=[],
	outputs=[streaming_chat_thread_id_state]
	)

	# ALL CHATBOT SELECT LIST
	all_chatbot_select_btn.click(
	show_all_chatbot_accordion,
	inputs=[],
	outputs=[chatbot_select_accordion, all_chatbot_select_btn]
	)
	# OPENAI ASSISTANT CHATBOT 連接按鈕點擊事件
	def setup_question_button_click(button, inputs_list, outputs_list, chat_func, scroll_to_output=True):
	button.click(
	chat_func,
	inputs=inputs_list,
	outputs=outputs_list,
	scroll_to_output=scroll_to_output
	)

	# 其他精靈 ai_chatbot 模式
	ai_send_button.click(
	chat_with_any_ai,
	inputs=[ai_chatbot_ai_type, password, video_id, user_data, trascript_state, key_moments, ai_msg, ai_chatbot, content_subject, content_grade, questions_answers_json, ai_chatbot_socratic_mode_btn, ai_chatbot_thread_id, ai_name],
	outputs=[ai_msg, ai_chatbot, ai_send_button, ai_send_feedback_btn, ai_chatbot_thread_id],
	scroll_to_output=True
	)
	ai_send_feedback_btn.click(
	feedback_with_ai,
	inputs=[user_data, ai_chatbot_ai_type, ai_chatbot, ai_chatbot_thread_id],
	outputs=[ai_chatbot, ai_send_feedback_btn],
	scroll_to_output=True
	)
	# 其他精靈 ai_chatbot 连接 QA 按钮点击事件
	ai_chatbot_question_buttons = [ai_chatbot_question_1, ai_chatbot_question_2, ai_chatbot_question_3]
	for question_btn in ai_chatbot_question_buttons:
	inputs_list = [ai_chatbot_ai_type, password, video_id, user_data, trascript_state, key_moments, question_btn, ai_chatbot, content_subject, content_grade, questions_answers_json, ai_chatbot_socratic_mode_btn, ai_chatbot_thread_id, ai_name]
	outputs_list = [ai_msg, ai_chatbot, ai_send_button, ai_send_feedback_btn, ai_chatbot_thread_id]
	setup_question_button_click(question_btn, inputs_list, outputs_list, chat_with_any_ai)

	# 為生成問題按鈕設定特殊的點擊事件
	question_buttons = [
	ai_chatbot_question_1,
	ai_chatbot_question_2,
	ai_chatbot_question_3
	]
	create_questions_btn.click(
	change_questions,
	inputs=[password, df_string_output],
	outputs=question_buttons
	)
	ai_chatbot_audio_input.change(
	process_open_ai_audio_to_chatbot,
	inputs=[password, ai_chatbot_audio_input],
	outputs=[ai_msg]
	)

	# 当输入 YouTube 链接时触发
	process_youtube_link_inputs = [password, youtube_link, LLM_model]
	process_youtube_link_outputs = [
	video_id,
	questions_answers_json,
	df_string_output,
	summary_text,
	df_summarise,
	key_moments,
	key_moments_html,
	mind_map,
	mind_map_html,
	transcript_html,
	simple_html_content,
	reading_passage_text,
	reading_passage,
	content_subject,
	content_grade,
	]
	update_state_inputs = [
	content_subject,
	content_grade,
	df_string_output,
	key_moments,
	questions_answers_json,
	]
	update_state_outputs = [
	content_subject_state,
	content_grade_state,
	trascript_state,
	key_moments_state,
	streaming_chat_thread_id_state,
	ai_chatbot_question_1,
	ai_chatbot_question_2,
	ai_chatbot_question_3
	]

	junyi_link.input(
	process_junyi_link_to_youtube_link,
	inputs=[junyi_link],
	outputs=[youtube_link]
	).then(
	process_youtube_link,
	inputs=process_youtube_link_inputs,
	outputs=process_youtube_link_outputs
	).then(
	update_state,
	inputs=update_state_inputs,
	outputs=update_state_outputs
	)


	youtube_link.input(
	process_youtube_link,
	inputs=process_youtube_link_inputs,
	outputs=process_youtube_link_outputs
	).then(
	update_state,
	inputs=update_state_inputs,
	outputs=update_state_outputs
	)

	youtube_link_btn.click(
	process_youtube_link,
	inputs=process_youtube_link_inputs,
	outputs=process_youtube_link_outputs
	).then(
	update_state,
	inputs=update_state_inputs,
	outputs=update_state_outputs
	)


	# --- CRUD admin ---
	def setup_content_buttons(buttons_config):
	for config in buttons_config:
	button = config['button']
	action = config['action']
	inputs = config['inputs']
	outputs = config['outputs']
	button.click(
	fn=action,
	inputs=inputs,
	outputs=outputs
	)

	content_buttons_config = [
	# Transcript actions
	{
	'button': transcript_get_button,
	'action': get_LLM_content,
	'inputs': [video_id, transcript_kind],
	'outputs': [df_string_output]
	},
	{
	'button': transcript_create_button,
	'action': create_LLM_content,
	'inputs': [video_id, df_string_output, transcript_kind, LLM_model],
	'outputs': [df_string_output]
	},
	{
	'button': transcript_delete_button,
	'action': delete_LLM_content,
	'inputs': [video_id, transcript_kind],
	'outputs': [df_string_output]
	},
	{
	'button': transcript_edit_button,
	'action': enable_edit_mode,
	'inputs': [],
	'outputs': [df_string_output]
	},
	{
	'button': transcript_update_button,
	'action': update_LLM_content,
	'inputs': [video_id, df_string_output, transcript_kind],
	'outputs': [df_string_output]
	},
	# Reading passage actions
	{
	'button': reading_passage_get_button,
	'action': get_LLM_content,
	'inputs': [video_id, reading_passage_kind],
	'outputs': [reading_passage_text]
	},
	{
	'button': reading_passage_create_button,
	'action': create_LLM_content,
	'inputs': [video_id, df_string_output, reading_passage_kind, LLM_model],
	'outputs': [reading_passage_text]
	},
	{
	'button': reading_passage_delete_button,
	'action': delete_LLM_content,
	'inputs': [video_id, reading_passage_kind],
	'outputs': [reading_passage_text]
	},
	{
	'button': reading_passage_edit_button,
	'action': enable_edit_mode,
	'inputs': [],
	'outputs': [reading_passage_text]
	},
	{
	'button': reading_passage_update_button,
	'action': update_LLM_content,
	'inputs': [video_id, reading_passage_text, reading_passage_kind],
	'outputs': [reading_passage_text]
	},
	# Summary actions
	{
	'button': summary_get_button,
	'action': get_LLM_content,
	'inputs': [video_id, summary_kind],
	'outputs': [summary_text]
	},
	{
	'button': summary_create_button,
	'action': create_LLM_content,
	'inputs': [video_id, df_string_output, summary_kind, LLM_model],
	'outputs': [summary_text]
	},
	{
	'button': summary_delete_button,
	'action': delete_LLM_content,
	'inputs': [video_id, summary_kind],
	'outputs': [summary_text]
	},
	{
	'button': summary_edit_button,
	'action': enable_edit_mode,
	'inputs': [],
	'outputs': [summary_text]
	},
	{
	'button': summary_update_button,
	'action': update_LLM_content,
	'inputs': [video_id, summary_text, summary_kind],
	'outputs': [summary_text]
	},
	# Key moments actions
	{
	'button': key_moments_get_button,
	'action': get_LLM_content,
	'inputs': [video_id, key_moments_kind],
	'outputs': [key_moments]
	},
	{
	'button': key_moments_create_button,
	'action': create_LLM_content,
	'inputs': [video_id, df_string_output, key_moments_kind, LLM_model],
	'outputs': [key_moments]
	},
	{
	'button': key_moments_delete_button,
	'action': delete_LLM_content,
	'inputs': [video_id, key_moments_kind],
	'outputs': [key_moments]
	},
	{
	'button': key_moments_edit_button,
	'action': enable_edit_mode,
	'inputs': [],
	'outputs': [key_moments]
	},
	{
	'button': key_moments_update_button,
	'action': update_LLM_content,
	'inputs': [video_id, key_moments, key_moments_kind],
	'outputs': [key_moments]
	},
	# Questions actions
	{
	'button': questions_get_button,
	'action': get_LLM_content,
	'inputs': [video_id, questions_kind],
	'outputs': [questions_json]
	},
	{
	'button': questions_create_button,
	'action': create_LLM_content,
	'inputs': [video_id, df_string_output, questions_kind, LLM_model],
	'outputs': [questions_json]
	},
	{
	'button': questions_delete_button,
	'action': delete_LLM_content,
	'inputs': [video_id, questions_kind],
	'outputs': [questions_json]
	},
	{
	'button': questions_edit_button,
	'action': enable_edit_mode,
	'inputs': [],
	'outputs': [questions_json]
	},
	{
	'button': questions_update_button,
	'action': update_LLM_content,
	'inputs': [video_id, questions_json, questions_kind],
	'outputs': [questions_json]
	},
	# Questions answers actions
	{
	'button': questions_answers_get_button,
	'action': get_LLM_content,
	'inputs': [video_id, questions_answers_kind],
	'outputs': [questions_answers_json]
	},
	{
	'button': questions_answers_create_button,
	'action': create_LLM_content,
	'inputs': [video_id, df_string_output, questions_answers_kind, LLM_model],
	'outputs': [questions_answers_json]
	},
	{
	'button': questions_answers_delete_button,
	'action': delete_LLM_content,
	'inputs': [video_id, questions_answers_kind],
	'outputs': [questions_answers_json]
	},
	{
	'button': questions_answers_edit_button,
	'action': enable_edit_mode,
	'inputs': [],
	'outputs': [questions_answers_json]
	},
	{
	'button': questions_answers_update_button,
	'action': update_LLM_content,
	'inputs': [video_id, questions_answers_json, questions_answers_kind],
	'outputs': [questions_answers_json]
	},
	# Worksheet actions
	{
	'button': worksheet_get_button,
	'action': get_LLM_content,
	'inputs': [video_id, worksheet_kind],
	'outputs': [worksheet_json]
	},
	{
	'button': worksheet_create_button,
	'action': create_LLM_content,
	'inputs': [video_id, df_string_output, worksheet_kind, LLM_model],
	'outputs': [worksheet_json]
	},
	{
	'button': worksheet_delete_button,
	'action': delete_LLM_content,
	'inputs': [video_id, worksheet_kind],
	'outputs': [worksheet_json]
	},
	{
	'button': worksheet_edit_button,
	'action': enable_edit_mode,
	'inputs': [],
	'outputs': [worksheet_json]
	},
	{
	'button': worksheet_update_button,
	'action': update_LLM_content,
	'inputs': [video_id, worksheet_json, worksheet_kind],
	'outputs': [worksheet_json]
	},
	]
	setup_content_buttons(content_buttons_config)

	# --- Education Material ---
	def setup_education_buttons(buttons_config):
	for config in buttons_config:
	button = config["button"]
	action = config["action"]
	inputs = config["inputs"]
	outputs = config["outputs"]
	button.click(
	fn=action,
	inputs=inputs,
	outputs=outputs
	)
	education_buttons_config = [
	# 學習單相關按鈕
	{
	"button": worksheet_content_btn,
	"action": get_ai_content,
	"inputs": [password, user_data, video_id, df_string_output, content_subject, content_grade, content_level, worksheet_algorithm, worksheet_content_type_name],
	"outputs": [worksheet_result_original, worksheet_result, worksheet_prompt, worksheet_result_prompt]
	},
	{
	"button": worksheet_result_fine_tune_btn,
	"action": generate_ai_content_fine_tune_result,
	"inputs": [password, user_data, worksheet_result_prompt, df_string_output, worksheet_result, worksheet_result_fine_tune_prompt, worksheet_content_type_name],
	"outputs": [worksheet_result]
	},
	{
	"button": worksheet_download_button,
	"action": download_exam_result,
	"inputs": [worksheet_result],
	"outputs": [worksheet_result_word_link]
	},
	{
	"button": worksheet_result_retrun_original,
	"action": return_original_exam_result,
	"inputs": [worksheet_result_original],
	"outputs": [worksheet_result]
	},
	# 教案相關按鈕
	{
	"button": lesson_plan_btn,
	"action": get_ai_content,
	"inputs": [password, user_data, video_id, df_string_output, content_subject, content_grade, content_level, lesson_plan_time, lesson_plan_content_type_name],
	"outputs": [lesson_plan_result_original, lesson_plan_result, lesson_plan_prompt, lesson_plan_result_prompt]
	},
	{
	"button": lesson_plan_result_fine_tune_btn,
	"action": generate_ai_content_fine_tune_result,
	"inputs": [password, user_data, lesson_plan_result_prompt, df_string_output, lesson_plan_result, lesson_plan_result_fine_tune_prompt, lesson_plan_content_type_name],
	"outputs": [lesson_plan_result]
	},
	{
	"button": lesson_plan_download_button,
	"action": download_exam_result,
	"inputs": [lesson_plan_result],
	"outputs": [lesson_plan_result_word_link]
	},
	{
	"button": lesson_plan_result_retrun_original,
	"action": return_original_exam_result,
	"inputs": [lesson_plan_result_original],
	"outputs": [lesson_plan_result]
	},
	# 出場券相關按鈕
	{
	"button": exit_ticket_btn,
	"action": get_ai_content,
	"inputs": [password, user_data, video_id, df_string_output, content_subject, content_grade, content_level, exit_ticket_time, exit_ticket_content_type_name],
	"outputs": [exit_ticket_result_original, exit_ticket_result, exit_ticket_prompt, exit_ticket_result_prompt]
	},
	{
	"button": exit_ticket_result_fine_tune_btn,
	"action": generate_ai_content_fine_tune_result,
	"inputs": [password, user_data, exit_ticket_result_prompt, df_string_output, exit_ticket_result, exit_ticket_result_fine_tune_prompt, exit_ticket_content_type_name],
	"outputs": [exit_ticket_result]
	},
	{
	"button": exit_ticket_download_button,
	"action": download_exam_result,
	"inputs": [exit_ticket_result],
	"outputs": [exit_ticket_result_word_link]
	},
	{
	"button": exit_ticket_result_retrun_original,
	"action": return_original_exam_result,
	"inputs": [exit_ticket_result_original],
	"outputs": [exit_ticket_result]
	}
	]
	setup_education_buttons(education_buttons_config)

	# init_params
	init_outputs = [
	admin,
	reading_passage_admin,
	summary_admmin,
	see_details,
	worksheet_accordion,
	lesson_plan_accordion,
	exit_ticket_accordion,
	password,
	youtube_link,
	block_ready_flag,
	chatbot_open_ai_streaming,
	chatbot_ai,
	ai_chatbot_params,
	is_env_prod,
	]
	demo.load(
	init_params,
	inputs =[youtube_link],
	outputs = init_outputs
	)

	app = gr.mount_gradio_app(
	app, demo, "/", server_name="0.0.0.0", server_port=7860, show_error=True
	)
	return app

	if __name__ == "__main__":
	import uvicorn
	port = int(os.environ.get("PORT", 7860))
	app = create_app()
	uvicorn.run(app, host="0.0.0.0", port=port)