generate_correct_grammatical_spelling_errors

app.py

@@ -510,37 +510,62 @@ def update_supporting_sentences_input(supporting_sentences_radio):
 
 def generate_conclusion_sentences(model, max_tokens, sys_content, scenario, eng_level, topic, points, topic_sentence, user_generate_conclusion_sentence_prompt):
     """
-    根据系统提示和用户输入的情境、主题、要点、主题句，调用OpenAI API生成相关的结论句。
+    根据系统提示和用户输入的情境、主题、要点、主题句，调用 LLM 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_conclusion_sentence_prompt}
-    """
-    messages = [
-        {"role": "system", "content": sys_content},
-        {"role": "user", "content": user_content}
-    ]
+    try:
+        user_content = f"""
+            scenario is: {scenario}
+            english level is: {eng_level}
+            topic is: {topic}
+            points is: {points}
+            topic sentence is: {topic_sentence}
+            ---
+            {user_generate_conclusion_sentence_prompt}
+        """
+        
+        messages = [
+            {"role": "system", "content": sys_content},
+            {"role": "user", "content": user_content}
+        ]
 
-    request_payload = {
-        "model": model,
-        "messages": messages,
-        "max_tokens": max_tokens,
-        "response_format": { "type": "json_object" }
-    }
+        # 根據模型選擇 provider
+        if "gemini" in model.lower():
+            print("====gemini====")
+            provider = GeminiProvider()
+        else:
+            print("====openai====")
+            provider = OpenAIProvider(OPEN_AI_CLIENT)
+
+        # 使用 LLMService 處理請求
+        llm_service = LLMService(provider)
+        content = llm_service.chat(
+            prompt=f"{sys_content}\n{user_content}" if "gemini" in model.lower() else None,
+            messages=messages,
+            model=model,
+            max_tokens=max_tokens,
+            response_format={"type": "json_object"}
+        )
+
+        # 處理回應格式
+        if isinstance(content, str) and "```json" in content:
+            content = content.replace("```json", "").replace("```", "")
+            
+        try:
+            response_content = json.loads(content)
+            json_content = response_content["results"]
+            gr_update = gr.update(choices=[json_content], visible=True)
+        except (json.JSONDecodeError, KeyError, ValueError) as e:
+            print(f"Error parsing conclusion sentences: {e}")
+            raise gr.Error("無法解析結論句，請重新嘗試")
 
-    try:
-        response = OPEN_AI_CLIENT.chat.completions.create(**request_payload)
-        response_content = json.loads(response.choices[0].message.content)
-        json_content = response_content["results"]
-        gr_update = gr.update(choices=[json_content], visible=True)
     except Exception as e:
-        print(f"An error occurred while generating conclusion sentences: {e}")
-        raise gr.Error("網路塞車，請重新嘗試一次！")
+        print(f"An error occurred while generating conclusion sentences: {str(e)}")
+        error_msg = "網路塞車，請重新嘗試一次！"
+        if "rate limit" in str(e).lower():
+            error_msg = "請求過於頻繁，請稍後再試"
+        elif "invalid_request_error" in str(e).lower():
+            error_msg = "請求格式錯誤，請檢查輸入"
+        raise gr.Error(error_msg)
 
     return gr_update
 
