Update app.py

app.py

@@ -1,24 +1,13 @@
-"""
-디지털 굿판 (Digital Gut-pan) - 도시 속 디지털 의례 공간
-- 음성 기반 감정 분석
-- 소원 아카이브 시스템
-- PWA 지원
-"""
-
-import os
-import json
+import gradio as gr
 import numpy as np
 import librosa
-from datetime import datetime
-from flask import Flask, send_from_directory, render_template
-import gradio as gr
 from transformers import pipeline
+from datetime import datetime
+import os
 import requests
+import json
 from dotenv import load_dotenv
 
-# Flask 앱 초기화
-app = Flask(__name__)
-
 # 환경변수 로드
 load_dotenv()
 
@@ -42,19 +31,67 @@ ONCHEON_STORY = """
 온천천 온천장역에서 장전역까지 걸으며 더 깊은 체험이 가능합니다.
 """
 
-# 경로 설정
-PATHS = {
-    'data': 'data',
-    'assets': 'assets',
-    'static': 'static',
-    'templates': 'templates',
-    'generated_images': 'generated_images',
-    'wishes': 'data/wishes'
-}
+class SimpleDB:
+    def __init__(self, reflections_path="data/reflections.json", wishes_path="data/wishes.json"):
+        self.reflections_path = reflections_path
+        self.wishes_path = wishes_path
+        os.makedirs('data', exist_ok=True)
+        self.reflections = self._load_json(reflections_path)
+        self.wishes = self._load_json(wishes_path)
+
+    def _load_json(self, file_path):
+        if not os.path.exists(file_path):
+            with open(file_path, 'w', encoding='utf-8') as f:
+                json.dump([], f, ensure_ascii=False, indent=2)
+        try:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                return json.load(f)
+        except Exception as e:
+            print(f"Error loading {file_path}: {e}")
+            return []
 
-# 디렉토리 생성
-for path in PATHS.values():
-    os.makedirs(path, exist_ok=True)
+    def save_reflection(self, name, reflection, sentiment, timestamp=None):
+        if timestamp is None:
+            timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        
+        reflection_data = {
+            "timestamp": timestamp,
+            "name": name,
+            "reflection": reflection,
+            "sentiment": sentiment
+        }
+        
+        self.reflections.append(reflection_data)
+        self._save_json(self.reflections_path, self.reflections)
+        return True
+
+    def save_wish(self, name, wish, emotion_data=None, timestamp=None):
+        if timestamp is None:
+            timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        wish_data = {
+            "name": name,
+            "wish": wish,
+            "emotion": emotion_data,
+            "timestamp": timestamp
+        }
+        self.wishes.append(wish_data)
+        self._save_json(self.wishes_path, self.wishes)
+        return True
+
+    def _save_json(self, file_path, data):
+        try:
+            with open(file_path, 'w', encoding='utf-8') as f:
+                json.dump(data, f, ensure_ascii=False, indent=2)
+            return True
+        except Exception as e:
+            print(f"Error saving to {file_path}: {e}")
+            return False
+
+    def get_all_reflections(self):
+        return sorted(self.reflections, key=lambda x: x["timestamp"], reverse=True)
+
+    def get_all_wishes(self):
+        return self.wishes
 
 # API 설정
 HF_API_TOKEN = os.getenv("roots", "")
@@ -79,76 +116,11 @@ except Exception as e:
     speech_recognizer = None
     text_analyzer = None
 
