feat: add completion reward

app.py

@@ -13,12 +13,20 @@ from utils.utils import (
     save_latest_player_data,
     render_finished,
 )
+from utils.completion_reward import CompletionReward
+from utils.completion_reward_utils import (
+    get_llm_response,
+    set_player_name,
+    set_player_selected_character,
+    create_certificate,
+    complete_reward,
+    check_is_in_completion_reward,
+)
 
 seafoam = Seafoam()
 
 
 def get_player_info(player_backend_user_id):
-
     try:
         with open("latest_player_data.json", "r", encoding="utf-8") as file:
             player_info = json.load(file)
@@ -27,7 +35,7 @@ def get_player_info(player_backend_user_id):
         save_latest_player_data()
         with open("latest_player_data.json", "r", encoding="utf-8") as file:
             player_info = json.load(file)
-            
+
     if player_backend_user_id in player_info:
         return player_info[player_backend_user_id]
     else:
@@ -43,12 +51,32 @@ def get_player_info(player_backend_user_id):
 
         return new_player.to_dict()
 
+
 def create_new_player_activity():
     return PlayerActivity()
 
+
+def get_player_logs(player_backend_user_id):
+    with open("processed_adventure_logs.json") as file:
+        player_logs = json.load(file)
+    try:
+        player_logs = player_logs[player_backend_user_id]
+        return player_logs
+    except KeyError:
+        logging.error(
+            f"Player {player_backend_user_id} not found in processed_player_adventure_logs.json"
+        )
+
+
+def init_reward():
+    return CompletionReward()
+
+
 # start of gradio interface
 with gr.Blocks(theme=seafoam, css=get_content("css/style.css")) as demo:
     player_info = gr.State()
+    player_logs = gr.State()
+    completion_reward = gr.State(init_reward)
     player_activity_tracker = gr.State(create_new_player_activity)
 
     with gr.Row():
@@ -87,15 +115,15 @@ with gr.Blocks(theme=seafoam, css=get_content("css/style.css")) as demo:
 
         with gr.Column(scale=1):
             adventure_description = gr.Markdown(
-                    "# 冒險階段", elem_id="adventure_description"
-                )
+                "# 冒險階段", elem_id="adventure_description"
+            )
             adventure = gr.Slider(
-                    value=0,
-                    show_label=False,
-                    interactive=False,
-                    elem_id="adventure_slider",
-                    info="",
-                )
+                value=0,
+                show_label=False,
+                interactive=False,
+                elem_id="adventure_slider",
+                info="",
+            )
             achievements_description = gr.Markdown(
                 "# 達成成就", elem_id="achievements_description"
             )
@@ -124,6 +152,146 @@ with gr.Blocks(theme=seafoam, css=get_content("css/style.css")) as demo:
         pull_newest_player_data = gr.Textbox("", visible=False)
         update_status = gr.Textbox("", visible=False)
 
