Update app.py

app.py

@@ -1,25 +1,24 @@
-import gradio as gr
+"""
+디지털 굿판 (Digital Gut-pan) - 도시 속 디지털 의례 공간
+- 음성 기반 감정 분석
+- 소원 아카이브 시스템
+- PWA 지원
+"""
+
+import os
+import json
 import numpy as np
 import librosa
-from transformers import pipeline
 from datetime import datetime
-import os
 from flask import Flask, send_from_directory, render_template
+import gradio as gr
+from transformers import pipeline
 import requests
-import json
 from dotenv import load_dotenv
 
+# Flask 앱 초기화
 app = Flask(__name__)
 
-# PWA 관련 라우트
-@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)
-
 # 환경변수 로드
 load_dotenv()
 
@@ -43,67 +42,19 @@ ONCHEON_STORY = """
 온천천 온천장역에서 장전역까지 걸으며 더 깊은 체험이 가능합니다.
 """
 
-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 []
-
-    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
+# 경로 설정
+PATHS = {
+    'data': 'data',
+    'assets': 'assets',
+    'static': 'static',
+    'templates': 'templates',
+    'generated_images': 'generated_images',
+    'wishes': 'data/wishes'
+}
 
-    def get_all_reflections(self):
-        return sorted(self.reflections, key=lambda x: x["timestamp"], reverse=True)
-
-    def get_all_wishes(self):
-        return self.wishes
+# 디렉토리 생성
+for path in PATHS.values():
+    os.makedirs(path, exist_ok=True)
 
 # API 설정
 HF_API_TOKEN = os.getenv("roots", "")
@@ -128,11 +79,76 @@ except Exception as e:
     speech_recognizer = None
     text_analyzer = None
 
-# 필요한 디렉토리 생성
-os.makedirs("generated_images", exist_ok=True)
+# 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
+}
 
 # 음성 분석 관련 함수들
 def calculate_baseline_features(audio_data):
+    """기존 음성 분석 함수 유지"""
     try:
         if isinstance(audio_data, tuple):
             sr, y = audio_data
@@ -160,6 +176,7 @@ def calculate_baseline_features(audio_data):
         return None
 
 def map_acoustic_to_emotion(features, baseline_features=None):
