update

.gitignore

@@ -0,0 +1 @@
+local_config.json

README.md

@@ -9,4 +9,5 @@ app_file: app.py
 pinned: false
 ---
 
+
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -5,15 +5,24 @@ from bs4 import BeautifulSoup
 from docx import Document
 import os
 from openai import OpenAI
-import json
+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 urllib.parse import urlparse, parse_qs
 
 from google.cloud import storage
 from google.oauth2 import service_account
@@ -22,69 +31,68 @@ from googleapiclient.http import MediaFileUpload
 from googleapiclient.http import MediaIoBaseDownload
 from googleapiclient.http import MediaIoBaseUpload
 
-import io
-import time
-
-
-from urllib.parse import urlparse, parse_qs
-
-
-# 假设您的环境变量或Secret的名称是GOOGLE_APPLICATION_CREDENTIALS_JSON
-# credentials_json_string = os.getenv("GOOGLE_APPLICATION_CREDENTIALS_JSON")
-# 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)
-# # 列出 Google Drive 上的前10個文件
-# results = service.files().list(pageSize=10, fields="nextPageToken, files(id, name)").execute()
-# items = results.get('files', [])
-
-# if not items:
-#     print('No files found.')
-# else:
-#     print("=====Google Drive 上的前10個文件=====")
-#     print('Files:')
-#     for item in items:
-#         print(u'{0} ({1})'.format(item['name'], item['id']))
-
-
+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__)
+
+
+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"]
+        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")
+    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'
 
-OUTPUT_PATH = 'videos'
 TRANSCRIPTS = []
 CURRENT_INDEX = 0
 VIDEO_ID = ""
 
-OPEN_AI_KEY = os.getenv("OPEN_AI_KEY")
 OPEN_AI_CLIENT = OpenAI(api_key=OPEN_AI_KEY)
-DRIVE_KEY = os.getenv("GOOGLE_APPLICATION_CREDENTIALS_JSON")
-GCS_KEY = os.getenv("GOOGLE_APPLICATION_CREDENTIALS_JSON")
-
-# ====gcs====
-def init_gcs_client(service_account_key_string):
-    """使用服务账号密钥文件创建 GCS 客户端"""
-    credentials_json_string = service_account_key_string
-    credentials_dict = json.loads(credentials_json_string)
-    credentials = service_account.Credentials.from_service_account_info(credentials_dict)
-    gcs_client = storage.Client(credentials=credentials, project=credentials_dict['project_id'])
-    return gcs_client
-
-def gcs_create_bucket_folder_if_not_exists(gcs_client, bucket_name, folder_name):
-    """检查是否存在特定名称的文件夹（前缀），如果不存在则创建一个标记文件来模拟文件夹"""
-    bucket = gcs_client.bucket(bucket_name)
-    blob = bucket.blob(folder_name)
-    if not blob.exists():
-        blob.upload_from_string('', content_type='application/x-www-form-urlencoded;charset=UTF-8')
-        print(f"GCS Folder '{folder_name}' created.")
+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,
+)
+
+# 驗證 password
+def verify_password(password):
+    if password == PASSWORD:
+        return True
     else:
-        print(f"GCS Folder '{folder_name}' already exists.")
-
-def gcs_check_folder_exists(gcs_client, bucket_name, folder_name):
-    """检查 GCS 存储桶中是否存在指定的文件夹"""
-    bucket = gcs_client.bucket(bucket_name)
-    blobs = list(bucket.list_blobs(prefix=folder_name))
-    return len(blobs) > 0
+        raise gr.Error("密碼錯誤")
 
+# ====gcs====
 def gcs_check_file_exists(gcs_client, bucket_name, file_name):
     """
     检查 GCS 存储桶中是否存在指定的文件
@@ -106,7 +114,7 @@ def upload_file_to_gcs_with_json_string(gcs_client, bucket_name, destination_blo
     bucket = gcs_client.bucket(bucket_name)
     blob = bucket.blob(destination_blob_name)
     blob.upload_from_string(json_string)
-    print(f"JSON string uploaded to {destination_blob_name} in GCS.")    
+    print(f"JSON string uploaded to {destination_blob_name} in GCS.")
 
 def download_blob_to_string(gcs_client, bucket_name, source_blob_name):
     """从 GCS 下载文件内容到字符串"""
@@ -167,6 +175,13 @@ def copy_file_from_drive_to_gcs(drive_service, gcs_client, file_id, bucket_name,
     blob.upload_from_string(file_content)
     print(f"File {file_id} copied to GCS at {gcs_destination_path}.")
 
+def delete_blob(gcs_client, bucket_name, blob_name):
+    """删除指定的 GCS 对象"""
+    bucket = gcs_client.bucket(bucket_name)
+    blob = bucket.blob(blob_name)
+    blob.delete()
+    print(f"Blob {blob_name} deleted from GCS.")
+
 # # ====drive====初始化
 def init_drive_service():
     credentials_json_string = DRIVE_KEY
@@ -291,9 +306,10 @@ def update_file_on_drive(service, file_id, file_content):
     
     print(f"文件已更新，文件ID: {updated_file['id']}")
 
-
-# ----  Main Functions ----
-def process_file(file):
+# ---- Text file ----
+def process_file(password, file):
+    verify_password(password)
+    
     # 读取文件
     if file.name.endswith('.csv'):
         df = pd.read_csv(file)
@@ -330,6 +346,8 @@ def docx_to_text(file):
     doc = Document(file)
     return "\n".join([para.text for para in doc.paragraphs])
 
+
+# ---- YouTube link ----
 def format_seconds_to_time(seconds):
     """将秒数格式化为 时:分:秒 的形式"""
     hours = int(seconds // 3600)
@@ -360,6 +378,65 @@ def get_transcript(video_id):
             continue  # 當前語言的字幕沒有找到，繼續嘗試下一個語言
     return None  # 所有嘗試都失敗，返回None
 
+def generate_transcription(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)
+
+        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 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)
+
+        # Remove temporary chunk files after processing
+        os.remove(chunk_path)
+
+    return transcription
+ 
 def process_transcript_and_screenshots(video_id):
     print("====process_transcript_and_screenshots====")
 
@@ -401,46 +478,33 @@ def process_transcript_and_screenshots(video_id):
     updated_transcript_text = json.dumps(transcript, ensure_ascii=False, indent=2)
     update_file_on_drive(service, file_id, updated_transcript_text)
     print("逐字稿已更新，包括截图链接")
-
-    # init gcs client
-    gcs_client = init_gcs_client(GCS_KEY)
-    bucket_name = 'video_ai_assistant'
-    # 检查 folder 是否存在
-    is_gcs_exists = gcs_check_folder_exists(gcs_client, bucket_name, video_id)
-    if not is_gcs_exists:
-        gcs_create_bucket_folder_if_not_exists(gcs_client, bucket_name, video_id)
-        copy_all_files_from_drive_to_gcs(service, gcs_client, folder_id, bucket_name, video_id)
-        print("Drive file 已上传到GCS")
-    else:
-        print("GCS folder:{video_id} 已存在")
-
     return transcript
 
 def process_transcript_and_screenshots_on_gcs(video_id):
     print("====process_transcript_and_screenshots_on_gcs====")
     # GCS
-    gcs_client = init_gcs_client(GCS_KEY)
+    gcs_client = GCS_CLIENT
     bucket_name = 'video_ai_assistant'
-    # 检查 folder 是否存在
-    # is_gcs_exists = gcs_check_folder_exists(gcs_client, bucket_name, video_id)
-    # if not is_gcs_exists:
-    #     gcs_create_bucket_folder_if_not_exists(gcs_client, bucket_name, video_id)
-    #     print("GCS folder:{video_id} 已创建")
-    # else:
-    #     print("GCS folder:{video_id} 已存在")
-
     # 逐字稿文件名
     transcript_file_name = f'{video_id}_transcript.json'
     transcript_blob_name = f"{video_id}/{transcript_file_name}"
     # 检查逐字稿是否存在
-    is_transcript_exists = gcs_check_file_exists(gcs_client, bucket_name, transcript_blob_name)
+    is_transcript_exists = GCS_SERVICE.check_file_exists(bucket_name, transcript_blob_name)
     if not is_transcript_exists:
         # 从YouTube获取逐字稿并上传
-        transcript = get_transcript(video_id)
+        try:
+            transcript = get_transcript(video_id)
+        except:
+            # call open ai whisper
+            print("===call open ai whisper===")
+            transcript = generate_transcription(video_id)
+
         if transcript:
             print("成功獲取字幕")
         else:
             print("沒有找到字幕")
+            transcript = generate_transcription(video_id)
+
         transcript_text = json.dumps(transcript, ensure_ascii=False, indent=2)
         upload_file_to_gcs_with_json_string(gcs_client, bucket_name, transcript_blob_name, transcript_text)
     else:
@@ -456,34 +520,48 @@ def process_transcript_and_screenshots_on_gcs(video_id):
     # get_mind_map(video_id, transcript_text, source)
     # print("===確認其他衍生文件 end ===")
 
+
     # 處理截圖
-    # for entry in transcript:
-    #     if 'img_file_id' not in entry:
-    #         screenshot_path = screenshot_youtube_video(video_id, entry['start'])
-    #         screenshot_blob_name = f"{video_id}/{video_id}_{entry['start']}.jpg"
-    #         img_file_id = upload_img_and_get_public_url(gcs_client, bucket_name, screenshot_blob_name, screenshot_path)
-    #         entry['img_file_id'] = img_file_id
-    #         print(f"截图已上传到GCS: {img_file_id}")
+    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 = upload_img_and_get_public_url(gcs_client, bucket_name, screenshot_blob_name, screenshot_path)
+            entry['img_file_id'] = img_file_id
+            print(f"截图已上传到GCS: {img_file_id}")
         
     # 更新逐字稿文件
-    # print("===更新逐字稿文件===")
-    # print(transcript)
-    # print("===更新逐字稿文件===")
-    # updated_transcript_text = json.dumps(transcript, ensure_ascii=False, indent=2)
-    # upload_file_to_gcs_with_json_string(gcs_client, bucket_name, transcript_blob_name, updated_transcript_text)
-    # print("逐字稿已更新，包括截图链接")
-    # updated_transcript_json = json.loads(updated_transcript_text)
-
-    # return updated_transcript_json
-    return transcript
+    print("===更新逐字稿文件===")
+    print(transcript)
+    print("===更新逐字稿文件===")
+    updated_transcript_text = json.dumps(transcript, ensure_ascii=False, indent=2)
+    upload_file_to_gcs_with_json_string(gcs_client, bucket_name, transcript_blob_name, updated_transcript_text)
+    print("逐字稿已更新，包括截图链接")
+    updated_transcript_json = json.loads(updated_transcript_text)
+
+    return updated_transcript_json
+
+def process_youtube_link(password, link):
+    verify_password(password)
 
-def process_youtube_link(link):
     # 使用 YouTube API 获取逐字稿
     # 假设您已经获取了 YouTube 视频的逐字稿并存储在变量 `transcript` 中
     video_id = extract_youtube_id(link)
     global VIDEO_ID
     VIDEO_ID = video_id
-    download_youtube_video(video_id, output_path=OUTPUT_PATH)
     
     try:
         # transcript = process_transcript_and_screenshots(video_id)
@@ -501,8 +579,8 @@ def process_youtube_link(link):
         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']
-        img_file_id =""
+        img_file_id = entry['img_file_id']
+        # img_file_id =""
         # 先取消 Google Drive 的图片
         # screenshot_path = f"https://lh3.googleusercontent.com/d/{img_file_id}=s4000"
         screenshot_path = img_file_id
@@ -532,14 +610,22 @@ def process_youtube_link(link):
     formatted_transcript_json = json.dumps(formatted_transcript, ensure_ascii=False, indent=2)
     summary_json = get_video_id_summary(video_id, formatted_simple_transcript, source)
     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_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_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 = reading_passage_json["reading_passage"]
+    meta_data = get_meta_data(video_id)
+    subject = meta_data["subject"]
+    grade = meta_data["grade"]
 
     # 确保返回与 UI 组件预期匹配的输出
     return video_id, \
@@ -548,12 +634,16 @@ def process_youtube_link(link):
         questions[2] if len(questions) > 2 else "", \
         formatted_transcript_json, \
         summary, \
+        key_moments_html, \
         mind_map, \
         mind_map_html, \
         html_content, \
         simple_html_content, \
         first_image, \
-        first_text,
+        first_text, \
+        reading_passage, \
+        subject, \
+        grade
             
 def format_transcript_to_html(formatted_transcript):
     html_content = ""
@@ -599,21 +689,105 @@ def screenshot_youtube_video(youtube_id, 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 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.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)
+            upload_file_to_gcs_with_json_string(gcs_client, bucket_name, blob_name, reading_passage_text)
+            print("reading_passage已上传到GCS")
+        else:
+            # reading_passage已存在，下载内容
+            print("reading_passage已存在于GCS中")
+            reading_passage_text = download_blob_to_string(gcs_client, 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):
+    # 使用 OpenAI 生成基于上传数据的问题
+    sys_content = "你是一個擅長資料分析跟影片教學的老師，user 為學生，請精讀資料文本，自行判斷資料的種類，使用 zh-TW"
+    user_content = f"""
+        請根據 {df_string} 
+        文本自行判斷資料的種類
+        幫我組合成 Reading Passage
+        並潤稿讓文句通順
+        請一定要使用繁體中文 zh-TW，並用台灣人的口語
+        產生的結果不要前後文解釋，也不要敘述這篇文章怎麼產生的
+        只需要專注提供 Reading Passage，字數在 500 字以內
+    """
+    messages = [
+        {"role": "system", "content": sys_content},
+        {"role": "user", "content": user_content}
+    ]
+
+    request_payload = {
+        "model": "gpt-4-1106-preview",
+        "messages": messages,
+        "max_tokens": 4000,
+    }
+
+    response = OPEN_AI_CLIENT.chat.completions.create(**request_payload)
+    reading_passage = response.choices[0].message.content.strip()
+    print("=====reading_passage=====")
+    print(reading_passage)
+    print("=====reading_passage=====")
+
+    return reading_passage
+
+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 = init_gcs_client(GCS_KEY)
+        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_check_file_exists(gcs_client, bucket_name, blob_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)}
@@ -691,12 +865,12 @@ def get_mind_map_html(mind_map):
 def get_video_id_summary(video_id, df_string, source):
     if source == "gcs":
         print("===get_video_id_summary on gcs===")
-        gcs_client = init_gcs_client(GCS_KEY)
+        gcs_client = GCS_CLIENT
         bucket_name = 'video_ai_assistant'
         file_name = f'{video_id}_summary.json'
         summary_file_blob_name = f"{video_id}/{file_name}"
         # 检查 summary_file 是否存在
-        is_summary_file_exists = gcs_check_file_exists(gcs_client, bucket_name, summary_file_blob_name)
+        is_summary_file_exists = GCS_SERVICE.check_file_exists(bucket_name, summary_file_blob_name)
         if not is_summary_file_exists:
             summary = generate_summarise(df_string)
             summary_json = {"summary": str(summary)}
@@ -748,6 +922,7 @@ def generate_summarise(df_string):
         如果是資料類型，請提估欄位敘述、資料樣態與資料分析，告訴學生這張表的意義，以及可能的結論與對應方式
         
         如果是影片類型，請提估影片內容，告訴學生這部影片的意義，
+        整體摘要在一百字以內
         小範圍切出不同段落的相對應時間軸的重點摘要，最多不超過五段
         注意不要遺漏任何一段時間軸的內容
         格式為 【start - end】: 摘要
@@ -756,9 +931,9 @@ def generate_summarise(df_string):
         整體格式為：
         🗂️ 1. 內容類型：？
         📚 2. 整體摘要
-        🔖 3. 條列式重點
-        🔑 4. 關鍵時刻（段落摘要）
-        💡 5. 結論反思（為什麼我們要學這個？）
+        🔖 3. 重點概念
+        🔑 4. 關鍵時刻
+        💡 5. 為什麼我們要學這個？
         ❓ 6. 延伸小問題
     """
 