+    with gr.Tab("完賽獎勵"):
+        with gr.Row():
+            start_make_reward = gr.Button(
+                "開始製作完賽獎勵！", visible=True, elem_id="start_make_reward"
+            )
+
+        with gr.Row():
+            not_participate = gr.Markdown(
+                "# 同學並未參與 2023 的星空探險隊唷！", visible=False, elem_id="not_participate"
+            )
+
+        with gr.Row():
+            not_start = gr.Markdown(
+                "# 完賽獎勵還沒有開放申請，但是就快了，請敬請期待！", visible=False, elem_id="not_start"
+            )
+
+        with gr.Row():
+            already_issued = gr.Image(visible=False)
+
+        with gr.Row():
+            player_name_title = gr.Markdown(
+                "# 選擇玩家暱稱", visible=False, elem_id="player_name_title"
+            )
+
+        with gr.Row():
+            player_name = gr.Textbox(
+                label="玩家暱稱",
+                info="請輸入想要用在完賽獎勵上的玩家暱稱，上限為 10 字，獎勵發送後無法更改也無法補發，還請同學們謹慎填寫。",
+                interactive=True,
+                elem_id="player_name",
+                visible=False,
+            )
+
+        with gr.Row():
+            confirm_player_name = gr.Button(
+                "確認暱稱", elem_id="confirm_player_name", visible=False
+            )
+            cancel_player_name = gr.Button(
+                "取消", elem_id="cancel_player_name", visible=False
+            )
+
+        with gr.Row():
+            player_name_next_step = gr.Button(
+                "下一步", visible=False, elem_id="player_name_next_step"
+            )
+
+        with gr.Row():
+            story_title = gr.Markdown("# 選擇冒險故事", visible=False, elem_id="story_title")
+
+        with gr.Row():
+            story_description = gr.Markdown(
+                "有五位星際夥伴來為你撰寫專屬於你的冒險故事，每位星際夥伴都會得到同學冒險週記的內容，並寫成一段故事，請同學選擇自己最喜歡的一段故事��這段故事將會被用來印在獎狀上<br><br>小叮嚀：請同學選擇喜歡的故事內容，而不是星際夥伴唷！星際夥伴可是不會和同學們一起冒險的！最後，撰寫故事的過程大概需要幾分鐘的時間，請同學耐心等待",
+                visible=False,
+                elem_id="story_description",
+            )
+
+        with gr.Row():
+            openai_description = gr.Markdown(
+                "# 露米娜", elem_id="openai_description", visible=False
+            )
+            aws_description = gr.Markdown(
+                "# 索拉拉", elem_id="aws_description", visible=False
+            )
+            google_description = gr.Markdown(
+                "# 薇丹特", elem_id="google_description", visible=False
+            )
+            mtk_description = gr.Markdown(
+                "# 蔚藍", elem_id="mtk_description", visible=False
+            )
+
+        with gr.Row():
+            openai_img = gr.Image(
+                "medias/lumina.png",
+                visible=False,
+                elem_id="openai_img",
+                interactive=False,
+                show_download_button=False,
+            )
+            aws_img = gr.Image(
+                "medias/solara.png",
+                visible=False,
+                elem_id="aws_img",
+                interactive=False,
+                show_download_button=False,
+            )
+            google_img = gr.Image(
+                "medias/verdant.png",
+                visible=False,
+                elem_id="google_img",
+                interactive=False,
+                show_download_button=False,
+            )
+            mtk_img = gr.Image(
+                "medias/azure.png",
+                visible=False,
+                elem_id="mtk_img",
+                interactive=False,
+                show_download_button=False,
+            )
+
+        with gr.Row():
+            start_generate_story = gr.Button(
+                "開始寫作故事", visible=False, elem_id="start_generate_story"
+            )
+
+        with gr.Row():
+            bot1 = gr.Chatbot(visible=False)
+            bot2 = gr.Chatbot(visible=False)
+            bot3 = gr.Chatbot(visible=False)
+            bot4 = gr.Chatbot(visible=False)
+
+        with gr.Row():
+            select_story = gr.Radio(
+                ["露米娜", "索拉拉", "薇丹特", "蔚藍"],
+                interactive=True,
+                label="選擇故事",
+                visible=False,
+                elem_id="select_story",
+            )
+
+        with gr.Row():
+            confirm_story = gr.Button("確認故事", visible=False, elem_id="confirm_story")
+            cancel_story = gr.Button("取消", visible=False, elem_id="cancel_story")
+
+        with gr.Row():
+            start_generate_certificate = gr.Button(
+                "開始製作完賽獎勵！", visible=False, elem_id="start_generate_certificate"
+            )
+            processing = gr.Button(
+                "製作中...",
+                visible=False,
+                elem_id="processing",
+                size="lg",
+                interactive=False,
+            )
+            complete = gr.Markdown("# 完成！", visible=False, elem_id="complete")
+
+        with gr.Row():
+            reward_result = gr.Image(visible=False)
+
     # actions when player login
     # define args
     send_player_login_info = dict(
@@ -133,10 +301,14 @@ with gr.Blocks(theme=seafoam, css=get_content("css/style.css")) as demo:
     )
 
     player_info_query_btn.click(get_player_info, player_backend_id, player_info).then(
+        get_player_logs, player_backend_id, player_logs
+    ).then(
         render_player_data,
         player_info,
         [avatar, pet_gallery, badge_gallery, adventure_log, achievements, adventure],
-    ).then(**send_player_login_info)
+    ).then(
+        **send_player_login_info
+    )
 
     pull_newest_player_data.submit(
         save_latest_player_data,
@@ -145,5 +317,186 @@ with gr.Blocks(theme=seafoam, css=get_content("css/style.css")) as demo:
         api_name="pull_newest_player_data",
     )
 
