app.py

import os
import gradio as gr
from openai import OpenAI
import json


OPEN_AI_KEY = os.getenv("OPEN_AI_KEY")
OPEN_AI_CLIENT = OpenAI(api_key=OPEN_AI_KEY)


def generate_topics(model, max_tokens, sys_content, scenario, eng_level, user_generate_topics_prompt):
    """
    根据系统提示和用户输入的情境及主题，调用OpenAI API生成相关的主题句。
    """
    user_content = f"""
        scenario is {scenario}
        english level is {eng_level}
        {user_generate_topics_prompt}
    """
    messages = [
        {"role": "system", "content": sys_content},
        {"role": "user", "content": user_content}
    ]

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

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

    return content

def generate_points(model, max_tokens, sys_content, scenario, eng_level, topic, user_generate_points_prompt):
    """
    根据系统提示和用户输入的情境、主题，调用OpenAI API生成相关的主题句。
    """
    user_content = f"""
        scenario is {scenario}
        english level is {eng_level}
        topic is {topic}
        {user_generate_points_prompt}
    """
    messages = [
        {"role": "system", "content": sys_content},
        {"role": "user", "content": user_content}
    ]

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

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

    return content

def generate_topic_sentences(model, max_tokens, sys_content, scenario, eng_level, topic, points, user_generate_topic_sentences_prompt):
    """
    根据系统提示和用户输入的情境及要点，调用OpenAI API生成相关的主题句及其合理性解释。
    """
    user_content = f"""
        scenario is {scenario}
        english level is {eng_level}
        topic is {topic}
        points is {points}
        {user_generate_topic_sentences_prompt}
    """
    messages = [
        {"role": "system", "content": sys_content},
        {"role": "user", "content": user_content}
    ]
    response_format = { "type": "json_object" }


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

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

    return content

def parse_and_display_topic_sentences(json_data):
    """
    解析JSON格式的主题句数据，并转换成易于阅读的格式。
    """
    # 将JSON字符串解析成Python字典
    data = json.loads(json_data)
    
    # 初始化一个空字符串用于存放最终的格式化文本
    formatted_text = ""
    
    # 遍历每个主题句及其评价
    for key, value in data.items():
        topic_sentence = value[0]['topic-sentence']
        appropriate = "適當" if value[0]['appropriate'] == "Y" else "不適當"
        reason = value[0]['reason']
        
        # 将每个主题句的信息添加到格式化文本中
        formatted_text += f"主题句 {int(key)+1}: {topic_sentence}\n"
        formatted_text += f"是否適當: {appropriate}\n"
        formatted_text += f"原因: {reason}\n\n"
    
    return formatted_text

def generate_supporting_sentences(model, max_tokens, sys_content, scenario, eng_level, topic, points, topic_sentence, user_generate_supporting_sentences_prompt):
    """
    根据系统提示和用户输入的情境、主题、要点、主题句，调用OpenAI API生成相关的支持句。
    """
    user_content = f"""
        scenario is {scenario}
        english level is {eng_level}
        topic is {topic}
        points is {points}
        topic sentence is {topic_sentence}
        {user_generate_supporting_sentences_prompt}
    """
    messages = [
        {"role": "system", "content": sys_content},
        {"role": "user", "content": user_content}
    ]

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

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

    return content