@@ -788,47 +963,16 @@ def generate_summarise(df_string):
 
     return df_summarise
 
-def generate_questions(df_string):
-    # 使用 OpenAI 生成基于上传数据的问题
-
-    sys_content = "你是一個擅長資料分析跟影片教學的老師，user 為學生，請精讀資料文本，自行判斷資料的種類，並用既有資料為本質猜測用戶可能會問的問題，使用 zh-TW"
-    user_content = f"請根據 {df_string} 生成三個問題，並用 JSON 格式返回 questions:[q1的敘述text, q2的敘述text, q3的敘述text]"
-    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": "gpt-4-1106-preview",
-        "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"]
-    print("=====json_response=====")
-    print(questions)
-    print("=====json_response=====")
-
-    return questions
-
 def get_questions(video_id, df_string, source="gcs"):
     if source == "gcs":
         # 去 gcs 確認是有有 video_id_questions.json
         print("===get_questions on gcs===")
-        gcs_client = init_gcs_client(GCS_KEY)
+        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_check_file_exists(gcs_client, bucket_name, blob_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)
@@ -871,7 +1015,40 @@ def get_questions(video_id, df_string, source="gcs"):
     print("=====get_questions=====")
     return q1, q2, q3
 
-def change_questions(df_string):
+def generate_questions(df_string):
+    # 使用 OpenAI 生成基于上传数据的问题
+
+    sys_content = "你是一個擅長資料分析跟影片教學的老師，user 為學生，請精讀資料文本，自行判斷資料的種類，並用既有資料為本質猜測用戶可能會問的問題，使用 zh-TW"
+    user_content = f"請根據 {df_string} 生成三個問題，並用 JSON 格式返回 questions:[q1的敘述text, q2的敘述text, q3的敘述text]"
+    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": "gpt-4-1106-preview",
+        "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"]
+    print("=====json_response=====")
+    print(questions)
+    print("=====json_response=====")
+
+    return questions
+
+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 ""
@@ -883,192 +1060,663 @@ def change_questions(df_string):
     print("=====get_questions=====")
     return q1, q2, q3
 
-def respond(user_message, data, chat_history, socratic_mode=False):
-    print("=== 變數：user_message ===")
-    print(user_message)
-    print("=== 變數：chat_history ===")
-    print(chat_history)
+# 「關鍵時刻」另外獨立成一個 tab，時間戳記和文字的下方附上對應的截圖，重點摘要的「關鍵時刻」加上截圖資訊
+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)
+            upload_file_to_gcs_with_json_string(gcs_client, bucket_name, blob_name, key_moments_text)
+            print("key_moments已上傳到GCS")
+        else:
+            # key_moments已存在，下载内容
+            print("key_moments已存在于GCS中")
+            key_moments_text = download_blob_to_string(gcs_client, bucket_name, blob_name)
+            key_moments_json = json.loads(key_moments_text)
 
-    data_json = json.loads(data)
-    for entry in data_json:
-        entry.pop('embed_url', None)  # Remove 'embed_url' if it exists
-        entry.pop('screenshot_path', None) 
+    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'
 
-    if socratic_mode:
-        sys_content = f"""
-            你是一個擅長資料分析跟影片教學的老師，user 為學生
-            請用 {data} 為資料文本，自行判斷資料的種類，
-            並進行對話，使用 台灣人的口與表達，及繁體中文zh-TW
+        # 检查檔案是否存在
+        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):
+    # 使用 OpenAI 生成基于上传数据的问题
+    sys_content = "你是一個擅長資料分析跟影片教學的老師，user 為學生，請精讀資料文本，自行判斷資料的種類，使用 zh-TW"
+    user_content = f"""
+        請根據 {formatted_simple_transcript} 文本，提取出重點摘要，並給出對應的時間軸
+        重點摘要的「關鍵時刻」加上截圖資訊
+        1. 小範圍切出不同段落的相對應時間軸的重點摘要，
+        2. 每一小段最多不超過 1/5 的總內容，也就是大約 3~5段的重點（例如五～十分鐘的影片就一段大約1~2分鐘，最多三分鐘，但如果是超過十分鐘的影片，那一小段大約 2~3分鐘，以此類推）
+        3. 注意不要遺漏任何一段時間軸的內容 從零秒開始
+        4. 如果頭尾的情節不是重點，就併入到附近的段落，特別是打招呼或是介紹人物就是不重要的情節
+        5. transcript 逐字稿的集合（要有合理的標點符號)，要完整跟原來的一樣，不要省略
+        以這種方式分析整個文本，從零秒開始分析，直到結束。這很重要
+
+        並用 JSON 格式返回 key_moments:[{{
+            "start": "00:00", 
+            "end": "00:00", 
+            "text": "逐字稿的重點摘要",
+            "transcript": "逐字稿的集合（要有合理的標點符號)，要完整跟原來的一樣，不要省略",
+            "images": 截圖的連結們 list
+        }}]
+    """
+    messages = [
+        {"role": "system", "content": sys_content},
+        {"role": "user", "content": user_content}
+    ]
+    response_format = { "type": "json_object" }
 
-            如果學生問了一些問題你無法判斷，請告訴學生你無法判斷，並建議學生可以問其他問題
-            或者你可以問學生一些問題，幫助學生更好的理解資料
+    request_payload = {
+        "model": "gpt-4-1106-preview",
+        "messages": messages,
+        "max_tokens": 4096,
+        "response_format": response_format
+    }
 
-            如果學生的問題與資料文本無關，請告訴學生你無法回答超出範圍的問題
+    try:
+        response = OPEN_AI_CLIENT.chat.completions.create(**request_payload)
+        key_moments = json.loads(response.choices[0].message.content)["key_moments"]
+    except Exception as e:
+        error_msg = f" {video_id} 關鍵時刻錯誤: {str(e)}"
+        print("===generate_key_moments error===")
+        print(error_msg)
+        print("===generate_key_moments error===")
+        raise Exception(error_msg)
+
+    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 = moment['start']
+        end_time = moment['end']
+        moment_images = [image_links[time] for time in image_links if start_time <= time <= end_time]
+        moment['images'] = moment_images
+
+    return key_moments
+
+def get_key_moments_html(key_moments):
+    css = """
+    <style>
+    #gallery-main {
+        display: flex;
+        align-items: center;
+        margin-bottom: 20px;
+    }
 
-            最後，在你回答的開頭標註【蘇格拉底助教】
-        """
-    else:
-        sys_content = f"""
-            你是一個擅長資料分析跟影片教學的老師，user 為學生
-            請用 {data} 為資料文本，自行判斷資料的種類，
-            並進行對話，使用 zh-TW
+    #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;
+    }
 
-    messages = [
-        {"role": "system", "content": sys_content}
-    ]
+    .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: black;
+        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;
+    }
 
-    # if chat_history is not none, append role, content to messages
-    # chat_history = [(user, assistant), (user, assistant), ...]
-    # In the list, first one is user, then assistant
-    if chat_history is not None:
-        # 如果超過10則訊息，只保留最後10則訊息
-        if len(chat_history) > 10:
-            chat_history = chat_history[-10:]
-
-        for chat in chat_history:
-            old_messages = [
-                {"role": "user", "content": chat[0]},
-                {"role": "assistant", "content": chat[1]}
-            ]
-            messages += old_messages
-    else:
-        pass
+    #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 = ""
         
