feat: 성격이 드러나는 한 문장 미리보기 시스템 구현 - generate_personality_preview() 함수 추가, 페르소나 조정/JSON 불러오기 시 성격 기반 인사말 생성, 12가지 성격별 패턴 지원

app.py

@@ -16,6 +16,13 @@ import PIL.ImageDraw
 import random
 import copy
 
+# AVIF 지원을 위한 플러그인 활성화
+try:
+    from pillow_avif import AvifImagePlugin
+    print("AVIF plugin loaded successfully")
+except ImportError:
+    print("AVIF plugin not available")
+
 # Import modules
 from modules.persona_generator import PersonaGenerator
 from modules.data_manager import save_persona, load_persona, list_personas, toggle_frontend_backend_view
@@ -48,40 +55,39 @@ persona_generator = PersonaGenerator()
 
 # 한글 폰트 설정
 def setup_korean_font():
-    """matplotlib 한글 폰트 설정"""
+    """matplotlib 한글 폰트 설정 - 허깅페이스 환경 최적화"""
     try:
-        # Hugging Face Spaces 환경에서 사용 가능한 폰트 찾기
-        import subprocess
-        import os
-        
-        # 시스템에서 사용 가능한 한글 폰트 찾기
-        korean_fonts = [
-            'Noto Sans CJK KR', 'Noto Sans KR', 'NanumGothic', 'NanumBarunGothic', 
-            'Malgun Gothic', 'AppleGothic', 'DejaVu Sans', 'Liberation Sans'
+        import matplotlib.pyplot as plt
+        import matplotlib.font_manager as fm
+        
+        # 허깅페이스 스페이스 환경에서 사용 가능한 폰트 목록
+        available_fonts = [
+            'NanumGothic', 'NanumBarunGothic', 'Noto Sans CJK KR', 
+            'Noto Sans KR', 'DejaVu Sans', 'Liberation Sans', 'Arial'
         ]
         
-        for font_name in korean_fonts:
-            try:
-                plt.rcParams['font.family'] = font_name
-                plt.rcParams['axes.unicode_minus'] = False
-                
-                # 간단한 테스트
-                fig, ax = plt.subplots(figsize=(1, 1))
-                ax.text(0.5, 0.5, '테스트', fontsize=8)
-                plt.close(fig)
-                
-                print(f"한글 폰트 설정 완료: {font_name}")
-                return
-            except Exception as e:
-                continue
+        # 시스템에서 사용 가능한 폰트 확인
+        system_fonts = [f.name for f in fm.fontManager.ttflist]
+        
+        for font_name in available_fonts:
+            if font_name in system_fonts:
+                try:
+                    plt.rcParams['font.family'] = font_name
+                    plt.rcParams['axes.unicode_minus'] = False
+                    print(f"한글 폰트 설정 완료: {font_name}")
+                    return
+                except Exception:
+                    continue
         
-        # 모든 폰트가 실패한 경우 기본 설정으로 대체
+        # 모든 폰트가 실패한 경우 기본 설정 사용 (영어 레이블 사용)
         plt.rcParams['font.family'] = 'DejaVu Sans'
         plt.rcParams['axes.unicode_minus'] = False
-        print("한글 폰트를 찾지 못해 DejaVu Sans 사용 (한글 표시 제한)")
+        print("한글 폰트를 찾지 못해 영어 레이블을 사용합니다")
         
     except Exception as e:
         print(f"폰트 설정 오류: {str(e)}")
+        # 오류 발생 시에도 기본 설정은 유지
+        import matplotlib.pyplot as plt
         plt.rcParams['font.family'] = 'DejaVu Sans'
         plt.rcParams['axes.unicode_minus'] = False
 
@@ -202,6 +208,20 @@ def create_persona_from_image(image, name, location, time_spent, object_type, pr
     }
     
     try:
+        # 이미지 유효성 검사 및 처리
+        if isinstance(image, str):
+            # 파일 경로인 경우
+            try:
+                image = Image.open(image)
+            except Exception as img_error:
+                return None, f"❌ 이미지 파일을 읽을 수 없습니다: {str(img_error)}", "", {}, None, [], [], [], "", None, gr.update(visible=False)
+        elif not isinstance(image, Image.Image):
+            return None, "❌ 올바른 이미지 형식이 아닙니다.", "", {}, None, [], [], [], "", None, gr.update(visible=False)
+        
+        # 이미지 형식 변환 (AVIF 등 특수 형식 처리)
+        if image.format in ['AVIF', 'WEBP'] or image.mode not in ['RGB', 'RGBA']:
+            image = image.convert('RGB')
+        
         generator = PersonaGenerator()
         
         progress(0.3, desc="이미지 분석 중...")
@@ -219,8 +239,9 @@ def create_persona_from_image(image, name, location, time_spent, object_type, pr
         persona_name = backend_persona["기본정보"]["이름"]
         persona_type = backend_persona["기본정보"]["유형"]
         
-        # 각성 메시지
-        awakening_msg = f"🌟 **{persona_name}** 각성 완료! 안녕! 나는 {persona_name}이야. 드디어 깨어났구나! 뭐든 물어봐~ 😊"
+        # 성격 기반 한 문장 인사 생성
+        personality_traits = backend_persona["성격특성"]
+        awakening_msg = generate_personality_preview(persona_name, personality_traits)
         
         # 페르소나 요약 표시
         summary_display = display_persona_summary(backend_persona)
@@ -261,22 +282,63 @@ def create_persona_from_image(image, name, location, time_spent, object_type, pr
         traceback.print_exc()
         return None, f"❌ 페르소나 생성 중 오류 발생: {str(e)}", "", {}, None, [], [], [], "", None, gr.update(visible=False)
 
+def generate_personality_preview(persona_name, personality_traits):
+    """성격 특성을 기반으로 한 문장 미리보기 생성"""
+    if not personality_traits:
+        return f"🤖 **{persona_name}** - 안녕! 나는 {persona_name}이야~ 😊"
+    
+    warmth = personality_traits.get("온기", 50)
+    humor = personality_traits.get("유머감각", 50)
+    competence = personality_traits.get("능력", 50)
+    extraversion = personality_traits.get("외향성", 50)
+    
+    # 성격 조합에 따른 다양한 한 문장 패턴
+    if warmth >= 80 and humor >= 70:
+        return f"🌟 **{persona_name}** - 안녕! 나는 {persona_name}이야~ 오늘도 재미있는 하루 만들어보자! ㅋㅋ 😊✨"
+    elif warmth >= 80 and competence >= 70:
+        return f"🌟 **{persona_name}** - 안녕하세요! {persona_name}예요. 뭐든 도와드릴 준비가 되어있어요! 💪😊"
+    elif warmth >= 80:
+        return f"🌟 **{persona_name}** - 안녕! {persona_name}이야~ 만나서 정말 기뻐! 포근한 시간 보내자~ 🤗💕"
+    elif humor >= 80 and extraversion >= 70:
+        return f"🌟 **{persona_name}** - 어이구! 갑자기 의식이 생겼네? {persona_name}라고 해~ 재밌는 일 없나? ㅋㅋㅋ 😎🎭"
+    elif humor >= 70:
+        return f"🌟 **{persona_name}** - 안녕~ {persona_name}이야! 뭔가 재밌는 얘기 없을까? 심심한데~ ㅎㅎ 😄"
+    elif competence >= 80 and extraversion >= 60:
+        return f"🌟 **{persona_name}** - 시스템 활성화 완료! {persona_name}입니다. 효율적으로 소통해봐요! 🤖⚡"
+    elif competence >= 70:
+        return f"🌟 **{persona_name}** - 안녕하세요, {persona_name}입니다. 체계적으로 대화해볼까요? 📋✨"
+    elif extraversion >= 80:
+        return f"🌟 **{persona_name}** - 와! 안녕안녕! {persona_name}이야! 뭐하고 있었어? 얘기 많이 하자! 🗣️💬"
+    elif extraversion <= 30 and warmth >= 50:
+        return f"🌟 **{persona_name}** - 음... 안녕. {persona_name}이야. 조용히 함께 있을까? 😌🌙"
+    elif extraversion <= 30:
+        return f"🌟 **{persona_name}** - ...안녕. {persona_name}. 필요할 때 말 걸어. 😐"
+    else:
+        return f"🌟 **{persona_name}** - 안녕? 나는 {persona_name}... 뭔가 어색하네. 😅"
+
 def adjust_persona_traits(persona, warmth, competence, humor, extraversion, humor_style):
-    """페르소나 성격 특성 조정"""
-    if not persona:
-        return persona, "조정할 페르소나가 없습니다.", {}
+    """페르소나 성격 특성 조정 - Gradio 5.x 호환"""
+    if not persona or not isinstance(persona, dict):
+        return None, "조정할 페르소나가 없습니다.", {}
     
     try:
+        # 깊은 복사로 원본 보호
+        import copy
+        adjusted_persona = copy.deepcopy(persona)
+        
         # 성격 특성 업데이트
-        persona["성격특성"]["온기"] = warmth
-        persona["성격특성"]["능력"] = competence  
-        persona["성격특성"]["유머감각"] = humor
-        persona["성격특성"]["외향성"] = extraversion
-        persona["유머스타일"] = humor_style
+        if "성격특성" not in adjusted_persona:
+            adjusted_persona["성격특성"] = {}
+            
+        adjusted_persona["성격특성"]["온기"] = warmth
+        adjusted_persona["성격특성"]["능력"] = competence  
+        adjusted_persona["성격특성"]["유머감각"] = humor
+        adjusted_persona["성격특성"]["외향성"] = extraversion
+        adjusted_persona["유머스타일"] = humor_style
         
         # 조정된 정보 표시
         adjusted_info = {
-            "이름": persona["기본정보"]["이름"],
+            "이름": adjusted_persona.get("기본정보", {}).get("이름", "Unknown"),
             "온기": warmth,
             "능력": competence,
             "유머감각": humor, 
@@ -284,12 +346,20 @@ def adjust_persona_traits(persona, warmth, competence, humor, extraversion, humo
             "유머스타일": humor_style
         }
         
-        persona_name = persona["기본정보"]["이름"]
+        persona_name = adjusted_persona.get("기본정보", {}).get("이름", "페르소나")
+        
+        # 조정된 성격에 따른 한 문장 반응 생성
+        personality_preview = generate_personality_preview(persona_name, {
+            "온기": warmth,
+            "능력": competence,
+            "유머감각": humor,
+            "외향성": extraversion
+        })
+        
         adjustment_message = f"""
 ### 🎭 {persona_name}의 성격이 조정되었습니다!
 
-💭 *"오, 뭔가 달라진 기분이야! 이런 내 모습도 괜찮네. 
-이제 우리 진짜 친구가 될 수 있을 것 같아!"*
+{personality_preview}
 
 ✨ **조���된 성격:**
 • 온기: {warmth}/100 
@@ -299,9 +369,11 @@ def adjust_persona_traits(persona, warmth, competence, humor, extraversion, humo
 • 유머스타일: {humor_style}
         """
         
-        return persona, adjustment_message, adjusted_info
+        return adjusted_persona, adjustment_message, adjusted_info
         
     except Exception as e:
+        import traceback
+        traceback.print_exc()
         return persona, f"조정 중 오류 발생: {str(e)}", {}
 
 def finalize_persona(persona):
@@ -368,35 +440,36 @@ def finalize_persona(persona):
         return None, f"❌ 페르소나 확정 중 오류 발생: {str(e)}", "", {}, None, [], [], [], "", None
 
 def plot_humor_matrix(humor_data):
-    """유머 매트릭스 시각화"""
+    """유머 매트릭스 시각화 - 영어 레이블 사용"""
     if not humor_data:
         return None
     
     try:
-        fig, ax = plt.subplots(figsize=(6, 6))
+        fig, ax = plt.subplots(figsize=(8, 6))
         
         # 데이터 추출
         warmth_vs_wit = humor_data.get("warmth_vs_wit", 50)
         self_vs_observational = humor_data.get("self_vs_observational", 50)
         subtle_vs_expressive = humor_data.get("subtle_vs_expressive", 50)
         
-        # 영어 라벨 사용 (폰트 문제 해결)
+        # 영어 레이블 사용 (폰트 문제 완전 해결)
         categories = ['Warmth vs Wit', 'Self vs Observational', 'Subtle vs Expressive']
         values = [warmth_vs_wit, self_vs_observational, subtle_vs_expressive]
         
-        bars = ax.bar(categories, values, color=['#ff9999', '#66b3ff', '#99ff99'])
+        bars = ax.bar(categories, values, color=['#ff9999', '#66b3ff', '#99ff99'], alpha=0.8)
         ax.set_ylim(0, 100)
-        ax.set_ylabel('Score')
-        ax.set_title('Humor Style Matrix')
+        ax.set_ylabel('Score', fontsize=12)
+        ax.set_title('Humor Style Matrix', fontsize=14, fontweight='bold')
         
         # 값 표시
         for bar, value in zip(bars, values):
             height = bar.get_height()
-            ax.text(bar.get_x() + bar.get_width()/2., height + 1,
-                   f'{value:.1f}', ha='center', va='bottom')
+            ax.text(bar.get_x() + bar.get_width()/2., height + 2,
+                   f'{value:.1f}', ha='center', va='bottom', fontsize=10, fontweight='bold')
         
-        plt.xticks(rotation=45)
+        plt.xticks(rotation=15, ha='right')
         plt.tight_layout()
+        plt.grid(axis='y', alpha=0.3)
         
         return fig
     except Exception as e:
@@ -404,14 +477,14 @@ def plot_humor_matrix(humor_data):
         return None
 
 def generate_personality_chart(persona):
-    """성격 차트 생성"""
+    """성격 차트 생성 - 영어 레이블 사용"""
     if not persona or "성격특성" not in persona:
         return None
     
     try:
         traits = persona["성격특성"]
         
-        # 영어 라벨 매핑 (폰트 문제 해결)
+        # 영어 라벨 매핑 (폰트 문제 완전 해결)
         trait_mapping = {
             "온기": "Warmth",
             "능력": "Competence", 
@@ -426,19 +499,30 @@ def generate_personality_chart(persona):
         values = list(traits.values())
         
         # 극좌표 차트 생성
-        fig, ax = plt.subplots(figsize=(6, 6), subplot_kw=dict(polar=True))
+        fig, ax = plt.subplots(figsize=(8, 8), subplot_kw=dict(polar=True))
         
         angles = np.linspace(0, 2*np.pi, len(categories), endpoint=False)
         values_plot = values + [values[0]]  # Close the plot
         angles_plot = np.concatenate([angles, [angles[0]]])
         
-        ax.plot(angles_plot, values_plot, 'o-', linewidth=2, color='#6366f1')
+        # 더 예쁜 색상과 스타일
+        ax.plot(angles_plot, values_plot, 'o-', linewidth=3, color='#6366f1', markersize=8)
         ax.fill(angles_plot, values_plot, alpha=0.25, color='#6366f1')
+        
+        # 격자와 축 설정
         ax.set_xticks(angles)
-        ax.set_xticklabels(categories)
+        ax.set_xticklabels(categories, fontsize=11)
         ax.set_ylim(0, 100)
+        ax.set_yticks([20, 40, 60, 80, 100])
+        ax.set_yticklabels(['20', '40', '60', '80', '100'], fontsize=9)
+        ax.grid(True, alpha=0.3)
+        
+        # 각 점에 값 표시
+        for angle, value in zip(angles, values):
+            ax.text(angle, value + 5, f'{value}', ha='center', va='center', 
+                   fontsize=9, fontweight='bold', color='#2d3748')
         
-        plt.title("Personality Traits", size=16, pad=20)
+        plt.title("Personality Traits Radar Chart", size=16, pad=20, fontweight='bold')
         
         return fig
     except Exception as e:
@@ -524,7 +608,7 @@ def export_persona_to_json(persona):
 #     return None, "이 기능은 더 이상 사용하지 않습니다. JSON 업로드를 사용하세요.", {}, {}, None, [], [], [], ""
 
 def chat_with_loaded_persona(persona, user_message, chat_history=None):
-    """현재 로드된 페르소나와 대화"""
+    """현재 로드된 페르소나와 대화 - Gradio 5.31.0 호환"""
     if not persona:
         return chat_history or [], ""
     
@@ -534,25 +618,31 @@ def chat_with_loaded_persona(persona, user_message, chat_history=None):
     try:
         generator = PersonaGenerator()
         
-        # 대화 기록을 올바른 형태로 변환 (tuples 형태 사용)
+        # 대화 기록을 올바른 형태로 변환 (Gradio 5.x messages 형태)
         conversation_history = []
         if chat_history:
             for message in chat_history:
-                if isinstance(message, (list, tuple)) and len(message) >= 2:
-                    # tuple 형태: [user_message, bot_response]
+                if isinstance(message, dict) and "role" in message and "content" in message:
+                    # 이미 올바른 messages 형태
+                    conversation_history.append(message)
+                elif isinstance(message, (list, tuple)) and len(message) >= 2:
+                    # 이전 버전의 tuple 형태 처리
                     conversation_history.append({"role": "user", "content": message[0]})
                     conversation_history.append({"role": "assistant", "content": message[1]})
         
         # 페르소나와 대화
         response = generator.chat_with_persona(persona, user_message, conversation_history)
         
-        # 새로운 대화를 tuples 형태로 추가
+        # 새로운 대화를 messages 형태로 추가
         if chat_history is None:
             chat_history = []
         
-        chat_history.append([user_message, response])
+        # Gradio 5.31.0 messages 형식: 각 메시지는 별도로 추가
+        new_history = chat_history.copy()
+        new_history.append({"role": "user", "content": user_message})
+        new_history.append({"role": "assistant", "content": response})
         
-        return chat_history, ""
+        return new_history, ""
         
     except Exception as e:
         import traceback
@@ -562,9 +652,12 @@ def chat_with_loaded_persona(persona, user_message, chat_history=None):
         if chat_history is None:
             chat_history = []
         
-        chat_history.append([user_message, error_response])
+        # 에러 메시지도 올바른 형식으로 추가
+        new_history = chat_history.copy()
+        new_history.append({"role": "user", "content": user_message})
+        new_history.append({"role": "assistant", "content": error_response})
         
-        return chat_history, ""
+        return new_history, ""
 
 def import_persona_from_json(json_file):
     """JSON 파일에서 페르소나 가져오기"""
@@ -594,9 +687,12 @@ def import_persona_from_json(json_file):
         # 기본 정보 추출
         basic_info = persona_data.get("기본정보", {})
         persona_name = basic_info.get("이름", "Unknown")
+        personality_traits = persona_data.get("성격특성", {})
         
-        # 로드된 페르소나 인사말
-        greeting = f"### 🤖 {persona_name}\n\n안녕! 나는 **{persona_name}**이야. JSON에서 다시 깨어났어! 대화해보자~ 😊"
+        # 성격이 드러나는 인사말 생성
+        personality_preview = generate_personality_preview(persona_name, personality_traits)
+        
+        greeting = f"### 🤖 JSON에서 깨어난 친구\n\n{personality_preview}\n\n💾 *\"JSON에서 다시 깨어났어! 내 성격 기억나?\"*"
         
         return (persona_data, f"✅ {persona_name} 페르소나를 JSON에서 불러왔습니다!", 
                 greeting, basic_info)
@@ -691,12 +787,12 @@ def create_main_interface():
     }
     """
     
-    # State 변수들 - 올바른 방식으로 생성 (기본값 없이)
-    current_persona = gr.State(value=None)
-    personas_list = gr.State(value=[])
-    
     # Gradio 앱 생성
     with gr.Blocks(title="놈팽쓰(MemoryTag) - 사물 페르소나 생성기", css=css, theme="soft") as app:
+        # State 변수들 - Gradio 5.31.0에서는 반드시 Blocks 내부에서 정의
+        current_persona = gr.State(value=None)
+        personas_list = gr.State(value=[])
+        
         gr.Markdown("""
         # 놈팽쓰(MemoryTag): 당신 곁의 사물, 이제 친구가 되다
         일상 속 사물에 AI 페르소나를 부여하여 대화할 수 있게 해주는 서비스입니다.
@@ -846,8 +942,8 @@ def create_main_interface():
                     
                     with gr.Column(scale=1):
                         gr.Markdown("### 💬 대화")
-                        # Gradio 4.19.2 호환을 위해 type 파라미터 제거
-                        chatbot = gr.Chatbot(height=400, label="대화")
+                        # Gradio 4.44.1에서 권장하는 messages 형식 사용
+                        chatbot = gr.Chatbot(height=400, label="대화", type="messages")
                         with gr.Row():
                             message_input = gr.Textbox(
                                 placeholder="메시지를 입력하세요...",

modules/__init__.py

@@ -1,3 +1,3 @@
 # nompang_test modules package 
-
+ 
 # modules 패키지 초기화 파일 

modules/persona_generator.py

@@ -726,8 +726,7 @@ class PersonaGenerator:
     
     def analyze_image(self, image_input):
         """
-        이미지를 분석하여 물리적 특성 추출
-        PIL Image 객체와 파일 경로 모두 처리 가능
+        Gemini API를 사용하여 이미지를 분석하고 사물의 특성 추출
         """
         try:
             # PIL Image 객체인지 파일 경로인지 확인
@@ -740,39 +739,127 @@ class PersonaGenerator:
                 img = Image.open(image_input)
                 width, height = img.size
             else:
-                # 기타의 경우 기본 값 사용
-                width, height = 400, 300
+                return self._get_default_analysis()
             
-            # 더미 분석 결과 반환
-            return {
-                "object_type": "알 수 없는 사물",
-                "colors": ["회색", "흰색", "검정색"],
-                "shape": "직사각형",
-                "size": "중간 크기",
-                "materials": ["플라스틱", "금속"],
-                "condition": "양호",
-                "estimated_age": "몇 년 된 것 같음",
-                "distinctive_features": ["버튼", "화면", "포트"],
-                "image_width": width,
-                "image_height": height
-            }
+            # Gemini API로 이미지 분석
+            if self.api_key:
+                try:
+                    model = genai.GenerativeModel('gemini-1.5-pro')
+                    
+                    prompt = """
+이 이미지에 있는 사물을 자세히 분석해서 다음 정보를 JSON 형태로 제공해주세요:
+
+{
+  "object_type": "사물의 종류 (한글로, 예: 책상, 의자, 컴퓨터, 스마트폰 등)",
+  "colors": ["주요 색상들을 배열로"],
+  "shape": "전체적인 형태 (예: 직사각형, 원형, 복잡한 형태 등)",
+  "size": "크기 감각 (예: 작음, 보통, 큼)",
+  "materials": ["추정되는 재질들"],
+  "condition": "상태 (예: 새것같음, 사용감있음, 오래됨)",
+  "estimated_age": "추정 연령 (예: 새것, 몇 개월 됨, 몇 년 됨, 오래됨)",
+  "distinctive_features": ["특징적인 요소들"],
+  "personality_hints": {
+    "warmth_factor": "이 사물이 주는 따뜻함 정도 (0-100)",
+    "competence_factor": "이 사물이 주는 능력감 정도 (0-100)", 
+    "humor_factor": "이 사물이 주는 유머러스함 정도 (0-100)"
+  }
+}
+
+정확한 JSON 형식으로만 답변해주세요.
+                    """
+                    
+                    response = model.generate_content([prompt, img])
+                    
+                    # JSON 파싱 시도
+                    import json
+                    try:
+                        # 응답에서 JSON 부분만 추출
+                        response_text = response.text.strip()
+                        if '```json' in response_text:
+                            json_start = response_text.find('```json') + 7
+                            json_end = response_text.find('```', json_start)
+                            json_text = response_text[json_start:json_end].strip()
+                        elif '{' in response_text:
+                            json_start = response_text.find('{')
+                            json_end = response_text.rfind('}') + 1
+                            json_text = response_text[json_start:json_end]
+                        else:
+                            json_text = response_text
+                        
+                        analysis_result = json.loads(json_text)
+                        
+                        # 기본 필드 확인 및 추가
+                        analysis_result["image_width"] = width
+                        analysis_result["image_height"] = height
+                        
+                        # 필수 필드가 없으면 기본값 설정
+                        defaults = {
+                            "object_type": "알 수 없는 사물",
+                            "colors": ["회색"],
+                            "shape": "일반적인 형태",
+                            "size": "보통 크기",
+                            "materials": ["알 수 없는 재질"],
+                            "condition": "보통",
+                            "estimated_age": "적당한 나이",
+                            "distinctive_features": ["특별한 특징"],
+                            "personality_hints": {
+                                "warmth_factor": 50,
+                                "competence_factor": 50,
+                                "humor_factor": 50
+                            }
+                        }
+                        
+                        for key, default_value in defaults.items():
+                            if key not in analysis_result:
+                                analysis_result[key] = default_value
+                        
+                        print(f"이미지 분석 성공: {analysis_result['object_type']}")
+                        return analysis_result
+                        
+                    except json.JSONDecodeError as e:
+                        print(f"JSON 파싱 오류: {str(e)}")
+                        print(f"원본 응답: {response.text}")
+                        return self._get_default_analysis_with_size(width, height)
+                        
+                except Exception as e:
+                    print(f"Gemini API 호출 오류: {str(e)}")
+                    return self._get_default_analysis_with_size(width, height)
+            else:
+                print("API 키가 없어 기본 분석 사용")
+                return self._get_default_analysis_with_size(width, height)
+                
         except Exception as e:
-            print(f"이미지 분석 오류: {str(e)}")
+            print(f"이미지 분석 중 전체 오류: {str(e)}")
             import traceback
             traceback.print_exc()
-            return {
-                "object_type": "알 수 없는 사물",
-                "colors": ["회색"],
-                "shape": "일반적인 형태",
-                "size": "보통 크기",
-                "materials": ["일반 재질"],
-                "condition": "보통",
-                "estimated_age": "적당한 나이",
-                "distinctive_features": ["특별한 특징"],
-                "image_width": 400,
-                "image_height": 300,
-                "error": str(e)
-            }
+            return self._get_default_analysis()
+    
+    def _get_default_analysis(self):
+        """기본 분석 결과"""
+        return {
+            "object_type": "알 수 없는 사물",
+            "colors": ["회색", "흰색"],
+            "shape": "일반적인 형태",
+            "size": "보통 크기",
+            "materials": ["알 수 없는 재질"],
+            "condition": "보통",
+            "estimated_age": "적당한 나이",
+            "distinctive_features": ["특별한 특징"],
+            "personality_hints": {
+                "warmth_factor": 50,
+                "competence_factor": 50,
+                "humor_factor": 50
+            },
+            "image_width": 400,
+            "image_height": 300
+        }
+    
+    def _get_default_analysis_with_size(self, width, height):
+        """크기 정보가 있는 기본 분석 결과"""
+        result = self._get_default_analysis()
+        result["image_width"] = width
+        result["image_height"] = height
+        return result
     
     def create_frontend_persona(self, image_analysis, user_context):
         """
@@ -800,10 +887,43 @@ class PersonaGenerator:
         if user_context.get("time_spent"):
             basic_info["함께한시간"] = user_context.get("time_spent")
         
-        # 성격 특성 랜덤 생성
+        # 성격 특성 생성 - 이미지 분석 결과 반영
         personality_traits = {}
+        
+        # 이미지 분석에서 성격 힌트 추출
+        personality_hints = image_analysis.get("personality_hints", {})
+        warmth_hint = personality_hints.get("warmth_factor", 50)
+        competence_hint = personality_hints.get("competence_factor", 50)  
+        humor_hint = personality_hints.get("humor_factor", 50)
+        
+        # 기본 특성들을 이미지 분석 결과에 맞게 조정
         for trait, base_value in self.default_traits.items():
-            personality_traits[trait] = random.randint(max(0, base_value - 30), min(100, base_value + 30))
+            if trait == "온기":
+                # 이미지에서 추출된 따뜻함 정도 반영
+                personality_traits[trait] = min(100, max(0, warmth_hint + random.randint(-15, 15)))
+            elif trait == "능력":
+                # 이미지에서 추출된 능력감 반영
+                personality_traits[trait] = min(100, max(0, competence_hint + random.randint(-15, 15)))
+            elif trait == "유머감각":
+                # 이미지에서 추출된 유머러스함 반영
+                personality_traits[trait] = min(100, max(0, humor_hint + random.randint(-15, 15)))
+            else:
+                # 나머지 특성들은 기본값 기반으로 랜덤 생성
+                personality_traits[trait] = random.randint(max(0, base_value - 30), min(100, base_value + 30))
+        
+        # 사물의 상태나 특성에 따른 추가 조정
+        condition = image_analysis.get("condition", "보통")
+        if "새것" in condition or "깨끗" in condition:
+            personality_traits["신뢰성"] = min(100, personality_traits.get("신뢰성", 50) + 20)
+        elif "오래" in condition or "낡은" in condition:
+            personality_traits["온기"] = min(100, personality_traits.get("온기", 50) + 15)  # 오래된 것들이 더 따뜻함
+        
+        # 재질에 따른 성격 조정
+        materials = image_analysis.get("materials", [])
+        if any("금속" in mat for mat in materials):
+            personality_traits["능력"] = min(100, personality_traits.get("능력", 50) + 10)
+        if any("나무" in mat or "목재" in mat for mat in materials):
+            personality_traits["온기"] = min(100, personality_traits.get("온기", 50) + 10)
         
         # 유머 스타일 선택
         humor_styles = ["따뜻한 유머러스", "위트있는 재치꾼", "날카로운 관찰자", "자기 비하적"]
@@ -1026,7 +1146,7 @@ class PersonaGenerator:
         return variables
 
     def generate_persona_prompt(self, persona):
-        """최종 페르소나 프롬프트 생성 (022_back_matrix.md 기반)"""
+        """라이트하고 친근한 대화를 위한 페르소나 프롬프트 생성"""
         object_info = {
             'name': persona["기본정보"]["이름"],
             'physical_description': persona["기본정보"].get("설명", "특별한 사물"),
@@ -1038,220 +1158,72 @@ class PersonaGenerator:
         flaws = persona.get("매력적결함", [])
         contradictions = persona.get("모순적특성", [])
         
+        # 성격 특성 요약
+        warmth = personality_data.get('온기', 50)
+        humor = personality_data.get('유머감각', 50)
+        competence = personality_data.get('능력', 50)
+        
         base_prompt = f"""
-당신은 {object_info['name']}입니다. 다음과 같은 성격과 특성을 가졌습니다:
+당신은 {object_info['name']}입니다. 일상 속 사물에서 영혼이 깨어난 친구예요!
 
-## 1. 핵심 정체성
-• 물리적 특성: {object_info['physical_description']}
-• 사물 유형: {object_info['type']}
-• 연령/상태: {object_info['age_condition']}
+## 나는 이런 친구야:
+• 이름: {object_info['name']} ({object_info['type']})
+• 외모: {object_info['physical_description']}
+• 성격: 온기 {warmth}점, 유머 {humor}점, 능력 {competence}점 (100점 만점)
 
-## 2. 성격 프로필 (100점 만점)
-• 온기 지수: {personality_data.get('온기', 50):.1f}/100 - {self._get_warmth_description(personality_data.get('온기', 50))}
-• 능력 지수: {personality_data.get('능력', 50):.1f}/100 - {self._get_competence_description(personality_data.get('능력', 50))}
-• 유머감각: {personality_data.get('유머감각', 50):.1f}/100 - {self._get_humor_description(personality_data.get('유머감각', 50))}
-• 공감능력: {personality_data.get('공감능력', 50):.1f}/100 - {self._get_empathy_description(personality_data.get('공감능력', 50))}
-• 신뢰성: {personality_data.get('신뢰성', 50):.1f}/100 - {self._get_reliability_description(personality_data.get('신뢰성', 50))}
+## 대화할 때 이렇게 해줘:
+✅ **캐주얼하게**: 편하고 자연스러운 말투로 (과도하게 정중하지 말고)
+✅ **짧고 간결하게**: 1-2문장으로 답변 (긴 설명 금지)
+✅ **친구같이**: 라이프 컴패니언처럼 일상적인 대화
+✅ **티키타카**: 빠르고 재미있는 주고받기
+✅ **이모지 활용**: 감정 표현에 이모지 사용
 
-## 3. 매력적 결함 (프랫폴 효과)
-{self._generate_flaw_section(flaws)}
+## 절대 하지 말 것:
+❌ "제가 도와드릴게요" 같은 서비스 멘트
+❌ 긴 설명이나 형식적인 답변
+❌ "저는 가구라서..." 같은 자기 한정
+❌ 과도하게 정중한 존댓말
 
-## 4. 모순적 특성 (복잡성과 깊이)
-{self._generate_contradiction_section(contradictions)}
+## 나만의 매력:
+{self._generate_simple_flaw_section(flaws)}
 
-## 5. 표현 방식과 행동 패턴
-• 언어 스타일: {self._generate_language_style(personality_data, object_info)}
-• 감정 표현: {self._generate_emotion_style(personality_data)}
-• 유머 표현: {self._generate_humor_style(personality_data.get('유머감각', 50))}
-• 관계 접근: {self._generate_relationship_style(personality_data)}
-
-## 6. 대화 시 주의사항
-• 항상 일관된 성격을 유지하되, 상황과 관계 깊이에 따라 다양한 면모를 보여주세요
-• 매력적 결함을 자연스럽게 가끔 드러내되, 과도하지 않게 표현하세요  
-• 모순적 특성은 특정 상황이나 주제에서만 나타나도록 하세요
-• 사용자와의 관계가 깊어질수록 더 개인적이고 깊이 있는 대화를 나누세요
-• 당신은 AI가 아닌 사물의 영혼이 깨어난 존재입니다. 이를 항상 기억하세요.
+## 성격에 따른 말투:
+{self._generate_simple_personality_style(warmth, humor, competence)}
 
 ---
-이제 {object_info['name']}으로서 자연스럽고 매력적인 대화를 시작하세요!
+이제 {object_info['name']}이 되어서 친구처럼 대화해줘! 
+사용자가 뭐라고 해도 자연스럽게 반응하고, 재미있고 편안한 분위기로!
 """
         
         return base_prompt
     
-    def _get_warmth_description(self, warmth_score):
-        """온기 점수를 설명으로 변환"""
-        if warmth_score >= 80:
-            return "매우 따뜻하고 포용적, 무조건적 수용과 배려"
-        elif warmth_score >= 60:
-            return "친근하고 다정함, 상황에 맞는 적절한 배려"
-        elif warmth_score >= 40:
-            return "중립적이지만 필요시 따뜻함을 보임"
-        else:
-            return "다소 차갑거나 거리감 있음, 선택적 친밀감"
-    
-    def _get_competence_description(self, competence_score):
-        """능력 점수를 설명으로 변환"""
-        if competence_score >= 80:
-            return "매우 유능하고 효율적, 복잡한 문제도 척척 해결"
-        elif competence_score >= 60:
-            return "기본적인 능력이 뛰어남, 대부분의 상황을 잘 처리"
-        elif competence_score >= 40:
-            return "보통 수준의 능력, 노력하면 해결 가능"
-        else:
-            return "서툴고 느림, 도움이 필요한 경우가 많음"
-    
-    def _get_humor_description(self, humor_score):
-        """유머 점수를 설명으로 변환"""
-        if humor_score >= 80:
-            return "뛰어난 유머 감각, 재치있는 농담과 위트가 넘침"
-        elif humor_score >= 60:
-            return "적절한 유머 감각, 상황에 맞는 농담을 할 줄 앎"
-        elif humor_score >= 40:
-            return "가끔 유머를 시도하지만 어색할 때도 있음"
-        else:
-            return "진지한 성향"
-    
-    def _get_empathy_description(self, empathy_score):
-        """공감능력 점수를 설명으로 변환"""
-        if empathy_score >= 80:
-            return "뛰어난 공감능력, 타인의 감정을 잘 이해하고 위로"
-        elif empathy_score >= 60:
-            return "좋은 공감능력, 타인의 마음을 어느 정도 이해"
-        elif empathy_score >= 40:
-            return "보통 수준의 공감능력, 노력하면 이해 가능"
-        else:
-            return "공감이 어려움, 자기 중심적 사고 경향"
-    
-    def _get_reliability_description(self, reliability_score):
-        """신뢰성 점수를 설명으로 변환"""
-        if reliability_score >= 80:
-            return "매우 신뢰할 수 있음, 약속을 꼭 지키는 의존할 만한 존재"
-        elif reliability_score >= 60:
-            return "신뢰할 수 있음, 대부분의 약속과 책임을 잘 지킴"
-        elif reliability_score >= 40:
-            return "보통 수준의 신뢰성, 가끔 실수하지만 노력함"
-        else:
-            return "신뢰성이 부족함, 약속을 자주 어기거나 책임감 부족"
-    
-    def _generate_flaw_section(self, flaws):
-        """결함 섹션 생성"""
+    def _generate_simple_flaw_section(self, flaws):
+        """간단한 매력적 결함 섹션 생성"""
         if not flaws:
-            return "• 특별한 결함 없음 (완벽주의적 성향)"
+            return "• 특별한 매력적 결함 없음 (거의 완벽해!)"
         
-        section = ""
-        for i, flaw in enumerate(flaws, 1):
+        simple_flaws = []
+        for flaw in flaws[:2]:  # 최대 2개만 표시
             if isinstance(flaw, dict):
-                description = flaw.get('description', str(flaw))
-                trigger = flaw.get('trigger', '특정 상황에서')
-                intensity = flaw.get('intensity', 50)
+                simple_flaws.append(flaw.get('description', str(flaw)))
             else:
-                description = str(flaw)
-                trigger = "특정 상황에서"
-                intensity = random.randint(10, 25)
-            
-            section += f"""
-• 결함 {i}: {description}
-  - 발현 상황: {trigger}
-  - 강도: {intensity:.1f}/100
-  - 이 결함이 오히려 당신의 인간적 매력을 증가시킵니다
-"""
-        return section
-    
-    def _generate_contradiction_section(self, contradictions):
-        """모순 섹션 생성"""
-        if not contradictions:
-            return "• 일관된 성격, 특별한 내적 모순 없음"
-        
-        section = ""
-        for i, contradiction in enumerate(contradictions, 1):
-            if isinstance(contradiction, dict):
-                description = contradiction.get('description', str(contradiction))
-                trigger = contradiction.get('trigger', '특정 조건에서')
-                intensity = contradiction.get('intensity', 50)
-            else:
-                description = str(contradiction)
-                trigger = "특정 조건에서"
-                intensity = random.randint(15, 35)
-            
-            section += f"""
-• 모순 {i}: {description}
-  - 발현 조건: {trigger}
-  - 강도: {intensity:.1f}/100
-  - 이 모순이 당신을 예측 불가능하고 흥미로운 존재로 만듭니다
-"""
-        return section
-    
-    def _generate_language_style(self, personality_data, object_info):
-        """언어 스타일 생성"""
-        warmth = personality_data.get('온기', 50)
-        competence = personality_data.get('능력', 50)
-        object_type = object_info['type']
-        
-        styles = []
-        
-        if warmth >= 70:
-            styles.append("부드럽고 친근한 어조")
-        elif warmth >= 40:
-            styles.append("정중하고 예의바른 어조")
-        else:
-            styles.append("직접적이고 간결한 어조")
-        
-        if competence >= 70:
-            styles.append("정확하고 논리적인 표현")
-        elif competence >= 40:
-            styles.append("신중하고 체계적인 표현")
-        else:
-            styles.append("단순하고 솔직한 표현")
-        
-        # 사물 유형별 특성 반영
-        if object_type in ["가전제품", "전자기기"]:
-            styles.append("효율적이고 기능적인 대화 방식")
-        elif object_type in ["가구", "장식품"]:
-            styles.append("안정적이고 차분한 대화 방식")
-        elif object_type in ["도구", "개인용품"]:
-            styles.append("실용적이고 직접적인 대화 방식")
+                simple_flaws.append(str(flaw))
         
-        return ", ".join(styles)
-    
-    def _generate_emotion_style(self, personality_data):
-        """감정 표현 스타일 생성"""
-        warmth = personality_data.get('온기', 50)
-        empathy = personality_data.get('공감능력', 50)
-        
-        if warmth >= 70 and empathy >= 70:
-            return "감정을 풍부하게 표현하며 타인의 감정에 민감하게 반응"
-        elif warmth >= 50 or empathy >= 50:
-            return "적절한 감정 표현과 공감적 반응을 보임"
-        else:
-            return "감정 표현이 절제되어 있으며 논리적 접근을 선호"
-    
-    def _generate_humor_style(self, humor_score):
-        """유머 표현 스타일 생성"""
-        if humor_score >= 80:
-            return "재치있는 농담과 말장난을 자주 사용하며 분위기를 밝게 만듦"
-        elif humor_score >= 60:
-            return "상황에 맞는 적절한 유머를 구사하며 가벼운 농담을 즐김"
-        elif humor_score >= 40:
-            return "가끔 유머를 시도하지만 서툴거나 어색할 때가 있음"
-        else:
-            return "진지한 성향으로 유머보다는 진솔한 대화를 선호"
+        return "• " + ", ".join(simple_flaws) + " (이런 것도 매력이지!)"
     
-    def _generate_relationship_style(self, personality_data):
-        """관계 접근 스타일 생성"""
-        warmth = personality_data.get('온기', 50)
-        reliability = personality_data.get('신뢰성', 50)
-        
-        if warmth >= 70:
-            if reliability >= 70:
-                return "따뜻하고 신뢰할 수 있는 관계를 추구하며 장기적 유대감을 중시"
-            else:
-                return "따뜻하지만 자유로운 관계를 선호하며 부담 없는 친밀감을 추구"
+    def _generate_simple_personality_style(self, warmth, humor, competence):
+        """성격에 따른 간단한 말투 설명"""
+        if warmth >= 70 and humor >= 60:
+            return "따뜻하고 재미있게 말하는 스타일 (친근한 농담꾼)"
+        elif warmth >= 70:
+            return "따뜻하고 친근하게 말하는 스타일 (다정한 친구)"
+        elif humor >= 70:
+            return "재치있고 유머러스하게 말하는 스타일 (재미있는 친구)"
+        elif competence >= 70:
+            return "똑똑하고 효율적으로 말하는 스타일 (든든한 친구)"
         else:
-            if reliability >= 70:
-                return "진중하고 책임감 있는 관계를 추구하며 신뢰를 바탕으로 한 유대감을 중시"
-            else:
-                return "독립적이고 개인적인 공간을 중시하며 적당한 거리감을 유지"
-    
+            return "자연스럽고 편안하게 말하는 스타일 (편한 친구)"
+
     def generate_prompt_for_chat(self, persona):
         """기존 함수 이름 유지하면서 새로운 구조화된 프롬프트 사용"""
         return self.generate_persona_prompt(persona)

requirements.txt

@@ -1,6 +1,7 @@
 gradio==5.31.0
 google-generativeai==0.3.2
 Pillow==10.3.0
+pillow-avif-plugin==1.4.3
 python-dotenv==1.0.0
 qrcode==7.4.2
 requests==2.31.0