-# Flask 라우트
-@app.route('/static/<path:path>')
-def serve_static(path):
-    return send_from_directory('static', path)
-
-@app.route('/assets/<path:path>')
-def serve_assets(path):
-    return send_from_directory('assets', path)
-
-@app.route('/wishes/<path:path>')
-def serve_wishes(path):
-    return send_from_directory('data/wishes', path)
-
-# CSS 스타일
-GRADIO_CSS = """
-    @media (max-width: 600px) {
-        .container { padding: 10px !important; }
-        .gradio-row { 
-            flex-direction: column !important;
-            gap: 10px !important;
-        }
-        .gradio-button { 
-            width: 100% !important; 
-            margin: 5px 0 !important;
-            min-height: 44px !important;
-            touch-action: manipulation !important;
-            user-select: none !important;
-        }
-        .gradio-textbox { width: 100% !important; }
-        .gradio-audio { width: 100% !important; }
-        .gradio-image { width: 100% !important; }
-        #audio-recorder { width: 100% !important; }
-        #result-image { width: 100% !important; }
-        .gradio-dataframe {
-            overflow-x: auto !important;
-            max-width: 100% !important;
-        }
-    }
-    
-    /* UI 개선 */
-    .gradio-button {
-        transition: all 0.3s ease;
-    }
-    .gradio-button:active {
-        transform: scale(0.98);
-    }
-    
-    /* 모바일 최적화 */
-    * {
-        -webkit-tap-highlight-color: transparent;
-        -webkit-touch-callout: none;
-    }
-    
-    .record-button {
-        position: relative !important;
-        touch-action: manipulation !important;
-    }
-"""
-
-# 초기 상태 정의
-INITIAL_STATE = {
-    "user_name": "",
-    "baseline_features": None,
-    "current_tab": 0,
-    "last_emotion": None
-}
+# 필요한 디렉토리 생성
+os.makedirs("generated_images", exist_ok=True)
 
 # 음성 분석 관련 함수들
 def calculate_baseline_features(audio_data):
-    """기존 음성 분석 함수 유지"""
     try:
         if isinstance(audio_data, tuple):
             sr, y = audio_data
@@ -176,7 +148,6 @@ def calculate_baseline_features(audio_data):
         return None
 
 def map_acoustic_to_emotion(features, baseline_features=None):