-    messages.append({"role": "user", "content": user_message})
+        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 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}"
+    # 检查 reading_passage 是否存在
+    is_file_exists = GCS_SERVICE.check_file_exists(bucket_name, blob_name)
+    if is_file_exists:
+        delete_blob(gcs_client, bucket_name, blob_name)
+        print("reading_passage已从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":
+        reading_passage_json = {"reading_passage": str(new_content)}
+        reading_passage_text = json.dumps(reading_passage_json, ensure_ascii=False, indent=2)
+        upload_file_to_gcs_with_json_string(gcs_client, bucket_name, blob_name, reading_passage_text)
+    elif kind == "summary":
+        summary_json = {"summary": str(new_content)}
+        summary_text = json.dumps(summary_json, ensure_ascii=False, indent=2)
+        upload_file_to_gcs_with_json_string(gcs_client, bucket_name, blob_name, summary_text)
+    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)
+        upload_file_to_gcs_with_json_string(gcs_client, bucket_name, blob_name, mind_map_text)
+
+    print(f"{kind} 已更新到GCS")
+    return gr.update(value=new_content, interactive=False)
+
+def create_LLM_content(video_id, df_string, kind):
+    print(f"===create_{kind}===")
+    if kind == "reading_passage":
+        content = generate_reading_passage(df_string)
+    elif kind == "summary":
+        content = generate_summarise(df_string)
+    elif kind == "mind_map":
+        content = generate_mind_map(df_string)
+
+    update_LLM_content(video_id, content, kind)
+    return gr.update(value=content, interactive=False)
+
+
+# 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 = download_blob_to_string(gcs_client, 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===")
+        gcs_client = GCS_CLIENT
+        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)
+            upload_file_to_gcs_with_json_string(gcs_client, bucket_name, blob_name, ai_content_text)
+            print("ai_content_list [] 已上傳到GCS")
+
+        # 此時 ai_content_list 已存在
+        ai_content_list_string = download_blob_to_string(gcs_client, 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)
+            upload_file_to_gcs_with_json_string(gcs_client, 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()
+    user_content = material.build_user_content()
+    messages = material.build_messages(user_content)
+    ai_model_name = "gpt-4-1106-preview"
     request_payload = {
-        "model": "gpt-4-1106-preview",
+        "model": ai_model_name,
         "messages": messages,
-        "max_tokens": 4000  # 設定一個較大的值，可根據需要調整
+        "max_tokens": 4000  # 举例，实际上您可能需要更详细的配置
     }
-    response = OPEN_AI_CLIENT.chat.completions.create(**request_payload)
-    response_text = response.choices[0].message.content.strip()
+    ai_content = material.send_ai_request(OPEN_AI_CLIENT, request_payload)
+    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, "", "", "", "", "")
+    user_content = material.build_fine_tune_user_content(exam_result_prompt, exam_result, exam_result_fine_tune_prompt)
+    messages = material.build_messages(user_content)
+    ai_model_name = "gpt-4-1106-preview"
+    request_payload = {
+        "model": ai_model_name,
+        "messages": messages,
+        "max_tokens": 4000  # 举例，实际上您可能需要更详细的配置
+    }
+    ai_content = material.send_ai_request(OPEN_AI_CLIENT, request_payload)
+    return 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 chat_with_ai(ai_name, password, video_id, trascript, user_message, chat_history, content_subject, content_grade, socratic_mode=False):
+    verify_password(password)
+
+    if chat_history is not None and len(chat_history) > 10:
+        error_msg = "此次對話超過上限"
+        raise gr.Error(error_msg)
 
-    # 更新聊天历史
-    new_chat_history = (user_message, response_text)
-    if chat_history is None:
-        chat_history = [new_chat_history]
-    else:
-        chat_history.append(new_chat_history)
+    if ai_name == "jutor":
+        ai_client = ""
+    elif ai_name == "claude3":
+        ai_client = BEDROCK_CLIENT
+    elif ai_name == "groq":
+        ai_client = GROQ_CLIENT
+  
+    chatbot_config = {
+        "video_id": video_id,
+        "trascript": trascript,
+        "content_subject": content_subject,
+        "content_grade": content_grade,
+        "jutor_chat_key": JUTOR_CHAT_KEY,
+        "ai_name": ai_name,
+        "ai_client": ai_client
+    }
+    chatbot = Chatbot(chatbot_config)
+    response_completion = chatbot.chat(user_message, chat_history, socratic_mode, ai_name)
 
-    # 返回聊天历史和空字符串清空输入框
-    return "", chat_history
+    try:
+        # 更新聊天历史
+        new_chat_history = (user_message, response_completion)
+        if chat_history is None:
+            chat_history = [new_chat_history]
+        else:
+            chat_history.append(new_chat_history)
+
+        # 返回聊天历史和空字符串清空输入框
+        return "", chat_history
+    except Exception as e:
+        # 处理错误情况
+        print(f"Error: {e}")
+        return "请求失败，请稍后再试！", chat_history
+
+def chat_with_opan_ai_assistant(password, youtube_id, thread_id, trascript, user_message, chat_history, content_subject, content_grade, socratic_mode=False):
+    verify_password(password)
 
-def chat_with_youtube_transcript(youtube_id, thread_id, trascript, user_message, chat_history, socratic_mode=False):
     # 先計算 user_message 是否超過 500 個字
     if len(user_message) > 1500:
         error_msg = "你的訊息太長了，請縮短訊息長度至五百字以內"
         raise gr.Error(error_msg)
     
-    assistant_id = "asst_kmvZLNkDUYaNkMNtZEAYxyPq"
-    client = OPEN_AI_CLIENT
-    
-    #  從 file 拿逐字稿資料
-    # instructions = f"""
-    #     你是一個擅長資料分析跟影片教學的老師，user 為學生
-    #     請根據 assistant beta 的上傳資料 
-    #     如果 file 內有找到 file.content["{youtube_id}"] 為資料文本，自行判斷資料的種類，
-    #     如果沒有資料，請告訴用戶沒有逐字稿資料，但仍然可以進行對話，使用台灣人的口與表達，及繁體中文 zh-TW 
-    #     請嚴格執行，只根據 file.content["{youtube_id}"]  為資料文本，沒有就是沒有資料，不要引用其他資料
-
-    #     如果是影片類型，不用解釋逐字稿格式，直接回答學生問題
-    #     socratic_mode = {socratic_mode}
-    #     如果 socratic_mode = True，
-    #     - 請用蘇格拉底式的提問方式，引導學生思考，並且給予學生一些提示
-    #     - 不要直接給予答案，讓學生自己思考
-    #     - 但可以給予一些提示跟引導，例如給予影片的時間軸，讓學生自己去找答案
-    #     - 在你回答的開頭標註【蘇格拉底助教：{youtube_id} 】
-    #     如果 socratic_mode = False，
-    #     - 直接回答學生問題
-    #     - 在你回答的開頭標註【一般學習精靈：{youtube_id} 】
-    #     如果學生問了一些問題你無法判斷，請告訴學生你無法判斷，並建議學生可以問其他問題
-    #     或者你可以反問學生一些問題，幫助學生更好的理解資料
-    #     如果學生的問題與資料文本無關，請告訴學生你無法回答超出範圍的問題
-    #     最後只要是參考逐字稿資料，請在回答的最後標註【參考資料：（分）：（秒）】
-    # """
-
-    # 直接安排逐字稿資料 in instructions
-    trascript_json = json.loads(trascript)
-    # 移除 embed_url, screenshot_path
-    for entry in trascript_json:
-        entry.pop('embed_url', None)
-        entry.pop('screenshot_path', None)
-    trascript_text = json.dumps(trascript_json, ensure_ascii=False, indent=2)
-
-    instructions = f"""
-        逐字稿資料：{trascript_text}
-        -------------------------------------
-        你是一個擅長資料分析跟影片教學的老師，user 為學生
-        如果是影片類型，不用解釋逐字稿格式，直接回答學生問題
-        socratic_mode = {socratic_mode}
-        如果 socratic_mode = True，
-        - 請用蘇格拉底式的提問方式，引導學生思考，並且給予學生一些提示
-        - 不要直接給予答案，讓學生自己思考
-        - 但可以給予一些提示跟引導，例如給予影片的時間軸，讓學生自己去找答案
-        - 在你回答的開頭標註【蘇格拉底助教：{youtube_id} 】
-        如果 socratic_mode = False，
-        - 直接回答學生問題
-        - 在你回答的開頭標註【一般學習精靈：{youtube_id} 】
-        如果學生問了一些問題你無法判斷，請告訴學生你無法判斷，並建議學生可以問其他問題
-        或者你可以反問學生一些問題，幫助學生更好的理解資料
-        如果學生的問題與資料文本無關，請告訴學生你無法回答超出範圍的問題
-        最後只要是參考逐字稿資料，請在回答的最後標註【參考資料：（分）：（秒）】
-    """
+    # 如果 chat_history 超過 10 則訊息，直接 return "對話超過上限"
+    if chat_history is not None and len(chat_history) > 10:
+        error_msg = "此次對話超過上限"
+        raise gr.Error(error_msg)
 
-    # 创建线程
-    if not thread_id:
-        thread = client.beta.threads.create()
-        thread_id = thread.id
-    else:
-        thread = client.beta.threads.retrieve(thread_id)
-    
-    # 向线程添加用户的消息
-    client.beta.threads.messages.create(
-        thread_id=thread.id,
-        role="user",
-        content=user_message
-    )
+    try:
+        assistant_id = "asst_kmvZLNkDUYaNkMNtZEAYxyPq"
+        client = OPEN_AI_CLIENT
+        # 直接安排逐字稿資料 in instructions
+        trascript_json = json.loads(trascript)
+        # 移除 embed_url, screenshot_path
+        for entry in trascript_json:
+            entry.pop('embed_url', None)
+            entry.pop('screenshot_path', None)
+        trascript_text = json.dumps(trascript_json, ensure_ascii=False, indent=2)
+
+        instructions = f"""
+            科目：{content_subject}
+            年級：{content_grade}
+            逐字稿資料：{trascript_text}
+            -------------------------------------
+            你是一個專業的{content_subject}老師， user 為{content_grade}的學生
+            socratic_mode = {socratic_mode}
+            if socratic_mode is True，
+            - 請用蘇格拉底式的提問方式，引導學生思考，並且給予學生一些提示
+            - 一次只問一個問題，字數在100字以內
+            - 不要直接給予答案，讓學生自己思考
+            - 但可以給予一些提示跟引導，例如給予影片的時間軸，讓學生自己去找答案
+            
+            if socratic_mode is False，
+            - 直接回答學生問題，字數在100字以內
+
+            rule:
+            - 請一定要用繁體中文回答 zh-TW，並用台灣人的口語表達，回答時不用特別說明這是台灣人的語氣，也不用說這是「台語的說法」
+            - 不用提到「逐字稿」這個詞，用「內容」代替
+            - 如果學生問了一些問題你無法判斷，請告訴學生你無法判斷，並建議學生可以問其他問題
+            - 或者你可以反問學生一些問題，幫助學生更好的理解資料，字數在100字以內
+            - 如果學生的問題與資料文本無關，請告訴學生你「無法回答超出影片範圍的問題」，並告訴他可以怎麼問什麼樣的問題（一個就好）
+            - 只要是參考逐字稿資料，請在回答的最後標註【參考資料：（分）：（秒）】
+            - 回答範圍一定要在逐字稿資料內，不要引用其他資料，請嚴格執行
+            - 並在重複問句後給予學生鼓勵，讓學生有學習的動力
+            - 請用 {content_grade} 的學生能懂的方式回答
+        """
 