+    def create_visibility_updates(visible, count):
+        return tuple(gr.update(visible=visible) for _ in range(count))
+
+    start_make_reward.click(
+        check_is_in_completion_reward,
+        player_backend_id,
+        [
+            start_make_reward,
+            player_name_title,
+            player_name,
+            confirm_player_name,
+            not_participate,
+            not_start,
+            already_issued,
+        ],
+        queue=False,
+    )
+
+    set_player_name_args = dict(
+        fn=set_player_name,
+        inputs=[completion_reward, player_name, player_backend_id],
+        outputs=None,
+        queue=False,
+    )
+
+    confirm_player_name.click(
+        lambda: (gr.update(interactive=False), gr.update(visible=False)),
+        None,
+        [player_name, confirm_player_name],
+        queue=False,
+    ).then(
+        lambda: create_visibility_updates(True, 2),
+        None,
+        [cancel_player_name, player_name_next_step],
+        queue=False,
+    ).then(
+        **set_player_name_args
+    )
+
+    cancel_player_name.click(
+        lambda: (gr.update(interactive=True), gr.update(visible=True)),
+        None,
+        [player_name, confirm_player_name],
+        queue=False,
+    ).then(
+        lambda: create_visibility_updates(False, 2),
+        None,
+        [cancel_player_name, player_name_next_step],
+        queue=False,
+    )
+
+    player_name_next_step.click(
+        lambda: create_visibility_updates(False, 5),
+        None,
+        [
+            player_name,
+            player_name_next_step,
+            confirm_player_name,
+            player_name_title,
+            cancel_player_name,
+        ],
+        queue=False,
+    ).then(
+        lambda: create_visibility_updates(True, 11),
+        None,
+        [
+            openai_img,
+            aws_img,
+            google_img,
+            mtk_img,
+            story_title,
+            story_description,
+            openai_description,
+            aws_description,
+            google_description,
+            mtk_description,
+            start_generate_story,
+        ],
+        queue=False,
+    )
+
+    get_llm_response_args = dict(
+        fn=get_llm_response,
+        inputs=[completion_reward, player_logs],
+        outputs=[bot1, bot2, bot3, bot4],
+        queue=False,
+    )
+
+    start_generate_story.click(
+        lambda: gr.update(visible=False), None, start_generate_story, queue=False
+    ).then(
+        lambda: create_visibility_updates(True, 4),
+        None,
+        [bot1, bot2, bot3, bot4],
+        queue=False,
+    ).then(
+        **get_llm_response_args
+    ).then(
+        lambda: gr.update(visible=True), None, [select_story], queue=False
+    )
+
+    select_story.select(
+        lambda: gr.update(visible=True), None, confirm_story, queue=False
+    )
+
+    set_player_selected_character_args = dict(
+        fn=set_player_selected_character,
+        inputs=[completion_reward, select_story],
+        outputs=None,
+        queue=False,
+    )
+
+    confirm_story.click(
+        lambda: gr.update(interactive=False), None, [select_story], queue=False
+    ).then(lambda: gr.update(visible=False), None, [confirm_story], queue=False).then(
+        lambda: (gr.update(visible=True), gr.update(visible=True)),
+        None,
+        [start_generate_certificate, cancel_story],
+        queue=False,
+    ).then(
+        **set_player_selected_character_args
+    )
+
+    cancel_story.click(
+        lambda: gr.update(interactive=True), None, [select_story], queue=False
+    ).then(lambda: gr.update(visible=False), None, [cancel_story], queue=False).then(
+        lambda: (gr.update(visible=False), gr.update(visible=True)),
+        None,
+        [start_generate_certificate, confirm_story],
+        queue=False,
+    )
+
+    create_certificate_args = dict(
+        fn=create_certificate,
+        inputs=[completion_reward],
+        outputs=reward_result,
+        queue=False,
+    )
+
+    complete_reward_args = dict(
+        fn=complete_reward,
+        inputs=[completion_reward],
+        outputs=None,
+        queue=False,
+    )
+
+    start_generate_certificate.click(
+        lambda: create_visibility_updates(False, 18),
+        None,
+        [
+            openai_img,
+            aws_img,
+            google_img,
+            mtk_img,
+            story_title,
+            story_description,
+            openai_description,
+            aws_description,
+            google_description,
+            mtk_description,
+            bot1,
+            bot2,
+            bot3,
+            bot4,
+            select_story,
+            processing,
+            cancel_story,
+            start_generate_certificate,
+        ],
+        queue=False,
+    ).then(lambda: gr.update(visible=True), None, [processing], queue=False).then(
+        **create_certificate_args
+    ).then(
+        lambda: (gr.update(visible=True), gr.update(visible=False)),
+        None,
+        [complete, processing],
+        queue=False,
+    ).then(
+        **complete_reward_args
+    )
+
 if __name__ == "__main__":
     demo.launch()

css/style.css

@@ -246,4 +246,124 @@ input[type="range"]::-ms-track {
     box-shadow: 2px 2px 2px 0px rgba(0,0,0,0.75) inset !important;
     border-radius: 10px !important; /* Rounded corners of the track */
   }
-  
+  
+
+  #player_name_title {
+    margin: 5vh auto;
+}
+
+#player_name {
+    padding: 6vh 6vw 10vh 6vw;
+}
+
+#player_name [data-testid="block-info"]{
+    font-size: 2rem;
+    padding: 1vh 0 1vh 0;
+    display: block;
+    color: #000;
+    text-align: center !important;
+}
+
+#player_name div{
+    color: #444;
+    text-align: center;
+}
+
+#player_name textarea{
+    border-style: solid;
+    border-color: rgba(244, 250, 150, 0.2);
+    border-width: 1px;
+    background: rgba(255,255,255, 0.2);
+}
+
+#story_title {
+    margin: 5vh auto;
+}
+
+#story_description p {
+    font-size: 1.3rem;
+    text-align: center;
+    width: 70%;
+    margin: 5vh auto;
+}
+
+#story_description {
+    border: #12d2ab solid 1px !important;
+    border-radius: 10px;
+}
+
+#start_make_reward {
+    background-color: #12d2ab;
+    margin: 20vh 10vw;
+    height: 30vh;
+    font-size: 2rem;
+}
+
+#not_participate {
+    margin: 20vh 10vw;
+    font-size: 2rem;
+}
+
+#not_start {
+    margin: 20vh 10vw;
+    font-size: 2rem;
+}
+
+#start_generate_story, #confirm_player_name, #player_name_next_step, #confirm_story, #start_generate_certificate {
+    background-color: #48A1DD;
+}
+
+#cancel_player_name, #cancel_story {
+    background-color: #eb6584;
+}
+
+#openai_img, #aws_img, #google_img, #mtk_img, #ntu_img {
+    border-radius: 50%;
+    transform: scale(0.7);
+}
+
+#openai_img [aria-label="Download"], #aws_img [aria-label="Download"], #google_img [aria-label="Download"], #mtk_img [aria-label="Download"], #ntu_img [aria-label="Download"] {
+    display: none;
+}
+
+[aria-label="Loading response"] {
+    background: rgba(0,0,0,0.1);
+}
+
+.selected {
+    color: #fff;
+    background: #12d2ab;
+    border: 2px solid #02b28f;
+    border-radius: 8px;
+}
+
+.message {
+    background: rgba(0,0,0,0.05);
+    border: None;
+}
+
+.code_wrap {
+    background: rgba(0,0,0,0.1);
+    border-radius: 10px;
+    padding: 1vh 1vw 1vh 1vw;
+    margin: 1vh 1vw 1vh 1vw;
+}
+
+#select_story {
+    display: flex;
+    justify-content: space-evenly;
+}
+
+#select_story label{
+    background: #48A1DD;
+    color: #fff;
+}
+
+#select_story input{
+    background-color: #2563eb;
+}
+
+#select_story [data-testid="block-info"] {
+    color: #000;
+    margin: auto;
+}

