video_bot_999

Sleeping

App Files Files Community

video_bot_999 / app.py

youngtsai

update

aaa2911 5 months ago

raw

history blame

163 kB

	import gradio as gr
	import pandas as pd
	import requests
	from bs4 import BeautifulSoup
	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._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 timedelta
	from urllib.parse import urlparse, parse_qs

	from google.cloud import storage
	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

	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)
	PASSWORD = config["PASSWORD"]
	GCS_KEY = json.dumps(config["GOOGLE_APPLICATION_CREDENTIALS_JSON"])
	DRIVE_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"]
	OPEN_AI_KEY_BOT2 = config["OPEN_AI_KEY_BOT2"]
	OPEN_AI_ASSISTANT_ID_GPT4_BOT2 = config["OPEN_AI_ASSISTANT_ID_GPT4_BOT2"]
	OPEN_AI_ASSISTANT_ID_GPT3_BOT2 = config["OPEN_AI_ASSISTANT_ID_GPT3_BOT2"]
	GROQ_API_KEY = config["GROQ_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"]
	else:
	PASSWORD = os.getenv("PASSWORD")
	GCS_KEY = os.getenv("GOOGLE_APPLICATION_CREDENTIALS_JSON")
	DRIVE_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")
	OPEN_AI_KEY_BOT2 = os.getenv("OPEN_AI_KEY_BOT2")
	OPEN_AI_ASSISTANT_ID_GPT4_BOT2 = os.getenv("OPEN_AI_ASSISTANT_ID_GPT4_BOT2")
	OPEN_AI_ASSISTANT_ID_GPT3_BOT2 = os.getenv("OPEN_AI_ASSISTANT_ID_GPT3_BOT2")
	GROQ_API_KEY = os.getenv("GROQ_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'

	TRANSCRIPTS = []
	CURRENT_INDEX = 0
	CHAT_LIMIT = 10

	# CLIENTS CONFIG
	GROQ_CLIENT = Groq(api_key=GROQ_API_KEY)
	GCS_SERVICE = GoogleCloudStorage(GCS_KEY)
	GCS_CLIENT = GCS_SERVICE.client
	BEDROCK_CLIENT = boto3.client(
	service_name="bedrock-runtime",
	aws_access_key_id=AWS_ACCESS_KEY,
	aws_secret_access_key=AWS_SECRET_KEY,
	region_name=AWS_REGION_NAME,
	)

	# 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-3.5-turbo",
	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},
	{"account":"bot2", "open_ai_api_key": OPEN_AI_KEY_BOT2, "assistant_gpt4_id": OPEN_AI_ASSISTANT_ID_GPT4_BOT2, "assistant_gpt3_id": OPEN_AI_ASSISTANT_ID_GPT3_BOT2},
	]
	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 get_transcript_by_yt_api(video_id):
	transcript_list = YouTubeTranscriptApi.list_transcripts(video_id)
	languages = []
	for t in transcript_list:
	languages.append(t.language_code)

	for language in languages:
	try:
	transcript = YouTubeTranscriptApi.get_transcript(video_id, languages=[language])
	print("===transcript===")
	print(transcript)
	print("===transcript===")
	return transcript # 成功獲取字幕，直接返回結果
	except NoTranscriptFound:
	continue # 當前語言的字幕沒有找到，繼續嘗試下一個語言
	return None # 所有嘗試都失敗，返回None

	def generate_transcription_by_whisper(video_id):
	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'],
	'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====")
	# GCS
	gcs_client = GCS_CLIENT
	bucket_name = 'video_ai_assistant'
	# 逐字稿文件名
	transcript_file_name = f'{video_id}_transcript.json'
	transcript_blob_name = f"{video_id}/{transcript_file_name}"
	# 检查逐字稿是否存在
	is_new_transcript = False
	is_transcript_exists = GCS_SERVICE.check_file_exists(bucket_name, transcript_blob_name)
	video_duration = get_video_duration(video_id)
	if not is_transcript_exists:
	print("逐字稿文件不存在于GCS中，重新建立")
	# 从YouTube获取逐字稿并上传
	try:
	transcript = get_transcript_by_yt_api(video_id)
	except:
	# call open ai whisper
	print("===call open ai whisper===")
	transcript = generate_transcription_by_whisper(video_id)

	if transcript:
	print("成功獲取字幕")
	else:
	print("沒有找到字幕")
	transcript = generate_transcription_by_whisper(video_id)
	if video_duration:
	transcript = [entry for entry in transcript if entry['start'] <= video_duration]

	transcript_text = json.dumps(transcript, ensure_ascii=False, indent=2)
	GCS_SERVICE.upload_json_string(bucket_name, transcript_blob_name, transcript_text)

	is_new_transcript = True
	else:
	# 逐字稿已存在，下载逐字稿内容
	print("逐字稿已存在于GCS中")
	transcript_text = GCS_SERVICE.download_as_string(bucket_name, transcript_blob_name)
	transcript = json.loads(transcript_text)
	if video_duration:
	transcript = [entry for entry in transcript if entry['start'] <= video_duration]

	# print("===確認其他衍生文件===")
	# source = "gcs"
	# get_questions(video_id, transcript_text, source)
	# get_video_id_summary(video_id, transcript_text, source)
	# get_mind_map(video_id, transcript_text, source)
	# print("===確認其他衍生文件 end ===")


	# 處理截圖
	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):
	# try 5 times 如果都失敗就 raise
	for i in range(5):
	try:
	download_youtube_video(video_id)
	break
	except Exception as e:
	if i == 4:
	raise gr.Error(f"下载视频失败: {str(e)}")
	time.sleep(5)
	# 截图
	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(bucket_name, screenshot_blob_name, screenshot_path)
	entry['img_file_id'] = img_file_id
	print(f"截图已上传到GCS: {img_file_id}")
	is_new_transcript = True

	# 確認是否更新逐字稿文件
	if is_new_transcript:
	# 更新逐字稿文件
	print("===更新逐字稿文件===")
	print(transcript)
	print("===更新逐字稿文件===")
	updated_transcript_text = json.dumps(transcript, ensure_ascii=False, indent=2)
	GCS_SERVICE.upload_json_string(bucket_name, transcript_blob_name, updated_transcript_text)
	print("逐字稿已更新，包括截图链接")
	updated_transcript_json = json.loads(updated_transcript_text)
	else:
	updated_transcript_json = transcript

	return updated_transcript_json

	def process_youtube_link(password, link):
	verify_password(password)

	# 使用 YouTube API 获取逐字稿
	# 假设您已经获取了 YouTube 视频的逐字稿并存储在变量 `transcript` 中
	video_id = extract_youtube_id(link)

	try:
	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)

	global TRANSCRIPTS
	TRANSCRIPTS = formatted_transcript

	# 基于逐字稿生成其他所需的输出
	source = "gcs"
	questions_answers = get_questions_answers(video_id, formatted_simple_transcript, source)
	questions_answers_json = json.dumps(questions_answers, ensure_ascii=False, indent=2)
	summary_json = get_video_id_summary(video_id, formatted_simple_transcript, source)
	summary_text = summary_json["summary"]
	summary = summary_json["summary"]
	key_moments_json = get_key_moments(video_id, formatted_simple_transcript, formatted_transcript, source)
	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)
	first_image = formatted_transcript[0]['screenshot_path']
	# first_image = "https://www.nameslook.com/names/dfsadf-nameslook.png"
	first_text = formatted_transcript[0]['text']
	mind_map_json = get_mind_map(video_id, formatted_simple_transcript, source)
	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)
	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, \
	first_image, \
	first_text, \
	reading_passage_text, \
	reading_passage, \
	subject, \
	grade

	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])
	segments.append(segment)

	return segments

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

	try:
	model = "gpt-4-turbo"
	# 使用 OPEN AI 生成 Reading Passage
	messages = [
	{"role": "system", "content": sys_content},
	{"role": "user", "content": user_content}
	]

	request_payload = {
	"model": model,
	"messages": messages,
	"max_tokens": 4000,
	"response_format": response_format
	}

	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()
	except Exception as e:
	print(f"Error generating reading passage: {str(e)}")
	print("using REDROCK")
	# 使用 REDROCK 生成 Reading Passage
	messages = [
	{"role": "user", "content": user_content}
	]
	model_id = "anthropic.claude-3-sonnet-20240229-v1:0"
	# 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')

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

	return content

	def get_reading_passage(video_id, df_string, source):
	if source == "gcs":
	print("===get_reading_passage on gcs===")
	gcs_client = GCS_CLIENT
	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)
	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):
	print("===generate_reading_passage===")
	segments = split_data(df_string, word_base=100000)
	all_content = []

	for segment in segments:
	sys_content = "你是一個擅長資料分析跟影片教學的老師，user 為學生，請精讀資料文本，自行判斷資料的種類，使用 zh-TW"
	user_content = f"""
	請根據 {segment}
	文本自行判斷資料的種類
	幫我組合成 Reading Passage
	並潤稿讓文句通順
	請一定要使用繁體中文 zh-TW，並用台灣人的口語
	產生的結果不要前後文解釋，也不要敘述這篇文章怎麼產生的
	只需要專注提供 Reading Passage，字數在 500 字以內
	敘述中，請把數學或是專業術語，用 Latex 包覆（$...$），並且不要去改原本的文章
	加減乘除、根號、次方等等的運算式口語也換成 LATEX 數學符號
	請直接給出文章，不用介紹怎麼處理的或是文章字數等等
	"""
	content = generate_content_by_LLM(sys_content, user_content)
	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):
	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)
	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)
	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):
	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)
	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):
	if source == "gcs":
	print("===get_video_id_summary on gcs===")
	gcs_client = GCS_CLIENT
	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)
	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)
	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):
	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)
	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)
	else:
	final_content = all_content[0]

	return final_content

	def get_questions(video_id, df_string, source="gcs"):
	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)
	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)
	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):
	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]
	}}
	"""

	try:
	model = "gpt-4-turbo"
	messages = [
	{"role": "system", "content": sys_content},
	{"role": "user", "content": user_content}
	]
	response_format = { "type": "json_object" }

	print("=====messages=====")
	print(messages)
	print("=====messages=====")


	request_payload = {
	"model": model,
	"messages": messages,
	"max_tokens": 4000,
	"response_format": response_format
	}

	response = OPEN_AI_CLIENT.chat.completions.create(**request_payload)
	questions = json.loads(response.choices[0].message.content)["questions"]
	except:
	messages = [
	{"role": "user", "content": user_content}
	]
	model_id = "anthropic.claude-3-sonnet-20240229-v1:0"
	# 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())
	response_completion = response_body.get('content')[0].get('text')
	questions = json.loads(response_completion)["questions"]

	print("=====json_response=====")
	print(questions)
	print("=====json_response=====")

	return questions

	def get_questions_answers(video_id, df_string, source="gcs"):
	if source == "gcs":
	try:
	print("===get_questions_answers on gcs===")
	gcs_client = GCS_CLIENT
	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)
	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 = get_questions(video_id, df_string, source)
	questions_answers = [{"question": q, "answer": ""} for q in questions]

	return questions_answers

	def generate_questions_answers(df_string):
	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)
	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):
	if source == "gcs":
	print("===get_key_moments on gcs===")
	gcs_client = GCS_CLIENT
	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)
	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)
	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)

	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)
	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):
	print("===generate_key_moments===")
	# 使用 OpenAI 生成基于上传数据的问题
	sys_content = "你是一個擅長資料分析跟影片教學的老師，user 為學生，請精讀資料文本，自行判斷資料的種類，使用 zh-TW"
	user_content = f"""
	請根據 {formatted_simple_transcript} 文本，提取出重點摘要，並給出對應的時間軸
	1. 小範圍切出不同段落的相對應時間軸的重點摘要，
	2. 每一小段最多不超過 1/5 的總內容，也就是大約 3~5段的重點（例如五～十分鐘的影片就一段大約1~2分鐘，最多三分鐘，但如果是超過十分鐘的影片，那一小段大約 2~3分鐘，以此類推）
	3. 注意不要遺漏任何一段時間軸的內容從零秒開始
	4. 如果頭尾的情節不是重點，特別是打招呼或是介紹人物、或是say goodbye 就是不重要的情節，就不用擷取
	5. 以這種方式分析整個文本，從零秒開始分析，直到結束。這很重要
	6. 關鍵字從transcript extract to keyword，保留專家名字、專業術語、年份、數字、期刊名稱、地名、數學公式
	7. text, keywords please use or transfer to zh-TW, it's very important

	Example: retrun JSON
	{{key_moments:[{{
	"start": "00:00",
	"end": "01:00",
	"text": "逐字稿的重點摘要",
	"keywords": ["關鍵字", "關鍵字"]
	}}]
	}}
	"""

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

	for segment in segments:
	sys_content = "你是一個擅長資料分析跟影片教學的老師，user 為學生，請精讀資料文本，自行判斷資料的種類，使用 zh-TW"
	user_content = f"""
	請根據 {segment} 文本，提取出重點摘要，並給出對應的時間軸
	1. 小範圍切出不同段落的相對應時間軸的重點摘要，
	2. 每一小段最多不超過 1/5 的總內容，也就是大約 3~5段的重點（例如五～十分鐘的影片就一段大約1~2分鐘，最多三分鐘，但如果是超過十分鐘的影片，那一小段大約 2~3分鐘，以此類推）
	3. 注意不要遺漏任何一段時間軸的內容從零秒開始
	4. 如果頭尾的情節不是重點，特別是打招呼或是介紹人物、或是say goodbye 就是不重要的情節，就不用擷取
	5. 以這種方式分析整個文本，從零秒開始分析，直到結束。這很重要
	6. 關鍵字從transcript extract to keyword，保留專家名字、專業術語、年份、數字、期刊名稱、地名、數學公式
	7. text, keywords please use or transfer zh-TW, it's very important

	Example: retrun JSON
	{{key_moments:[{{
	"start": "00:00",
	"end": "01:00",
	"text": "逐字稿的重點摘要",
	"keywords": ["關鍵字", "關鍵字"]
	}}]
	}}
	"""
	response_format = { "type": "json_object" }
	content = generate_content_by_LLM(sys_content, user_content, response_format)
	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

	all_content += key_moments

	return all_content

	def generate_key_moments_keywords(transcript):
	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)
	keywords = content.strip().split(",")
	all_content += keywords

	return all_content

	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;
	}

	@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):
	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>
	"""

	key_moments_html += f"""
	<div class="gallery-container" id="gallery-main">
	<div id="gallery"><!-- gallery start -->
	<div id="gallery-container">
	{gallery_content}
	</div>
	</div>
	<div id="text-content">
	<h3>{moment['start']} - {moment['end']}</h3>
	<p><strong>摘要: {moment['text']} </strong></p>
	<p>內容: {moment['transcript']}</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"]
	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===")
	gcs_client = GCS_CLIENT
	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_text = json.dumps(key_moments_json, ensure_ascii=False, indent=2)
	GCS_SERVICE.upload_json_string(bucket_name, blob_name, key_moments_text)
	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):
	print(f"===create_{kind}===")
	print(f"video_id: {video_id}")

	if kind == "reading_passage_latex":
	content = generate_reading_passage(df_string)
	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)
	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)
	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)
	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)
	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-4-turbo",
	"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-4-turbo",
	"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


	# 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, 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")
	else:
	ai_content_json = ai_content_json[-1]
	ai_content = ai_content_json["content"]
	prompt = ai_content_json["prompt"]

	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_exam_fine_tune_result(password, exam_result_prompt , df_string_output, exam_result, exam_result_fine_tune_prompt):
	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)

	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, 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}
	Assistant Role: you are a {content_subject} assistant. you can call yourself as {content_subject} 學伴
	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.
	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.
	- Single question, under 100 characters
	- 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 by Taiwanese style 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
	"""
	return instructions

	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}")
	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)

	if ai_type == "chat_completions":
	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)
	thread_id = ""
	elif ai_type == "assistant":
	client = OPEN_AI_CLIENT
	assistant_id = OPEN_AI_ASSISTANT_ID_GPT4 #GPT 4 turbo
	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)
	key_moments_text = json.dumps(key_moments_json, ensure_ascii=False)
	instructions = get_instructions(content_subject, content_grade, key_moments_text, socratic_mode)
	print(f"=== instructions:{instructions} ===")
	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",
	}
	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)

	# 返回聊天历史和空字符串清空输入框
	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": GROQ_CLIENT,
	"ai_model_name": "groq_llama3",
	},
	"lili": {
	"ai_name": "lili",
	"ai_client": BEDROCK_CLIENT,
	"ai_model_name": "claude3",
	},
	"maimai": {
	"ai_name": "maimai",
	"ai_client": GROQ_CLIENT,
	"ai_model_name": "groq_mixtral",
	}
	}
	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)
	key_moments_text = json.dumps(key_moments_json, ensure_ascii=False)

	instructions = get_instructions(content_subject, content_grade, 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(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-4-turbo"
	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")

	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_text = messages.data[0].content[0].text.value
	else:
	response_text = "學習精靈有點累，請稍後再試！"

	except Exception as e:
	if fallback:
	response = client.chat.completions.create(
	model="gpt-4-turbo",
	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-4-turbo",
	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, trascript, 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)

	try:
	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
	# 直接安排逐字稿資料 in instructions
	# if isinstance(trascript, str):
	# trascript_json = json.loads(trascript)
	# else:
	# trascript_json = trascript
	# trascript_text = json.dumps(trascript_json, ensure_ascii=False)
	# # trascript_text 移除 \n, 空白
	# trascript_text = trascript_text.replace("\n", "").replace(" ", "")

	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)
	key_moments_text = json.dumps(key_moments_json, ensure_ascii=False)

	instructions = get_instructions(content_subject, content_grade, 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={
	"youtube_id": video_id,
	"user_data": user_data,
	"content_subject": content_subject,
	"content_grade": content_grade,
	"assistant_id": assistant_id,
	"is_streaming": "true",
	}
	)

	# 向线程添加用户的消息
	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}")

	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

	# --- Slide mode ---
	def update_slide(direction):
	global TRANSCRIPTS
	global CURRENT_INDEX

	print("=== 更新投影片 ===")
	print(f"CURRENT_INDEX: {CURRENT_INDEX}")
	# print(f"TRANSCRIPTS: {TRANSCRIPTS}")

	CURRENT_INDEX += direction
	if CURRENT_INDEX < 0:
	CURRENT_INDEX = 0 # 防止索引小于0
	elif CURRENT_INDEX >= len(TRANSCRIPTS):
	CURRENT_INDEX = len(TRANSCRIPTS) - 1 # 防止索引超出范围

	# 获取当前条目的文本和截图 URL
	current_transcript = TRANSCRIPTS[CURRENT_INDEX]
	slide_image = current_transcript["screenshot_path"]
	slide_text = current_transcript["text"]

	return slide_image, slide_text

	def prev_slide():
	return update_slide(-1)

	def next_slide():
	return update_slide(1)


	# --- 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 = ""
	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)

	# 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", "")
	if "junyiacademy" in origin:
	password_text = "6161"
	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)

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

	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">
	<style>
	svg.markmap {{
	width: 100%;
	height: 100vh;
	}}
	</style>
	<script src="https://cdn.jsdelivr.net/npm/markmap-autoloader@0.15.2"></script>

	<script>
	const 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>
	"""

	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) as demo:
	with gr.Row() as admin:
	password = gr.Textbox(label="Password", type="password", elem_id="password_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)
	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=True, visible=True)
	latex_delimiters = [{"left": "$", "right": "$", "display": False}]
	with gr.Accordion("選擇 AI 小精靈", elem_id="chatbot_select_accordion") as chatbot_select_accordion:
	with gr.Row():
	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?v=20200513013523726"
	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)
	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"):
	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)
	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"):
	lili_chatbot_avatar_url = "https://junyitopicimg.s3.amazonaws.com/live/v1283-new-topic-44-icon.png?v=20230529071206714"
	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)
	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"):
	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)
	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", 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)
	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)
	# 尚未開放
	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,
	additional_inputs=additional_inputs,
	submit_btn="送出",
	retry_btn=None,
	undo_btn="⏪ 上一步",
	clear_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, likeable=True, 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}])
	with gr.Tab("關鍵時刻"):
	with gr.Row():
	key_moments_html = gr.HTML(value="")
	with gr.Tab("教學備課"):
	with gr.Row():
	content_subject = gr.Dropdown(label="選擇主題", choices=["數學", "自然", "國文", "英文", "社會","物理", "化學", "生物", "地理", "歷史", "公民"], value="", visible=False)
	content_grade = gr.Dropdown(label="選擇年級", choices=["一年級", "二年級", "三年級", "四年級", "五年級", "六年級", "七年級", "八年級", "九年級", "十年級", "十一年級", "十二年級"], value="", visible=False)
	content_level = gr.Dropdown(label="差異化教學", choices=["基礎", "中級", "進階"], value="基礎")
	with gr.Row():
	with gr.Tab("學習單"):
	with gr.Row():
	with gr.Column(scale=1):
	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_exam_result_fine_tune_prompt = gr.Textbox(label="根據結果，輸入你想更改的想法")
	worksheet_exam_result_fine_tune_btn = gr.Button("微調結果", variant="primary")
	worksheet_exam_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_exam_result_prompt = gr.Textbox(visible=False)
	worksheet_exam_result_original = gr.Textbox(visible=False)
	# worksheet_exam_result = gr.Textbox(label="初次生成結果", show_copy_button=True, interactive=True, lines=40)
	worksheet_exam_result = gr.Markdown(label="初次生成結果", latex_delimiters = [{"left": "$", "right": "$", "display": False}])
	worksheet_download_exam_result_button = gr.Button("轉成 word，完成後請點擊右下角 download 按鈕", variant="primary")
	worksheet_exam_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_exam_result_fine_tune_prompt = gr.Textbox(label="根據結果，輸入你想更改的想法")
	lesson_plan_exam_result_fine_tune_btn = gr.Button("微調結果", variant="primary")
	lesson_plan_exam_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_exam_result_prompt = gr.Textbox(visible=False)
	lesson_plan_exam_result_original = gr.Textbox(visible=False)
	lesson_plan_exam_result = gr.Markdown(label="初次生成結果", latex_delimiters = [{"left": "$", "right": "$", "display": False}])

	lesson_plan_download_exam_result_button = gr.Button("轉成 word，完成後請點擊右下角 download 按鈕", variant="primary")
	lesson_plan_exam_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_exam_result_fine_tune_prompt = gr.Textbox(label="根據結果，輸入你想更改的想法")
	exit_ticket_exam_result_fine_tune_btn = gr.Button("微調結果", variant="primary")
	exit_ticket_exam_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_exam_result_prompt = gr.Textbox(visible=False)
	exit_ticket_exam_result_original = gr.Textbox(visible=False)
	exit_ticket_exam_result = gr.Markdown(label="初次生成結果", latex_delimiters = [{"left": "$", "right": "$", "display": False}])

	exit_ticket_download_exam_result_button = gr.Button("轉成 word，完成後請點擊右下角 download 按鈕", variant="primary")
	exit_ticket_exam_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("See Details", open=False) as see_details:
	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("投影片"):
	slide_image = gr.Image()
	slide_text = gr.Textbox()
	with gr.Row():
	prev_button = gr.Button("Previous")
	next_button = gr.Button("Next")
	prev_button.click(fn=prev_slide, inputs=[], outputs=[slide_image, slide_text])
	next_button.click(fn=next_slide, inputs=[], outputs=[slide_image, slide_text])
	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.Tab("心智圖",elem_id="mind_map_tab"):
	mind_map_html = gr.HTML()

	# 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=[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]
	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,
	slide_image,
	slide_text,
	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
	]

	youtube_link.change(
	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],
	'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],
	'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],
	'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],
	'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],
	'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],
	'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],
	'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, video_id, df_string_output, content_subject, content_grade, content_level, worksheet_algorithm, worksheet_content_type_name],
	"outputs": [worksheet_exam_result_original, worksheet_exam_result, worksheet_prompt, worksheet_exam_result_prompt]
	},
	{
	"button": worksheet_exam_result_fine_tune_btn,
	"action": generate_exam_fine_tune_result,
	"inputs": [password, worksheet_exam_result_prompt, df_string_output, worksheet_exam_result, worksheet_exam_result_fine_tune_prompt],
	"outputs": [worksheet_exam_result]
	},
	{
	"button": worksheet_download_exam_result_button,
	"action": download_exam_result,
	"inputs": [worksheet_exam_result],
	"outputs": [worksheet_exam_result_word_link]
	},
	{
	"button": worksheet_exam_result_retrun_original,
	"action": return_original_exam_result,
	"inputs": [worksheet_exam_result_original],
	"outputs": [worksheet_exam_result]
	},
	# 教案相關按鈕
	{
	"button": lesson_plan_btn,
	"action": get_ai_content,
	"inputs": [password, video_id, df_string_output, content_subject, content_grade, content_level, lesson_plan_time, lesson_plan_content_type_name],
	"outputs": [lesson_plan_exam_result_original, lesson_plan_exam_result, lesson_plan_prompt, lesson_plan_exam_result_prompt]
	},
	{
	"button": lesson_plan_exam_result_fine_tune_btn,
	"action": generate_exam_fine_tune_result,
	"inputs": [password, lesson_plan_exam_result_prompt, df_string_output, lesson_plan_exam_result, lesson_plan_exam_result_fine_tune_prompt],
	"outputs": [lesson_plan_exam_result]
	},
	{
	"button": lesson_plan_download_exam_result_button,
	"action": download_exam_result,
	"inputs": [lesson_plan_exam_result],
	"outputs": [lesson_plan_exam_result_word_link]
	},
	{
	"button": lesson_plan_exam_result_retrun_original,
	"action": return_original_exam_result,
	"inputs": [lesson_plan_exam_result_original],
	"outputs": [lesson_plan_exam_result]
	},
	# 出場券相關按鈕
	{
	"button": exit_ticket_btn,
	"action": get_ai_content,
	"inputs": [password, video_id, df_string_output, content_subject, content_grade, content_level, exit_ticket_time, exit_ticket_content_type_name],
	"outputs": [exit_ticket_exam_result_original, exit_ticket_exam_result, exit_ticket_prompt, exit_ticket_exam_result_prompt]
	},
	{
	"button": exit_ticket_exam_result_fine_tune_btn,
	"action": generate_exam_fine_tune_result,
	"inputs": [password, exit_ticket_exam_result_prompt, df_string_output, exit_ticket_exam_result, exit_ticket_exam_result_fine_tune_prompt],
	"outputs": [exit_ticket_exam_result]
	},
	{
	"button": exit_ticket_download_exam_result_button,
	"action": download_exam_result,
	"inputs": [exit_ticket_exam_result],
	"outputs": [exit_ticket_exam_result_word_link]
	},
	{
	"button": exit_ticket_exam_result_retrun_original,
	"action": return_original_exam_result,
	"inputs": [exit_ticket_exam_result_original],
	"outputs": [exit_ticket_exam_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,
	chatbot_open_ai_streaming,
	chatbot_ai,
	ai_chatbot_params,
	]
	demo.load(
	init_params,
	inputs =[youtube_link],
	outputs = init_outputs
	)

	demo.launch(allowed_paths=["videos"])