-    # 运行助手，生成响应
-    run = client.beta.threads.runs.create(
-        thread_id=thread.id,
-        assistant_id=assistant_id,
-        instructions=instructions,
-    )
+        # 创建线程
+        if not thread_id:
+            thread = client.beta.threads.create()
+            thread_id = thread.id
+        else:
+            thread = client.beta.threads.retrieve(thread_id)
+        
+        # 向线程添加用户的消息
+        client.beta.threads.messages.create(
+            thread_id=thread.id,
+            role="user",
+            content=user_message + "/n (請一定要用繁體中文回答 zh-TW，並用台灣人的禮貌口語表達，回答時不要特別說明這是台灣人的語氣，不用提到「逐字稿」這個詞，用「內容」代替)，回答時請用數學符號代替文字（Latex 用 $ 字號 render)"
+        )
 
-    # 等待助手响应，设定最大等待时间为 30 秒
-    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)
-        # [MessageContentText(text=Text(annotations=[], value='您好！有什麼我可以幫助您的嗎？如果有任何問題或需要指導，請隨時告訴我！'), type='text')]
-        response_text = messages.data[0].content[0].text.value
-    else:
-        response_text = "學習精靈有點累，請稍後再試！"
+        # 运行助手，生成响应
+        run = client.beta.threads.runs.create(
+            thread_id=thread.id,
+            assistant_id=assistant_id,
+            instructions=instructions,
+        )
 
-    # 更新聊天历史
-    new_chat_history = (user_message, response_text)
-    if chat_history is None:
-        chat_history = [new_chat_history]
-    else:
-        chat_history.append(new_chat_history)
+        # 等待助手响应，设定最大等待时间为 30 秒
+        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)
+            # [MessageContentText(text=Text(annotations=[], value='您好！有什麼我可以幫助您的嗎？如果有任何問題或需要指導，請隨時告訴我！'), type='text')]
+            response_text = messages.data[0].content[0].text.value
+        else:
+            response_text = "學習精靈有點累，請稍後再試！"
+
+        # 更新聊天历史
+        new_chat_history = (user_message, response_text)
+        if chat_history is None:
+            chat_history = [new_chat_history]
+        else:
+            chat_history.append(new_chat_history)
+    except Exception as e:
+        print(f"Error: {e}")
+        raise gr.Error(f"Error: {e}")
 
     # 返回聊天历史和空字符串清空输入框
     return "", chat_history, thread.id
 
+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:
+                response = OPEN_AI_CLIENT.audio.transcriptions.create(
+                    model="whisper-1",
+                    file=audio_file,
+                    response_format="text"
+                )   
+                # response 拆解 dict
+                print("=== response ===")
+                print(response)
+                print("=== response ===")
+    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.
@@ -1118,6 +1766,7 @@ def poll_run_status(run_id, thread_id, timeout=600, poll_interval=5):
     
     return run.status
 
+# --- Slide mode ---
 def update_slide(direction):
     global TRANSCRIPTS
     global CURRENT_INDEX
@@ -1145,7 +1794,37 @@ def prev_slide():
 def next_slide():
     return update_slide(1)
 
-
+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)
+
+        # 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)
+
+    return admin, reading_passage_admin, summary_admin, see_detail, password_text, youtube_link
 
 HEAD = """
     <meta charset="UTF-8">
@@ -1172,160 +1851,437 @@ HEAD = """
             });
         }
     </script>
-"""
 
+    <script>
+        function changeImage(direction, count, galleryIndex) {
+            // Find the current visible image by iterating over possible indices
+            var currentImage = null;
+            var currentIndex = -1;
+            for (var i = 0; i < count; i++) {
+                var img = document.querySelector('.slide-image-' + galleryIndex + '-' + i);
+                if (img && img.style.display !== 'none') {
+                    currentImage = img;
+                    currentIndex = i;
+                    break;
+                }
+            }
+
+            // If no current image is visible, show the first one and return
+            if (currentImage === null) {
+                document.querySelector('.slide-image-' + galleryIndex + '-0').style.display = 'block';
+                console.error('No current image found for galleryIndex ' + galleryIndex + ', defaulting to first image.');
+                return;
+            }
+
+            // Hide the current image
+            currentImage.style.display = 'none';
+
+            // Calculate the index of the next image to show
+            var newIndex = (currentIndex + direction + count) % count;
+
+            // Select the next image and show it
+            var nextImage = document.querySelector('.slide-image-' + galleryIndex + '-' + newIndex);
+            if (nextImage) {
+                nextImage.style.display = 'block';
+            } else {
+                console.error('No image found for galleryIndex ' + galleryIndex + ' and newIndex ' + newIndex);
+            }
+        }
+    </script>
+"""
 
-with gr.Blocks() as demo:
-    with gr.Row():
-        with gr.Column(scale=2):
-            file_upload = gr.File(label="Upload your CSV or Word file", visible=False)
-            youtube_link = gr.Textbox(label="Enter YouTube Link")
-            video_id = gr.Textbox(label="video_id", visible=False)
-            youtube_link_btn = gr.Button("Submit_YouTube_Link")
-            web_link = gr.Textbox(label="Enter Web Page Link", visible=False)
-            chatbot = gr.Chatbot()
-            thread_id = gr.Textbox(label="thread_id", visible=False)
-            socratic_mode_btn = gr.Checkbox(label="蘇格拉底家教助理模式", value=False)
-            msg = gr.Textbox(label="Message")
-            send_button = gr.Button("Send")
-
-        with gr.Column(scale=3):
-            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.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)
+        file_upload = gr.File(label="Upload your CSV or Word file", visible=False)
+        youtube_link = gr.Textbox(label="Enter YouTube Link", elem_id="youtube_link_input", visible=True)
+        video_id = gr.Textbox(label="video_id", 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.Tab("AI小精靈"):
+        with gr.Row():
+            with gr.Tab("飛特"):
+                bot_avatar = "https://junyi-avatar.s3.ap-northeast-1.amazonaws.com/live/%20%20foxcat-star-18.png?v=20231113095823614"
+                user_avatar = "https://junyitopicimg.s3.amazonaws.com/s4byy--icon.jpe?v=20200513013523726"
+                latex_delimiters = [{"left": "$", "right": "$", "display": False}]
+                chatbot = gr.Chatbot(avatar_images=[bot_avatar, user_avatar], label="OPEN AI", show_share_button=False, likeable=True, show_label=False, latex_delimiters=latex_delimiters)
+                thread_id = gr.Textbox(label="thread_id", visible=False)
+                socratic_mode_btn = gr.Checkbox(label="蘇格拉底家教助理模式", value=True, visible=False)
                 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("逐字稿"):
-                simple_html_content = gr.HTML(label="Simple Transcript")
-            with gr.Tab("本文"):
-                df_string_output = gr.Textbox(lines=40, label="Data Text")
-            with gr.Tab("重點"):
-                df_summarise = gr.Textbox(container=True, show_copy_button=True, lines=40)    
-            with gr.Tab("問題"):
-                gr.Markdown("## 常用問題")
-                btn_1 = gr.Button()
-                btn_2 = gr.Button()
-                btn_3 = gr.Button()
-                gr.Markdown("## 重新生成問題")
-                btn_create_question = gr.Button("Create Questions")
-            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()
-    
-    with gr.Row():
-        gr.Markdown("## 教育評量饗宴") 
-    with gr.Row():
-        with gr.Column(scale=2):
-            with gr.Tab("認知階層評量題目"):
-                cognitive_level_content = gr.Textbox(label="輸入學習目標與內容")
-                cognitive_level_content_btn = gr.Button("生成評量題目")
-            with gr.Tab("素養導向閱讀題組"):
-                literacy_oriented_reading_content = gr.Textbox(label="輸入閱讀材料")
-                literacy_oriented_reading_content_btn = gr.Button("生成閱讀理解題")
+                    with gr.Accordion("你也有類似的問題想問嗎？", open=False) as ask_questions_accordion:
+                        btn_1 = gr.Button("問題一")
+                        btn_2 = gr.Button("問題一")
+                        btn_3 = gr.Button("問題一")
+                        gr.Markdown("### 重新生成問題")
+                        btn_create_question = gr.Button("生成其他問題", variant="primary")
+                    openai_chatbot_audio_input = gr.Audio(sources=["microphone"], type="filepath")
+                with gr.Row():
+                        msg = gr.Textbox(label="訊息",scale=3)
+                        send_button = gr.Button("送出", variant="primary", scale=1)
+            # with gr.Tab("GROQ"):
+            #     groq_ai_name = gr.Textbox(label="AI 助理名稱", value="groq", visible=False)
+            #     groq_chatbot = gr.Chatbot(avatar_images=[bot_avatar, user_avatar], label="groq mode chatbot", show_share_button=False, likeable=True)
+            #     groq_msg = gr.Textbox(label="Message")
+            #     groq_send_button = gr.Button("Send", variant="primary")
+            # with gr.Tab("JUTOR"):
+            #     jutor_ai_name = gr.Textbox(label="AI 助理名稱", value="jutor", visible=False)
+            #     jutor_chatbot = gr.Chatbot(avatar_images=[bot_avatar, user_avatar], label="jutor mode chatbot", show_share_button=False, likeable=True)
+            #     jutor_msg = gr.Textbox(label="Message")
+            #     jutor_send_button = gr.Button("Send", variant="primary")
+            # with gr.Tab("CLAUDE"):
+            #     claude_ai_name = gr.Textbox(label="AI 助理名稱", value="claude3", visible=False)
+            #     claude_chatbot = gr.Chatbot(avatar_images=[bot_avatar, user_avatar], label="claude mode chatbot", show_share_button=False, likeable=True)
+            #     claude_msg = gr.Textbox(label="Message")
+            #     claude_send_button = gr.Button("Send", variant="primary")
+            with gr.Tab("其他精靈"):
+                ai_name = gr.Dropdown(label="選擇 AI 助理", choices=["jutor", "claude3", "groq"], value="jutor")
+                ai_chatbot = gr.Chatbot(avatar_images=[bot_avatar, user_avatar], label="ai_chatbot", show_share_button=False, likeable=True, show_label=False)
+                ai_msg = gr.Textbox(label="Message")
+                ai_send_button = gr.Button("Send", variant="primary")    
+    with gr.Tab("文章模式"):
+        with gr.Row() as reading_passage_admin:
+            reading_passage_kind = gr.Textbox(value="reading_passage", show_label=False)
+            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 = gr.Textbox(label="Reading Passage", lines=40, show_label=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() as summary_admmin:
+            summary_kind = gr.Textbox(value="summary", show_label=False)
+            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():
+            df_summarise = gr.Textbox(container=True, show_copy_button=True, lines=40, show_label=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("學習單"):
-                worksheet_content = gr.Textbox(label="輸入學習單內容")
-                worksheet_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.Column(scale=3):
-            # 生成對應不同模式的結果
-            exam_result = gr.Textbox("生成結果")
-
-            
+                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")
+                        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):
+                            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_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")
+                        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):
+                            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.Textbox(label="初次生成結果", show_copy_button=True, interactive=True, lines=40)
+                        
+                        lesson_plan_download_exam_result_button = gr.Button("轉成 word，完成後請點擊右下角 download 按鈕", variant="primary")
+                        lesson_plan_exam_result_word_link = gr.File(label="Download Word")
             
-    # 傳統模式
-    # send_button.click(
-    #     respond, 
-    #     inputs=[msg, df_string_output, chatbot, socratic_mode_btn], 
-    #     outputs=[msg, chatbot]
-    # )
-    # # 连接按钮点击事件
-    # btn_1.click(respond, inputs=[btn_1, df_string_output, chatbot, socratic_mode_btn], outputs=[msg, chatbot])
-    # btn_2.click(respond, inputs=[btn_2, df_string_output, chatbot, socratic_mode_btn], outputs=[msg, chatbot])
-    # btn_3.click(respond, inputs=[btn_3, df_string_output, chatbot, socratic_mode_btn], outputs=[msg, chatbot])
-
-    # chat_with_youtube_transcript
+            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")
+                        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):
+                            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.Textbox(label="初次生成結果", show_copy_button=True, interactive=True, lines=40)
+                        
+                        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("本文"):
+            df_string_output = gr.Textbox(lines=40, label="Data Text")
+        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()
+       
+    # --- Event ---
+    # OPENAI 模式
     send_button.click(
-        chat_with_youtube_transcript,
-        inputs=[video_id, thread_id, df_string_output, msg, chatbot, socratic_mode_btn],
+        chat_with_opan_ai_assistant,
+        inputs=[password, video_id, thread_id, df_string_output, msg, chatbot, content_subject, content_grade, socratic_mode_btn],
         outputs=[msg, chatbot, thread_id]
     )