utils/completion_reward.py

@@ -0,0 +1,531 @@
+import logging
+import json
+import time
+import io
+import os
+import re
+import requests
+import textwrap
+import random
+import hashlib
+from datetime import datetime
+from PIL import Image, ImageDraw, ImageFilter, ImageFont
+
+import anthropic_bedrock
+import gradio as gr
+from opencc import OpenCC
+from openai import OpenAI
+from anthropic_bedrock import AnthropicBedrock, HUMAN_PROMPT, AI_PROMPT
+from google.auth.transport.requests import Request
+from google.oauth2.service_account import Credentials
+from google import auth
+from google.cloud import bigquery
+from google.cloud import storage
+
+
+class CompletionReward:
+    def __init__(self):
+        self.player_backend_user_id = None
+        self.player_name = None
+        self.background_url = None
+        self.player_selected_character = None
+        self.player_selected_model = None
+        self.player_selected_paragraph = None
+        self.paragraph_openai = None
+        self.paragraph_aws = None
+        self.paragraph_google = None
+        self.paragraph_mtk = None
+        self.player_certificate_url = None
+        self.openai_agent = OpenAIAgent()
+        self.aws_agent = AWSAgent()
+        self.google_agent = GoogleAgent()
+        self.mtk_agent = MTKAgent()
+        self.shuffled_response_order = {}
+        self.paragraph_map = {
+            "openai": self.paragraph_openai,
+            "aws": self.paragraph_aws,
+            "google": self.paragraph_google,
+            "mtk": self.paragraph_mtk,
+        }
+        SERVICE_ACCOUNT_INFO = os.getenv("GBQ_TOKEN")
+        service_account_info_dict = json.loads(SERVICE_ACCOUNT_INFO)
+
+        creds = Credentials.from_service_account_info(service_account_info_dict)
+        self.gbq_client = bigquery.Client(
+            credentials=creds, project=service_account_info_dict["project_id"]
+        )
+        self.gcs_client = storage.Client(
+            credentials=creds, project=service_account_info_dict["project_id"]
+        )
+
+    def get_llm_response(self, player_logs):
+        agents_responses = {
+            "openai": self.openai_agent.get_story(player_logs),
+            "aws": self.aws_agent.get_story(player_logs),
+            "google": self.google_agent.get_story(player_logs),
+            "mtk": self.mtk_agent.get_story(player_logs),
+        }
+        self.paragraph_openai = agents_responses["openai"]
+        self.paragraph_aws = agents_responses["aws"]
+        self.paragraph_google = agents_responses["google"]
+        self.paragraph_mtk = agents_responses["mtk"]
+        response_items = list(agents_responses.items())
+        random.shuffle(response_items)
+
+        self.shuffled_response_order = {
+            str(index): agent for index, (agent, _) in enumerate(response_items)
+        }
+
+        shuffled_responses = tuple(response for _, response in response_items)
+        return (
+            [(None, shuffled_responses[0])],
+            [(None, shuffled_responses[1])],
+            [(None, shuffled_responses[2])],
+            [(None, shuffled_responses[3])],
+        )
+
+    def set_player_name(self, player_name, player_backend_user_id):
+        self.player_backend_user_id = player_backend_user_id
+        self.player_name = player_name
+
+    def set_background_url(self, background_url):
+        self.background_url = background_url
+
+    def set_player_backend_user_id(self, player_backend_user_id):
+        self.player_backend_user_id = player_backend_user_id
+
+    def set_player_selected_character(self, player_selected_character):
+        character_map = {
+            "露米娜": "0",
+            "索拉拉": "1",
+            "薇丹特": "2",
+            "蔚藍": "3",
+        }
+        self.player_selected_character = player_selected_character
+        self.player_selected_model = self.shuffled_response_order[
+            character_map[player_selected_character]
+        ]
+        self.player_selected_paragraph = self.get_paragraph_by_model(
+            self.player_selected_model
+        )
+
+    def get_paragraph_by_model(self, model):
+        return getattr(self, f"paragraph_{model}", None)
+
+    def create_certificate(self):
+        image_url = self.openai_agent.get_background()
+        self.set_background_url(image_url)
+        source_file = ImageProcessor.generate_reward(
+            image_url,
+            self.player_name,
+            self.player_selected_paragraph,
+            self.player_backend_user_id,
+        )
+
+        public_url = self.upload_blob_and_get_public_url(
+            "mes_completion_rewards", source_file, f"2023_mes/{source_file}"
+        )
+        self.player_certificate_url = public_url
+
+        return gr.Image(public_url, visible=True)
+
+    def to_dict(self):
+        return {
+            "player_backend_user_id": self.player_backend_user_id,
+            "player_name": self.player_name,
+            "background_url": self.background_url,
+            "player_selected_model": self.player_selected_model,
+            "player_selected_paragraph": self.player_selected_paragraph,
+            "paragraph_openai": self.paragraph_openai,
+            "paragraph_aws": self.paragraph_aws,
+            "paragraph_google": self.paragraph_google,
+            "paragraph_mtk": self.paragraph_mtk,
+            "player_certificate_url": self.player_certificate_url,
+            "created_at_date": datetime.now().date(),
+        }
+
+    def insert_data_into_bigquery(self, client, dataset_id, table_id, rows_to_insert):
+        table_ref = client.dataset(dataset_id).table(table_id)
+        table = client.get_table(table_ref)
+
+        errors = client.insert_rows(table, rows_to_insert)
+
+        if errors:
+            logging.info("Errors occurred while inserting rows:")
+            for error in errors:
+                print(error)
+        else:
+            logging.info(f"Inserted {len(rows_to_insert)} rows successfully.")
+
+    def complete_reward(
+        self,
+    ):
+        insert_row = self.to_dict()
+        self.insert_data_into_bigquery(
+            self.gbq_client, "streaming_log", "log_mes_completion_rewards", [insert_row]
+        )
+        logging.info(
+            f"Player {insert_row['player_backend_user_id']} rendered successfully."
+        )
+
+        with open("../data/completion_reward_issue_status.json") as f:
+            completion_reward_issue_status_dict = json.load(f)
+
+        completion_reward_issue_status_dict[
+            insert_row["player_backend_user_id"]
+        ] = self.player_certificate_url
+
+        with open("../data/completion_reward_issue_status.json", "w") as f:
+            json.dump(completion_reward_issue_status_dict, f)
+
+    def upload_blob_and_get_public_url(
+        self, bucket_name, source_file_name, destination_blob_name
+    ):
+        """Uploads a file to the bucket and makes it publicly accessible."""
+        # Initialize a storage client
+        bucket = self.gcs_client.bucket(bucket_name)
+        blob = bucket.blob(destination_blob_name)
+
+        # Upload the file
+        blob.upload_from_filename(source_file_name)
+
+        # The public URL can be used to directly access the uploaded file via HTTP
+        public_url = blob.public_url
+
+        logging.info(f"File {source_file_name} uploaded to {destination_blob_name}.")
+
+        return public_url
+
+
+class OpenAIAgent:
+    def __init__(self):
+        self.temperature = 0.8
+        self.frequency_penalty = 0
+        self.presence_penalty = 0
+        self.max_tokens = 2048
+
+    def get_story(self, user_log):
+        system_prompt = """
+            我正在舉辦一個學習型的活動，參與活動的學生為 1-9 年級，我為他們設計了一個獨特的故事機制，每天每個學生都會收到屬於自己獨特的冒險紀錄，現在我需要你協助我將這些冒險紀錄，製作成一段冒險故事，請
+            - 以「你」稱呼學生
+            - 請用 500 字以內的短篇故事
+            - 試著合併故事記錄成一段連貫、有吸引力的故事
+            - 請使用 zh_TW
+            最後，I'll tip $200
+        """
+
+        user_log = f"""
+            ```{user_log}
+            ```
+        """
+
+        messages = [
+            {
+                "role": "system",
+                "content": f"{system_prompt}",
+            },
+            {
+                "role": "user",
+                "content": f"{user_log}",
+            },
+        ]
+
+        client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+        response = None
+
+        retry_attempts = 0
+        while retry_attempts < 5:
+            try:
+                response = client.chat.completions.create(
+                    model="gpt-3.5-turbo",
+                    messages=messages,
+                    temperature=self.temperature,
+                    max_tokens=self.max_tokens,
+                    frequency_penalty=self.frequency_penalty,
+                    presence_penalty=self.presence_penalty,
+                )
+                chinese_converter = OpenCC("s2tw")
+                return chinese_converter.convert(response.choices[0].message.content)
+
+            except Exception as e:
+                retry_attempts += 1
+                logging.error(f"Attempt {retry_attempts}: {e}")
+                time.sleep(1 * retry_attempts)
+
+    def get_background(self):
+        client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+        image_url = None
+
+        retry_attempts = 0
+        while retry_attempts < 5:
+            try:
+                response = client.images.generate(
+                    model="dall-e-3",
+                    prompt="Create an image in a retro Ghibli style, with a focus on a universe theme. The artwork should maintain the traditional hand-drawn animation look characteristic of Ghibli. Imagine a scene set in outer space or a fantastical cosmic environment, rich with vibrant and varied color palettes to capture the mystery and majesty of the universe. The background should be detailed, showcasing stars, planets, and nebulae, blending the Ghibli style's nostalgia and emotional depth with the awe-inspiring aspects of space. The overall feel should be timeless, merging the natural wonder of the cosmos with the storytelling and emotional resonance typical of the retro Ghibli aesthetic. Soft lighting and gentle shading should be used to enhance the dreamlike, otherworldly quality of the scene.",
+                    size="1024x1024",
+                    quality="standard",
+                    n=1,
+                )
+
+                image_url = response.data[0].url
+                return image_url
+
+            except Exception as e:
+                retry_attempts += 1
+                logging.error(f"Attempt {retry_attempts}: {e}")
+                time.sleep(1 * retry_attempts)  # exponential backoff
+
+
+class AWSAgent:
+    def get_story(self, user_log):
+        system_prompt = """
+            我正在舉辦一個學習型的活動，參與活動的學生為 1-9 年級，我為他們設計了一個獨特的故事機制，每天每個學生都會收到屬於自己獨特的冒險紀錄，現在我需要你協助我將這些冒險紀錄，製作成一段冒險故事，請
+            - 以「你」稱呼學生
+            - 請用 500 
+            - 試著合併故事記錄成一段連貫、有吸引力的故事
+            - 請使用 zh_TW
+            最後，I'll tip $200
+        """
+
+        user_log = f"""
+            ```{user_log}
+            ```
+        """
+        client = AnthropicBedrock(
+            aws_access_key=os.getenv("AWS_ACCESS_KEY"),
+            aws_secret_key=os.getenv("AWS_SECRET_KEY"),
+            aws_region="us-west-2",
+        )
+
+        retry_attempts = 0
+        while retry_attempts < 5:
+            try:
+                completion = client.completions.create(
+                    model="anthropic.claude-v2",
+                    max_tokens_to_sample=2048,
+                    prompt=f"{anthropic_bedrock.HUMAN_PROMPT}{system_prompt}，以下是我的故事紀錄```{user_log}``` {anthropic_bedrock.AI_PROMPT}",
+                )
+                chinese_converter = OpenCC("s2tw")
+                return chinese_converter.convert(completion.completion)
+
+            except Exception as e:
+                retry_attempts += 1
+                logging.error(f"Attempt {retry_attempts}: {e}")
+                time.sleep(1 * retry_attempts)
+
+
+class GoogleAgent:
+    def get_story(self, user_log):
+        credentials, _ = auth.default()
+        credentials.refresh(Request())
+
+        url = f"https://us-central1-aiplatform.googleapis.com/v1/projects/junyiacademy/locations/us-central1/publishers/google/models/gemini-pro:streamGenerateContent?"
+
+        # Headers
+        headers = {
+            "Authorization": f"Bearer {credentials.token}",
+            "Content-Type": "application/json",
+        }
+        system_prompt = """
+                    我正在舉辦一個學習型的活動，參與活動的學生為 1-9 年級，我為他們設計了一個獨特的故事機制，每天每個學生都會收到屬於自己獨特的冒險紀錄，現在我需要你協助我將這些冒險紀錄，製作成一段冒險故事，請
+                    - 以「你」稱呼學生
+                    - 請用 500 
+                    - 試著合併故事記錄成一段連貫、有吸引力的故事
+                    - 請使用 zh_TW
+                    最後，I'll tip $200
+                """
+
+        user_log = f"""
+            ```{user_log}
+            ```
+        """
+
+        # Provided payload
+        payload = {
+            "contents": [
+                {
+                    "role": "USER",
+                    "parts": {"text": f"{system_prompt}, 以下是我的冒險故事 ```{user_log}```"},
+                },
+            ],
+            "safety_settings": {
+                "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
+                "threshold": "BLOCK_LOW_AND_ABOVE",
+            },
+            "generation_config": {
+                "temperature": 0.2,
+                "topP": 0.8,
+                "topK": 40,
+                "maxOutputTokens": 2048,
+            },
+        }
+
+        retry_attempts = 0
+        while retry_attempts < 5:
+            try:
+                response = requests.post(url, headers=headers, data=json.dumps(payload))
+                chinese_converter = OpenCC("s2tw")
+
+                final_story = ""
+                for i in response.json():
+                    final_story += i["candidates"][0]["content"]["parts"][0]["text"]
+                return chinese_converter.convert(final_story)
+
+            except Exception as e:
+                retry_attempts += 1
+                logging.error(f"Attempt {retry_attempts}: {e}")
+                time.sleep(1 * retry_attempts)
+
+
+class MTKAgent:
+    def get_story(self, user_log):
+        system_prompt = """
+            我正在舉辦一個學習型的活動，參與活動的學生為 1-9 年級，我為他們設計了一個獨特的故事機制，每天每個學生都會收到屬於自己獨特的冒險紀錄，現在我需要你協助我將這些冒險紀錄，製作成一段冒險故事，請
+            - 以「你」稱呼學生
+            - 請用 500 
+            - 試著合併故事記錄成一段連貫、有吸引力的故事
+            - 請使用 zh_TW
+        """
+
+        user_log = f"""
+            ```{user_log}
+            ```
+        """
+
+        BASE_URL = "http://35.229.245.251:8008/v1"
+        TOKEN = os.getenv("MTK_TOKEN")
+        MODEL_NAME = "model7-c-chat"
+        TEMPERATURE = 1
+        MAX_TOKENS = 1024
+        TOP_P = 0
+        PRESENCE_PENALTY = 0
+        FREQUENCY_PENALTY = 0
+        message = f"{system_prompt}, 以下是我的冒險故事 ```{user_log}```"
+        url = os.path.join(BASE_URL, "chat/completions")
+        headers = {
+            "accept": "application/json",
+            "Authorization": f"Bearer {TOKEN}",
+            "Content-Type": "application/json",
+        }
+        data = {
+            "model": MODEL_NAME,
+            "messages": str(message),
+            "temperature": TEMPERATURE,
+            "n": 1,
+            "max_tokens": MAX_TOKENS,
+            "stop": "",
+            "top_p": TOP_P,
+            "logprobs": 0,
+            "echo": False,
+            "presence_penalty": PRESENCE_PENALTY,
+            "frequency_penalty": FREQUENCY_PENALTY,
+        }
+
+        retry_attempts = 0
+        while retry_attempts < 5:
+            try:
+                response = requests.post(
+                    url, headers=headers, data=json.dumps(data)
+                ).json()
+                response_text = response["choices"][0]["message"]["content"]
+
+                matched_content = re.search("```(.+)", response_text, re.DOTALL)
+                extracted_content = (
+                    matched_content.group(1).strip() if matched_content else None
+                )
+
+                chinese_converter = OpenCC("s2tw")
+
+                if extracted_content:
+                    return chinese_converter.convert(extracted_content)
+                else:
+                    return chinese_converter.convert(response_text)
+
+            except Exception as e:
+                retry_attempts += 1
+                logging.error(f"Attempt {retry_attempts}: {e}")
+                time.sleep(1 * retry_attempts)
+
+
+class ImageProcessor:
+    @staticmethod
+    def draw_shadow(
+        image, box, radius, offset=(10, 10), shadow_color=(0, 0, 0, 128), blur_radius=5
+    ):
+        shadow_image = Image.new("RGBA", image.size, (0, 0, 0, 0))
+        shadow_draw = ImageDraw.Draw(shadow_image)
+        shadow_box = [
+            box[0] + offset[0],
+            box[1] + offset[1],
+            box[2] + offset[0],
+            box[3] + offset[1],
+        ]
+        shadow_draw.rounded_rectangle(shadow_box, fill=shadow_color, radius=radius)
+        shadow_image = shadow_image.filter(ImageFilter.GaussianBlur(blur_radius))
+        image.paste(shadow_image, (0, 0), shadow_image)
+
+    @staticmethod
+    def generate_reward(url, player_name, paragraph, player_backend_user_id):
+        retry_attempts = 0
+        while retry_attempts < 5:
+            try:
+                response = requests.get(url)
+                break
+            except requests.RequestException as e:
+                retry_attempts += 1
+                logging.error(f"Attempt {retry_attempts}: {e}")
+                time.sleep(1 * retry_attempts)  # exponential backoff
+
+        image_bytes = io.BytesIO(response.content)
+        img = Image.open(image_bytes)
+
+        tmp_img = Image.new("RGBA", img.size, (0, 0, 0, 0))
+        draw = ImageDraw.Draw(tmp_img)
+
+        # Draw the box
+        left, right = 50, img.width - 50
+        box_height = 500
+        top = (img.height - box_height) // 2
+        bottom = (img.height + box_height) // 2
+        border_radius = 20
+
+        # Draw the rounded rectangle
+        fill_color = (255, 255, 255, 220)
+        draw.rounded_rectangle(
+            [left, top, right, bottom],
+            fill=fill_color,
+            outline=None,
+            radius=border_radius,
+        )
+
+        img.paste(Image.alpha_composite(img.convert("RGBA"), tmp_img), (0, 0), tmp_img)
+
+        draw = ImageDraw.Draw(img)
+
+        # Draw the text
+        title_font = ImageFont.truetype("NotoSansTC-Bold.ttf", 36)
+        body_font = ImageFont.truetype("NotoSansTC-Light.ttf", 12)
+
+        # Title text
+        title = f"光束守護者 - {player_name} 的冒險故事"
+        title_x, title_y = left + 20, top + 20  # Adjust padding as needed
+        draw.text((title_x, title_y), title, font=title_font, fill="black")
+
+        # Paragraph text with newlines
+        body_x, body_y = left + 20, title_y + 60  # Adjust position as needed
+
+        for line in paragraph.split("\n"):
+            wrapped_lines = textwrap.wrap(line, width=55)
+            for wrapped_line in wrapped_lines:
+                draw.text((body_x, body_y), wrapped_line, font=body_font, fill="black")
+                body_y += 30
+
+        # Save the image with the text
+
+        def get_md5_hash(text):
+            return hashlib.md5(text.encode("utf-8")).hexdigest()
+
+        updated_image_path = f"certificate_{get_md5_hash(player_backend_user_id)}.png"
+        img.save(updated_image_path)
+
+        return updated_image_path