-    """기존 감정 매핑 함수 유지"""
     if features is None:
         return {
             "primary": "알 수 없음",
@@ -253,47 +224,7 @@ def map_acoustic_to_emotion(features, baseline_features=None):
 
     return emotions
 
-class WishArchive:
-    """소원 아카이브 관리 클래스"""
-    
-    def __init__(self):
-        """아카이브 초기화"""
-        self.archive_path = os.path.join(PATHS['wishes'], 'wish_archive.json')
-        os.makedirs(os.path.dirname(self.archive_path), exist_ok=True)
-        self.wishes = self._load_archive()
-
-    def _load_archive(self) -> list:
-        """아카이브 파일 로드"""
-        if not os.path.exists(self.archive_path):
-            return []
-        try:
-            with open(self.archive_path, 'r', encoding='utf-8') as f:
-                return json.load(f)
-        except Exception as e:
-            print(f"Error loading wish archive: {e}")
-            return []
-
-    def add_wish(self, wish_data: dict) -> bool:
-        """새로운 소원 추가"""
-        try:
-            self.wishes.append(wish_data)
-            with open(self.archive_path, 'w', encoding='utf-8') as f:
-                json.dump(self.wishes, f, ensure_ascii=False, indent=2)
-            return True
-        except Exception as e:
-            print(f"Error saving wish: {e}")
-            return False
-
-    def get_display_data(self) -> list:
-        """화면 표시용 데이터"""
-        return [
-            [wish["timestamp"], wish["wish"], wish["name"]]
-            for wish in sorted(self.wishes, key=lambda x: x["timestamp"], reverse=True)
-        ]
-
-
 def analyze_voice(audio_data, state):
-    """기존 음성 분석 함수 유지"""
     if audio_data is None:
         return state, "음성을 먼저 녹음해주세요.", "", "", ""
 
@@ -357,19 +288,128 @@ def analyze_voice(audio_data, state):
         return state, f"오류 발생: {str(e)}", "", "", ""
 
 
+def generate_detailed_prompt(text, emotions, text_sentiment):
+    emotion_colors = {
+        "기쁨/열정": "밝은 노랑과 따뜻한 주황색",
+        "분노/강조": "강렬한 빨강과 짙은 검정",
+        "놀람/흥분": "선명한 파랑과 밝은 보라",
+        "관심/호기심": "연한 하늘색과 민트색",
+        "슬픔/우울": "어두운 파랑과 회색",
+        "피로/무기력": "탁한 갈색과 짙은 회색",
+        "평온/안정": "부드러운 초록과 베이지",
+        "차분/진지": "차분한 남색과 깊은 보라"
+    }
+
+    if emotions["intensity"] > 70:
+        visual_style = "역동적인 붓질과 강한 대비"
+    elif emotions["intensity"] > 40:
+        visual_style = "균형잡힌 구도와 중간 톤의 조화"
+    else:
+        visual_style = "부드러운 그라데이션과 차분한 톤"
+
+    prompt = f"한국 전통 민화 스타일의 추상화, {emotion_colors.get(emotions['primary'], '자연스러운 색상')} 기반. "
+    prompt += f"{visual_style}로 표현된 {emotions['primary']}의 감정. "
+    prompt += f"음성의 특징({', '.join(emotions['characteristics'])})을 화면의 동적 요소로 표현. "
+    prompt += f"발화 내용 '{text}'에서 느껴지는 감정({text_sentiment['label']} - 점수: {text_sentiment['score']:.2f})을 은유적 이미지로 담아내기."
+
+    return prompt
+
+def generate_image_from_prompt(prompt):
+    if not prompt:
+        print("No prompt provided")
+        return None
+
+    try:
+        response = requests.post(
+            API_URL,
+            headers=headers,
+            json={
+                "inputs": prompt,
+                "parameters": {
+                    "negative_prompt": "ugly, blurry, poor quality, distorted",
+                    "num_inference_steps": 30,
+                    "guidance_scale": 7.5
+                }
+            }
+        )
+
+        if response.status_code == 200:
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            image_path = f"generated_images/image_{timestamp}.png"
+            os.makedirs("generated_images", exist_ok=True)
+            
+            with open(image_path, "wb") as f:
+                f.write(response.content)
+            
+            return image_path
+        else:
+            print(f"Error: {response.status_code}")
+            print(f"Response: {response.text}")
+            return None
+    except Exception as e:
+        print(f"Error generating image: {str(e)}")
+        return None
+
+def safe_state_update(state, updates):
+    try:
+        new_state = {**state, **updates}
+        # 중요 상태값 검증
+        if "user_name" in updates:
+            new_state["user_name"] = str(updates["user_name"]).strip() or "익명"
+        if "baseline_features" in updates:
+            if updates["baseline_features"] is None:
+                return state  # baseline이 None이면 상태 업데이트 하지 않음
+        return new_state
+    except Exception as e:
+        print(f"State update error: {e}")
+        return state
+
 def create_interface():
-    """Gradio 인터페이스 생성"""
-    wish_archive = WishArchive()
+    db = SimpleDB()
     
     initial_state = {
         "user_name": "",
         "baseline_features": None,
-        "current_tab": 0,
-        "last_emotion": None,
-        "analysis_complete": False
+        "reflections": [],
+        "wish": None,
+        "final_prompt": "",
+        "image_path": None,
+        "current_tab": 0
     }
 
-    with gr.Blocks(theme=gr.themes.Soft(), css=GRADIO_CSS, analytics_enabled=False, title="디지털 굿판") as app:
+    css = """
+        @media (max-width: 600px) {
+            .container { padding: 10px !important; }
+            .gradio-row { 
+                flex-direction: column !important;
+                gap: 10px !important;
+            }
+            .gradio-button { 
+                width: 100% !important; 
+                margin: 5px 0 !important;
+                min-height: 44px !important;  /* 모바일 터치 영역 개선 */
+            }
+            .gradio-textbox { width: 100% !important; }
+            .gradio-audio { width: 100% !important; }
+            .gradio-image { width: 100% !important; }
+            #audio-recorder { width: 100% !important; }
+            #result-image { width: 100% !important; }
+            .gradio-dataframe {
+                overflow-x: auto !important;
+                max-width: 100% !important;
+            }
+        }
+    
+        /* 전반적인 UI 개선 */
+        .gradio-button {
+            transition: all 0.3s ease;
+        }
+        .gradio-button:active {
+            transform: scale(0.98);
+        }
+    """
+
+    with gr.Blocks(theme=gr.themes.Soft(), css=css) as app:
         state = gr.State(value=initial_state)
         
         gr.Markdown("# 디지털 굿판")
@@ -391,37 +431,26 @@ def create_interface():
                         interactive=True
                     )
                     name_submit_btn = gr.Button("굿판 시작하기", variant="primary")