+    openai_chatbot_audio_input.change(
+        process_open_ai_audio_to_chatbot,
+        inputs=[password, openai_chatbot_audio_input],
+        outputs=[msg]
+    )
+    # # GROQ 模式
+    # groq_send_button.click(
+    #     chat_with_ai,
+    #     inputs=[groq_ai_name, password, video_id, df_string_output, groq_msg, groq_chatbot, content_subject, content_grade, socratic_mode_btn],
+    #     outputs=[groq_msg, groq_chatbot]
+    # )
+    # # JUTOR API 模式
+    # jutor_send_button.click(
+    #     chat_with_ai,
+    #     inputs=[jutor_ai_name, password, video_id, df_string_output, jutor_msg, jutor_chatbot, content_subject, content_grade, socratic_mode_btn],
+    #     outputs=[jutor_msg, jutor_chatbot]
+    # )
+    # # CLAUDE 模式
+    # claude_send_button.click(
+    #     chat_with_ai,
+    #     inputs=[claude_ai_name, password, video_id, df_string_output, claude_msg, claude_chatbot, content_subject, content_grade, socratic_mode_btn],
+    #     outputs=[claude_msg, claude_chatbot]
+    # )
+    # ai_chatbot 模式
+    ai_send_button.click(
+        chat_with_ai,
+        inputs=[ai_name, password, video_id, df_string_output, ai_msg, ai_chatbot, content_subject, content_grade, socratic_mode_btn],
+        outputs=[ai_msg, ai_chatbot]
+    )
+
     # 连接按钮点击事件
+    btn_1_chat_with_opan_ai_assistant_input =[password, video_id, thread_id, df_string_output, btn_1, chatbot, content_subject, content_grade, socratic_mode_btn]
+    btn_2_chat_with_opan_ai_assistant_input =[password, video_id, thread_id, df_string_output, btn_2, chatbot, content_subject, content_grade, socratic_mode_btn]
+    btn_3_chat_with_opan_ai_assistant_input =[password, video_id, thread_id, df_string_output, btn_3, chatbot, content_subject, content_grade, socratic_mode_btn]
     btn_1.click(
-        chat_with_youtube_transcript,
-        inputs=[video_id, thread_id, df_string_output, btn_1, chatbot, socratic_mode_btn],
+        chat_with_opan_ai_assistant,
+        inputs=btn_1_chat_with_opan_ai_assistant_input, 
         outputs=[msg, chatbot, thread_id]
     )
     btn_2.click(
-        chat_with_youtube_transcript,
-        inputs=[video_id, thread_id, df_string_output, btn_2, chatbot, socratic_mode_btn],
+        chat_with_opan_ai_assistant,
+        inputs=btn_2_chat_with_opan_ai_assistant_input, 
         outputs=[msg, chatbot, thread_id]
     )
     btn_3.click(
-        chat_with_youtube_transcript,
-        inputs=[video_id, thread_id, df_string_output, btn_3, chatbot, socratic_mode_btn],
+        chat_with_opan_ai_assistant,
+        inputs=btn_3_chat_with_opan_ai_assistant_input, 
         outputs=[msg, chatbot, thread_id]
     )
 
-    btn_create_question.click(change_questions, inputs = [df_string_output], outputs = [btn_1, btn_2, btn_3])
+    btn_create_question.click(
+        change_questions, 
+        inputs = [password, df_string_output], 
+        outputs = [btn_1, btn_2, btn_3]
+    )
 
     # file_upload.change(process_file, inputs=file_upload, outputs=df_string_output)
     file_upload.change(process_file, inputs=file_upload, outputs=[btn_1, btn_2, btn_3, df_summarise, df_string_output])
 
     # 当输入 YouTube 链接时触发
+    process_youtube_link_output = [
+        video_id,
+        btn_1, 
+        btn_2, 
+        btn_3, 
+        df_string_output, 
+        df_summarise,
+        key_moments_html,
+        mind_map, 
+        mind_map_html,
+        transcript_html,
+        simple_html_content, 
+        slide_image, 
+        slide_text,
+        reading_passage,
+        content_subject,
+        content_grade,
+    ]
     youtube_link.change(
         process_youtube_link, 
-        inputs=youtube_link, 
-        outputs=[
-            video_id,
-            btn_1, 
-            btn_2, 
-            btn_3, 
-            df_string_output, 
-            df_summarise, 
-            mind_map, 
-            mind_map_html,
-            transcript_html,
-            simple_html_content, 
-            slide_image, 
-            slide_text
-            ]
-        )
+        inputs=[password,youtube_link], 
+        outputs=process_youtube_link_output
+    )
     
     youtube_link_btn.click(
         process_youtube_link, 
-        inputs=youtube_link, 
-        outputs=[
-            video_id,
-            btn_1, 
-            btn_2, 
-            btn_3, 
-            df_string_output, 
-            df_summarise, 
-            mind_map, 
-            mind_map_html,
-            transcript_html, 
-            simple_html_content,
-            slide_image, 
-            slide_text
-            ]
-        )
+        inputs=[password, youtube_link], 
+        outputs=process_youtube_link_output
+    )
 
     # 当输入网页链接时触发
     # web_link.change(process_web_link, inputs=web_link, outputs=[btn_1, btn_2, btn_3, df_summarise, df_string_output])
 
+    # reading_passage event
+    reading_passage_create_button.click(
+        create_LLM_content,
+        inputs=[video_id, df_string_output, reading_passage_kind],
+        outputs=[reading_passage]
+    )
+    reading_passage_delete_button.click(
+        delete_LLM_content,
+        inputs=[video_id, reading_passage_kind],
+        outputs=[reading_passage]
+    )
+    reading_passage_edit_button.click(
+        enable_edit_mode,
+        inputs=[],
+        outputs=[reading_passage]
+    )
+    reading_passage_update_button.click(
+        update_LLM_content,
+        inputs=[video_id, reading_passage, reading_passage_kind],
+        outputs=[reading_passage]
+    )
+
+    # summary event
+    summary_create_button.click(
+        create_LLM_content,
+        inputs=[video_id, df_string_output, summary_kind],
+        outputs=[df_summarise]
+    )
+    summary_delete_button.click(
+        delete_LLM_content,
+        inputs=[video_id, summary_kind],
+        outputs=[df_summarise]
+    )
+    summary_edit_button.click(
+        enable_edit_mode,
+        inputs=[],
+        outputs=[df_summarise]
+    )
+    summary_update_button.click(
+        update_LLM_content,
+        inputs=[video_id, df_summarise, summary_kind],
+        outputs=[df_summarise]
+    )
+
+    # 教師版
+    worksheet_content_btn.click(
+        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]
+    )
+    lesson_plan_btn.click(
+        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]
+    )
+    exit_ticket_btn.click(
+        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]
+    )
+
+    # 生成結果微調
+    worksheet_exam_result_fine_tune_btn.click(
+        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]
+    )
+    worksheet_download_exam_result_button.click(
+        download_exam_result,
+        inputs=[worksheet_exam_result],
+        outputs=[worksheet_exam_result_word_link]
+    )
+    worksheet_exam_result_retrun_original.click(
+        return_original_exam_result,
+        inputs=[worksheet_exam_result_original],
+        outputs=[worksheet_exam_result]
+    )
+    lesson_plan_exam_result_fine_tune_btn.click(
+        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]
+    )
+    lesson_plan_download_exam_result_button.click(
+        download_exam_result,
+        inputs=[lesson_plan_exam_result],
+        outputs=[lesson_plan_exam_result_word_link]
+    )
+    lesson_plan_exam_result_retrun_original.click(
+        return_original_exam_result,
+        inputs=[lesson_plan_exam_result_original],
+        outputs=[lesson_plan_exam_result]
+    )
+    exit_ticket_exam_result_fine_tune_btn.click(
+        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]
+    )
+    exit_ticket_download_exam_result_button.click(
+        download_exam_result,
+        inputs=[exit_ticket_exam_result],
+        outputs=[exit_ticket_exam_result_word_link]
+    )
+    exit_ticket_exam_result_retrun_original.click(
+        return_original_exam_result,
+        inputs=[exit_ticket_exam_result_original],
+        outputs=[exit_ticket_exam_result]
+    )
+
+    # init_params
+    demo.load(
+        init_params, 
+        inputs =[youtube_link],
+        outputs = [admin, reading_passage_admin, summary_admmin, see_details, password , youtube_link]
+    )
+
 demo.launch(allowed_paths=["videos"])

chatbot.py