@@ -556,103 +581,181 @@ def generate_paragraph(topic_sentence, supporting_sentences, conclusion_sentence
 
 def generate_paragraph_evaluate(model, sys_content, paragraph, user_generate_paragraph_evaluate_prompt):
     """
-    根据用户输入的段落，调用OpenAI API生成相关的段落分析。
-    """
-    user_content = f"""
-        paragraph is: {paragraph}
-        ---
-        {user_generate_paragraph_evaluate_prompt}
+    根據用戶輸入的段落，調用 LLM API 生成相關的段落分析。
+    
+    Args:
+        model (str): 使用的 LLM 模型名稱
+        sys_content (str): 系統提示內容
+        paragraph (str): 要評估的段落
+        user_generate_paragraph_evaluate_prompt (str): 用戶評估提示
+        
+    Returns:
+        gr.update: 包含評估結果的表格更新
     """
-    messages = [
-        {"role": "system", "content": sys_content},
-        {"role": "user", "content": user_content}
-    ]
+    def parse_evaluation_response(content):
+        """解析 LLM 回應內容"""
+        try:
+            if isinstance(content, str):
+                # 處理可能的 markdown 格式
+                if "```json" in content:
+                    json_blocks = content.split("```json")
+                    for block in json_blocks:
+                        if "```" in block:
+                            content = block.split("```")[0].strip()
+                        else:
+                            content = block.strip()
+                
+                # 清理內容確保是有效的 JSON
+                content = content.strip()
+                if content.startswith("```") and content.endswith("```"):
+                    content = content[3:-3].strip()
+                
+                print(f"Cleaned content: {content}")
+                return json.loads(content)
+            return content
+        except (json.JSONDecodeError, KeyError, ValueError) as e:
+            print(f"Error parsing evaluation response: {e}")
+            raise ValueError("無法解析評估結果")
+
+    def handle_evaluation_error(error):
+        """處理評估過程中的錯誤"""
+        if "rate limit" in str(error).lower():
+            return "請求過於頻繁，請稍後再試"
+        elif "invalid_request_error" in str(error).lower():
+            return "請求格式錯誤，請檢查輸入"
+        elif isinstance(error, ValueError):
+            return str(error)
+        return "網路塞車，請重新嘗試一次！"
 
-    response_format = { "type": "json_object" }
+    try:
+        # 準備請求內容
+        user_content = f"""
+            paragraph is: {paragraph}
+            ---
+            {user_generate_paragraph_evaluate_prompt}
+        """
+        
+        messages = [
+            {"role": "system", "content": sys_content},
+            {"role": "user", "content": user_content}
+        ]
 
-    request_payload = {
-        "model": model,
-        "messages": messages,
-        "max_tokens": 2000,
-        "response_format": response_format
-    }
+        # 根據模型選擇 provider
+        if "gemini" in model.lower():
+            print("====gemini====")
+            provider = GeminiProvider()
+        else:
+            print("====openai====")
+            provider = OpenAIProvider(OPEN_AI_CLIENT)
 
-    max_attempts = 2
-    attempt = 0
-    while attempt < max_attempts:
-        try:
-            response = OPEN_AI_CLIENT.chat.completions.create(**request_payload)
-            content = response.choices[0].message.content
+        # 使用 LLMService 處理請求
+        llm_service = LLMService(provider)
+        content = llm_service.chat(
+            prompt=f"{sys_content}\n{user_content}" if "gemini" in model.lower() else None,
+            messages=messages,
+            model=model,
+            max_tokens=2000,
+            response_format={"type": "json_object"}
+        )
 
-            print(f"====generate_paragraph_evaluate====")
-            print(content)
+        print(f"====generate_paragraph_evaluate====")
+        print(content)
 
-            data = json.loads(content)
-            table_data = [
-                ["學測架構|內容（Content）", data['content']['level'], data['content']['explanation']],
-                ["學測架構|組織（Organization）", data['organization']['level'], data['organization']['explanation']],
-                ["學測架構|文法、句構（Grammar/Sentence Structure）", data['grammar_and_usage']['level'], data['grammar_and_usage']['explanation']],
-                ["學測架構|字彙、拼字（Vocabulary/Spelling）", data['vocabulary']['level'], data['vocabulary']['explanation']],
-                ["JUTOR 架構|連貫性和連接詞（Coherence and Cohesion）", data['coherence_and_cohesion']['level'], data['coherence_and_cohesion']['explanation']]
-            ]
-            headers = ["架構", "評分", "解釋"]
-            gr_update = gr.update(value=table_data, headers=headers, visible=True)
-            break
-        except Exception as e:
-            print(f"An error occurred while generating paragraph evaluate: {e}")
-            attempt += 1
-            if attempt == max_attempts:
-                raise gr.Error("網路塞車，請重新嘗試一次！")
+        # 解析回應內容
+        data = parse_evaluation_response(content)
+        
+        # 準備表格數據
+        table_data = [
+            ["學測架構|內容（Content）", data['content']['level'], data['content']['explanation']],
+            ["學測架構|組織（Organization）", data['organization']['level'], data['organization']['explanation']],
+            ["學測架構|文法、句構（Grammar/Sentence Structure）", data['grammar_and_usage']['level'], data['grammar_and_usage']['explanation']],
+            ["學測架構|字彙、拼字（Vocabulary/Spelling）", data['vocabulary']['level'], data['vocabulary']['explanation']],
+            ["JUTOR 架構|連貫性和連接詞（Coherence and Cohesion）", data['coherence_and_cohesion']['level'], data['coherence_and_cohesion']['explanation']]
+        ]
+        headers = ["架構", "評分", "解釋"]
+        
+        return gr.update(value=table_data, headers=headers, visible=True)
 
-    return gr_update
+    except Exception as e:
+        print(f"An error occurred while generating paragraph evaluate: {str(e)}")
+        error_msg = handle_evaluation_error(e)
+        raise gr.Error(error_msg)
 
 def generate_correct_grammatical_spelling_errors(model, sys_content, eng_level, paragraph, user_correct_grammatical_spelling_errors_prompt):
     """
-    根据用户输入的段落，调用OpenAI API生成相关的文法和拼字错误修正。
-    """
-    user_content = f"""
-        level is: {eng_level}
-        paragraph is: {paragraph}
-        ---
-        {user_correct_grammatical_spelling_errors_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": 1000,
-        "response_format": response_format
-    }
+    try:
+        user_content = f"""
+            level is: {eng_level}
+            paragraph is: {paragraph}
+            ---
+            {user_correct_grammatical_spelling_errors_prompt}
+        """
+        
+        messages = [
+            {"role": "system", "content": sys_content},
+            {"role": "user", "content": user_content}
+        ]
 
-    max_attempts = 2
-    attempt = 0
-    while attempt < max_attempts:
+        # 根據模型選擇 provider
+        if "gemini" in model.lower():
+            print("====gemini====")
+            provider = GeminiProvider()
+        else:
+            print("====openai====")
+            provider = OpenAIProvider(OPEN_AI_CLIENT)
+
+        # 使用 LLMService 處理請求
+        llm_service = LLMService(provider)
+        content = llm_service.chat(
+            prompt=f"{sys_content}\n{user_content}" if "gemini" in model.lower() else None,
+            messages=messages,
+            model=model,
+            max_tokens=1000,
+            response_format={"type": "json_object"}
+        )
+
+        # 處理回應格式
+        if isinstance(content, str) and "```json" in content:
+            content = content.replace("```json", "").replace("```", "")
+            
         try:
-            response = OPEN_AI_CLIENT.chat.completions.create(**request_payload)
-            content = response.choices[0].message.content
             data = json.loads(content)
-            print(f"data: {data}")
-
             corrections_list = [
                 [item['original'], item['correction'], item['explanation']]
                 for item in data['Corrections and Explanations']
             ]
             headers = ["原文", "建議", "解釋"]
+            
+            corrections_list_gr_update = gr.update(
+                value=corrections_list, 
+                headers=headers, 
+                wrap=True, 
+                visible=True
+            )
+            revised_paragraph_gr_update = gr.update(
+                value=data["Revised Paragraph"], 
+                visible=False
+            )
+            
+            return corrections_list_gr_update, revised_paragraph_gr_update
+
+        except (json.JSONDecodeError, KeyError, ValueError) as e:
+            print(f"Error parsing corrections: {e}")
+            raise gr.Error("無法解析修正建議，請重新嘗試")
+
+    except Exception as e:
+        print(f"An error occurred while generating corrections: {str(e)}")
+        error_msg = "網路塞車，請重新嘗試一次！"
+        if "rate limit" in str(e).lower():
+            error_msg = "請求過於頻繁，請稍後再試"
+        elif "invalid_request_error" in str(e).lower():
+            error_msg = "請求格式錯誤，請檢查輸入"
+        elif "model_not_found" in str(e).lower():
+            error_msg = "選擇的模型不存在或無法存取"
+        raise gr.Error(error_msg)
 
-            corrections_list_gr_update = gr.update(value=corrections_list, headers=headers, wrap=True, visible=True)
-            reverse_paragraph_gr_update = gr.update(value=data["Revised Paragraph"], visible=False)
-            break
-        except Exception as e:
-            print(f"An error occurred while generating correct grammatical spelling errors: {e}")
-            attempt += 1
-            if attempt == max_attempts:
-                raise gr.Error("網路塞車，請重新嘗試一次！")
-    
-    return corrections_list_gr_update, reverse_paragraph_gr_update
 
 def highlight_diff_texts(highlight_list, text):
     # Convert DataFrame to JSON string