-                
+            
                 # 2단계: 세계관 설명
                 story_section = gr.Column(visible=False)
                 with story_section:
                     gr.Markdown(ONCHEON_STORY)
                     continue_btn = gr.Button("준비하기", variant="primary")
-                
-                # 3단계: 축원 의식 (수정된 부분)
+            
+                # 3단계: 축원 의식
                 blessing_section = gr.Column(visible=False)
                 with blessing_section:
                     gr.Markdown("### 축원의식을 시작하겠습니다")
                     gr.Markdown("'명짐 복짐 짊어지고 안가태평하시기를 비도발원 축원 드립니다'")
-                    with gr.Column() as recording_section:
-                        baseline_audio = gr.Audio(
-                            label="축원 문장 녹음하기",
-                            sources=["microphone"],
-                            type="numpy",
-                            streaming=False
-                        )
-                        analysis_status = gr.Markdown(
-                            "",
-                            visible=False
-                        )
-                    
-                    with gr.Column(visible=False) as baseline_results:
-                        baseline_status = gr.Markdown("")
-                        set_baseline_btn = gr.Button(
-                            "축원 마치기", 
-                            variant="primary",
-                            visible=False
-                        )
+                    baseline_audio = gr.Audio(
+                        label="축원 문장 녹음하기",
+                        sources=["microphone"],
+                        type="numpy",
+                        streaming=False
+                    )
+                    set_baseline_btn = gr.Button("축원 마치기", variant="primary")
+                    baseline_status = gr.Markdown("")
 
                 # 4단계: 굿판 입장 안내
                 entry_guide_section = gr.Column(visible=False)
@@ -434,7 +463,6 @@ def create_interface():
                     """)
                     enter_btn = gr.Button("청신 의식 시작하기", variant="primary")
 
-            # 청신 탭
             with gr.TabItem("청신") as tab_listen:
                 gr.Markdown("## 청신 - 소리로 정화하기")
                 gr.Markdown("""
@@ -453,6 +481,21 @@ def create_interface():
                         show_download_button=True,
                         visible=True
                     )
+                    with gr.Column():
+                        reflection_input = gr.Textbox(
+                            label="지금 이 순간의 감상을 자유롭게 적어보세요",
+                            lines=3,
+                            max_lines=5
+                        )
+                        save_btn = gr.Button("감상 저장하기", variant="secondary")
+                        reflections_display = gr.Dataframe(
+                            headers=["시간", "감상", "감정 분석"],
+                            label="기록된 감상들",
+                            value=[],  # 초기값은 빈 리스트
+                            interactive=False,
+                            wrap=True,
+                            row_count=(5, "dynamic")  # 동적으로 행 수 조정
+                        )
 
             # 기원 탭
             with gr.TabItem("기원") as tab_wish:
@@ -465,10 +508,6 @@ def create_interface():
                             type="numpy",
                             streaming=False
                         )
-                        voice_analysis_status = gr.Markdown(
-                            "",
-                            visible=False
-                        )
                         with gr.Row():
                             clear_btn = gr.Button("녹음 지우기", variant="secondary")
                             analyze_btn = gr.Button("소원 분석하기", variant="primary")
@@ -489,7 +528,18 @@ def create_interface():
 
             # 송신 탭
             with gr.TabItem("송신") as tab_send:
-                gr.Markdown("## 송신 - 소지(소원지)를 남겨주세요")
+                gr.Markdown("## 송신 - 소지(소원지)를 그려 날려 태워봅시다")
+                final_prompt = gr.Textbox(
+                    label="생성된 프롬프트",
+                    interactive=False,
+                    lines=3
+                )
+                generate_btn = gr.Button("마음의 그림 그리기", variant="primary")
+                result_image = gr.Image(
+                    label="생성된 이미지",
+                    show_download_button=True
+                )
+            
                 gr.Markdown("## 온천천에 전하고 싶은 소원을 남겨주세요")
                 final_reflection = gr.Textbox(
                     label="소원",
@@ -498,292 +548,228 @@ def create_interface():
                 )
                 save_final_btn = gr.Button("소원 전하기", variant="primary")
                 gr.Markdown("""
-                💫 여러분의 소원은 11월 25일 온천천 벽면에 설치될 소원나무에 전시될 예정입니다.
-                따뜻한 마음을 담아 작성해주세요.
-                """)
+💫 여러분의 소원은 11월 25일 온천천 벽면에 설치될 소원나무에 전시될 예정입니다.
+따뜻한 마음을 담아 작성해주세요.
+""")
                 wishes_display = gr.Dataframe(
                     headers=["시간", "소원", "이름"],
                     label="기록된 소원들",
-                    value=wish_archive.get_display_data(),
+                    value=[],
                     interactive=False,
                     wrap=True
                 )
 
         # 이벤트 핸들러들
-        def handle_baseline_recording(audio, state):
-            """기준 음성 분석"""
+        def handle_name_submit(name, state):
+            if not name.strip():
+                return (
+                    gr.update(visible=True),
+                    gr.update(visible=False),
+                    gr.update(visible=False),
+                    gr.update(visible=False),
+                    state
+                )
+            state = safe_state_update(state, {"user_name": name})
+            return (
+                gr.update(visible=False),
+                gr.update(visible=True),
+                gr.update(visible=False),
+                gr.update(visible=False),
+                state
+            )
+        
+        def handle_continue():
+            return (
+                gr.update(visible=False),
+                gr.update(visible=False),
+                gr.update(visible=True),
+                gr.update(visible=False)
+            )
+        
+        def handle_blessing_complete(audio, state):
             if audio is None:
-                return {
-                    "state": state,
-                    "analysis": gr.update(visible=True, value="음성을 먼저 녹음해주세요."),
-                    "results": gr.update(visible=False),
-                    "status": "",
-                    "button": gr.update(visible=False)
-                }
+                return state, "음성을 먼저 녹음해주세요.", gr.update(visible=True), gr.update(visible=False)
             
             try:
-                # 분석 중임을 표시
-                analysis_update = gr.update(visible=True, value="음성을 분석하고 있습니다...")
-                yield {
-                    "state": state,
-                    "analysis": analysis_update,
-                    "results": gr.update(visible=False),
-                    "status": "",
-                    "button": gr.update(visible=False)
-                }
+                # ... (기존 음성 처리 코드)
+                return (
+                    state,
+                    "축원이 완료되었습니다.",
+                    gr.update(visible=False),
+                    gr.update(visible=True)
+                )
+            except Exception as e:
+                return state, f"오류가 발생했습니다: {str(e)}", gr.update(visible=True), gr.update(visible=False)
+        
+        def handle_enter():
+            return gr.update(selected=1)  # 청신 탭으로 이동
+
+        def handle_start():
+            return gr.update(visible=False), gr.update(visible=True)
+
+        def handle_baseline(audio, current_state):
+            if audio is None:
+                return current_state, "음성을 먼저 녹음해주세요.", gr.update(selected=0)
+            
+            try:
+                sr, y = audio
+                y = y.astype(np.float32)
+                features = calculate_baseline_features((sr, y))
+                if features:
+                    current_state = safe_state_update(current_state, {
+                        "baseline_features": features,
+                        "current_tab": 1
+                    })
+                    return current_state, "기준점이 설정되었습니다. 청신 탭으로 이동합니다.", gr.update(selected=1)
+                return current_state, "기준점 설정에 실패했습니다. 다시 시도해주세요.", gr.update(selected=0)
+            except Exception as e:
+                print(f"Baseline error: {str(e)}")
+                return current_state, "오류가 발생했습니다. 다시 시도해주세요.", gr.update(selected=0)
+
+        def handle_save_reflection(text, state):
+            if not text.strip():
+                return state, []
+            
+            try:
+                current_time = datetime.now().strftime("%H:%M:%S")
+                if text_analyzer:
+                    sentiment = text_analyzer(text)[0]
+                    sentiment_text = f"{sentiment['label']} ({sentiment['score']:.2f})"
+                    db.save_reflection(state.get("user_name", "익명"), text, sentiment)
+                else:
+                    sentiment_text = "분석 불가"
+                    db.save_reflection(state.get("user_name", "익명"), text, {"label": "unknown", "score": 0.0})
+
+                new_reflection = [current_time, text, sentiment_text]
+                reflections = state.get("reflections", [])
+                reflections.append(new_reflection)
+                state = safe_state_update(state, {"reflections": reflections})
                 
-                features = calculate_baseline_features(audio)
-                if features is None:
-                    return {
-                        "state": state,
-                        "analysis": gr.update(visible=True, value="음성 분석에 실패했습니다. 다시 시도해주세요."),
-                        "results": gr.update(visible=False),
-                        "status": "",
-                        "button": gr.update(visible=False)
-                    }
+                return state, db.get_all_reflections()
+            except Exception as e:
+                print(f"Error saving reflection: {e}")
+                return state, state.get("reflections", [])
+
+        def save_reflection_fixed(text, state):
+            if not text.strip():
+                return state, []
+            
+            try:
+                current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+                name = state.get("user_name", "익명")
                 
-                # 분석 성공 시
-                new_state = {**state, "baseline_features": features, "analysis_complete": True}
-                return {
-                    "state": new_state,
-                    "analysis": gr.update(visible=False),
-                    "results": gr.update(visible=True),
-                    "status": "축원 문장이 정상적으로 인식되었습니다.",
-                    "button": gr.update(visible=True)
-                }
+                if text_analyzer:
+                    sentiment = text_analyzer(text)[0]
+                    sentiment_text = f"{sentiment['label']} ({sentiment['score']:.2f})"
+                else:
+                    sentiment_text = "분석 불가"
+        
+                # DB에 저장
+                db.save_reflection(name, text, sentiment_text)
                 
+                # 화면에 표시할 데이터 형식으로 변환
+                display_data = []
+                all_reflections = db.get_all_reflections()
+                for ref in all_reflections:
+                    display_data.append([
+                        ref["timestamp"],
+                        ref["reflection"],
+                        ref["sentiment"]
+                    ])
+        
+                # 상태 업데이트
+                state = safe_state_update(state, {"reflections": display_data})
+                
+                return state, display_data
+        
             except Exception as e:
-                return {
-                    "state": state,
-                    "analysis": gr.update(visible=True, value=f"오류가 발생했습니다: {str(e)}"),
-                    "results": gr.update(visible=False),
-                    "status": "",
-                    "button": gr.update(visible=False)
-                }
+                print(f"Error saving reflection: {e}")
+                return state, []
+
 
-        def handle_blessing_complete(state):
-            """축원 완료 처리"""
-            if not state.get("analysis_complete"):
-                return state, "음성 분석이 완료되지 않았습니다.", gr.update(visible=True), gr.update(visible=False)
+        def handle_save_wish(text, state):
+            if not text.strip():
+                return "소원을 입력해주세요.", []
             
-            return state, "축원이 완료되었습니다.", gr.update(visible=False), gr.update(visible=True)
+            try:
+                name = state.get("user_name", "익명")
+                db.save_wish(name, text)
+                wishes = db.get_all_wishes()
+                wish_display_data = [
+                    [wish["timestamp"], wish["wish"], wish["name"]]
+                    for wish in wishes
+                ]
+                return "소원이 저장되었습니다.", wish_display_data
+            except Exception as e:
+                print(f"Error saving wish: {e}")
+                return "오류가 발생했습니다.", []
 
         # 이벤트 연결
-        baseline_audio.change(
-            fn=handle_baseline_recording,
-            inputs=[baseline_audio, state],
-            outputs=[
-                state,
-                analysis_status,
-                baseline_results,
-                baseline_status,
-                set_baseline_btn
-            ]
+        name_submit_btn.click(
+            fn=handle_name_submit,
+            inputs=[name_input, state],
+            outputs=[welcome_section, story_section, blessing_section, entry_guide_section, state]
+        )
+
+        continue_btn.click(
+            fn=handle_continue,
+            outputs=[story_section, welcome_section, blessing_section, entry_guide_section]
         )
 
         set_baseline_btn.click(
             fn=handle_blessing_complete,
-            inputs=[state],
+            inputs=[baseline_audio, state],
             outputs=[state, baseline_status, blessing_section, entry_guide_section]
         )
 
-    return app
+        enter_btn.click(
+            fn=handle_enter,
+            outputs=[tabs]
+        )
 
-def create_pwa_files():
-    """PWA 필요 파일들 생성"""
-    # manifest.json 생성
-    manifest_path = 'static/manifest.json'
-    if not os.path.exists(manifest_path):
-        manifest_data = {
-            "name": "디지털 굿판",
-            "short_name": "디지털 굿판",
-            "description": "현대 도시 속 디지털 의례 공간",
-            "start_url": "/",
-            "display": "standalone",
-            "background_color": "#ffffff",
-            "theme_color": "#000000",
-            "orientation": "portrait",
-            "icons": [
-                {
-                    "src": "/static/icons/icon-72x72.png",
-                    "sizes": "72x72",
-                    "type": "image/png",
-                    "purpose": "any maskable"
-                },
-                {
-                    "src": "/static/icons/icon-96x96.png",
-                    "sizes": "96x96",
-                    "type": "image/png",
-                    "purpose": "any maskable"
-                },
-                {
-                    "src": "/static/icons/icon-128x128.png",
-                    "sizes": "128x128",
-                    "type": "image/png",
-                    "purpose": "any maskable"
-                },
-                {
-                    "src": "/static/icons/icon-144x144.png",
-                    "sizes": "144x144",
-                    "type": "image/png",
-                    "purpose": "any maskable"
-                },
-                {
-                    "src": "/static/icons/icon-152x152.png",
-                    "sizes": "152x152",
-                    "type": "image/png",
-                    "purpose": "any maskable"
-                },
-                {
-                    "src": "/static/icons/icon-192x192.png",
-                    "sizes": "192x192",
-                    "type": "image/png",
-                    "purpose": "any maskable"
-                },
-                {
-                    "src": "/static/icons/icon-384x384.png",
-                    "sizes": "384x384",
-                    "type": "image/png",
-                    "purpose": "any maskable"
-                },
-                {
-                    "src": "/static/icons/icon-512x512.png",
-                    "sizes": "512x512",
-                    "type": "image/png",
-                    "purpose": "any maskable"
-                }
-            ]
-        }
-        with open(manifest_path, 'w', encoding='utf-8') as f:
-            json.dump(manifest_data, f, ensure_ascii=False, indent=2)
-
-    # service-worker.js 생성
-    sw_path = 'static/service-worker.js'
-    if not os.path.exists(sw_path):
-        with open(sw_path, 'w', encoding='utf-8') as f:
-            f.write('''
-// 캐시 이름 설정
-const CACHE_NAME = 'digital-gutpan-v1';
-
-// 캐시할 파일 목록
-const urlsToCache = [
-  '/',
-  '/static/icons/icon-72x72.png',
-  '/static/icons/icon-96x96.png',
-  '/static/icons/icon-128x128.png',
-  '/static/icons/icon-144x144.png',
-  '/static/icons/icon-152x152.png',
-  '/static/icons/icon-192x192.png',
-  '/static/icons/icon-384x384.png',
-  '/static/icons/icon-512x512.png',
-  '/assets/main_music.mp3'
-];
-
-// 서비스 워커 설치 시
-self.addEventListener('install', event => {
-  event.waitUntil(
-    caches.open(CACHE_NAME)
-      .then(cache => cache.addAll(urlsToCache))
-      .then(() => self.skipWaiting())
-  );
-});
-
-// 서비스 워커 활성화 시
-self.addEventListener('activate', event => {
-  event.waitUntil(
-    caches.keys().then(cacheNames => {
-      return Promise.all(
-        cacheNames.map(cacheName => {
-          if (cacheName !== CACHE_NAME) {
-            return caches.delete(cacheName);
-          }
-        })
-      );
-    }).then(() => self.clients.claim())
-  );
-});
-
-// 네트워크 요청 처리
-self.addEventListener('fetch', event => {
-  event.respondWith(
-    caches.match(event.request)
-      .then(response => {
-        if (response) {
-          return response;
-        }
-        return fetch(event.request);
-      })
-  );
-});
-            '''.strip())
-
-    # index.html 생성
-    index_path = 'templates/index.html'
-    if not os.path.exists(index_path):
-        with open(index_path, 'w', encoding='utf-8') as f:
-            f.write('''<!DOCTYPE html>
-<html lang="ko">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no">
-    <title>디지털 굿판</title>
-    <link rel="manifest" href="/manifest.json">
-    <meta name="theme-color" content="#000000">
-    <meta name="apple-mobile-web-app-capable" content="yes">
-    <meta name="apple-mobile-web-app-status-bar-style" content="black">
-    <meta name="apple-mobile-web-app-title" content="디지털 굿판">
-    <link rel="apple-touch-icon" href="/static/icons/icon-152x152.png">
-    <script>
-        // 화면 꺼짐 방지
-        async function preventSleep() {
-            try {
-                if ('wakeLock' in navigator) {
-                    const wakeLock = await navigator.wakeLock.request('screen');
-                    console.log('화면 켜짐 유지 활성화');
-                    
-                    document.addEventListener('visibilitychange', async () => {
-                        if (document.visibilityState === 'visible') {
-                            await preventSleep();
-                        }
-                    });
-                }
-            } catch (err) {
-                console.log('화면 켜짐 유지 실패:', err);
-            }
-        }
+        play_music_btn.click(
+            fn=lambda: "assets/main_music.mp3",
+            outputs=[audio]
+        )
 
-        // 서비스 워커 등록
-        if ('serviceWorker' in navigator) {
-            window.addEventListener('load', async () => {
-                try {
-                    const registration = await navigator.serviceWorker.register('/service-worker.js');
-                    console.log('ServiceWorker 등록 성공:', registration.scope);
-                    await preventSleep();
-                } catch (err) {
-                    console.log('ServiceWorker 등록 실패:', err);
-                }
-            });
-        }
-    </script>
-</head>
-<body>
-    <div id="gradio-app"></div>
-</body>
-</html>''')
+        save_btn.click(
+            fn=save_reflection_fixed,  # handle_save_reflection -> save_reflection_fixed
+            inputs=[reflection_input, state],
+            outputs=[state, reflections_display]
+        )
 
-if __name__ == "__main__":
-    # 필요한 디렉토리 생성
-    for directory in ['static/icons', 'assets', 'templates', 'data', 'generated_images']:
-        os.makedirs(directory, exist_ok=True)
+        clear_btn.click(
+            fn=lambda: None,
+            outputs=[voice_input]
+        )
 
-    # PWA 파일 생성
-    create_pwa_files()
+        analyze_btn.click(
+            fn=analyze_voice,
+            inputs=[voice_input, state],
+            outputs=[state, transcribed_text, voice_emotion, text_emotion, final_prompt]
+        )
+
+        generate_btn.click(
+            fn=generate_image_from_prompt,
+            inputs=[final_prompt],
+            outputs=[result_image]
+        )
+
+        save_final_btn.click(
+            fn=handle_save_wish,
+            inputs=[final_reflection, state],
+            outputs=[baseline_status, wishes_display]
+        )
+    return app
 
-    # Gradio 인터페이스 생성 및 실행
+if __name__ == "__main__":
     demo = create_interface()
     demo.launch(
+        debug=True,
+        share=True,
         server_name="0.0.0.0",
         server_port=7860,
-        share=True,
-        debug=True
-    )
+        show_error=True,
+        height=None,
+        width="100%"
+    )