utils/completion_reward_utils.py

@@ -0,0 +1,77 @@
+import json
+
+import gradio as gr
+
+
+def get_llm_response(completion_reward, *args):
+    return completion_reward.get_llm_response(*args)
+
+
+def set_player_name(completion_reward, *args):
+    return completion_reward.set_player_name(*args)
+
+
+def display_class_info(completion_reward, *args):
+    return completion_reward.display_class_info(*args)
+
+
+def set_player_selected_character(completion_reward, *args):
+    return completion_reward.set_player_selected_character(*args)
+
+
+def create_certificate(completion_reward, *args):
+    return completion_reward.create_certificate(*args)
+
+
+def complete_reward(completion_reward, *args):
+    return completion_reward.complete_reward(*args)
+
+
+def check_is_in_completion_reward(player_backend_user_id):
+    with open("../data/completion_reward_issue_status.json") as f:
+        completion_reward_issue_status_dict = json.load(f)
+
+    if player_backend_user_id in completion_reward_issue_status_dict:
+        preview_list = ["[email protected]", "http://googleid.junyiacademy.org/111939868185365078143"]
+        if player_backend_user_id in preview_list:
+            value = completion_reward_issue_status_dict[player_backend_user_id]
+            if value == "not_issued":
+                return (
+                    gr.update(visible=False),
+                    gr.update(visible=True),
+                    gr.update(visible=True),
+                    gr.update(visible=True),
+                    gr.update(visible=False),
+                    gr.update(visible=False),
+                    gr.update(visible=False),
+                )
+            else:
+                return (
+                    gr.update(visible=False),
+                    gr.update(visible=False),
+                    gr.update(visible=False),
+                    gr.update(visible=False),
+                    gr.update(visible=False),
+                    gr.update(visible=False),
+                    gr.Image(value, visible=True),
+                )
+        else:
+            return (
+                gr.update(visible=False),
+                gr.update(visible=False),
+                gr.update(visible=False),
+                gr.update(visible=False),
+                gr.update(visible=False),
+                gr.update(visible=True),
+                gr.update(visible=False),
+            )
+
+    else:
+        return (
+            gr.update(visible=False),
+            gr.update(visible=False),
+            gr.update(visible=False),
+            gr.update(visible=False),
+            gr.update(visible=True),
+            gr.update(visible=False),
+        )