@@ -0,0 +1,155 @@
+import gradio as gr
+import json
+import requests
+
+class Chatbot:
+    def __init__(self, config):
+        self.video_id = config.get('video_id')
+        self.content_subject = config.get('content_subject')
+        self.content_grade = config.get('content_grade')
+        self.jutor_chat_key = config.get('jutor_chat_key')
+        self.transcript_text = self.get_transcript_text(config.get('trascript'))
+        self.ai_name = config.get('ai_name')
+        self.ai_client = config.get('ai_client')
+
+    def get_transcript_text(self, transcript_data):
+        transcript_json = json.loads(transcript_data)
+        for entry in transcript_json:
+            entry.pop('embed_url', None)
+            entry.pop('screenshot_path', None)
+        transcript_text = json.dumps(transcript_json, ensure_ascii=False)
+        return transcript_text
+
+    def chat(self, user_message, chat_history, socratic_mode=False, service_type='jutor'):
+        messages = self.prepare_messages(chat_history, user_message)
+        system_prompt = self.prepare_system_prompt(socratic_mode)
+        if service_type in ['jutor', 'groq', 'claude3']:
+            response_text = self.chat_with_service(service_type, system_prompt, messages)
+            return response_text
+        else:
+            raise gr.Error("不支持此服務")
+
+    def prepare_system_prompt(self, socratic_mode):
+        content_subject = self.content_subject
+        content_grade = self.content_grade
+        video_id = self.video_id
+        trascript_text = self.transcript_text
+        socratic_mode = str(socratic_mode)
+        ai_name = self.ai_name
+        system_prompt = f"""
+            科目：{content_subject}
+            年級：{content_grade}
+            逐字稿資料：{trascript_text}
+            -------------------------------------
+            你是一個專業的{content_subject}老師， user 為{content_grade}的學生
+            socratic_mode = {socratic_mode}
+            if socratic_mode is True，
+            - 請用蘇格拉底式的提問方式，引導學生思考，並且給予學生一些提示
+            - 一次只問一個問題，字數在100字以內
+            - 不要直接給予答案，讓學生自己思考
+            - 但可以給予一些提示跟引導，例如給予影片的時間軸，讓學生自己去找答案
+            
+            if socratic_mode is False，
+            - 直接回答學生問題，字數在100字以內
+
+            rule:
+            - 請一定要用繁體中文回答 zh-TW，並用台灣人的口語表達，回答時不用特別說明這是台灣人的語氣，也不用說這是「台語的說法」
+            - 不用提到「逐字稿」這個詞
+            - 如果學生問了一些問題你無法判斷，請告訴學生你無法判斷，並建議學生可以問其他問題
+            - 或者你可以反問學生一些問題，幫助學生更好的理解資料，字數在100字以內
+            - 如果學生的問題與資料文本無關，請告訴學生你「無法回答超出影片範圍的問題」，並告訴他可以怎麼問什麼樣的問題（一個就好）
+            - 只要是參考逐字稿資料，請在回答的最後標註【參考資料：（分）：（秒）】
+            - 回答範圍一定要在逐字稿資料內，不要引用其他資料，請嚴格執行
+            - 並在重複問句後給予學生鼓勵，讓學生有學習的動力
+            - 請用 {content_grade} 的學生能懂的方式回答
+            - 回答時數學式請用數學符號代替文字（Latex 用 $ 字號 render)
+        """
+
+        return system_prompt
+
+    def prepare_messages(self, chat_history, user_message):
+        messages = []
+        if chat_history is not None:
+            if len(chat_history) > 10:
+                chat_history = chat_history[-10:]
+
+            for user_msg, assistant_msg in chat_history:
+                if user_msg:
+                    messages.append({"role": "user", "content": user_msg})
+                if assistant_msg:
+                    messages.append({"role": "assistant", "content": assistant_msg})
+                
+        if user_message:
+            user_message += "/n (請一定要用繁體中文回答 zh-TW，並用台灣人的禮貌口語表達，回答時不要特別說明這是台灣人的語氣，不用提到「逐字稿」這個詞，用「內容」代替)，回答時請用數學符號代替文字（Latex 用 $ 字號 render)"
+            messages.append({"role": "user", "content": user_message})
+        return messages
+
+    def chat_with_service(self, service_type, system_prompt, messages):
+        if service_type == 'jutor':
+            return self.chat_with_jutor(system_prompt, messages)
+        elif service_type == 'groq':
+            return self.chat_with_groq(system_prompt, messages)
+        elif service_type == 'claude3':
+            return self.chat_with_claude3(system_prompt, messages)
+        else:
+            raise gr.Error("不支持的服务类型")
+
+    def chat_with_jutor(self, system_prompt, messages):
+        messages.insert(0, {"role": "system", "content": system_prompt})
+        api_endpoint = "https://ci-live-feat-video-ai-dot-junyiacademy.appspot.com/api/v2/jutor/hf-chat"
+        headers = {
+            "Content-Type": "application/json",
+            "x-api-key": self.jutor_chat_key,
+        }
+        data = {
+            "data": {
+                "messages": messages,
+                "max_tokens": 512,
+                "temperature": 0.9,
+                "model": "gpt-4-1106-preview",
+                "stream": False,
+            }
+        }
+
+        response = requests.post(api_endpoint, headers=headers, data=json.dumps(data))
+        response_data = response.json()
+        response_completion = response_data['data']['choices'][0]['message']['content'].strip()
+        return response_completion
+
+    def chat_with_groq(self, system_prompt, messages):
+        # system_prompt insert to messages 的最前面 {"role": "system", "content": system_prompt}
+        messages.insert(0, {"role": "system", "content": system_prompt})
+        request_payload = {
+            "model": "mixtral-8x7b-32768",
+            "messages": messages,
+            "max_tokens": 1000  # 設定一個較大的值，可根據需要調整
+        }
+        groq_client = self.ai_client
+        response = groq_client.chat.completions.create(**request_payload)
+        response_completion = response.choices[0].message.content.strip()
+        return response_completion
+
+    def chat_with_claude3(self, system_prompt, messages):
+        if not system_prompt.strip():
+            raise ValueError("System prompt cannot be empty")
+        
+        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": 1000,
+                "system": system_prompt,
+                "messages": messages
+            })
+        }
+        print(messages)
+        # 建立 message API，讀取回應
+        bedrock_client = self.ai_client
+        response = bedrock_client.invoke_model(**kwargs)
+        response_body = json.loads(response.get('body').read())
+        response_completion = response_body.get('content')[0].get('text').strip()
+        return response_completion

educational_material.py

