Update app.py

app.py

@@ -2,128 +2,148 @@ import gradio as gr
 import pandas as pd
 import numpy as np
 from datetime import datetime
-from typing import List, Dict, Tuple
+from typing import List, Dict, Tuple, Optional
+from dataclasses import dataclass
 import requests
 import json
 import plotly.graph_objects as go
 import random
+from abc import ABC, abstractmethod
+import logging
+from functools import lru_cache
 
-class GeminiAPI:
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+@dataclass
+class PersonalityQuestion:
+    question: str
+    choices: List[str]
+    required: bool = True
+
+class APIClient(ABC):
+    @abstractmethod
+    def analyze_personality(self, responses: List[str]) -> Dict:
+        pass
+    
+    @abstractmethod
+    def get_career_advice(self, question: str, context: Optional[Dict] = None) -> str:
+        pass
+
+class GeminiAPI(APIClient):
     def __init__(self, api_key: str):
         self.api_key = api_key
         self.headers = {"Content-Type": "application/json"}
+        self.base_url = "https://generativelanguage.googleapis.com/v1beta"
+        self.model = "gemini-1.5-flash-latest"
     
-    def analyze_personality(self, responses: List[str]) -> Dict:
+    @lru_cache(maxsize=100)
+    def analyze_personality(self, responses: Tuple[str]) -> Dict:
+        """
+        Analyze personality based on user responses.
+        Using tuple as input for lru_cache compatibility.
+        """
         try:
-            if not responses or len(responses) == 0:
+            responses_list = list(responses)
+            if not responses_list:
                 raise ValueError("Không có câu trả lời để phân tích")
 
-            prompt = f"""
-            Dựa trên các câu trả lời sau của người dùng, hãy phân tích và xác định:
-            1. Kiểu tính cách MBTI
-            2. Điểm mạnh và điểm yếu
-            3. Các nghề nghiệp phù hợp nhất
-            4. Lộ trình phát triển đề xuất
-            
-            Câu trả lời của người dùng:
-            {json.dumps(responses, ensure_ascii=False)}
-            
-            Trả về kết quả theo định dạng JSON với các trường:
-            {{
-                "mbti_type": "string",
-                "strengths": ["string"],
-                "weaknesses": ["string"],
-                "recommended_careers": ["string"],
-                "development_path": ["string"]
-            }}
-            """
-            
-            payload = {
-                "contents": [{
-                    "parts": [{
-                        "text": prompt
-                    }]
-                }]
-            }
-            
-            response = requests.post(
-                f"https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash-latest:generateContent?key={self.api_key}",
-                headers=self.headers,
-                json=payload,
-                timeout=10
-            )
+            prompt = self._create_personality_prompt(responses_list)
+            result = self._make_api_request(prompt)
             
-            if response.status_code == 200:
-                result = response.json()
-                return self._parse_gemini_response(result)
-            print(f"API Error: {response.status_code} - {response.text}")
-            return self.get_fallback_analysis()
+            return self._parse_gemini_response(result)
             
         except Exception as e:
-            print(f"Error in analyze_personality: {str(e)}")
+            logger.error(f"Error in analyze_personality: {str(e)}")
             return self.get_fallback_analysis()
 
-    def get_career_advice(self, question: str, context: Dict = None) -> str:
+    def get_career_advice(self, question: str, context: Optional[Dict] = None) -> str:
         try:
             if not question.strip():
                 return "Vui lòng nhập câu hỏi của bạn"
 
-            prompt = f"""
-            Vai trò: Bạn là một chuyên gia tư vấn nghề nghiệp với nhiều năm kinh nghiệm.
-            
-            Thông tin người dùng:
-            {json.dumps(context, ensure_ascii=False) if context else "Chưa có thông tin"}
-            
-            Câu hỏi: {question}
-            
-            Hãy tư vấn chi tiết về:
-            1. Phân tích vấn đề
-            2. Giải pháp cụ thể
-            3. Các bước thực hiện
-            4. Ví dụ thực tế
-            """
-            
-            payload = {
-                "contents": [{
-                    "parts": [{
-                        "text": prompt
-                    }]
-                }]
-            }
-            
-            response = requests.post(
-                f"https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash-latest:generateContent?key={self.api_key}",
-                headers=self.headers,
-                json=payload,
-                timeout=10
-            )
+            prompt = self._create_advice_prompt(question, context)
+            result = self._make_api_request(prompt)
             
