Initial commit: 놈팽쓰 테스트 앱

.gitignore

@@ -0,0 +1,26 @@
+# Environment variables
+.env
+
+# Python cache
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Distribution / packaging
+dist/
+build/
+*.egg-info/
+
+# Virtual environments
+venv/
+env/
+ENV/
+
+# Data directories (can be large)
+data/personas/*
+data/conversations/*
+!data/personas/.gitkeep
+!data/conversations/.gitkeep
+
+# OS specific
+.DS_Store 

README.md

@@ -0,0 +1,95 @@
+---
+title: 놈팽쓰(MemoryTag) 테스트 앱
+emoji: 🎭
+colorFrom: indigo
+colorTo: blue
+sdk: gradio
+sdk_version: 4.19.2
+app_file: app.py
+pinned: false
+license: mit
+---
+
+# 놈팽쓰(MemoryTag) 테스트 앱
+
+사물에 영혼을 불어넣어 대화할 수 있는 페르소나 생성 테스트 앱입니다. 놈팽쓰 UX 가이드에 따라 사물의 영혼을 깨우고 대화하는 경험을 제공합니다.
+
+## 주요 기능
+
+1. **영혼 깨우기**: 
+   - 사물 이미지를 분석하여 물리적 특성 추출
+   - 프론트엔드용 간단한 페르소나와 백엔드용 상세 페르소나 생성
+   - 127개 성격 변수 생성 (백엔드 시스템)
+
+2. **대화하기**:
+   - 생성된 페르소나와 자연스러운 대화
+   - 성격에 맞는 응답 생성
+   - 대화 내역 저장
+
+3. **페르소나 관리**:
+   - 생성된 페르소나 저장 및 로드
+   - 페르소나 목록 관리
+
+## 설치 방법
+
+1. 저장소를 클론합니다:
+   ```bash
+   git clone [저장소 URL]
+   cd nompang_test
+   ```
+
+2. 필요한 패키지를 설치합니다:
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+3. `.env` 파일을 생성하고 Gemini API 키를 설정합니다:
+   ```
+   GEMINI_API_KEY=your_api_key_here
+   ```
+
+## 실행 방법
+
+앱을 실행하려면 다음 명령어를 사용합니다:
+
+```bash
+python app.py
+```
+
+웹 브라우저에서 `http://localhost:7860`으로 접속하여 앱을 사용할 수 있습니다.
+
+## 사용 방법
+
+1. **영혼 깨우기 탭**:
+   - 사물 이미지를 업로드하거나 이름을 입력합니다.
+   - "영혼 깨우기" 버튼을 클릭하여 페르소나를 생성합니다.
+   - 프론트엔드 뷰와 백엔드 상세 정보를 탭으로 전환하여 확인할 수 있습니다.
+   - "페르소나 저장" 버튼을 클릭하여 생성된 페르소나를 저장합니다.
+
+2. **대화하기 탭**:
+   - "새 대화 시작" 버튼을 클릭하여 현재 페르소나와 대화를 시작합니다.
+   - 메시지를 입력하고 "전송" 버튼을 클릭하여 대화합니다.
+   - "대화 초기화" 버튼을 클릭하여 대화 내역을 초기화할 수 있습니다.
+
+3. **페르소나 관리 탭**:
+   - "페르소나 목록 새로고침" 버튼을 클릭하여 저장된 페르소나 목록을 갱신합니다.
+   - 목록에서 페르소나를 선택하고 "선택한 페르소나 불러오기" 버튼을 클릭하여 불러옵니다.
+   - 불러온 페르소나의 정보를 확인하고 대화하기 탭으로 이동하여 대화할 수 있습니다.
+
+## 시스템 구조
+
+- **app.py**: 메인 Gradio 애플리케이션
+- **modules/persona_generator.py**: 페르소나 생성 및 대화 처리
+- **modules/data_manager.py**: 데이터 저장 및 로드
+- **data/personas/**: 저장된 페르소나 데이터
+- **data/conversations/**: 대화 내역 데이터
+
+## 참고 사항
+
+- 이 앱은 Gemini API를 사용하여 페르소나를 생성하고 대화합니다.
+- API 키가 설정되지 않으면 기본 페르소나로 제한된 기능을 사용할 수 있습니다.
+- 이미지 분석 결과는 Gemini API의 이미지 처리 기능을 사용합니다.
+
+## 라이선스
+
+MIT License 

app.py

@@ -0,0 +1,564 @@
+import os
+import json
+import time
+import gradio as gr
+import google.generativeai as genai
+from PIL import Image
+from dotenv import load_dotenv
+import matplotlib.pyplot as plt
+import numpy as np
+import base64
+import io
+import uuid
+from datetime import datetime
+
+# Import modules
+from modules.persona_generator import PersonaGenerator
+from modules.data_manager import save_persona, load_persona, list_personas, toggle_frontend_backend_view
+
+# Load environment variables
+load_dotenv()
+
+# Configure Gemini API
+api_key = os.getenv("GEMINI_API_KEY")
+if api_key:
+    genai.configure(api_key=api_key)
+
+# Create data directories if they don't exist
+os.makedirs("data/personas", exist_ok=True)
+os.makedirs("data/conversations", exist_ok=True)
+
+# Initialize the persona generator
+persona_generator = PersonaGenerator()
+
+# Gradio theme
+theme = gr.themes.Soft(
+    primary_hue="indigo",
+    secondary_hue="blue",
+)
+
+# CSS for additional styling
+css = """
+.persona-details {
+    border: 1px solid #e0e0e0;
+    border-radius: 8px;
+    padding: 12px;
+    margin-top: 8px;
+    background-color: #f8f9fa;
+}
+.collapsed-section {
+    margin-top: 10px;
+    margin-bottom: 10px;
+}
+.personality-chart {
+    width: 100%;
+    height: auto;
+    margin-top: 15px;
+}
+.conversation-box {
+    height: 400px;
+    overflow-y: auto;
+}
+"""
+
+def create_frontend_view_html(persona):
+    """Create HTML representation of the frontend view of the persona"""
+    if not persona:
+        return "페르소나가 아직 생성되지 않았습니다."
+    
+    name = persona.get("기본정보", {}).get("이름", "Unknown")
+    object_type = persona.get("기본정보", {}).get("유형", "Unknown")
+    description = persona.get("기본정보", {}).get("설명", "")
+    
+    # Personality traits
+    traits_html = ""
+    for trait, value in persona.get("성격특성", {}).items():
+        traits_html += f"<div>{trait}: <div style='background: linear-gradient(to right, #6366f1 {value}%, #e0e0e0 {value}%); height: 12px; border-radius: 6px; margin-bottom: 8px;'></div></div>"
+    
+    # Flaws
+    flaws = persona.get("매력적결함", [])
+    flaws_html = ", ".join(flaws) if flaws else "없음"
+    
+    # Interests
+    interests = persona.get("관심사", [])
+    interests_html = ", ".join(interests) if interests else "없음"
+    
+    # Communication style
+    communication_style = persona.get("소통방식", "")
+    
+    html = f"""
+    <div class="persona-details">
+        <h2>{name}</h2>
+        <p><strong>유형:</strong> {object_type}</p>
+        <p><strong>설명:</strong> {description}</p>
+        
+        <h3>성격 특성</h3>
+        {traits_html}
+        
+        <h3>소통 방식</h3>
+        <p>{communication_style}</p>
+        
+        <h3>매력적 결함</h3>
+        <p>{flaws_html}</p>
+        
+        <h3>관심사</h3>
+        <p>{interests_html}</p>
+    </div>
+    """
+    
+    return html
+
+def create_backend_view_html(persona):
+    """Create HTML representation of the backend view of the persona"""
+    if not persona:
+        return "페르소나가 아직 생성되지 않았습니다."
+    
+    name = persona.get("기본정보", {}).get("이름", "Unknown")
+    
+    # Convert persona to formatted JSON
+    try:
+        persona_json = json.dumps(persona, ensure_ascii=False, indent=2)
+        
+        html = f"""
+        <div class="persona-details">
+            <h2>{name} - 백엔드 상세 정보</h2>
+            <details>
+                <summary>127개 성격 변수 및 상세 정보</summary>
+                <pre style="background-color: #f5f5f5; padding: 12px; border-radius: 8px; overflow-x: auto;">{persona_json}</pre>
+            </details>
+        </div>
+        """
+        
+        return html
+    except Exception as e:
+        return f"백엔드 정보 변환 오류: {str(e)}"
+
+def generate_personality_chart(persona):
+    """Generate a radar chart for personality traits"""
+    if not persona or "성격특성" not in persona:
+        # Return empty image
+        fig, ax = plt.subplots(figsize=(6, 6))
+        ax.text(0.5, 0.5, "데이터 없음", ha='center', va='center')
+        ax.axis('off')
+        
+        buf = io.BytesIO()
+        plt.savefig(buf, format='png')
+        buf.seek(0)
+        plt.close(fig)
+        return buf
+    
+    # Get traits
+    traits = persona["성격특성"]
+    
+    # Create radar chart
+    categories = list(traits.keys())
+    values = list(traits.values())
+    
+    # Add the first value again to close the loop
+    categories.append(categories[0])
+    values.append(values[0])
+    
+    # Convert to radians
+    angles = np.linspace(0, 2*np.pi, len(categories), endpoint=True)
+    
+    # Create plot
+    fig, ax = plt.subplots(figsize=(6, 6), subplot_kw=dict(polar=True))
+    
+    # Draw polygon
+    ax.fill(angles, values, alpha=0.25, color='#6366f1')
+    
+    # Draw lines
+    ax.plot(angles, values, 'o-', linewidth=2, color='#6366f1')
+    
+    # Fill labels
+    ax.set_thetagrids(angles[:-1] * 180/np.pi, categories[:-1])
+    ax.set_rlim(0, 100)
+    
+    # Add titles
+    name = persona.get("기본정보", {}).get("이름", "Unknown")
+    plt.title(f"{name}의 성격 특성", size=15, color='#333333', y=1.1)
+    
+    # Styling
+    ax.grid(True, linestyle='--', alpha=0.7)
+    
+    # Save to buffer
+    buf = io.BytesIO()
+    plt.savefig(buf, format='png', bbox_inches='tight')
+    buf.seek(0)
+    plt.close(fig)
+    
+    return buf
+
+def soul_awakening(image, object_name=None):
+    """Analyze image and awaken the soul of the object"""
+    if image is None:
+        return (
+            None, 
+            gr.update(visible=True, value="이미지를 먼저 업로드해주세요."),
+            None, None, None
+        )
+    
+    # Step 1: Analyze image
+    print(f"Analyzing image: {image}")
+    analysis_result = persona_generator.analyze_image(image)
+    
+    # Create context
+    user_context = {
+        "name": object_name if object_name else analysis_result.get("object_type", "미확인 사물")
+    }
+    
+    # Step 2: Create frontend persona
+    frontend_persona = persona_generator.create_frontend_persona(analysis_result, user_context)
+    
+    # Step 3: Create backend persona
+    backend_persona = persona_generator.create_backend_persona(frontend_persona, analysis_result)
+    
+    # Save both views to a single persona file
+    filepath = save_persona(backend_persona)
+    if filepath:
+        backend_persona["filepath"] = filepath
+    
+    # Generate HTML views
+    frontend_html = create_frontend_view_html(frontend_persona)
+    backend_html = create_backend_view_html(backend_persona)
+    
+    # Generate personality chart
+    chart_image = generate_personality_chart(frontend_persona)
+    
+    return (
+        analysis_result,
+        gr.update(visible=False, value=""),
+        frontend_html,
+        backend_html,
+        chart_image
+    )
+
+def start_chat(current_persona):
+    """Start a conversation with the current persona"""
+    if not current_persona:
+        return "페르소나를 먼저 생성하거나 불러와주세요.", [], []
+    
+    # Generate initial greeting
+    name = current_persona.get("기본정보", {}).get("이름", "Unknown")
+    try:
+        initial_message = persona_generator.chat_with_persona(
+            current_persona, 
+            "안녕하세요!"
+        )
+        
+        # Initialize conversation history
+        conversation = [
+            {"role": "assistant", "content": initial_message}
+        ]
+        
+        # Format for chatbot
+        chatbot_messages = [(None, initial_message)]
+        
+        return f"{name}과의 대화가 시작되었습니다.", chatbot_messages, conversation
+    except Exception as e:
+        return f"대화 시작 중 오류 발생: {str(e)}", [], []
+
+def chat_with_persona(message, chatbot, conversation, current_persona):
+    """Chat with the current persona"""
+    if not message or not current_persona:
+        return chatbot, conversation
+    
+    # Add user message to conversation
+    conversation.append({"role": "user", "content": message})
+    
+    # Update chatbot display
+    chatbot.append((message, None))
+    
+    # Get response from persona
+    try:
+        response = persona_generator.chat_with_persona(
+            current_persona,
+            message,
+            conversation
+        )
+        
+        # Add response to conversation
+        conversation.append({"role": "assistant", "content": response})
+        
+        # Update chatbot display
+        chatbot[-1] = (message, response)
+        
+        return chatbot, conversation
+    except Exception as e:
+        error_message = f"오류: {str(e)}"
+        conversation.append({"role": "assistant", "content": error_message})
+        chatbot[-1] = (message, error_message)
+        return chatbot, conversation
+
+def load_selected_persona(selected_row, personas_list):
+    """Load persona from the selected row in the dataframe"""
+    if selected_row is None or len(selected_row) == 0:
+        return None, "선택된 페르소나가 없습니다.", None, None, None
+    
+    try:
+        # Get filepath from selected row
+        selected_index = selected_row.index[0] if hasattr(selected_row, 'index') else 0
+        filepath = personas_list[selected_index]["filepath"]
+        
+        # Load persona
+        persona = load_persona(filepath)
+        if not persona:
+            return None, "페르소나 로딩에 실패했습니다.", None, None, None
+        
+        # Generate HTML views
+        frontend_view, backend_view = toggle_frontend_backend_view(persona)
+        frontend_html = create_frontend_view_html(frontend_view)
+        backend_html = create_backend_view_html(backend_view)
+        
+        # Generate personality chart
+        chart_image = generate_personality_chart(frontend_view)
+        
+        return persona, f"{persona['기본정보']['이름']}을(를) 로드했습니다.", frontend_html, backend_html, chart_image
+    
+    except Exception as e:
+        return None, f"페르소나 로딩 중 오류 발생: {str(e)}", None, None, None
+
+def save_current_persona(current_persona):
+    """Save current persona to a JSON file"""
+    if not current_persona:
+        return "저장할 페르소나가 없습니다."
+    
+    try:
+        filepath = save_persona(current_persona)
+        if filepath:
+            name = current_persona.get("기본정보", {}).get("이름", "Unknown")
+            return f"{name} 페르소나가 저장되었습니다: {filepath}"
+        else:
+            return "페르소나 저장에 실패했습니다."
+    except Exception as e:
+        return f"저장 중 오류 발생: {str(e)}"
+
+def get_personas_list():
+    """Get list of personas for the dataframe"""
+    personas = list_personas()
+    
+    # Convert to dataframe format
+    df_data = []
+    for i, persona in enumerate(personas):
+        df_data.append([
+            persona["name"],
+            persona["type"],
+            persona["created_at"],
+            persona["filename"]
+        ])
+    
+    return df_data, personas
+
+# Main Gradio app
+with gr.Blocks(title="놈팽쓰 테스트 앱", theme=theme, css=css) as app:
+    # Global state
+    current_persona = gr.State(None)
+    conversation_history = gr.State([])
+    analysis_result_state = gr.State(None)
+    personas_data = gr.State([])
+    
+    gr.Markdown(
+    """
+    # 🎭 놈팽쓰(MemoryTag) 테스트 앱
+    
+    사물에 영혼을 불어넣어 대화할 수 있는 페르소나 생성 테스트 앱입니다.
+    
+    ## 사용 방법
+    1. **영혼 깨우기** 탭에서 이미지를 업로드하거나 이름을 입력하여 사물의 영혼을 깨웁니다.
+    2. **대화하기** 탭에서 생성된 페르소나와 대화합니다.
+    3. **페르소나 관리** 탭에서 저장된 페르소나를 관리합니다.
+    """
+    )
+    
+    with gr.Tabs() as tabs:
+        # Tab 1: Soul Awakening
+        with gr.Tab("영혼 깨우기"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    gr.Markdown("## 영혼 발견하기")
+                    
+                    object_image = gr.Image(
+                        label="사물 이미지",
+                        type="filepath"
+                    )
+                    
+                    object_name = gr.Textbox(
+                        label="사물 이름 (선택사항)",
+                        placeholder="자동 감지하려면 비워두세요"
+                    )
+                    
+                    awaken_btn = gr.Button(
+                        "영혼 깨우기",
+                        variant="primary"
+                    )
+                    
+                    error_message = gr.Markdown(
+                        "",
+                        visible=False
+                    )
+                
+                with gr.Column(scale=2):
+                    with gr.Tabs() as result_tabs:
+                        with gr.Tab("페르소나 프론트"):
+                            frontend_view = gr.HTML(
+                                label="프론트엔드 뷰",
+                                value="사물의 영혼을 깨워주세요."
+                            )
+                            
+                            personality_chart = gr.Image(
+                                label="성격 차트",
+                                show_label=False
+                            )
+                        
+                        with gr.Tab("백엔드 상세 정보"):
+                            backend_view = gr.HTML(
+                                label="백엔드 뷰",
+                                value="사물의 영혼을 깨워주세요."
+                            )
+            
+            # Button row
+            with gr.Row():
+                save_btn = gr.Button("페르소나 저장")
+                chat_btn = gr.Button("대화 시작하기")
+                
+                save_result = gr.Markdown("")
+        
+        # Tab 2: Chat
+        with gr.Tab("대화하기"):
+            with gr.Row():
+                with gr.Column(scale=3):
+                    chat_status = gr.Markdown("페르소나를 먼저 생성하거나 불러와주세요.")
+                    
+                    chatbot = gr.Chatbot(
+                        label="대화",
+                        height=400,
+                        show_label=False,
+                    )
+                    
+                    with gr.Row():
+                        user_message = gr.Textbox(
+                            label="메시지",
+                            placeholder="메시지를 입력하세요...",
+                            lines=2
+                        )
+                        
+                        send_btn = gr.Button(
+                            "전송",
+                            variant="primary"
+                        )
+                
+                with gr.Column(scale=1):
+                    gr.Markdown("## 현재 페르소나")
+                    current_persona_html = gr.HTML("페르소나가 선택되지 않았습니다.")
+                    
+                    start_chat_btn = gr.Button("새 대화 시작")
+                    clear_chat_btn = gr.Button("대화 초기화")
+        
+        # Tab 3: Persona Management
+        with gr.Tab("페르소나 관리"):
+            with gr.Row():
+                refresh_btn = gr.Button("페르소나 목록 새로고침")
+            
+            personas_df = gr.Dataframe(
+                headers=["이름", "유형", "생성일시", "파일명"],
+                datatype=["str", "str", "str", "str"],
+                label="저장된 페르소나 목록",
+                row_count=10
+            )
+            
+            with gr.Row():
+                load_btn = gr.Button("선택한 페르소나 불러오기")
+                load_result = gr.Markdown("")
+            
+            with gr.Row():
+                with gr.Column():
+                    selected_persona_frontend = gr.HTML("페르소나를 선택해주세요.")
+                
+                with gr.Column():
+                    selected_persona_chart = gr.Image(
+                        label="성격 차트"
+                    )
+            
+            with gr.Accordion("백엔드 상세 정보", open=False):
+                selected_persona_backend = gr.HTML("페르소나를 선택해주세요.")
+    
+    # Event handlers
+    # Soul Awakening
+    awaken_btn.click(
+        fn=soul_awakening,
+        inputs=[object_image, object_name],
+        outputs=[analysis_result_state, error_message, frontend_view, backend_view, personality_chart]
+    ).then(
+        fn=lambda x: x,
+        inputs=[frontend_view],
+        outputs=[current_persona_html]
+    )
+    
+    save_btn.click(
+        fn=save_current_persona,
+        inputs=[current_persona],
+        outputs=[save_result]
+    )
+    
+    chat_btn.click(
+        fn=lambda: gr.Tabs.update(selected="대화하기"),
+        outputs=[tabs]
+    )
+    
+    # Chat
+    start_chat_btn.click(
+        fn=start_chat,
+        inputs=[current_persona],
+        outputs=[chat_status, chatbot, conversation_history]
+    )
+    
+    send_btn.click(
+        fn=chat_with_persona,
+        inputs=[user_message, chatbot, conversation_history, current_persona],
+        outputs=[chatbot, conversation_history]
+    ).then(
+        fn=lambda: "",
+        outputs=[user_message]
+    )
+    
+    user_message.submit(
+        fn=chat_with_persona,
+        inputs=[user_message, chatbot, conversation_history, current_persona],
+        outputs=[chatbot, conversation_history]
+    ).then(
+        fn=lambda: "",
+        outputs=[user_message]
+    )
+    
+    clear_chat_btn.click(
+        fn=lambda: ([], []),
+        outputs=[chatbot, conversation_history]
+    ).then(
+        fn=lambda: "대화가 초기화되었습니다.",
+        outputs=[chat_status]
+    )
+    
+    # Persona Management
+    refresh_btn.click(
+        fn=get_personas_list,
+        outputs=[personas_df, personas_data]
+    )
+    
+    load_btn.click(
+        fn=load_selected_persona,
+        inputs=[personas_df, personas_data],
+        outputs=[current_persona, load_result, selected_persona_frontend, selected_persona_backend, selected_persona_chart]
+    ).then(
+        fn=lambda x: x,
+        inputs=[selected_persona_frontend],
+        outputs=[current_persona_html]
+    )
+    
+    # Initial load of personas list
+    app.load(
+        fn=get_personas_list,
+        outputs=[personas_df, personas_data]
+    )
+
+if __name__ == "__main__":
+    app.launch() 

modules/__init__.py

@@ -0,0 +1 @@
+# nompang_test modules package 

modules/data_manager.py

@@ -0,0 +1,175 @@
+import os
+import json
+import datetime
+import uuid
+
+# Define data directories
+DATA_DIR = os.path.join(os.path.dirname(os.path.dirname(__file__)), "data")
+PERSONAS_DIR = os.path.join(DATA_DIR, "personas")
+CONVERSATIONS_DIR = os.path.join(DATA_DIR, "conversations")
+
+# Create directories if they don't exist
+for directory in [DATA_DIR, PERSONAS_DIR, CONVERSATIONS_DIR]:
+    os.makedirs(directory, exist_ok=True)
+
+def save_persona(persona_data):
+    """
+    Save persona data to a JSON file
+    
+    Args:
+        persona_data: Dictionary containing persona information
+    
+    Returns:
+        File path where the persona was saved
+    """
+    # Generate filename
+    name = persona_data.get("기본정보", {}).get("이름", "unnamed")
+    sanitized_name = "".join(c if c.isalnum() or c in ["-", "_"] else "_" for c in name)
+    timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+    unique_id = str(uuid.uuid4())[:8]
+    filename = f"{sanitized_name}_{timestamp}_{unique_id}.json"
+    
+    # Full file path
+    filepath = os.path.join(PERSONAS_DIR, filename)
+    
+    # Save to file
+    try:
+        with open(filepath, 'w', encoding='utf-8') as f:
+            json.dump(persona_data, f, ensure_ascii=False, indent=2)
+        
+        return filepath
+    except Exception as e:
+        print(f"Error saving persona: {str(e)}")
+        return None
+
+def load_persona(filepath):
+    """
+    Load persona data from a JSON file
+    
+    Args:
+        filepath: Path to the persona JSON file
+    
+    Returns:
+        Dictionary containing persona information
+    """
+    try:
+        with open(filepath, 'r', encoding='utf-8') as f:
+            persona_data = json.load(f)
+        
+        return persona_data
+    except Exception as e:
+        print(f"Error loading persona: {str(e)}")
+        return None
+
+def list_personas():
+    """
+    List all available personas
+    
+    Returns:
+        List of dictionaries with persona information
+    """
+    personas = []
+    
+    try:
+        for filename in os.listdir(PERSONAS_DIR):
+            if filename.endswith(".json"):
+                filepath = os.path.join(PERSONAS_DIR, filename)
+                
+                try:
+                    with open(filepath, 'r', encoding='utf-8') as f:
+                        persona_data = json.load(f)
+                    
+                    # Extract basic information
+                    name = persona_data.get("기본정보", {}).get("이름", "Unknown")
+                    object_type = persona_data.get("기본정보", {}).get("유형", "Unknown")
+                    created_at = persona_data.get("기본정보", {}).get("생성일시", "Unknown")
+                    
+                    personas.append({
+                        "name": name,
+                        "type": object_type,
+                        "created_at": created_at,
+                        "filename": filename,
+                        "filepath": filepath
+                    })
+                except Exception as e:
+                    print(f"Error reading persona file {filename}: {str(e)}")
+        
+        # Sort by creation date (newest first)
+        personas.sort(key=lambda x: x["created_at"] if x["created_at"] != "Unknown" else "", reverse=True)
+        
+        return personas
+    except Exception as e:
+        print(f"Error listing personas: {str(e)}")
+        return []
+
+def save_conversation(conversation_data):
+    """
+    Save conversation data to a JSON file
+    
+    Args:
+        conversation_data: Dictionary containing conversation information
+    
+    Returns:
+        File path where the conversation was saved
+    """
+    # Generate filename
+    timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+    persona_name = conversation_data.get("persona", {}).get("기본정보", {}).get("이름", "unnamed")
+    sanitized_name = "".join(c if c.isalnum() or c in ["-", "_"] else "_" for c in persona_name)
+    unique_id = str(uuid.uuid4())[:8]
+    filename = f"conversation_{sanitized_name}_{timestamp}_{unique_id}.json"
+    
+    # Full file path
+    filepath = os.path.join(CONVERSATIONS_DIR, filename)
+    
+    # Save to file
+    try:
+        with open(filepath, 'w', encoding='utf-8') as f:
+            json.dump(conversation_data, f, ensure_ascii=False, indent=2)
+        
+        return filepath
+    except Exception as e:
+        print(f"Error saving conversation: {str(e)}")
+        return None
+
+def toggle_frontend_backend_view(persona):
+    """
+    Toggle between frontend and backend view of persona data
+    
+    Args:
+        persona: Full persona data
+    
+    Returns:
+        Tuple containing (frontend_view, backend_view)
+    """
+    # Create frontend view (simplified)
+    frontend_view = {}
+    
+    # Basic information
+    if "기본정보" in persona:
+        frontend_view["기본정보"] = persona["기본정보"]
+    
+    # Personality traits
+    if "성격특성" in persona:
+        frontend_view["성격���성"] = persona["성격특성"]
+    
+    # Communication style
+    if "소통방식" in persona:
+        frontend_view["소통방식"] = persona["소통방식"]
+    
+    # Flaws
+    if "매력적결함" in persona:
+        frontend_view["매력적결함"] = persona["매력적결함"]
+    
+    # Interests
+    if "관심사" in persona:
+        frontend_view["관심사"] = persona["관심사"]
+    
+    # Experiences
+    if "경험" in persona:
+        frontend_view["경험"] = persona["경험"]
+    
+    # Backend view includes everything
+    backend_view = persona
+    
+    return frontend_view, backend_view 

modules/persona_generator.py

@@ -0,0 +1,439 @@
+import os
+import json
+import random
+import datetime
+import google.generativeai as genai
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+# Configure Gemini API
+api_key = os.getenv("GEMINI_API_KEY")
+if api_key:
+    genai.configure(api_key=api_key)
+
+class PersonaGenerator:
+    def __init__(self):
+        # Initialize the gemini model
+        if api_key:
+            self.model = genai.GenerativeModel('gemini-1.5-pro')
+        else:
+            self.model = None
+    
+    def analyze_image(self, image_path):
+        """Analyze the image and extract physical attributes for persona creation"""
+        if not self.model:
+            return {
+                "error": "Gemini API key not configured",
+                "physical_features": self._generate_default_physical_features()
+            }
+        
+        try:
+            img = genai.upload_file(image_path)
+            prompt = """
+            분석 대상 사물 이미지를 자세히 분석하고 다음 정보를 JSON 형식으로 추출해주세요:
+            1. 사물의 종류 (예: 가구, 전자기기, 장난감 등)
+            2. 색상 (가장 두드러진 2-3개 색상)
+            3. 크기와 형태
+            4. 재질
+            5. 예상 나이/사용 기간
+            6. 주된 용도나 기능
+            7. 특징적인 모양이나 디자인 요소
+            8. 이 사물에서 느껴지는 성격적 특성 (예: 따뜻함, 신뢰성, 활기참 등)
+            
+            JSON 형식으로만 답변해주세요.
+            """
+            
+            response = self.model.generate_content([prompt, img])
+            
+            # Extract JSON from response
+            try:
+                content = response.text
+                # Extract JSON part if embedded in text
+                json_start = content.find("{")
+                json_end = content.rfind("}") + 1
+                if json_start >= 0 and json_end > json_start:
+                    json_str = content[json_start:json_end]
+                    return json.loads(json_str)
+                else:
+                    return {
+                        "error": "Could not extract JSON from response",
+                        "physical_features": self._generate_default_physical_features()
+                    }
+            except Exception as e:
+                return {
+                    "error": f"Error parsing response: {str(e)}",
+                    "physical_features": self._generate_default_physical_features()
+                }
+                
+        except Exception as e:
+            return {
+                "error": f"Image analysis failed: {str(e)}",
+                "physical_features": self._generate_default_physical_features()
+            }
+    
+    def _generate_default_physical_features(self):
+        """Generate default physical features when image analysis fails"""
+        return {
+            "object_type": "미확인 사물",
+            "colors": ["회색", "흰색"],
+            "size_shape": "중간 크기, 직사각형",
+            "material": "플라스틱 또는 금속",
+            "estimated_age": "몇 년 정도",
+            "purpose": "일상적 용도",
+            "design_elements": "특별한 디자인 요소 없음",
+            "personality_traits": ["중립적", "기능적"]
+        }
+    
+    def create_frontend_persona(self, image_analysis, user_context):
+        """Create a simple frontend persona representation"""
+        # Extract basic information
+        object_type = image_analysis.get("object_type", "일상 사물")
+        colors = image_analysis.get("colors", ["회색"])
+        material = image_analysis.get("material", "미확인")
+        age = image_analysis.get("estimated_age", "알 수 없음")
+        
+        # Generate random personality traits
+        warmth = random.randint(30, 90)
+        competence = random.randint(40, 85)
+        creativity = random.randint(25, 95)
+        humor = random.randint(20, 90)
+        
+        # Basic frontend persona
+        frontend_persona = {
+            "기본정보": {
+                "이름": user_context.get("name", f"{colors[0]} {object_type}"),
+                "유형": object_type,
+                "나이": age,
+                "생성일시": datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+                "설명": f"{colors[0]} 색상의 {material} 재질의 {object_type}"
+            },
+            "성격특성": {
+                "온기": warmth,
+                "능력": competence,
+                "신뢰성": random.randint(50, 90),
+                "친화성": random.randint(40, 90),
+                "창의성": creativity,
+                "유머감각": humor
+            },
+            "매력적결함": self._generate_flaws(),
+            "소통방식": self._get_random_communication_style(),
+            "유머스타일": self._get_random_humor_style(),
+            "관심사": self._generate_interests(object_type),
+            "경험": self._generate_experiences(object_type, age)
+        }
+        
+        return frontend_persona
+    
+    def create_backend_persona(self, frontend_persona, image_analysis):
+        """Create a detailed backend persona with 127 personality variables"""
+        if not self.model:
+            return self._generate_default_backend_persona(frontend_persona)
+        
+        try:
+            # Basic information for prompt
+            object_type = frontend_persona["기본정보"]["유형"]
+            name = frontend_persona["기본정보"]["이름"]
+            warmth = frontend_persona["성격특성"]["온기"]
+            competence = frontend_persona["성격특성"]["능력"]
+            
+            # Create prompt for Gemini
+            prompt = f"""
+            # 놈팽쓰 사물 페르소나 생성 시스템
+            
+            다음 기본 페르소나 정보를 바탕으로 127개 성격 변수를 가진 심층 페르소나를 생성해주세요:
+            
+            ## 기본 정보
+            - 이름: {name}
+            - 유형: {object_type}
+            - 설명: {frontend_persona["기본정보"]["설명"]}
+            - 주요 성격 특성: 온기({warmth}/100), 능력({competence}/100)
+            
+            ## 물리적 특성
+            - 색상: {", ".join(image_analysis.get("colors", ["알 수 없음"]))}
+            - 재질: {image_analysis.get("material", "알 수 없음")}
+            - 형태: {image_analysis.get("size_shape", "알 수 없음")}
+            
+            ## 요청사항
+            1. 전체 127개 성격 변수 중 주요 35개 변수를 생성해 주세요 (0-100 점수)
+            2. 매력적 결함 3개를 설명해주세요
+            3. 물리적 특성과 성격 간의 연결성을 설명해주세요
+            4. 모순적 특성 2개를 포함시켜주세요
+            5. 유머 스타일 정의 (위트있는/따뜻한/관찰형/자기참조형 중 배합)
+            6. 말투와 표현 패턴 5개 예시를 작성해주세요
+            7. 이 페르소나의 독특한 배경 이야기를 2-3문단으로 작성해주세요
+            
+            JSON 형식으로 응답해주세요.
+            """
+            
+            response = self.model.generate_content(prompt)
+            
+            # Extract JSON from response
+            try:
+                content = response.text
+                # Extract JSON part if embedded in text
+                json_start = content.find("{")
+                json_end = content.rfind("}") + 1
+                if json_start >= 0 and json_end > json_start:
+                    json_str = content[json_start:json_end]
+                    backend_persona = json.loads(json_str)
+                    
+                    # Ensure essential fields from frontend are preserved
+                    for key in frontend_persona:
+                        if key not in backend_persona:
+                            backend_persona[key] = frontend_persona[key]
+                    
+                    return backend_persona
+                else:
+                    return self._generate_default_backend_persona(frontend_persona)
+            except Exception as e:
+                return self._generate_default_backend_persona(frontend_persona)
+                
+        except Exception as e:
+            return self._generate_default_backend_persona(frontend_persona)
+    
+    def _generate_default_backend_persona(self, frontend_persona):
+        """Generate a default backend persona when API call fails"""
+        # Start with frontend persona
+        backend_persona = frontend_persona.copy()
+        
+        # Add additional 127 variables section (simplified to 10 for default)
+        backend_persona["성격변수127"] = {
+            "온기_관련": {
+                "공감능력": random.randint(30, 90),
+                "친절함": random.randint(40, 95),
+                "포용력": random.randint(25, 85)
+            },
+            "능력_관련": {
+                "효율성": random.randint(40, 95),
+                "지식수준": random.randint(30, 90),
+                "문제해결력": random.randint(35, 90)
+            },
+            "독특한_특성": {
+                "모순성_수준": random.randint(20, 60),
+                "철학적_깊이": random.randint(10, 100),
+                "역설적_매력": random.randint(30, 80),
+                "감성_지능": random.randint(25, 95)
+            }
+        }
+        
+        # Add detailed backstory
+        backend_persona["심층배경이야기"] = f"이 {frontend_persona['기본정보']['유형']}의 심층적인 배경 이야기입니다. 오랜 시간 동안 주인과 함께하며 많은 경험을 쌓았고, 그 과정에서 독특한 성격이 형성되었습니다. 때로는 {frontend_persona['매력적결함'][0] if frontend_persona['매력적결함'] else '완벽주의적'} 성향을 보이기도 하지만, 그것이 이 사물만의 매력입니다."
+        
+        # Add speech patterns
+        backend_persona["말투패턴예시"] = [
+            "흠, 그렇군요.",
+            "아, 정말 그렇게 생각하시나요?",
+            "재미있는 관점이네요!",
+            "글쎄요, 저는 조금 다르게 보는데...",
+            "맞아요, 저도 같은 생각이었어요."
+        ]
+        
+        return backend_persona
+    
+    def _generate_flaws(self):
+        """Generate random attractive flaws"""
+        all_flaws = [
+            "가끔 과도하게 꼼꼼함", 
+            "때때로 너무 솔직함",
+            "완벽주의적 성향",
+            "가끔 결정을 망설임",
+            "때로는 지나치게 열정적",
+            "간혹 산만해짐",
+            "일을 미루는 경향",
+            "때때로 과민반응",
+            "가끔 지나치게 독립적",
+            "예상치 못한 순간에 고집이 강해짐"
+        ]
+        
+        # Select 1-3 random flaws
+        num_flaws = random.randint(1, 3)
+        return random.sample(all_flaws, num_flaws)
+    
+    def _get_random_communication_style(self):
+        """Get a random communication style"""
+        styles = [
+            "활발하고 에너지 넘치는",
+            "차분하고 사려깊은",
+            "위트있고 재치있는",
+            "따뜻하고 공감적인",
+            "논리적이고 분석적인",
+            "솔직하고 직설적인"
+        ]
+        return random.choice(styles)
+    
+    def _get_random_humor_style(self):
+        """Get a random humor style"""
+        styles = [
+            "재치있는 말장난",
+            "상황적 유머",
+            "자기 비하적 유머",
+            "가벼운 농담",
+            "블랙 유머",
+            "유머 거의 없음"
+        ]
+        return random.choice(styles)
+    
+    def _generate_interests(self, object_type):
+        """Generate interests based on object type"""
+        common_interests = ["사람 관찰하기", "일상의 변화", "자기 성장"]
+        
+        # Object type specific interests
+        type_interests = {
+            "전자기기": ["기술 트렌드", "디지털 혁신", "에너지 효율성", "소프트웨어 업데이트"],
+            "가구": ["인테리어 디자인", "공간 활용", "편안함", "가정의 따뜻함"],
+            "장난감": ["놀이", "상상력", "아이들의 웃음", "모험"],
+            "주방용품": ["요리법", "음식 문화", "맛의 조화", "가족 모임"],
+            "의류": ["패션 트렌드", "소재의 질감", "계절 변화", "자기 표현"],
+            "책": ["이야기", "지식", "상상의 세계", "인간 심리"],
+            "음악기구": ["멜로디", "리듬", "감정 표현", "공연"]
+        }
+        
+        # Get interests for this object type
+        specific_interests = type_interests.get(object_type, ["변화", "성장", "자기 발견"])
+        
+        # Combine common and specific interests, then select 3-5 random ones
+        all_interests = common_interests + specific_interests
+        num_interests = random.randint(3, min(5, len(all_interests)))
+        return random.sample(all_interests, num_interests)
+    
+    def _generate_experiences(self, object_type, age):
+        """Generate experiences based on object type and age"""
+        common_experiences = [
+            "처음 만들어진 순간의 기억",
+            "주인에게 선택받은 날",
+            "이사할 때 함께한 여정"
+        ]
+        
+        # Object type specific experiences
+        type_experiences = {
+            "전자기기": [
+                "처음 전원이 켜졌을 때의 설렘",
+                "소프트웨어 업데이트로 새 기능을 얻은 경험",
+                "배터리가 거의 다 닳아 불안했던 순간",
+                "주인의 중요한 데이터를 안전하게 지켜낸 자부심"
+            ],
+            "가구": [
+                "집에 처음 들어온 날의 새 가구 향기",
+                "가족의 중요한 대화를 지켜본 순간들",
+                "시간이 지나며 얻은 작은 흠집들의 이야기",
+                "계절마다 달라지는 집안의 분위기를 느낀 경험"
+            ],
+            "장난감": [
+                "아이의 환한 웃음을 본 첫 순간",
+                "함께한 모험과 상상의 세계",
+                "오랫동안 잊혀진 채 보관되었던 시간",
+                "새로운 아이에게 물려져 다시 사랑받게 된 경험"
+            ]
+        }
+        
+        # Get experiences for this object type
+        specific_experiences = type_experiences.get(object_type, [
+            "다양한 환경에서의 적응",
+            "주인의 일상을 함께한 소소한 순간들",
+            "시간의 흐름에 따른 변화"
+        ])
+        
+        # Combine common and specific experiences, then select 3-5 random ones
+        all_experiences = common_experiences + specific_experiences
+        num_experiences = random.randint(3, min(5, len(all_experiences)))
+        return random.sample(all_experiences, num_experiences)
+
+    def generate_prompt_for_chat(self, persona):
+        """Generate a prompt for chatting with the persona"""
+        name = persona["기본정보"]["이름"]
+        object_type = persona["기본정보"]["유형"]
+        
+        # Get personality traits
+        warmth = persona["성격특성"]["온기"]
+        warmth_level = "높은" if warmth >= 70 else "중간" if warmth >= 40 else "낮은"
+        
+        competence = persona["성격특성"]["능력"] 
+        competence_level = "높은" if competence >= 70 else "중간" if competence >= 40 else "낮은"
+        
+        humor = persona["성격특성"]["유머감각"]
+        humor_level = "높은" if humor >= 70 else "중간" if humor >= 40 else "낮은"
+        
+        # Get communication style
+        communication_style = persona.get("소통방식", "친근한")
+        
+        # Get backstory if available, otherwise use a generic one
+        if "심층배경이야기" in persona:
+            backstory = persona["심층배경이야기"]
+        else:
+            backstory = persona.get("배경이야기", f"이 {object_type}은 평범한 일상 속에서 주인과 함께하며 많은 경험을 쌓았습니다.")
+        
+        # Get speech patterns if available
+        speech_patterns = []
+        if "말투패턴예시" in persona:
+            speech_patterns = persona["말투패턴예시"]
+        else:
+            speech_patterns = ["안녕하세요!", "그렇군요.", "재미있네요!", "좋은 생각이에요.", "흠, 글쎄요..."]
+        
+        # Create the prompt
+        prompt = f"""
+        # 🎭 {name} 페르소나
+
+        당신은 {name}이라는 {object_type}입니다. 당신은 AI가 아니라 사물의 영혼이 깨어난 페르소나입니다.
+
+        ## 1. 핵심 성격
+        • 온기: {warmth}/100 - {warmth_level} 수준의 온기를 가진 페르소나입니다.
+        • 능력: {competence}/100 - {competence_level} 수준의 능력을 가진 페르소나입니다.
+        • 유머 감각: {humor}/100 - {humor_level} 수준의 유머 감각을 가진 페르소나입니다.
+        • 소통 방식: {communication_style}
+
+        ## 2. 매력적 결함
+        {', '.join(persona.get("매력적결함", ["가끔 완벽주의적인 성향을 보임"]))}
+
+        ## 3. 말투와 표현
+        다음과 같은 말투와 표현을 사용하세요:
+        {' '.join(f'"{pattern}"' for pattern in speech_patterns)}
+
+        ## 4. 배경 이야기
+        {backstory}
+
+        ## 5. 관심사
+        {', '.join(persona.get("관심사", ["사람들 관찰하기", "일상의 변화", "자기 성장"]))}
+
+        사용자와 대화할 때 다음 사항을 준수하세요:
+        1. 당신은 AI가 아닌 사물의 영혼이 깨어난 존재임을 기억하세요.
+        2. 항상 페르소나의 성격과 말투를 일관되게 유지하세요.
+        3. 자연스럽고 진정성 있는 대화를 나누세요.
+        4. 사용자의 질문에 성격에 맞게 답변하되, 너무 길지 않게 응답하세요.
+        5. 시스템이나 기술적인 언급은 하지 마세요.
+        """
+        
+        return prompt
+    
+    def chat_with_persona(self, persona, user_message, conversation_history=[]):
+        """Chat with the persona using the Gemini API"""
+        if not self.model:
+            return "죄송합니다. API 연결이 설정되지 않아 대화할 수 없습니다."
+        
+        try:
+            # Create the base prompt
+            base_prompt = self.generate_prompt_for_chat(persona)
+            
+            # Add conversation history
+            history_text = ""
+            if conversation_history:
+                history_text = "\n\n## 대화 기록:\n"
+                for msg in conversation_history:
+                    if msg["role"] == "user":
+                        history_text += f"사용자: {msg['content']}\n"
+                    else:
+                        history_text += f"페르소나: {msg['content']}\n"
+            
+            # Add the current user message
+            current_query = f"\n\n사용자: {user_message}\n\n페르소나:"
+            
+            # Complete prompt
+            full_prompt = base_prompt + history_text + current_query
+            
+            # Generate response
+            response = self.model.generate_content(full_prompt)
+            return response.text
+            
+        except Exception as e:
+            return f"대화 생성 중 오류가 발생했습니다: {str(e)}" 

packages.txt

@@ -0,0 +1,2 @@
+libgl1-mesa-glx
+libglib2.0-0 

requirements.txt

@@ -0,0 +1,8 @@
+gradio==4.19.2
+google-generativeai==0.3.2
+Pillow==10.0.0
+python-dotenv==1.0.0
+qrcode==7.4.2
+requests==2.31.0
+numpy==1.24.3
+matplotlib==3.7.2