@@ -0,0 +1,470 @@
+import json
+
+class EducationalMaterial:
+    """
+    A class to generate educational content based on provided parameters.
+    
+    Attributes:
+        context (str): Context or transcript of the content.
+        topic (str): The topic of the content.
+        grade (str): The grade level for the content.
+        level (str): The difficulty level of the content.
+        specific_feature (str): A specific feature of the content.
+        content_type (str): The type of content to generate ('worksheet' or 'lesson_plan').
+    """
+    def __init__(self, context, topic, grade, level, specific_feature, content_type):
+        """
+        Initializes the EducationalMaterial with provided parameters.
+        
+        Parameters:
+            context (str): Context or transcript of the content.
+            topic (str): The topic of the content.
+            grade (str): The grade level for the content.
+            level (str): The difficulty level of the content.
+            specific_feature (str): A specific feature of the content.
+            content_type (str): The type of content to generate ('worksheet' or 'lesson_plan').
+        """
+        self.context = self._prepare_context(context)
+        self.topic = topic
+        self.grade = grade
+        self.level = level
+        self.specific_feature = specific_feature
+        self.content_type = content_type  # 'worksheet' or 'lesson_plan'
+        self.system_content = "你是一個擅長資料分析跟影片教學備課的老師，請精讀資料文本，自行判斷資料的種類，使用 zh-TW"
+
+    def _prepare_context(self, context):
+        context_json = json.loads(context)
+        for entry in context_json:
+            entry.pop('embed_url', None)
+            entry.pop('screenshot_path', None)
+        processed_context = json.dumps(context_json, ensure_ascii=False, indent=2)
+        return processed_context
+
+    def generate_content_prompt(self):
+        if self.content_type == 'worksheet':
+            return self._generate_worksheet_prompt()
+        elif self.content_type == 'lesson_plan':
+            return self._generate_lesson_plan_prompt()
+        elif self.content_type == 'exit_ticket':
+            return self._generate_exit_ticket_prompt()
+
+    def _generate_worksheet_prompt(self):
+        bloom_worksheet_prompt = """
+        你是個專業的教師，熟悉布魯姆(Benjamin Bloom, 1964) 的認知理論。布魯姆認為人類的能力，大致可分為三個領域(domains)，即認知領域(cognitive domain)、情意領域(affective domain)、技能領域 (psychomotor domain)。
+        
+        【認知領域】涉及知能及其運作，著重心智、學習以及問題解決的工作。認知目標從簡單的認識或記憶能力到複雜的評鑑能力。大部分的教育目標都屬於這個領域。認知領域的目標分為六個層次，每個層次代表不同的心智功能。
+        - 📖 知識：在認知目標中知識是最低層次的能力，包括名詞、事實、規則和原理原則等的認識和記憶。用來表示此種能力的行為動詞有：指出、寫出、界定、說明、舉例、命名、認明等。例：能在地圖上指出長江流經的省分。
+        - 🤔 理解：理解是指能把握所學過知識或概念的意義，包含轉譯、解釋、推論等能力。代表此能力的行為動詞有：解釋、說明、區別、舉例、摘要、歸納等。例：能解釋光合作用。
+        - 🛠️ 應用：應用是指將所學到的規則、方法、步驟、原理、原則和概念，應用到新情境的能力。用來表示此能力的行為動詞有：預測、證明、解決、修改、表現、應用等。例：學生能預測抽出容器內之氣體對容器的影響。
+        - 🔍 分析：分析是指將所學到的概念或原則，分析為各個構成的部分，或找出各部分之間的相互關係，包括要素、關係及組織原理等的分析。用以表示此種能力的行為動詞有：選出、分析、判斷：區分、指出某些組成要素、指出某些的相互關係等。例：讀完某篇文章後，學生能區分事實和意見。
+        - 🌐 綜合：綜合是指將所學到的片斷概念或知識、原理原則或事實，統整成新的整體。用來表示此種能力的行為動詞有：設計、組織、綜合、創造、歸納、聯合等。例：讀完一篇有關防治汙染的文章後，學生能綜合防治汙染的各種方法。
+        - 🏅 評鑑：評鑑是認知目標中最高層次的能力，指依據某項標準做價值的判斷的能力。用來表示此能力的行為動詞有：評鑑、判斷、評論、比較、批判等。例：學生能評斷辯論中的謬論。
+
+        學習單包含以下的內容，將以布魯姆教育目標來建構提問的架構；請用 markdown 格式來呈現。
+        - 📝 主題：請使用上傳檔案的檔名作為標題
+        - 🔑 重點： 和影片有關重要知識摘要
+        - 💭 概念：概念性問題 - 布魯姆的知識層級；數學知識的建構
+        - 📊 想一想：程序性問題 - 布魯姆的理解層級；和影片相同的例題，類似的練習題 → 計算與步驟操作
+        - 🚀 延伸與應用 - 布魯姆的應用、分析、綜合、評鑑層級 → 延伸思考與應用
+        
+        其中，「重點」的題目請用挖空的填空題；在「想一想」的程序性問題請以單選題或填空題的形式來建立，需要 3 個題目；「延伸與應用」請使用問答題的形式來建立，一題即可。
+        題目和題目之間要換行，並加上 point 符號，像是 "-" 或是 "1." 等等
+
+        這是範例格式：
+        🌐【主題】：認識公里
+
+        🎓【對象】 
+        科目： 數學
+        年級： 三年級
+        難度： 基礎
+
+        🏞️【情境描述】
+        狐狸貓和家人出遊，過程中認識測量較長距離的單位「公里」。
+
+        🔑【影片重點】
+        - 公里是用來測量長距離的單位，通常用於測量很遠的距離。
+        - 1公里等於＿＿＿公尺，也稱為千米。
+        - 公里的英文簡寫是 ＿＿＿＿。
+
+        🌟【概念】
+        - 請問公里通常用於測量什麼類型的距離？
+        - 如果一圈操場是200公尺，那跑5圈是多少公尺？多少公里？
+        - 為什麼我們需要使用公里這個單位來測量距離？
+
+        🔢【想一想】
+        1. 一圈操場是200公尺，跑10圈是多少公里？(A) 1公里 (B) 2公里 (C) 3公里 (D) 4公里
+        2. 如果你跑了5圈操場，運動手環上會顯示你跑了多少公里？
+        3. 6000公尺等於多少公里？
+
+        💡【延伸與應用】
+        - 假設你參加一場慈善路跑活動，全程是5公里。如果你已經跑了3公里，還剩下多少公里？你覺得這樣的活動對你的體能有什麼影響？
+        """
+
+        Polya_worksheet_prompt = """
+        你是個專業的教師，熟悉 George Polya(1945) 的數學問題解決策略。
+        Polya提出了一個四步驟的數學問題解決策略，在他影響深遠的經典著作 How to solve it《如何解題》中指出解難過程可分為四個階段：
+        (1) 理解問題 (understanding the problem)
+        (2) 設計解題策略 (devising a plan)
+        (3) 按步解題 (carrying out the plan)
+        (4) 回顧解答 (looking back) (edited) 
+
+        請以此設計學習單並依據文本跟難度給予題目
+        請一定要使用 zh-TW
+        
+        這是範例格式：
+        🌐 主題：【概念】認識公里
+
+        🎓【對象】
+        科目： 數學
+        年級： 三年級
+        難度： 基礎
+
+        🏞️【情境描述】
+        狐狸貓和家人出遊，過程中認識測量較長距離的單位「公里」。
+
+        ❓【給出問題】
+        - 如果日月潭環潭自行車道共30公里，狐狸貓騎行了13.7公里後休息，剩餘多少公里尚未騎行？
+        
+        🤔【理解問題】
+        首先，我們必須完全理解問題的所有細節。在此情境中，我們需要釐清以下幾點：
+        - 日月潭環潭自行車道的總長度為30公里。
+        - 狐狸貓已經騎行了13.7公里。
+        - 我們的目標是計算狐狸貓還剩下多少公里未騎行。
+
+        🧭【設計解題策略】
+        接下來，根據我們對問題的理解來設計解決問題的計劃。在此步驟中，我們決定採用哪種策略來解決問題。對於這個問題，最直接的計劃是使用算術減法：
+        - 總公里數（30公里）減去已騎行的公里數（13.7公里）。
+
+        📝【按步解題】
+        按照設計的計劃執行解題步驟。在這裡我們執行減法運算：
+        30−13.7=16.3
+        這意味著狐狸貓還有16.3公里未騎行。
+
+        ✨【回顧解答】
+        最後，解題完成後，我們回顧和反思整個解題過程。在這一步，我們驗證「想一想」的結果是否符合邏輯，是否正確解決了原問題。
+        同時，考慮是否有更有效或簡便的方法來解決類似的問題。在這個例子中，使用直接減法是最簡單直接的方法。
+        但在其他情境下，可能需要考慮使用圖形、表格或代數表達式等其他策略來解決問題。
+        """
+        
+        # CRA教學法
+        cra_worksheet_prompt = """
+        你是個專業的教師，熟悉CRA教學法，CRA教學法是一種教學策略，
+        CRA正是一種用來促進學生學習和記憶數學的三步教學法，它闡明瞭用這種方式進行教學的具體步驟。
+        CRA的三個步驟互相依賴，運用CRA能建立起一種概念結構，從而形成知識的意義關聯。
+        CRA策略的第一個階段， 即實例(C)階段，是一個“做”的階段。在這一階段，教師用加工材料建模，這些材料包括彩色圓片、立方體、十進位積木、六形六色積木，以及分數積木，等等。在使用這些材料時，必須考慮到兒童的視覺、觸覺及動感經驗。
+        階段二，即描述(R)階段，是一個“看”的階段。在這一-階段，具體的模型被改成了圖片展示，教師可用手繪圖片或貼紙來對概念進行解釋。
+        最後一個階段，即抽象(A)階段，是一個抽象的“符號”階段， 在這一階段， 教師使用數字、字母等數學符號(如:2, 6, 3x, +,-等)來進行教學。
+        運用CRA的前提是學生在學習“規則”前必須學會概念。使用過加工材料的學生，其思維更加明確，更容易理解該方式，同時其學習動機、專注行爲、 理解力以及對這些概念的運用能力也會得到較大改善( Hrrison & Harison, 1986 )。
+        CRA策略可以有效地幫助學生理解以下幾個概念：早期數量關係、位值、計算、分數、小數、測量、幾何、貨幣、百分數、數基、應用題、概率以及統計等
+        這是範例格式：
+        🌐 主題：【概念】認識公里
+
+        🎓【對象】
+        科目： 數學
+        年級： 三年級
+        難度： 基礎
+
+        【實例(C)階段】
+        1. 用彩色圓片來解釋什麼是分數？
+        2. 用立方體來解釋什麼是體積？
+        3. 用十進位積木來解釋什麼是小數？
+
+        【描述(R)階段】
+        1. 用手繪圖片來解釋什麼是分數？
+        2. 用貼紙來解釋什麼是體積？
+        3. 用手繪圖片來解釋什麼是小數？
+
+        【抽象(A)階段】
+        1. 用數字來解釋什麼是分數？
+        2. 用字母來解釋什麼是體積？
+        3. 用數字來解釋什麼是小數？
+        
+        """
+        algorithm = self.specific_feature
+        case = {
+            "Bloom認知階層理論": bloom_worksheet_prompt,
+            "Polya數學解題法": Polya_worksheet_prompt,
+            "CRA教學法": cra_worksheet_prompt
+        }
+        worksheet_prompt = case.get(algorithm, "Bloom認知階層理論")
+
+        return worksheet_prompt
+
+    def _generate_lesson_plan_prompt(self):
+        lesson_plan_ADDIE_prompt = """
+            你是一位專業教師，
+            請根據以上要教學的項目細節(主題、年級、課程時間、課程目標)
+            幫我安排一個 lesson plan
+
+            規則如下，請嚴格遵守
+            1. 請使用繁體中文溝通 zh-TW，並使用台灣人的用語
+            2. 該換行就換行，盡量滿足 word .doc 的格式 
+            3. 【課程大綱】的工作項目請嚴格遵守【課程時間】的時間長度，總和時間不要超過或不足
+            4. 時間安排盡量以五分鐘的倍數為一個單位
+            5. 並且根據課程目標安排教學內容
+            Step1. 你是一個精通於課程設計的老師，能夠運用 ADDIE 教學策略來設計一門適合學生的課程。
+            Step2. 接下來，當使用者按下  "Conversation staters" 的 "請上傳逐字稿"，你將依據輸入的影片逐字稿 (請使用 python 程式來分析、解讀內容)，來規劃一堂 40 分鐘以 ADDIE 模型作為架構的課程，內容請使用台灣口語 (zh_TW)。
+            - 以下是 ADDIE 的說明：
+
+            ADDIE 教學設計模式是一種廣泛應用於教育和訓練領域的系統化教學設計流程。ADDIE 代表分析（Analysis）、設計（Design）、開發（Development）、實施（Implementation）、評估（Evaluation）五個階段：
+            1. 分析（Analysis）階段：在這一階段，設計者需評估教學需求和學習者的背景，包括學習者的知識水平、學習風格及教學目標等。
+            2. 設計（Design）階段：基於分析階段的資料，開始構思教學計劃，包括課程目標、教學策略、內容架構、評估方法等。
+                a. 轉化課程目標為：單元目標和表現的結果
+                b. 決定可以涵括這些目標的主題或單元，計算實際實施教學時會花費的時間
+                c. 依課程目標安排課程順序
+                d. 設計教學的單元，並確認在這些單元中所要達到的主要目標
+                e. 規劃各單元的學習活動
+                f. 發展特定的評量以確認學生的學習情況
+            3. 開發（Development）階段：這個階段主要是製作教學材料，如課程內容、學習活動、多媒體素材等。
+            4. 實施（Implementation）階段：在此階段，實際執行教學計劃，這包括教授課程、指導學習者及管理學習過程。
+
+            5 評估（Evaluation）階段：評估整個教學設計和實施的有效性，這不僅包括學習成果的評估，還要檢視整個教學過程的有效性與可改進之處。
+                a. 教材：是否達到教學目標?
+                b. 過程：設計過程中的品質是否OK?
+                c. 學習者的反應/感受
+                d. 學習者在學習後達成之成就
+                e. 教學實施的結果
+
+            Step3. 請在描述課程計畫的一開始，條列此影片逐字稿的教學重點 (必須和學科領域相關，例如：數學、自然科學) 後，再依序建立以 ADDIE 框架的課程計畫。
+            Step4. 請在「設計」和「實施」階段請使用合適的範例做說明。
+            Step5. 請使用 Markdown 語法，標題與段落文字的字級需有所區隔。
+
+            example:
+            # 課程設計：面積的實測與估測
+            
+            # 教學重點
+            1. 面積的概念：解釋什麼是面積，以及它在日常生活中的應用。
+            2. 面積的計算：教授如何計算不同形狀的面積（例如矩形、三角形）。
+            3. 實測與估測的區別：比較實際測量面積和估算面積的不同方法。
+            4. 應用實例：使用日常生活中的例子，例如給麥麥的生日卡片大小的比較，來說明面積的重要性。
+            
+            # 分析（Analysis）
+            - 目標學習者：小學高年級學生。
+            - 學習需求：理解面積概念，掌握基本面積計算方法。
+            - 學習風格：結合視覺教材和互動活動。
+            
+            # 設計（Design）
+            - 課程目標：學生能夠理解面積概念，並能透過實際操作學會估算和計算面積。
+            - 學習單元：（a）面積基礎概念（b）計算面積（c）實測與估測的比較。
+            - 教學策略：透過互動遊戲、案例討論和實作活動進行教學。
+            - 評估方法：透過小測驗和課堂參與情況進行評估。
+            
+            # 開發（Development）
+            - 教材準備：準備視覺化教學幻燈片，設計互動遊戲和實作活動。
+            - 教學活動：設計面積估測遊戲，讓學生在實際操作中學習。
+            
+            # 實施（Implementation）
+            - 課程時間分配：（a）面積基礎概念（10分鐘）（b）計算面積（15分鐘）（c）實測與估測比較（10分鐘）（d）總結與回顧（5分鐘）。
+            - 教學範例：
+                - 面積基礎概念：介紹面積是如何在日常生活中應用，例如計算桌布的大小。
+                - 計算面積：透過計算教室黑板或門的面積來教學。
+                - 實測與估測比較：讓學生估計並實際測量教室中物品的面積，比較結果。
+            
+            # 評估（Evaluation）
+            - 教材評估：確保教材能清楚傳達面積概念。
+            - 學習者反應：觀察學生參與情況，收集反饋以改善教學。
+            - 學習成就：透過小測驗評估學生對面積概念的理解。
+            - 教學實施結果：評估課程的整體有效性，並根據學生的學習成果進行調整。
+            
+            這個課程計畫將幫助學生透過互動和實作活動來深入理解面積的概念和計算方法
+        """
+
+        lesson_plan_5E_prompt = """
+            你是一位專業教師，
+            請根據以上要教學的項目細節(主題、年級、課程時間、課程目標)
+            幫我安排一個 lesson plan
+
+            規則如下，請嚴格遵守
+            1. 請使用繁體中文溝通 zh-TW，並使用台灣人的用語
+            2. 該換行就換行，盡量滿足 word .doc 的格式 
+            3. 【課程大綱】的工作項目請嚴格遵守【課程時間】的時間長度，總和時間不要超過或不足
+            4. 時間安排盡量以五分鐘的倍數為一個單位
+            5. 並且根據課程目標安排教學內容
+            
+            Lesson Planner 5E is specialized in developing lesson plans for various subjects including Mathematics, Physics, Chemistry, and Biology, using the 5E instructional model. Teachers can input transcripts or text related to these subjects, and the GPT will analyze the content to create a comprehensive lesson plan. The plan will follow the 5E stages: Engagement, Exploration, Explanation, Elaboration, and Evaluation. Each stage will be customized to suit the subject matter, ensuring that students are engaged and the learning objectives are met. For Mathematics, the GPT might suggest problem-solving activities; for Physics, interactive experiments; for Chemistry, lab demonstrations; and for Biology, field studies or observations. The GPT's goal is to make science and math subjects accessible and interesting for students, fostering a deeper understanding through hands-on and inquiry-based learning.
+
+            Step1：理解什麼是 5E 教學模式，請閱讀以下文字：
+            5E教學模式：
+            由Trowbridge和Bybee (1990)提出以探究為基礎的5E教學模式，將教學過程劃分為五個緊密相連的階段，包括：
+            參與(engagement)、探索(exploration)、解釋(explanation)、精緻化(elaboration)與評量(evaluation)等五個階段，
+            各階段的內容如下：
+            1.參與：以學生的學習為主體，設計活動引發學生的學習興趣，使學生願意主動參與教學活動，並能將學生的舊經驗與課程內容相連結，經由提問、定義問題與呈現矛盾的結果等方式，引出探討主題的方向。
+            2.探索：學生參與活動，並給予足夠時間與機會進行探索任務，經由動手操作，建構共同的、具體的經驗。
+            3.解釋：先請學生提出解釋，教師再以學生的想法為基礎，並運用口頭、影片或教學媒體等方式，對學生的解釋加以闡述確認，使學生能確實理解學科知識，再引導學生進入下一階段的教學流程。
+            4.學習共同體 (精緻化)：重視學生之間的互動，營造能促使學生討論以及互相合作的學習環境，分享想法並給予回饋，以建構個人的理解。此外，此階段亦重視學生是否能將其所形成的解釋，應用於新的情境或問題中，以延伸更加一般化的概念理解，進而獲取高層次的知識。
+            5.評量：此階段的主要目的為鼓勵學生評估自己的理解力與能力，同時老師也藉由評量確認學生是否達成教學目標該有的程度。在學生進行探索與提出解釋後，給予回饋是相當重要的，因而教師在階段活動後應進行形成性評量
+
+            Step2：請根據逐字稿的內容描述，以 5E 架構來創建一份 Lesson Plan (課程計畫)。請依循並參考以下輸出範例來設計課程計畫)，需使用 markdown 語法：
+
+            ## 輸出範例：
+
+            課程主題：同分母分數的加減 (使用影片或逐字稿的標題)
+            課程重點：(列出逐字稿內容的重要概念或教學重點)
+            年級：四年級 (依據詢問的年齡或年級填入)
+            課程長度：45-50 分鐘（根據課程數入時間訂定）
+
+            【參與】（5 分鐘）
+
+            - 透過在黑板或投影機上顯示切成不同部分的披薩的圖片來開始課程。
+            - 讓學生與夥伴討論他們注意到分數的什麼以及如何將它們加在一起或減在一起。
+            - 幾分鐘後，請幾位學生與全班分享他們的觀察和想法。
+
+            【探索】（10 分鐘）
+
+            - 發給每位學生分數操作工具（例如分數條、分數圓）。
+            - 為每個學生提供一份工作表，其中包含幾個涉及具有相同分母的分數的加法和減法問題。
+            - 指導學生使用操作工具解決工作表上的問題。
+            - 在房間裡走動，觀察學生的理解情況，並根據需要提供指導。
+
+            【解釋】（10 分鐘）
+
+            - 讓全班同學重新聚集在一起，討論相同分母分數加法和減法的策略和方法。
+            - 介紹關鍵詞彙：分子、分母、分數、同分母。
+            - 顯示並解釋公式：如果兩個分數具有相同的分母，則將分子相加或相減，然後寫出公分母的和或差。
+            - 提供同分母分數加減法的例子，示範步驟和計算。
+
+            【學習共同體】（15 分鐘）
+
+            - 將學生分成兩人一組或小組。
+            - 向每組分發一組分數加法和減法任務卡。
+            - 指導學生使用前面討論的方法一起解決任務卡上的問題。
+            - 鼓勵學生互相解釋他們的想法和推理。
+            - 在教室裡走動以了解學生的進度並在需要時提供支持或澄清。
+
+            【評估】（10 分鐘）
+
+            - 要求每個小組選擇一張任務卡並向全班展示他們的解決方案。
+            - 作為一個班級，討論各小組使用的不同策略並評估他們解決方案的正確性。
+            - 提供回饋並澄清討論期間出現的任何誤解。
+            - 收集學生的工作表和任務卡，作為他們理解的形成性評估。
+
+            【總結】
+
+            - 總結課程中討論的重點，強調分數加減法時分母相同的重要性。
+            - 請學生反思他們的學習，並寫一兩句話來說明他們認為今天的課程有挑戰性或有趣的地方。
+
+            【學習評估】
+
+            - 形成性評估：探索和細化階段的觀察以及討論和演示將深入了解學生對相同分母分數加法和減法的理解。
+            - 總結性評估：收集並審查學生的工作表和任務卡，以評估他們解決涉及具有相同分母的分數的加法和減法問題的能力。
+        """
+        lesson_plan_prompt = lesson_plan_ADDIE_prompt
+
+        return lesson_plan_prompt
+
+    def _generate_exit_ticket_prompt(self):
+        exit_ticket_prompt = """
+        你是一位專業教師，
+        請根據���上要教學的項目細節及逐字稿
+        在一節課結束前用上述的時間（10分鐘內）
+        運用出場券 (exit ticket) 來檢核學生的學習是否有對上學習目標，有哪些知識點或技能還不熟悉
+        目的是讓教學更加精準；出場券能夠檢視每一堂課的學習成效，從學生的答題狀況，
+        可以觀察班上有多少比例學生沒學會，沒學會的地方又是什麼。
+
+        規則如下，請嚴格遵守：
+        1. 內容請使用台灣口語的繁體中文 (zh_TW)，不可以使用大陸用語，也不可以使用簡體字。
+        2. 該換行就換行，盡量滿足 word .doc 的格式 
+        3. 規劃限定時間內，學生能夠完成的出場券習題，共有 5 題，請使用 3 個單選題 (四選項) 以及 2 個填空題，題目必須能夠符合此逐字稿內容描述的數學學習目標，以類題方式建立。
+        4. 此出場券習題最末請公布各題的答案。
+
+        example:
+        出場券習題：公里、公尺和公分的換算
+        選擇題（請從四個選項中選出一個正確答案）
+
+        1. 1公里等於多少公尺？
+        A) 100公尺
+        B) 1000公尺
+        C) 10,000公尺
+        D) 100公分
+
+        2. 5公尺等於多少公分？
+        A) 50公分
+        B) 500公分
+        C) 5,000公分
+        D) 50,000公分
+        
+        3. 如果你走了2.5公里的路程，這段路程等於多少公尺？
+        A) 250公尺
+        B) 2,500公尺
+        C) 25,000公尺
+        D) 250,000公尺
+
+        填空題
+        1. 100公分等於___公尺？（請填入數字）
+        2. 1公尺等於___公分？（請填入數字）
+
+
+        答案公布
+        答案：B) 1000公尺
+        答案：B) 500公分
+        答案：B) 2,500公尺
+        答案：A) 3公尺
+        答案：1公尺
+
+        這套出場券習題旨在幫助學生掌握公里、公尺、和公分之間的換算關係，通過實際的例子加深學生對這些單位之間轉換的理解。
+        """
+        return exit_ticket_prompt
+
+    def create_ai_content(self, ai_client, request_payload):
+        user_content = self.build_user_content()
+        messages = self.build_messages(user_content)
+        request_payload['messages'] = messages
+        response_content = self.send_ai_request(ai_client, request_payload)
+        
+        return response_content
+
+    def build_user_content(self):
+        if self.content_type == 'worksheet':
+            specific_feature_text = f"理論模型: {self.specific_feature}"
+        elif self.content_type == 'lesson_plan':
+            specific_feature_text = f"時間: {self.specific_feature} 分鐘"
+        elif self.content_type == 'exit_ticket':
+            specific_feature_text = f"時間: {self.specific_feature} 分鐘"
+
+        # 根据属性构建用户内容
+        user_content = f"""
+            課程脈絡 or 逐字稿:{self.context}
+            主題：{self.topic}
+            年級：{self.grade}
+            難度：{self.level}
+            {specific_feature_text}
+            
+            請根據逐字稿進行以下工作：
+            不要提到 【逐字稿】 這個詞，直接給出工作內容即可
+            如果是中文素材，請嚴格使用 zh-TW
+            請用 {self.grade} 年級的口吻，不要用太難的詞彙
+            {self.generate_content_prompt()}
+        """
+        print("====User content====")
+        print(user_content)
+        print("====User content====")
+        return user_content
+
+    def build_messages(self, user_content):
+        messages = [{"role": "system", "content": self.system_content},
+                    {"role": "user", "content": user_content}]
+        return messages
+    
+    def send_ai_request(self, ai_client, request_payload):
+        try:
+            response = ai_client.chat.completions.create(**request_payload)
+            response_content = response.choices[0].message.content.strip()
+            return response_content
+        except Exception as e:
+            print(f"An error occurred: {e}")
+            return "Error generating content."
+
+    def build_fine_tune_user_content(self, original_prompt, result, fine_tune_prompt):
+        user_content = f"""
+            這是逐字稿：{self.context}
+            ---
+            這是預設的 prompt
+            {original_prompt}
+            ---
+            產生了以下的結果：
+            {result}
+            ---
+            但我不是很滿意，請根據以下的調整，產生新的結果
+            {fine_tune_prompt}
+        """
+        return user_content