-            if response.status_code == 200:
-                result = response.json()
-                return result['candidates'][0]['content']['parts'][0]['text']
-            print(f"API Error: {response.status_code} - {response.text}")
-            return "Xin lỗi, hiện tại tôi không thể xử lý yêu cầu. Vui lòng thử lại sau."
+            return result['candidates'][0]['content']['parts'][0]['text']
             
         except Exception as e:
-            print(f"Error in get_career_advice: {str(e)}")
+            logger.error(f"Error in get_career_advice: {str(e)}")
             return "Đã xảy ra lỗi. Vui lòng thử lại sau."
 
+    def _make_api_request(self, prompt: str) -> Dict:
+        payload = {
+            "contents": [{
+                "parts": [{
+                    "text": prompt
+                }]
+            }]
+        }
+        
+        response = requests.post(
+            f"{self.base_url}/models/{self.model}:generateContent?key={self.api_key}",
+            headers=self.headers,
+            json=payload,
+            timeout=10
+        )
+        
+        if response.status_code != 200:
+            logger.error(f"API Error: {response.status_code} - {response.text}")
+            raise Exception(f"API request failed with status {response.status_code}")
+            
+        return response.json()
+
+    def _create_personality_prompt(self, responses: List[str]) -> str:
+        return f"""
+        Dựa trên các câu trả lời sau của người dùng, hãy phân tích và xác định:
+        1. Kiểu tính cách MBTI
+        2. Điểm mạnh và điểm yếu
+        3. Các nghề nghiệp phù hợp nhất
+        4. Lộ trình phát triển đề xuất
+        
+        Câu trả lời của người dùng:
+        {json.dumps(responses, ensure_ascii=False)}
+        
+        Trả về kết quả theo định dạng JSON với các trường:
+        {{
+            "mbti_type": "string",
+            "strengths": ["string"],
+            "weaknesses": ["string"],
+            "recommended_careers": ["string"],
+            "development_path": ["string"]
+        }}
+        """
+
+    def _create_advice_prompt(self, question: str, context: Optional[Dict]) -> str:
+        return f"""
+        Vai trò: Bạn là một chuyên gia tư vấn nghề nghiệp với nhiều năm kinh nghiệm.
+        
+        Thông tin người dùng:
+        {json.dumps(context, ensure_ascii=False) if context else "Chưa có thông tin"}
+        
+        Câu hỏi: {question}
+        
+        Hãy tư vấn chi tiết về:
+        1. Phân tích vấn đề
+        2. Giải pháp cụ thể
+        3. Các bước thực hiện
+        4. Ví dụ thực tế
+        """
+
     def _parse_gemini_response(self, result: Dict) -> Dict:
         try:
             text_response = result['candidates'][0]['content']['parts'][0]['text']
-            try:
-                return json.loads(text_response)
-            except json.JSONDecodeError as e:
-                print(f"JSON Decode Error: {e}")
-                return self.get_fallback_analysis()
-        except KeyError as e:
-            print(f"KeyError: {e}")
-            return self.get_fallback_analysis()
-        except Exception as e:
-            print(f"Unexpected Error: {e}")
+            return json.loads(text_response)
+        except (json.JSONDecodeError, KeyError) as e:
+            logger.error(f"Error parsing response: {str(e)}")
             return self.get_fallback_analysis()