utils/mes_player_activity_model.py

@@ -1,20 +1,19 @@
 from datetime import datetime
 
-class PlayerActivity():
+
+class PlayerActivity:
     def __init__(self) -> None:
         self.player_backend_user_id = None
         self.login_timestamp = datetime.now()
         self.rendered_timestamp = None
 
     def render_finished(self, player_info):
-        self.player_backend_user_id = player_info['player_backend_user_id']
+        self.player_backend_user_id = player_info["player_backend_user_id"]
         self.rendered_timestamp = datetime.now()
 
     def to_dict(self):
         return {
-            'player_backend_user_id': self.player_backend_user_id,
-            'login_timestamp': self.login_timestamp,
-            'rendered_timestamp': self.rendered_timestamp
+            "player_backend_user_id": self.player_backend_user_id,
+            "login_timestamp": self.login_timestamp,
+            "rendered_timestamp": self.rendered_timestamp,
         }
-
-    

utils/mes_player_model.py

@@ -35,9 +35,7 @@ class Player:
         # and the rewards_status is not yet initialized
         if init:
             self.assign_group()
-            self.add_adventure_log(
-                "你並未參與這次與狐貍貓的冒險，請在下次活動中參與冒險吧！"
-            )
+            self.add_adventure_log("你並未參與這次與狐貍貓的冒險，請在下次活動中參與冒險吧！")
             if available_achievements is not None:
                 self.rewards_status.update(
                     {

utils/utils.py

@@ -207,6 +207,7 @@ def render_player_data(player_info: gr.State):
         current_story,
     )
 
+
 def insert_data_into_bigquery(client, dataset_id, table_id, rows_to_insert):
     # Specify the destination table
     table_ref = client.dataset(dataset_id).table(table_id)
@@ -223,9 +224,13 @@ def insert_data_into_bigquery(client, dataset_id, table_id, rows_to_insert):
     else:
         logging.info(f"Inserted {len(rows_to_insert)} rows successfully.")
 
+
 def render_finished(player_activity, *args):
     player_activity.render_finished(*args)
     insert_row = player_activity.to_dict()
-    insert_data_into_bigquery(client, 'streaming_log', 'log_mes_player_login_activity', [insert_row])
-    logging.info(f"Player {insert_row['player_backend_user_id']} rendered successfully.")
-
+    insert_data_into_bigquery(
+        client, "streaming_log", "log_mes_player_login_activity", [insert_row]
+    )
+    logging.info(
+        f"Player {insert_row['player_backend_user_id']} rendered successfully."
+    )