with gr.Blocks() as demo:
    with gr.Row():
        with gr.Column():
            # basic inputs
            gr.Markdown("## 1. Basic Inputs")
            model = gr.Radio(["gpt-4-1106-preview", "gpt-3.5-turbo"], label="Model", value="gpt-4-1106-preview")
            max_tokens = gr.Slider(minimum=50, maximum=4000, value=1000, label="Max Tokens")
            sys_content_input = gr.Textbox(label="System Prompt", value="You are an English teacher who is practicing with me to improve my English writing skill.")
            scenario_input = gr.Textbox(label="Scenario")
            eng_level_input = gr.Radio(["beginner", "intermediate", "advanced"], label="English Level", value="beginner")
            
            gr.Markdown("## 2. Generate Topic")
            default_generate_topics_prompt = """
                Give me 10 topics relevant to Scenario, 
                for a paragraph. Just the topics, no explanation, use simple English language. 
                Make sure the vocabulary you use is at english level.
            """
            user_generate_topics_prompt = gr.Textbox(label="Topics Prompt", value=default_generate_topics_prompt)
            generate_topics_button = gr.Button("Generate Topic Sentences")

            gr.Markdown("## 3. Generate Points")
            topic_input = gr.Textbox(label="Topic")
            default_generate_points_prompt = """
                Please provide main points to develop in a paragraph about topic in the context of scenario, 
                use simple English language and make sure the vocabulary you use is at eng_level.
                No more explanation either no developing these points into a simple paragraph.
            """  
            user_generate_points_prompt = gr.Textbox(label="Points Prompt", value=default_generate_points_prompt)
            generate_points_button = gr.Button("Generate Points")

            gr.Markdown("## 4. Generate Topic Sentences")
            points_input = gr.Textbox(label="Points")
            default_generate_topic_sentences_prompt = """
                Please provide one appropriate topic sentence that aptly introduces the subject for the given scenario and topic. 
                Additionally, provide two topic sentences that, while related to the topic, 
                would be considered inappropriate or less effective for the specified context. 
                Those sentences must include the three main points:". 
                Use English language and each sentence should not be too long.
                For each sentence, explain the reason in Traditional Chinese, Taiwan, 繁體中文 zh-TW. 
                Make sure the vocabulary you use is at level.

                Only return the result in JSON format starting as: 
                {{ 
                    "0": [ {{ "topic-sentence": "#","appropriate": "Y/N", "reason": "#中文解釋" }} ], 
                    "1": [ {{ "topic-sentence": "#","appropriate": "Y/N", "reason": "#中文解釋" }} ],
                    "2": [ {{ "topic-sentence": "#","appropriate": "Y/N", "reason": "#中文解釋" }} ] 
                }}            
            """
            user_generate_topic_sentences_prompt = gr.Textbox(label="Topic Sentences Prompt", value=default_generate_topic_sentences_prompt)
            generate_topic_sentences_button = gr.Button("Generate Topic Sentences")

            gr.Markdown("## 5. Generate Supporting Sentence")
            topic_sentence_input = gr.Textbox(label="Topic Sentences")
            default_generate_supporting_sentences_prompt = """
                I'm aiming to improve my writing. I have a topic sentence as topic_sentence_input. 
                Please assist me by "Developing supporting detials" based on the keyword: points to write three sentences as an example.
                - Make sure any revised vocabulary aligns with the eng_level. 
                - Guidelines for Length and Complexity: 
                Please keep the example concise and straightforward, 
                avoiding overly technical language. 
                Total word-count is around 50.           
            """
            user_generate_supporting_sentences_prompt = gr.Textbox(label="Supporting Sentences Prompt", value=default_generate_supporting_sentences_prompt)
            generate_supporting_sentences_button = gr.Button("Generate Supporting Sentences")

        with gr.Column():
            topic_output = gr.Textbox(label="Generated Topic")
            points_output = gr.Textbox(label="Generated Points")
            topic_sentence_output = gr.Textbox(label="Generated Topic Sentences")
            supporting_sentences_output = gr.Textbox(label="Generated Supporting Sentences")

    
    generate_topics_button.click(
        fn=generate_topics,
        inputs=[
            model, 
            max_tokens, 
            sys_content_input, 
            scenario_input, 
            eng_level_input,
            user_generate_topics_prompt
        ],
        outputs=topic_output
    )

    generate_points_button.click(
        fn=generate_points,
        inputs=[
            model, 
            max_tokens, 
            sys_content_input, 
            scenario_input, 
            eng_level_input,
            topic_input,
            user_generate_points_prompt
        ],
        outputs=points_output
    )

    generate_topic_sentences_button.click(
        fn=generate_topic_sentences,
        inputs=[
            model, 
            max_tokens, 
            sys_content_input, 
            scenario_input, 
            eng_level_input,
            topic_input,
            points_input,
            user_generate_topic_sentences_prompt
        ],
        outputs=topic_sentence_output
    )

    generate_supporting_sentences_button.click(
        fn=generate_supporting_sentences,
        inputs=[
            model, 
            max_tokens, 
            sys_content_input, 
            scenario_input, 
            eng_level_input,
            topic_input, 
            points_input,
            topic_sentence_input,
            user_generate_supporting_sentences_prompt
        ],
        outputs=supporting_sentences_output
    )

demo.launch()