+    """기존 감정 매핑 함수 유지"""
     if features is None:
         return {
             "primary": "알 수 없음",
@@ -236,7 +253,47 @@ 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, "음성을 먼저 녹음해주세요.", "", "", ""
 
@@ -300,225 +357,19 @@ 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_gradio_interface():
-    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;
-            }
-            .container { 
-                padding: 10px !important; 
-                overflow-x: hidden !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;
-            }
-        }
-        
-        /* 전반적인 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;
-        }
-    """
-    
-    with gr.Blocks(
-        theme=gr.themes.Soft(),
-        css=css,
-        analytics_enabled=False,
-        title="디지털 굿판"
-    ) as demo:
-        demo = create_interface()
-        return demo
-
-# 실행 코드 수정
-if __name__ == "__main__":
-    # 필요한 디렉토리 생성
-    for directory in ['static/icons', 'assets', 'templates', 'data', 'generated_images']:
-        os.makedirs(directory, exist_ok=True)
-
-    # PWA 파일 존재 확인 및 생성 (기존 코드 유지)
-
-    # Gradio 앱 생성
-    demo = create_gradio_interface()
-    
-    # Flask 앱에 Gradio 마운트
-    app = gr.mount_gradio_app(app, demo, path="/gradio")
-    
-    # Flask 서버 실행
-    app.run(
-        host="0.0.0.0",
-        port=7860,
-        debug=True
-    )
-
-# Gradio 앱 생성
-demo = create_gradio_interface()
-
-# Gradio 앱을 Flask에 마운트
-app = gr.mount_gradio_app(app, demo, path="/")
-
-
-
 def create_interface():
-    db = SimpleDB()
+    """Gradio 인터페이스 생성"""
+    wish_archive = WishArchive()
     
     initial_state = {
         "user_name": "",
         "baseline_features": None,
-        "reflections": [],
-        "wish": None,
-        "final_prompt": "",
-        "image_path": None,
-        "current_tab": 0
+        "current_tab": 0,
+        "last_emotion": None,
+        "analysis_complete": False
     }
 
-    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:
+    with gr.Blocks(theme=gr.themes.Soft(), css=GRADIO_CSS, analytics_enabled=False, title="디지털 굿판") as app:
         state = gr.State(value=initial_state)
         
         gr.Markdown("# 디지털 굿판")
@@ -540,26 +391,37 @@ 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("'명짐 복짐 짊어지고 안가태평하시기를 비도발원 축원 드립니다'")
-                    baseline_audio = gr.Audio(
-                        label="축원 문장 녹음하기",
-                        sources=["microphone"],
-                        type="numpy",
-                        streaming=False
-                    )
-                    set_baseline_btn = gr.Button("축원 마치기", variant="primary")
-                    baseline_status = 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
+                        )
 
                 # 4단계: 굿판 입장 안내
                 entry_guide_section = gr.Column(visible=False)
@@ -572,6 +434,7 @@ def create_interface():
                     """)
                     enter_btn = gr.Button("청신 의식 시작하기", variant="primary")
 
+            # 청신 탭
             with gr.TabItem("청신") as tab_listen:
                 gr.Markdown("## 청신 - 소리로 정화하기")
                 gr.Markdown("""
@@ -590,21 +453,6 @@ 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:
@@ -617,6 +465,10 @@ 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")
@@ -637,18 +489,7 @@ def create_interface():
 
             # 송신 탭
             with gr.TabItem("송신") as tab_send:
-                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("## 송신 - 소지(소원지)를 남겨주세요")
                 gr.Markdown("## 온천천에 전하고 싶은 소원을 남겨주세요")
                 final_reflection = gr.Textbox(
                     label="소원",
@@ -657,254 +498,229 @@ def create_interface():
                 )
                 save_final_btn = gr.Button("소원 전하기", variant="primary")
                 gr.Markdown("""
-💫 여러분의 소원은 11월 25일 온천천 벽면에 설치될 소원나무에 전시될 예정입니다.
-따뜻한 마음을 담아 작성해주세요.
-""")
+                💫 여러분의 소원은 11월 25일 온천천 벽면에 설치될 소원나무에 전시될 예정입니다.
+                따뜻한 마음을 담아 작성해주세요.
+                """)
                 wishes_display = gr.Dataframe(
                     headers=["시간", "소원", "이름"],
                     label="기록된 소원들",
-                    value=[],
+                    value=wish_archive.get_display_data(),
                     interactive=False,
                     wrap=True
                 )
 
         # 이벤트 핸들러들
-        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, "음성을 먼저 녹음해주세요.", gr.update(visible=True), gr.update(visible=False)
-            
-            try:
-                # ... (기존 음성 처리 코드)
-                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):
+        def handle_baseline_recording(audio, 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, []
+                return {
+                    "state": state,
+                    "analysis": gr.update(visible=True, value="음성을 먼저 녹음해주세요."),
+                    "results": gr.update(visible=False),
+                    "status": "",
+                    "button": gr.update(visible=False)
+                }
             
             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})
+                # 분석 중임을 표시
+                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, 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", "익명")
+                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)
+                    }
                 
-                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})
+                # 분석 성공 시
+                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)
+                }
                 
-                return state, display_data
-        
             except Exception as e:
-                print(f"Error saving reflection: {e}")
-                return state, []
-
+                return {
+                    "state": state,
+                    "analysis": gr.update(visible=True, value=f"오류가 발생했습니다: {str(e)}"),
+                    "results": gr.update(visible=False),
+                    "status": "",
+                    "button": gr.update(visible=False)
+                }
 
-        def handle_save_wish(text, state):
-            if not text.strip():
-                return "소원을 입력해주세요.", []
+        def handle_blessing_complete(state):
+            """축원 완료 처리"""
+            if not state.get("analysis_complete"):
+                return state, "음성 분석이 완료되지 않았습니다.", gr.update(visible=True), gr.update(visible=False)
             
-            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 "오류가 발생했습니다.", []
+            return state, "축원이 완료되었습니다.", gr.update(visible=False), gr.update(visible=True)
 
         # 이벤트 연결
-        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]
+        baseline_audio.change(
+            fn=handle_baseline_recording,
+            inputs=[baseline_audio, state],
+            outputs=[
+                state,
+                analysis_status,
+                baseline_results,
+                baseline_status,
+                set_baseline_btn
+            ]
         )
 
         set_baseline_btn.click(
             fn=handle_blessing_complete,
-            inputs=[baseline_audio, state],
+            inputs=[state],
             outputs=[state, baseline_status, blessing_section, entry_guide_section]
         )
 
-        enter_btn.click(
-            fn=handle_enter,
-            outputs=[tabs]
-        )
-
-        play_music_btn.click(
-            fn=lambda: "assets/main_music.mp3",
-            outputs=[audio]
-        )
-
-        save_btn.click(
-            fn=save_reflection_fixed,  # handle_save_reflection -> save_reflection_fixed
-            inputs=[reflection_input, state],
-            outputs=[state, reflections_display]
-        )
-
-        clear_btn.click(
-            fn=lambda: None,
-            outputs=[voice_input]
-        )
-
-        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 인터페이스 생성 함수
-def create_gradio_interface():
-    demo = create_interface()
-    return demo
-
-# Flask 라우트 추가
-@app.route('/')
-def root():
-    return render_template('index.html')
-
-@app.route('/manifest.json')
-def manifest():
-    return send_from_directory('static', 'manifest.json')
-
-@app.route('/service-worker.js')
-def service_worker():
-    return send_from_directory('static', 'service-worker.js')
-
-@app.route('/static/icons/<path:path>')
-def serve_icons(path):
-    return send_from_directory('static/icons', path)
-
-@app.route('/assets/<path:path>')
-def serve_custom_assets(path):
-    return send_from_directory('assets', path)
-
-if __name__ == "__main__":
-    # 필요한 디렉토리 생성
-    for directory in ['static/icons', 'assets', 'templates']:
-        os.makedirs(directory, exist_ok=True)
-
-    # PWA 파일 존재 확인 및 생성
-    if not os.path.exists('templates/index.html'):
-        with open('templates/index.html', 'w', encoding='utf-8') as f:
+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>
@@ -955,15 +771,23 @@ if __name__ == "__main__":
 </body>
 </html>''')
 
+if __name__ == "__main__":
+    # 필요한 디렉토리 생성
+    for directory in ['static/icons', 'assets', 'templates', 'data', 'generated_images']:
+        os.makedirs(directory, exist_ok=True)
+
+    # PWA 파일 생성
+    create_pwa_files()
+
     # Gradio 앱 생성
-    demo = create_gradio_interface()
+    demo = create_interface()
     
     # Flask 앱에 Gradio 마운트
-    app = gr.mount_gradio_app(app, demo, path="/gradio")
+    app = gr.mount_gradio_app(app, demo, path="/")
     
     # Flask 서버 실행
     app.run(
         host="0.0.0.0",
         port=7860,
         debug=True
-    )
+    )