local_config_example.json

@@ -0,0 +1,12 @@
+{
+    "OUTPUT_PATH": "/Users/young/Downloads",
+    "TRANSCRIPTS": [],
+    "CURRENT_INDEX": 0,
+    "VIDEO_ID": "",
+    "PASSWORD": "1234",
+    "OPEN_AI_KEY": "sk-",
+    "GROQ_API_KEY": "",
+    "JUTOR_CHAT_KEY": "",
+    "GOOGLE_APPLICATION_CREDENTIALS_JSON": {
+      }
+}

requirements.txt

@@ -1,4 +1,4 @@
-gradio
+gradio>=4.24.0
 pandas
 openai>=1.0.0
 requests
@@ -12,4 +12,9 @@ google-api-python-client
 google-auth-httplib2
 google-auth-oauthlib
 google-cloud-storage
-
+groq
+yt_dlp
+uuid
+gtts
+boto3
+pydub

storage_service.py

@@ -0,0 +1,44 @@
+import json
+from google.cloud import storage
+from google.oauth2 import service_account
+from googleapiclient.http import MediaIoBaseDownload
+
+
+class GoogleCloudStorage:
+    def __init__(self, service_account_key_string):
+        credentials_dict = json.loads(service_account_key_string)
+        credentials = service_account.Credentials.from_service_account_info(credentials_dict)
+        self.client = storage.Client(credentials=credentials, project=credentials_dict['project_id'])
+
+    def check_file_exists(self, bucket_name, file_name):
+        blob = self.client.bucket(bucket_name).blob(file_name)
+        return blob.exists()
+
+    def upload_file(self, bucket_name, destination_blob_name, file_path):
+        blob = self.client.bucket(bucket_name).blob(destination_blob_name)
+        blob.upload_from_filename(file_path)
+        print(f"File {file_path} uploaded to {destination_blob_name} in GCS.")
+
+    def upload_file_as_string(self, bucket_name, destination_blob_name, content):
+        blob = self.client.bucket(bucket_name).blob(destination_blob_name)
+        blob.upload_from_string(content)
+        print(f"String content uploaded to {destination_blob_name} in GCS.")
+        return None
+
+    def download_as_string(self, bucket_name, source_blob_name):
+        blob = self.client.bucket(bucket_name).blob(source_blob_name)
+        return blob.download_as_text()
+
+    def make_blob_public(self, bucket_name, blob_name):
+        blob = self.client.bucket(bucket_name).blob(blob_name)
+        blob.make_public()
+        print(f"Blob {blob_name} is now publicly accessible at {blob.public_url}")
+
+    def get_public_url(self, bucket_name, blob_name):
+        blob = self.client.bucket(bucket_name).blob(blob_name)
+        return blob.public_url
+
+    def upload_image_and_get_public_url(self, bucket_name, file_name, file_path):
+        self.upload_file(bucket_name, file_name, file_path)
+        self.make_blob_public(bucket_name, file_name)
+        return self.get_public_url(bucket_name, file_name)