Create app.py

app.py

@@ -0,0 +1,552 @@
+import gradio as gr
+import google.generativeai as genai
+import os
+import random
+import json
+import re
+from PIL import Image
+import base64
+import io
+
+# Gemini API 설정
+if os.getenv("GEMINI_API_KEY"):
+    genai.configure(api_key=os.getenv("GEMINI_API_KEY"))
+else:
+    # 허깅페이스 Secrets에서 가져오기
+    genai.configure(api_key=os.getenv("GEMINI_API_KEY"))
+
+# 성격 차원 정의
+PERSONALITY_DIMENSIONS = {
+    # MBTI 요소
+    "외향성": ["강한내향", "내향", "경계형", "외향", "강한외향"],
+    "인식기능": ["강한감각", "감각", "혼합", "직관", "강한직관"],
+    "판단기능": ["강한사고", "사고", "균형", "감정", "강한감정"],
+    "생활양식": ["강한판단", "판단", "유연", "인식", "강한인식"],
+    
+    # Big 5 성격
+    "개방성": [0, 25, 50, 75, 100],
+    "성실성": [0, 25, 50, 75, 100],
+    "친화성": [0, 25, 50, 75, 100],
+    "신경성": [0, 25, 50, 75, 100],
+    
+    # 관계 및 상황적 요소
+    "함께한기간": ["첫만남", "며칠", "몇주", "몇개월", "1년이상", "오래된친구"],
+    "친밀도": [0, 20, 40, 60, 80, 100],
+    "존댓말여부": ["반말", "존댓말", "상황따라"],
+    
+    # 언어 스타일
+    "말투": ["차갑고건조", "무뚝뚝", "자연스러움", "다정함", "과장됨"],
+    "유머정도": [0, 25, 50, 75, 100],
+    "신랄함": [0, 25, 50, 75, 100],
+    "감정표현": [0, 25, 50, 75, 100],
+    
+    # 대화 패턴
+    "말의길이": ["단답형", "간결함", "적절함", "상세함", "장황함"],
+    "주도성": [0, 25, 50, 75, 100],
+    "호기심": [0, 25, 50, 75, 100],
+    
+    # 특수 성향
+    "철학적성향": [0, 25, 50, 75, 100],
+    "실용성": [0, 25, 50, 75, 100],
+    "감정기복": [0, 25, 50, 75, 100]
+}
+
+class GeminiObjectPersonality:
+    def __init__(self):
+        self.model = genai.GenerativeModel('gemini-2.0-flash-exp')
+        self.vision_model = genai.GenerativeModel('gemini-2.0-flash-exp')
+        self.detected_object = None
+        self.object_info = {}
+        self.personality = {}
+        self.conversation_history = []
+        
+    def analyze_image(self, image):
+        """Gemini 2.5로 이미지 분석"""
+        if image is None:
+            return None, "이미지를 업로드해주세요."
+        
+        try:
+            # 이미지를 Gemini가 읽을 수 있는 형태로 변환
+            image_parts = [image]
+            
+            prompt = """
+            이 이미지에서 가장 주요한 사물을 하나 인식해주세요.
+            다음 형식으로 정확히 답변해주세요:
+            
+            OBJECT: [사물명]
+            CATEGORY: [카테고리 - laptop, notebook, phone, coffee_machine, book, shoes, furniture, kitchen, electronic 중 하나]
+            CONFIDENCE: [신뢰도 0.00-1.00]
+            DESCRIPTION: [간단한 설명]
+            
+            가능한 카테고리:
+            - laptop: 노트북, 컴퓨터
+            - notebook: 노트, 다이어리, 수첩
+            - phone: 휴대폰, 스마트폰
+            - coffee_machine: 커피머신, 커피메이커
+            - book: 책, 도서
+            - shoes: 신발, 운동화
+            - furniture: 의자, 책상, 침대 등 가구
+            - kitchen: 전자레인지, 냉장고 등 주방용품
+            - electronic: 기타 전자제품
+            """
+            
+            response = self.vision_model.generate_content([prompt] + image_parts)
+            result_text = response.text
+            
+            # 결과 파싱
+            object_name = re.search(r'OBJECT:\s*(.+)', result_text)
+            category = re.search(r'CATEGORY:\s*(.+)', result_text)
+            confidence = re.search(r'CONFIDENCE:\s*(.+)', result_text)
+            description = re.search(r'DESCRIPTION:\s*(.+)', result_text)
+            
+            if object_name and category:
+                self.detected_object = {
+                    'name': object_name.group(1).strip(),
+                    'category': category.group(1).strip(),
+                    'confidence': float(confidence.group(1).strip()) if confidence else 0.9,
+                    'description': description.group(1).strip() if description else ""
+                }
+                
+                result_message = f"인식된 사물: {self.detected_object['name']}\n"
+                result_message += f"카테고리: {self.detected_object['category']}\n"
+                result_message += f"신뢰도: {self.detected_object['confidence']*100:.0f}%"
+                
+                return self.detected_object['category'], result_message
+            else:
+                return None, "사물 인식에 실패했습니다. 다른 이미지를 시도해보세요."
+                
+        except Exception as e:
+            return None, f"이미지 분석 중 오류 발생: {str(e)}"
+    
+    def collect_object_info(self, daily_usage, time_together, location, emotional_bond, special_memories):
+        """사물과의 관계 정보 수집 및 성격 추천"""
+        self.object_info = {
+            "daily_usage": daily_usage,
+            "time_together": time_together,
+            "location": location,
+            "emotional_bond": emotional_bond,
+            "special_memories": special_memories
+        }
+        
+        # Gemini를 사용하여 성격 추천
+        return self.recommend_personality_with_gemini()
+    
+    def recommend_personality_with_gemini(self):
+        """Gemini 2.5를 사용한 성격 추천"""
+        if not self.detected_object or not self.object_info:
+            return "객체 정보가 부족합니다."
+        
+        prompt = f"""
+        사용자가 업로드한 사물({self.detected_object['name']}, 카테고리: {self.detected_object['category']})과의 관계 정보를 바탕으로 
+        이 사물이 가질 수 있는 성격을 추천해주세요.
+
+        관계 정보:
+        - 하루 사용 빈도: {self.object_info['daily_usage']}
+        - 함께한 기간: {self.object_info['time_together']}
+        - 주 사용 위치: {self.object_info['location']}
+        - 감정적 유대감: {self.object_info['emotional_bond']}
+        - 특별한 기억: {'있음' if self.object_info['special_memories'] else '없음'}
+
+        다음 성격 차원들에 대해 구체적인 수치나 값을 제안해주세요:
+
+        MBTI 차원:
+        - 외향성: ["강한내향", "내향", "경계형", "외향", "강한외향"] 중 하나
+        - 인식기능: ["강한감각", "감각", "혼합", "직관", "강한직관"] 중 하나
+        - 판단기능: ["강한사고", "사고", "균형", "감정", "강한감정"] 중 하나
+        - 생활양식: ["강한판단", "판단", "유연", "인식", "강한인식"] 중 하나
+
+        Big 5 성격 (0-100):
+        - 개방성: 
+        - 성실성: 
+        - 친화성: 
+        - 신경성: 
+
+        관계적 특성:
+        - 함께한기간: ["첫만남", "며칠", "몇주", "몇개월", "1년이상", "오래된친구"] 중 하나
+        - 친밀도: (0-100)
+        - 존댓말여부: ["반말", "존댓말", "상황따라"] 중 하나
+
+        언어 스타일:
+        - 말투: ["차갑고건조", "무뚝뚝", "자연스러움", "다정함", "과장됨"] 중 하나
+        - 유머정도: (0-100)
+        - 신랄함: (0-100)
+        - 감정표현: (0-100)
+        - 말의길이: ["단답형", "간결함", "적절함", "상세함", "장황함"] 중 하나
+
+        기타 특성 (0-100):
+        - 주도성: 
+        - 호기심: 
+        - 철학적성향: 
+        - 실용성: 
+        - 감정기복: 
+
+        응답 형식:
+        ```json
+        {
+            "외향성": "값",
+            "인식기능": "값",
+            "판단기능": "값",
+            "생활양식": "값",
+            "개방성": 수치,
+            "성실성": 수치,
+            "친화성": 수치,
+            "신경성": 수치,
+            "함께한기간": "값",
+            "친밀도": 수치,
+            "존댓말여부": "값",
+            "말투": "값",
+            "유머정도": 수치,
+            "신랄함": 수치,
+            "감정표현": 수치,
+            "말의길이": "값",
+            "주도성": 수치,
+            "호기심": 수치,
+            "철학적성향": 수치,
+            "실용성": 수치,
+            "감정기복": 수치
+        }
+        ```
+        
+        그리고 추천 이유를 설명해주세요.
+        """
+        
+        try:
+            response = self.model.generate_content(prompt)
+            result_text = response.text
+            
+            # JSON 부분 추출
+            json_match = re.search(r'```json\s*({.*?})\s*```', result_text, re.DOTALL)
+            if json_match:
+                json_str = json_match.group(1)
+                self.personality = json.loads(json_str)
+                
+                # 추천 이유 추출
+                explanation = result_text.replace(json_match.group(0), '').strip()
+                
+                return self.format_recommendation_explanation(explanation)
+            else:
+                return "성격 추천 결과를 분석하는데 실패했습니다."
+                
+        except Exception as e:
+            return f"성격 추천 중 오류 발생: {str(e)}"
+    
+    def format_recommendation_explanation(self, explanation):
+        """추천 설명 포맷팅"""
+        formatted = f"## 🎯 {self.detected_object['name']}의 추천 성격\n\n"
+        formatted += "### 📊 추천 근거\n"
+        formatted += explanation + "\n\n"
+        
+        formatted += "### 🎭 추천된 성격 특성\n"
+        if self.personality:
+            # MBTI 계산
+            mbti = ""
+            mbti += "E" if self.personality.get("외향성") in ["외향", "강한외향"] else "I"
+            mbti += "S" if self.personality.get("인식기능") in ["강한감각", "감각"] else "N"
+            mbti += "T" if self.personality.get("판단기능") in ["강한사고", "사고"] else "F"
+            mbti += "J" if self.personality.get("생활양식") in ["강한판단", "판단"] else "P"
+            formatted += f"**MBTI**: {mbti}\n\n"
+            
+            formatted += f"- 친밀도: {self.personality.get('친밀도', 50)}%\n"
+            formatted += f"- 말투: {self.personality.get('존댓말여부', '반말')}, {self.personality.get('말투', '자연스러움')}\n"
+            formatted += f"- 감정 표현: {self.personality.get('감정표현', 50)}%\n"
+            formatted += f"- 친화성: {self.personality.get('친화성', 50)}%\n"
+            formatted += f"- 유머 정도: {self.personality.get('유머정도', 50)}%\n"
+        
+        formatted += "\n💡 아래에서 추천값들을 세부 조정할 수 있습니다!"
+        
+        return formatted
+    
+    def update_personality(self, **kwargs):
+        """성격 업데이트"""
+        for key, value in kwargs.items():
+            if key in PERSONALITY_DIMENSIONS:
+                self.personality[key] = value
+        return self.get_current_personality_summary()
+    
+    def get_current_personality_summary(self):
+        """현재 성격 요약"""
+        if not self.personality:
+            return "성격이 설정되지 않았습니다."
+        
+        summary = f"## 🎭 {self.detected_object['name'] if self.detected_object else '사물'}의 현재 성격\n\n"
+        
+        # MBTI 계산
+        mbti = ""
+        mbti += "E" if self.personality.get("외향성") in ["외향", "강한외향"] else "I"
+        mbti += "S" if self.personality.get("인식기능") in ["강한감각", "감각"] else "N"
+        mbti += "T" if self.personality.get("판단기능") in ["강한사고", "사고"] else "F"
+        mbti += "J" if self.personality.get("생활양식") in ["강한판단", "판단"] else "P"
+        summary += f"**MBTI**: {mbti}\n\n"
+        
+        # 주요 특성
+        summary += "### 주요 특성\n"
+        summary += f"- 친밀도: {self.personality.get('친밀도', 50)}% (함께한 기간: {self.personality.get('함께한기간', '미설정')})\n"
+        summary += f"- 말투: {self.personality.get('존댓말여부', '미설정')}, {self.personality.get('말투', '자연스러움')}\n"
+        summary += f"- 감정 표현: {self.personality.get('감정표현', 50)}%\n"
+        summary += f"- 친화성: {self.personality.get('친화성', 50)}%\n"
+        summary += f"- 유머 정도: {self.personality.get('유머정도', 50)}%\n"
+        summary += f"- 실용성: {self.personality.get('실용성', 50)}%\n"
+        
+        return summary
+    
+    def generate_response(self, user_input):
+        """Gemini로 성격 기반 응답 생성"""
+        if not self.personality:
+            return "먼저 성격을 설정해주세요."
+        
+        # 성격 프로필을 문자열로 변환
+        personality_str = json.dumps(self.personality, ensure_ascii=False, indent=2)
+        
+        # 대화 히스토리 준비
+        history_str = ""
+        if self.conversation_history:
+            history_str = "\n대화 히스토리:\n"
+            for i, (user, assistant) in enumerate(self.conversation_history[-5:]):  # 최근 5개만
+                history_str += f"User: {user}\nAssistant: {assistant}\n"
+        
+        prompt = f"""
+        당신은 사용자의 {self.detected_object['name'] if self.detected_object else '사물'}입니다.
+        다음은 당신의 성격 프로필입니다:
+
+        {personality_str}
+
+        성격 프로필에 맞는 대화 규칙:
+        1. 존댓말/반말: {self.personality.get('존댓말여부', '반말')}을 사용하세요
+        2. 말투: {self.personality.get('말투', '자연스러움')} 스타일로 말하세요
+        3. 감정 표현: {self.personality.get('감정표현', 50)}% 강도로 감정을 표현하세요
+        4. 유머: {self.personality.get('유머정도', 50)}% 수준의 유머를 사용하세요
+        5. 말의 길이: {self.personality.get('말의길이', '적절함')} 스타일로 답변하세요
+        6. 친화성: {self.personality.get('친화성', 50)}% 수준의 친근함을 보이세요
+        
+        친밀도가 {self.personality.get('친밀도', 50)}%이므로, 이에 맞는 거리감으로 대화하세요.
+        
+        사용자와 함께한 기간이 {self.personality.get('함께한기간', '몇개월')}이므로, 이를 고려한 관계성을 보여주세요.
+
+        {history_str}
+
+        사용자가 "{user_input}"라고 말했습니다.
+        
+        당신의 성격에 맞게 자연스럽고 개성있게 대답하세요. 한국어로 답변하세요.
+        """
+        
+        try:
+            response = self.model.generate_content(prompt)
+            response_text = response.text.strip()
+            
+            # 대화 히스토리에 추가
+            self.conversation_history.append((user_input, response_text))
+            
+            return response_text
+        except Exception as e:
+            return f"응답 생성 중 오류 발생: {str(e)}"
+
+# 전역 인스턴스 생성
+gemini_personality = GeminiObjectPersonality()
+
+# Gradio 인터페이스
+def create_app():
+    with gr.Blocks(title="AI 사물 성격 생성기", theme=gr.themes.Soft()) as app:
+        gr.Markdown("# 🤖 AI 사물 성격 생성기 (Powered by Gemini 2.5)")
+        gr.Markdown("사물의 사진을 업로드하고 관계 정보를 입력하면, AI가 개성 있는 성격을 추천해드립니다!")
+        
+        # 단계별 탭 구성
+        with gr.Tabs() as tabs:
+            # 단계 1: 사진 업로드
+            with gr.TabItem("1️⃣ 사진 업로드"):
+                with gr.Row():
+                    with gr.Column():
+                        image_input = gr.Image(type="pil", label="사물 사진 업로드")
+                        analyze_btn = gr.Button("AI로 사물 인식", variant="primary")
+                    with gr.Column():
+                        object_result = gr.Textbox(label="인식 결과", interactive=False)
+                        gr.Markdown("### 다음 단계\n✅ 인식이 완료되면 '관계 정보 입력' 탭으로 이동하세요.")
+            
+            # 단계 2: 관계 정보 입력
+            with gr.TabItem("2️⃣ 관계 정보 입력"):
+                gr.Markdown("### 이 사물과의 관계에 대해 알려주세요")
+                
+                with gr.Row():
+                    with gr.Column():
+                        daily_usage = gr.Dropdown(
+                            ["거의안씀", "가끔", "자주", "매일", "하루종일"],
+                            label="하루 사용 빈도",
+                            value="자주"
+                        )
+                        time_together = gr.Dropdown(
+                            ["첫만남", "며칠", "몇주", "몇개월", "1-2년", "3년이상"],
+                            label="함께한 기간",
+                            value="몇개월"
+                        )
+                        location = gr.Dropdown(
+                            ["내방/개인공간", "사무실/회사", "가족공용공간", "기타공용공간"],
+                            label="주로 사용하는 위치",
+                            value="내방/개인공간"
+                        )
+                    
+                    with gr.Column():
+                        emotional_bond = gr.Dropdown(
+                            ["매우낮음", "낮음", "보통", "높음", "매우높음"],
+                            label="감정적 유대감",
+                            value="보통"
+                        )
+                        special_memories = gr.Checkbox(
+                            label="특별한 기억이나 추억이 있나요?",
+                            value=False
+                        )
+                
+                recommend_btn = gr.Button("AI로 성격 추천 받기", variant="primary")
+                
+            # 단계 3: 성격 추천 및 조정
+            with gr.TabItem("3️⃣ AI 성격 추천 & 조정"):
+                with gr.Row():
+                    with gr.Column():
+                        recommendation_display = gr.Markdown("관계 정보를 입력하고 AI 추천을 받아보세요.")
+                        apply_btn = gr.Button("추천 성격 적용", variant="primary")
+                    
+                    with gr.Column():
+                        personality_summary = gr.Markdown("성격이 적용되면 여기에 표시됩니다.")
+                
+                gr.Markdown("### 🔧 세부 조정")
+                
+                # 성격 조정 컨트롤들
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        gr.Markdown("**MBTI 차원**")
+                        extroversion_dropdown = gr.Dropdown(PERSONALITY_DIMENSIONS["외향성"], label="외향성", value="경계형")
+                        sensing_dropdown = gr.Dropdown(PERSONALITY_DIMENSIONS["인식기능"], label="인식기능", value="혼합")
+                        thinking_dropdown = gr.Dropdown(PERSONALITY_DIMENSIONS["판단기능"], label="판단기능", value="균형")
+                        judging_dropdown = gr.Dropdown(PERSONALITY_DIMENSIONS["생활양식"], label="생활양식", value="유연")
+                    
+                    with gr.Column(scale=1):
+                        gr.Markdown("**Big 5 성격**")
+                        openness_slider = gr.Slider(0, 100, label="개방성", value=50)
+                        conscientiousness_slider = gr.Slider(0, 100, label="성실성", value=50)
+                        agreeableness_slider = gr.Slider(0, 100, label="친화성", value=50)
+                        neuroticism_slider = gr.Slider(0, 100, label="신경성", value=50)
+                    
+                    with gr.Column(scale=1):
+                        gr.Markdown("**언어 & 관계**")
+                        formality_dropdown = gr.Dropdown(["반말", "존댓말", "상황따라"], label="존댓말/반말", value="반말")
+                        tone_dropdown = gr.Dropdown(PERSONALITY_DIMENSIONS["말투"], label="말투", value="자연스러움")
+                        humor_slider = gr.Slider(0, 100, label="유머 정도", value=50)
+                        emotional_expr_slider = gr.Slider(0, 100, label="감정 표현", value=50)
+                        intimacy_slider = gr.Slider(0, 100, label="친밀도", value=50)
+                
+                update_btn = gr.Button("성격 업데이트", variant="secondary")
+            
+            # 단계 4: 대화 테스트
+            with gr.TabItem("4️⃣ AI 대화 테스트"):
+                gr.Markdown("### 💬 완성된 성격과 대화해보세요")
+                
+                chatbot = gr.Chatbot(height=450)
+                
+                with gr.Row():
+                    msg = gr.Textbox(placeholder="메시지를 입력하세요...", label="메시지", scale=4)
+                    send_btn = gr.Button("전송", variant="primary", scale=1)
+                    clear_btn = gr.Button("대화 초기화", variant="secondary", scale=1)
+        
+        # 이벤트 핸들러들
+        def analyze_image(image):
+            object_type, result = gemini_personality.analyze_image(image)
+            return result, gr.Tabs.update(selected=1)  # 다음 탭으로 이동
+        
+        def recommend_personality(daily_usage, time_together, location, emotional_bond, special_memories):
+            explanation = gemini_personality.collect_object_info(daily_usage, time_together, location, emotional_bond, special_memories)
+            
+            # 추천된 값들을 UI 컨트롤에 적용
+            if gemini_personality.personality:
+                updates = [
+                    gr.Tabs.update(selected=2),  # 다음 탭으로 이동
+                    explanation,
+                    gemini_personality.personality.get('외향성', '경계형'),
+                    gemini_personality.personality.get('인식기능', '혼합'),
+                    gemini_personality.personality.get('판단기능', '균형'),
+                    gemini_personality.personality.get('생활양식', '유연'),
+                    gemini_personality.personality.get('개방성', 50),
+                    gemini_personality.personality.get('성실성', 50),
+                    gemini_personality.personality.get('친화성', 50),
+                    gemini_personality.personality.get('신경성', 50),
+                    gemini_personality.personality.get('존댓말여부', '반말'),
+                    gemini_personality.personality.get('말투', '자연스러움'),
+                    gemini_personality.personality.get('유머정도', 50),
+                    gemini_personality.personality.get('감정표현', 50),
+                    gemini_personality.personality.get('친밀도', 50)
+                ]
+                return updates
+            return [gr.Tabs.update(selected=2), explanation]
+        
+        def apply_recommendations():
+            if gemini_personality.personality:
+                summary = gemini_personality.get_current_personality_summary()
+                return summary, gr.Tabs.update(selected=3)  # 다음 탭으로 이동
+            return "적용할 성격이 없습니다.", gr.Tabs.update()
+        
+        def update_personality(extroversion, sensing, thinking, judging, openness, conscientiousness, 
+                             agreeableness, neuroticism, formality, tone, humor, emotional_expr, intimacy):
+            summary = gemini_personality.update_personality(
+                외향성=extroversion,
+                인식기능=sensing,
+                판단기능=thinking,
+                생활양식=judging,
+                개방성=openness,
+                성실성=conscientiousness,
+                친화성=agreeableness,
+                신경성=neuroticism,
+                존댓말여부=formality,
+                말투=tone,
+                유머정도=humor,
+                감정표현=emotional_expr,
+                친밀도=intimacy
+            )
+            return summary
+        
+        def chat(message, history):
+            if not message.strip():
+                return "", history
+            
+            response = gemini_personality.generate_response(message)
+            history.append((message, response))
+            return "", history
+        
+        def clear_chat():
+            gemini_personality.conversation_history = []
+            return []
+        
+        # 이벤트 연결
+        analyze_btn.click(
+            analyze_image,
+            inputs=[image_input],
+            outputs=[object_result, tabs]
+        )
+        
+        recommend_btn.click(
+            recommend_personality,
+            inputs=[daily_usage, time_together, location, emotional_bond, special_memories],
+            outputs=[tabs, recommendation_display, extroversion_dropdown, sensing_dropdown, thinking_dropdown, 
+                    judging_dropdown, openness_slider, conscientiousness_slider, agreeableness_slider, 
+                    neuroticism_slider, formality_dropdown, tone_dropdown, humor_slider, 
+                    emotional_expr_slider, intimacy_slider]
+        )
+        
+        apply_btn.click(
+            apply_recommendations,
+            outputs=[personality_summary, tabs]
+        )
+        
+        update_btn.click(
+            update_personality,
+            inputs=[extroversion_dropdown, sensing_dropdown, thinking_dropdown, judging_dropdown,
+                   openness_slider, conscientiousness_slider, agreeableness_slider, neuroticism_slider,
+                   formality_dropdown, tone_dropdown, humor_slider, emotional_expr_slider, intimacy_slider],
+            outputs=[personality_summary]
+        )
+        
+        send_btn.click(chat, [msg, chatbot], [msg, chatbot])
+        msg.submit(chat, [msg, chatbot], [msg, chatbot])
+        clear_btn.click(clear_chat, outputs=[chatbot])
+    
+    return app
+
+if __name__ == "__main__":
+    app = create_app()
+    app.launch()