-    
-    def get_fallback_analysis(self) -> Dict:
+
+    @staticmethod
+    def get_fallback_analysis() -> Dict:
         return {
             "mbti_type": "ENTJ",
             "strengths": [
@@ -154,12 +174,14 @@ class GeminiAPI:
 class DataProcessor:
     @staticmethod
     def validate_responses(responses: List[str]) -> bool:
+        """Validate user responses"""
         if not responses:
             return False
         return all(isinstance(response, str) and response.strip() for response in responses)
     
     @staticmethod
     def calculate_scores(responses: List[str]) -> Dict[str, float]:
+        """Calculate personality dimension scores"""
         if not responses:
             return {}
 
@@ -170,62 +192,62 @@ class DataProcessor:
             'J-P': 0   # Judging-Perceiving
         }
         
+        scoring_rules = {
+            0: ('nhóm', 'E-I'),
+            1: ('dữ liệu|logic', 'S-N'),
+            2: ('quy trình|chặt chẽ', 'T-F'),
+            3: ('lý thuyết|khái niệm', 'J-P')
+        }
+        
         for i, response in enumerate(responses):
-            response = response.lower().strip()
-            if i == 0:  # E-I
-                dimensions['E-I'] += 1 if "nhóm" in response else -1
-            elif i == 1:  # S-N
-                dimensions['S-N'] += 1 if "dữ liệu" in response or "logic" in response else -1
-            elif i == 2:  # T-F
-                dimensions['T-F'] += 1 if "quy trình" in response or "chặt chẽ" in response else -1
-            elif i == 3:  # J-P
-                dimensions['J-P'] += 1 if "lý thuyết" in response or "khái niệm" in response else -1
+            if i in scoring_rules:
+                keywords, dimension = scoring_rules[i]
+                matches_keyword = any(kw in response.lower() for kw in keywords.split('|'))
+                dimensions[dimension] += 1 if matches_keyword else -1
         
         return dimensions
 
 class CareerGuidanceSystem:
     def __init__(self, api_key: str):
-        self.gemini = GeminiAPI(api_key)
+        self.api_client = GeminiAPI(api_key)
         self.data_processor = DataProcessor()
-        self.current_analysis = None
-        self.chat_history = []
+        self.current_analysis: Optional[Dict] = None
+        self.chat_history: List[Dict] = []
         
         self.personality_questions = [
-            {
-                "question": "Bạn thích làm việc một mình hay theo nhóm?",
-                "choices": ["Thích làm việc một mình", "Thích làm việc nhóm"],
-                "required": True
-            },
-            {
-                "question": "Khi giải quyết vấn đề, bạn thường:",
-                "choices": ["Dựa vào dữ liệu và logic", "Dựa vào trực giác và cảm nhận"],
-                "required": True
-            },
-            {
-                "question": "Trong công việc, bạn ưu tiên:",
-                "choices": ["Tuân thủ quy trình chặt chẽ", "Linh hoạt và sáng tạo"],
-                "required": True
-            },
-            {
-                "question": "Bạn học hỏi tốt nhất thông qua:",
-                "choices": ["Lý thuyết và khái niệm", "Thực hành và trải nghiệm"],
-                "required": True
-            },
-            {
-                "question": "Trong tình huống mới, bạn thường:",
-                "choices": ["Lập kế hoạch chi tiết trước", "Ứng biến theo tình huống"],
-                "required": True
-            }
+            PersonalityQuestion(
+                "Bạn thích làm việc một mình hay theo nhóm?",
+                ["Thích làm việc một mình", "Thích làm việc nhóm"]
+            ),
+            PersonalityQuestion(
+                "Khi giải quyết vấn đề, bạn thường:",
+                ["Dựa vào dữ liệu và logic", "Dựa vào trực giác và cảm nhận"]
+            ),
+            PersonalityQuestion(
+                "Trong công việc, bạn ưu tiên:",
+                ["Tuân thủ quy trình chặt chẽ", "Linh hoạt và sáng tạo"]
+            ),
+            PersonalityQuestion(
+                "Bạn học hỏi tốt nhất thông qua:",
+                ["Lý thuyết và khái niệm", "Thực hành và trải nghiệm"]
+            ),
+            PersonalityQuestion(
+                "Trong tình huống mới, bạn thường:",
+                ["Lập kế hoạch chi tiết trước", "Ứng biến theo tình huống"]
+            )
         ]
     
     def analyze_user_responses(self, responses: List[str]) -> Dict:
+        """Analyze user responses and update current analysis"""
         if not self.data_processor.validate_responses(responses):
             raise ValueError("Vui lòng trả lời tất cả các câu hỏi")
         
-        self.current_analysis = self.gemini.analyze_personality(responses)
+        # Convert list to tuple for caching
+        self.current_analysis = self.api_client.analyze_personality(tuple(responses))
         return self.current_analysis
     
     def create_personality_report(self, analysis: Dict) -> str:
+        """Create a formatted personality analysis report"""
         return f"""
 # Báo cáo Phân tích Tính cách và Định hướng Nghề nghiệp
 
@@ -238,19 +260,34 @@ class CareerGuidanceSystem:
 {chr(10).join(['- ' + w for w in analysis['weaknesses']])}
 
 ## Nghề nghiệp phù hợp:
-{chr(10).join(['1. ' + c for c in analysis['recommended_careers']])}
+{chr(10).join([f'1. {c}' for c in analysis['recommended_careers']])}
 
 ## Lộ trình phát triển đề xuất:
-{chr(10).join(['1. ' + d for d in analysis['development_path']])}
+{chr(10).join([f'1. {d}' for d in analysis['development_path']])}
 
 Báo cáo được tạo ngày: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
         """
-    
+
     def get_advice(self, question: str) -> str:
-        return self.gemini.get_career_advice(question, self.current_analysis)
+        """Get career advice based on question and current analysis"""
+        return self.api_client.get_career_advice(question, self.current_analysis)
 
-def create_interface():
-    with gr.Blocks(theme=gr.themes.Soft()) as interface:
+class GradioInterface:
+    def __init__(self):
+        self.interface = self.create_interface()
+        self.system = None  # CareerGuidanceSystem object will be initialized with API key
+    
+    def create_interface(self) -> gr.Blocks:
+        with gr.Blocks(theme=gr.themes.Soft()) as interface:
+            self._create_header()
+            
+            with gr.Tabs():
+                self._create_chat_tab()
+                self._create_personality_tab()
+            
+        return interface
+    
+    def _create_header(self):
         gr.Markdown("""
         # 🎯 Hệ thống Tư vấn Hướng nghiệp AI
         
@@ -258,12 +295,11 @@ def create_interface():
         1. Nhập API key của bạn
         2. Trao đổi với AI để được tư vấn về tính cách, nghề nghiệp, và lộ trình phát triển
         """)
-        
-        # Tab Nhập API Key và Tư vấn Chi tiết
+    
+    def _create_chat_tab(self):
         with gr.Tab("🔑 & 💬 Nhập API Key & Tư vấn Chi tiết"):
             with gr.Row():
                 with gr.Column(scale=1):
-                    gr.Markdown("### Nhập API Key của bạn")
                     api_key_input = gr.Textbox(
                         label="API Key",
                         placeholder="Dán API Key ở đây",
@@ -272,12 +308,10 @@ def create_interface():
                     )
                 
                 with gr.Column(scale=2):
-                    gr.Markdown("### Trò chuyện với Chuyên gia Tư vấn AI")
                     chat_history = gr.Chatbot(
                         label="Cuộc trao đổi",
                         height=400,
-                        avatar_images=["user.png", "advisor.png"],
-                        type="messages"
+                        avatar_images=["user.png", "advisor.png"]
                     )
                     
                     with gr.Row():
@@ -289,129 +323,86 @@ def create_interface():
                         send_btn = gr.Button("📤 Gửi", variant="primary", scale=1)
                     
                     clear_btn = gr.Button("🗑️ Xóa lịch sử")
-        
-        # Tab Phân tích Tính Cách
+            
+            # Add event handlers
+            self._add_chat_handlers(api_key_input, chat_history, msg, send_btn, clear_btn)
+    
+    def _create_personality_tab(self):
         with gr.Tab("📈 Phân tích Tính Cách"):
-            gr.Markdown("### Phân tích Tính Cách")
             with gr.Row():
                 with gr.Column(scale=1):
-                    gr.Markdown("#### Câu hỏi về Tính Cách")
-                    personality_questions = CareerGuidanceSystem("").personality_questions
                     radio_buttons = []
-                    for i, q in enumerate(personality_questions):
-                        radio = gr.Radio(label=f"{i+1}. {q['question']}", choices=q["choices"], interactive=True)
+                    system = CareerGuidanceSystem("")  # Temporarily use an empty API key
+                    for i, q in enumerate(system.personality_questions):
+                        radio = gr.Radio(
+                            label=f"{i+1}. {q.question}",
+                            choices=q.choices,
+                            interactive=True
+                        )
                         radio_buttons.append(radio)
+                
                 with gr.Column(scale=2):
-                    gr.Markdown("#### Kết quả Phân tích")
                     personality_report = gr.Markdown("Kết quả sẽ hiển thị ở đây.")
             
             analyze_btn = gr.Button("Phân tích", variant="primary")
             
-            def analyze_personality(api_key, *responses):
-                if not api_key.strip():
-                    return "⚠️ Vui lòng nhập API key trước.", ""
-                
-                career_system = CareerGuidanceSystem(api_key)
-                try:
-                    analysis = career_system.analyze_user_responses(list(responses))
-                    report = career_system.create_personality_report(analysis)
-                    return "", report
-                except ValueError as ve:
-                    return str(ve), ""
-                except Exception as e:
-                    return f"⚠️ Có lỗi xảy ra: {str(e)}", ""
-            
-            analyze_btn.click(
-                analyze_personality,
-                inputs=[api_key_input] + radio_buttons,
-                outputs=[gr.Markdown(), personality_report]
-            )
-        
-        # Event handlers
-        def send_message(api_key, history, message):
+            # Add personality analysis handler
+            self._add_personality_handlers(analyze_btn, radio_buttons, personality_report)
+    
+    def _add_chat_handlers(self, api_key_input, chat_history, msg, send_btn, clear_btn):
+        def send_message(api_key: str, history: List[Dict], message: str) -> Tuple[List[Dict], str]:
             if not message.strip():
-                return history, ""
+                return history, "Vui lòng nhập câu hỏi của bạn."
+            
+            if not api_key.strip():
+                return history, "Vui lòng nhập API Key."
+            
+            if not self.system or self.system.api_client.api_key != api_key:
+                self.system = CareerGuidanceSystem(api_key)
+            
+            user_message = {
+                "type": "user",
+                "text": message
+            }
+            
+            history.append(user_message)
             
             try:
-                if not api_key.strip():
-                    return history + [{"role": "user", "content": message}, {"role": "assistant", "content": "⚠️ Vui lòng nhập API key trước."}], ""
-                
-                career_system = CareerGuidanceSystem(api_key)
-                
-                # Kiểm tra xem người dùng có muốn phân tích tính cách hay không
-                if "tính cách" in message.lower() or "phân tích" in message.lower():
-                    questions = career_system.personality_questions
-                    question_texts = [q["question"] for q in questions]
-                    response_text = "Để phân tích tính cách của bạn, vui lòng trả lời các câu hỏi sau:\n\n"
-                    response_text += "\n".join([f"{i+1}. {q}" for i, q in enumerate(question_texts)])
-                    return history + [{"role": "user", "content": message}, {"role": "assistant", "content": response_text}], ""
-                
-                # Kiểm tra xem người dùng có trả lời các câu hỏi về tính cách hay không
-                if any(str(i+1) + ". " in message for i in range(len(career_system.personality_questions))):
-                    responses = []
-                    for i in range(len(career_system.personality_questions)):
-                        question = career_system.personality_questions[i]["question"]
-                        for line in message.split("\n"):
-                            if f"{i+1}. " in line:
-                                response = line.split(f"{i+1}. ")[1].strip()
-                                responses.append(response)
-                                break
-                    if len(responses) != len(career_system.personality_questions):
-                        return history + [{"role": "user", "content": message}, {"role": "assistant", "content": "⚠️ Bạn chưa trả lời đầy đủ các câu hỏi. Vui lòng trả lời lại."}], ""
-                    
-                    # Phân tích tính cách
-                    analysis = career_system.analyze_user_responses(responses)
-                    report = career_system.create_personality_report(analysis)
-                    
-                    # Hiển thị báo cáo trong cuộc trò chuyện
-                    return history + [{"role": "user", "content": message}, {"role": "assistant", "content": report}], ""
-                
-                # Kiểm tra xem người dùng có cung cấp kiểu tính cách cụ thể hay không
-                if "lộ trình phát triển" in message.lower() and "kiểu tính cách" in message.lower():
-                    mbti_type = None
-                    for line in message.split():
-                        if line.upper() in ["ENTJ", "INTJ", "ENFJ", "INFJ", "ENTP", "INTP", "ENFP", "INFP", 
-                                           "ESTJ", "ISTJ", "ESFJ", "ISFJ", "ESTP", "ISTP", "ESFP", "ISFP"]:
-                            mbti_type = line.upper()
-                            break
-                    
-                    if mbti_type:
-                        question = f"Lộ trình phát triển nghề nghiệp cho kiểu tính cách: {mbti_type}"
-                        advice = career_system.get_advice(question)
-                        return history + [{"role": "user", "content": message}, {"role": "assistant", "content": advice}], ""
-                    else:
-                        return history + [{"role": "user", "content": message}, {"role": "assistant", "content": "⚠️ Vui lòng cung cấp kiểu tính cách hợp lệ (ví dụ: ENTJ)." }], ""
-                
-                # Nếu không phải phân tích tính cách, gửi câu hỏi tới AI
-                advice = career_system.get_advice(message)
-                return history + [{"role": "user", "content": message}, {"role": "assistant", "content": advice}], ""
+                response = self.system.get_advice(message)
+                advisor_message = {
+                    "type": "advisor",
+                    "text": response
+                }
+                history.append(advisor_message)
             except Exception as e:
-                print(f"Error in send_message: {str(e)}")
-                return history + [{"role": "user", "content": message}, {"role": "assistant", "content": "⚠️ Có lỗi xảy ra khi gửi tin nhắn"}], ""
+                advisor_message = {
+                    "type": "advisor",
+                    "text": f"Đã xảy ra lỗi: {str(e)}"
+                }
+                history.append(advisor_message)
+            
+            return history, ""
         
-        def clear_chat():
+        def clear_history():
             return [], ""
         
-        send_btn.click(
-            send_message,
-            inputs=[api_key_input, chat_history, msg],
-            outputs=[chat_history, msg]
-        )
-        
-        msg.submit(
-            send_message,
-            inputs=[api_key_input, chat_history, msg],
-            outputs=[chat_history, msg]
-        )
-        
-        clear_btn.click(
-            clear_chat,
-            inputs=[],
-            outputs=[chat_history, msg]
-        )
+        send_btn.click(send_message, inputs=[api_key_input, chat_history, msg], outputs=[chat_history, msg])
+        clear_btn.click(clear_history, outputs=[chat_history, msg])
     
-    return interface
+    def _add_personality_handlers(self, analyze_btn, radio_buttons, personality_report):
+        def analyze_personality(*responses) -> str:
+            if not all(responses):
+                return "Vui lòng trả lời tất cả các câu hỏi."
+            
+            try:
+                analysis = self.system.analyze_user_responses(responses)
+                report = self.system.create_personality_report(analysis)
+                return report
+            except Exception as e:
+                return f"Đã xảy ra lỗi: {str(e)}"
+        
+        analyze_btn.click(analyze_personality, inputs=radio_buttons, outputs=personality_report)
 
-if __name__ == "__main__":
-    interface = create_interface()
-    interface.launch()
+# Khởi tạo giao diện
+iface = GradioInterface()
+iface.interface.launch()