Update app.py

app.py

@@ -53,18 +53,12 @@ def serve_wishes(path):
 
 
 class SimpleDB:
-    """데이터 저장 및 관리 클래스"""
-    
-    def __init__(self, wishes_path="data/wishes.json"):
-        """
-        영구 저장이 필요한 소원 데이터만 파일로 관리
-        Args:
-            wishes_path: 소원 데이터 저장 경로
-        """
+    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(os.path.dirname(wishes_path), exist_ok=True)
+        os.makedirs('data', exist_ok=True)
+        self.reflections = self._load_json(reflections_path)
         self.wishes = self._load_json(wishes_path)
-        self.session_reflections = []  # 임시 메모리에만 저장되는 감상
 
     def _load_json(self, file_path):
         if not os.path.exists(file_path):
@@ -77,28 +71,29 @@ class SimpleDB:
             print(f"Error loading {file_path}: {e}")
             return []
 
-    def save_reflection(self, name, reflection, sentiment):
-        """
-        감상은 세션 메모리에만 저장
-        """
+    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": datetime.now().strftime("%H:%M:%S"),
+            "timestamp": timestamp,
             "name": name,
             "reflection": reflection,
             "sentiment": sentiment
         }
-        self.session_reflections.append(reflection_data)
+        
+        self.reflections.append(reflection_data)
+        self._save_json(self.reflections_path, self.reflections)
         return True
 
-    def save_wish(self, name, wish, emotion_data=None):
-        """
-        소원은 영구 저장
-        """
+    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 = {
-            "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
             "name": name,
             "wish": wish,
-            "emotion": emotion_data
+            "emotion": emotion_data,
+            "timestamp": timestamp
         }
         self.wishes.append(wish_data)
         self._save_json(self.wishes_path, self.wishes)
@@ -113,17 +108,11 @@ class SimpleDB:
             print(f"Error saving to {file_path}: {e}")
             return False
 
-    def get_session_reflections(self):
-        """현재 세션의 감상만 반환"""
-        return self.session_reflections
+    def get_all_reflections(self):
+        return sorted(self.reflections, key=lambda x: x["timestamp"], reverse=True)
 
     def get_all_wishes(self):
-        """저장된 모든 소원 반환"""
-        return sorted(self.wishes, key=lambda x: x["timestamp"], reverse=True)
-
-    def clear_session_data(self):
-        """세션 데이터 초기화"""
-        self.session_reflections = []
+        return self.wishes
 
 # API 설정
 HF_API_TOKEN = os.getenv("roots", "")
@@ -261,63 +250,59 @@ def analyze_voice(audio_data, state):
         return state, "음성을 먼저 녹음해주세요.", "", "", ""
 
     try:
-        sr, y = audio_data
-        y = y.astype(np.float32)
-        
-        if len(y) == 0:
-            return state, "음성이 감지되지 않았습니다.", "", "", ""
-
-        acoustic_features = calculate_baseline_features((sr, y))
-        if acoustic_features is None:
+        features = calculate_baseline_features(audio_data)
+        if features is None:
             return state, "음성 분석에 실패했습니다.", "", "", ""
 
-        # 음성 인식
+        # 기준점과 비교하여 감정 분석
+        voice_emotion = map_acoustic_to_emotion(
+            features, 
+            state.get("baseline_features")  # 기준점 전달
+        )
+        
+        # 음성 인식 (필요한 경우)
+        text = "음성이 인식되었습니다."
         if speech_recognizer:
             try:
+                sr, y = audio_data
                 transcription = speech_recognizer({"sampling_rate": sr, "raw": y.astype(np.float32)})
                 text = transcription["text"]
             except Exception as e:
                 print(f"Speech recognition error: {e}")
-                text = "음성 인식 실패"
-        else:
-            text = "음성 인식 모델을 불러올 수 없습니다."
-
-        # 음성 감정 분석
-        voice_emotion = map_acoustic_to_emotion(acoustic_features, state.get("baseline_features"))
-
-        # 텍스트 감정 분석
-        if text_analyzer and text:
-            try:
-                text_sentiment = text_analyzer(text)[0]
-                text_result = f"텍스트 감정 분석: {text_sentiment['label']} (점수: {text_sentiment['score']:.2f})"
-            except Exception as e:
-                print(f"Text analysis error: {e}")
-                text_sentiment = {"label": "unknown", "score": 0.0}
-                text_result = "텍스트 감정 분석 실패"
-        else:
-            text_sentiment = {"label": "unknown", "score": 0.0}
-            text_result = "텍스트 감정 분석을 수행할 수 없습니다."
-
-        voice_result = (
-            f"음성 감정: {voice_emotion['primary']} "
-            f"(강도: {voice_emotion['intensity']:.1f}%, 신뢰도: {voice_emotion['confidence']:.2f})\n"
-            f"특징: {', '.join(voice_emotion['characteristics'])}\n"
-            f"상세 분석:\n"
-            f"- 에너지 레벨: {voice_emotion['details']['energy_level']}\n"
-            f"- 말하기 속도: {voice_emotion['details']['speech_rate']}\n"
-            f"- 음높이 변화: {voice_emotion['details']['pitch_variation']}\n"
-            f"- 음성 크기: {voice_emotion['details']['voice_volume']}"
-        )
+                text = "음성 인식은 실패했으나, 감정 분석은 진행합니다."
+
+        # 감정 상태 변화 분석
+        baseline_emotion = state.get("baseline_emotion", {})
+        emotion_change = ""
+        if baseline_emotion:
+            baseline_intensity = baseline_emotion.get("intensity", 0)
+            current_intensity = voice_emotion["intensity"]
+            intensity_change = current_intensity - baseline_intensity
+            
+            emotion_change = f"""
+            💫 기준 상태와의 비교:
+            • 감정 변화: {baseline_emotion['primary']} → {voice_emotion['primary']}
+            • 강도 변화: {intensity_change:+.1f}%
+            """
+
+        voice_result = f"""
+        🎭 현재 감정 상태:
+        • 주요 감정: {voice_emotion['primary']}
+        • 감정 강도: {voice_emotion['intensity']:.1f}%
+        • 특징: {', '.join(voice_emotion['characteristics'])}
+        
+        {emotion_change}
+        """
 
         # 프롬프트 생성
-        prompt = generate_detailed_prompt(text, voice_emotion, text_sentiment)
+        prompt = generate_detailed_prompt(text, voice_emotion, {"label": "neutral", "score": 0.5})
         state = {**state, "final_prompt": prompt}
 
-        return state, text, voice_result, text_result, prompt
+        return state, text, voice_result, "", prompt
 
     except Exception as e:
         print(f"Error in analyze_voice: {str(e)}")
-        return state, f"오류 발생: {str(e)}", "", "", ""
+        return state, f"오류가 발생했습니다: {str(e)}", "", "", ""
 
 
 def generate_detailed_prompt(text, emotions, text_sentiment):
@@ -628,21 +613,6 @@ def create_interface():
         .gradio-button:active {
             transform: scale(0.98);
         }
-        .loader {
-            width: 48px;
-            height: 48px;
-            border: 5px solid #FFF;
-            border-bottom-color: #FF3D00;
-            border-radius: 50%;
-            display: inline-block;
-            box-sizing: border-box;
-            animation: rotation 1s linear infinite;
-        }
-    
-        @keyframes rotation {
-            0% { transform: rotate(0deg); }
-            100% { transform: rotate(360deg); }
-        }
     """
 
     with gr.Blocks(theme=gr.themes.Soft(), css=css) as app:
@@ -667,13 +637,13 @@ 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단계: 축원 의식
                 blessing_section = gr.Column(visible=False)
                 with blessing_section:
@@ -688,146 +658,88 @@ def create_interface():
                             streaming=False
                         )
                         set_baseline_btn = gr.Button("축원 마치기", variant="primary")
-                        
-                    with gr.Column() as analysis_section:
-                        analysis_status = gr.Markdown("")
-                        loading_icon = gr.HTML("""
-                            <div style="display:flex;justify-content:center;align-items:center;height:50px;overflow:hidden;">
-                                <div class="loader" style="width:30px;height:30px;"></div>
-                            </div>
-                        """)
-                        voice_features = gr.Textbox(
-                            label="음성 특성 분석",
-                            interactive=False,
-                            visible=False
-                        )
-                        text_sentiment = gr.Textbox(
-                            label="기본 감정 상태",
-                            interactive=False,
-                            visible=False
-                        )
-                        analysis_result = gr.Markdown(visible=False)
-                        next_button = gr.Button(
-                            "다음 단계로",
-                            variant="primary",
-                            visible=False
-                        )
-                
-                def next_section():
-                    """다음 단계로 이동하는 핸들러"""
-                    return (
-                        gr.update(visible=False),  # blessing_section
-                        gr.update(visible=True)    # entry_guide_section
-                    )
+                    
+                    # 분석 결과 표시 영역
+                    baseline_status = gr.Markdown("")  # 상태 메시지
+                    analysis_results = gr.Markdown(visible=False)  # 분석 결과
                 
                 def handle_blessing_complete(audio, state):
-                    """축원 완료 처리 핸들러"""
+                    """축원 완료 및 기준점 설정 핸들러"""
                     if audio is None:
                         return (
-                            state,                          
+                            state,
                             "음성을 먼저 녹음해주세요.",
-                            gr.update(visible=False),     # loading_icon
-                            gr.update(visible=False),     # voice_features
-                            gr.update(visible=False),     # text_sentiment
-                            gr.update(visible=False),     # analysis_result
-                            gr.update(visible=False),     # next_button
-                            gr.update(visible=True),      # blessing_section
-                            gr.update(visible=False)      # entry_guide_section
+                            gr.update(visible=True),
+                            gr.update(visible=False)
                         )
                     
                     try:
+                        # 기준점 설정을 위한 음성 분석
                         features = calculate_baseline_features(audio)
                         if features is None:
                             return (
                                 state,
-                                "❌ 음성 분석에 실패했습니다. 다시 시도해주세요.",
-                                gr.update(visible=False),
-                                gr.update(visible=False),
-                                gr.update(visible=False),
-                                gr.update(visible=False),
-                                gr.update(visible=False),
+                                "음성 분석에 실패했습니다. 다시 시도해주세요.",
                                 gr.update(visible=True),
                                 gr.update(visible=False)
                             )
-                        
+                
+                        # 기본 감정 상태 분석
                         baseline_emotion = map_acoustic_to_emotion(features)
                         
-                        voice_features_text = f"""
-                        🎭 음성 특성 분석:
-                        • 에너지 레벨: {baseline_emotion['details']['energy_level']}
-                        • 말하기 속도: {baseline_emotion['details']['speech_rate']}
-                        • 음높이 변화: {baseline_emotion['details']['pitch_variation']}
-                        • 음성 크기: {baseline_emotion['details']['voice_volume']}
-                        """
+                        # 상태 업데이트
+                        new_state = safe_state_update(state, {
+                            "baseline_features": features,
+                            "baseline_emotion": baseline_emotion
+                        })
+                
+                        # 분석 결과 표시
+                        result_text = f"""
+                        ✨ 축원이 완료되었습니다.
                         
-                        sentiment_text = f"""
-                        💫 기본 감정 상태:
+                        🎭 기본 감정 상태:
                         • 주요 감정: {baseline_emotion['primary']}
                         • 감정 강도: {baseline_emotion['intensity']:.1f}%
                         • 특징: {', '.join(baseline_emotion['characteristics'])}
-                        """
                         
-                        analysis_text = """
-                        ✨ 기준 음성 분석이 완료되었습니다.
-                        결과를 확인하신 후 아래의 '다음 단계로' 버튼을 눌러주세요.
+                        다음 단계로 진행해주세요.
                         """
                         
-                        new_state = {
-                            **state,
-                            "baseline_features": features,
-                            "baseline_emotion": baseline_emotion,
-                            "analysis_complete": True
-                        }
-                        
                         return (
                             new_state,
-                            "✅ 축원이 완료되었습니다.",
-                            gr.update(visible=False),                    # loading_icon
-                            gr.update(value=voice_features_text, visible=True),  # voice_features
-                            gr.update(value=sentiment_text, visible=True),       # text_sentiment
-                            gr.update(value=analysis_text, visible=True),        # analysis_result
-                            gr.update(visible=True),                     # next_button
-                            gr.update(visible=True),                     # blessing_section
-                            gr.update(visible=False)                     # entry_guide_section
+                            result_text,
+                            gr.update(visible=False),
+                            gr.update(visible=True)
                         )
-                        
+                
                     except Exception as e:
                         print(f"Error in handle_blessing_complete: {str(e)}")
                         return (
                             state,
-                            f"❌ 오류가 발생했습니다. 다시 시도해주세요.",
-                            gr.update(visible=False),
-                            gr.update(visible=False),
-                            gr.update(visible=False),
-                            gr.update(visible=False),
-                            gr.update(visible=False),
+                            f"오류가 발생했습니다. 다시 시도해주세요.",
                             gr.update(visible=True),
                             gr.update(visible=False)
                         )
-                                        
+
                 # 4단계: 굿판 입장 안내
                 entry_guide_section = gr.Column(visible=False)
                 with entry_guide_section:
                     gr.Markdown("## 굿판으로 입장하기")
-                    gr.Markdown(
-                        """
-                         * 청신 탭으로 이동해 주세요.
-                         * 부산광역시 동래구 온천장역에서 시작하면 더욱 깊은 경험을 시작할 수 있습니다.
-                         * (본격적인 경험을 시작하기에 앞서 이동을 권장드립니다)
-                         """
-                    )
+                    gr.Markdown("""
+                    * 청신 탭으로 이동해 주세요.
+                    * 부산광역시 동래구 온천장역에서 시작하면 더욱 깊은 경험을 시작할 수 있습니다.
+                    * (본격적인 경험을 시작하기에 앞서 이동을 권장드립니다)
+                    """)
                     enter_btn = gr.Button("청신 의식 시작하기", variant="primary")
 
             with gr.TabItem("청신") as tab_listen:
                 gr.Markdown("## 청신 - 소리로 정화하기")
-                gr.Markdown(
-                    """
-                    온천천의 소리를 들으며 마음을 정화해보세요.
-                    
-                    💫 이 앱은 온천천의 사운드스케이프를 녹음하여 제작되었으며,
-                    온천천 온천장역에서 장전역까지 걸으며 더 깊은 체험이 가능합니다.
-                    """
-                )
+                gr.Markdown("""
+                온천천의 소리를 들으며 마음을 정화해보세요.
+                
+                💫 이 앱은 온천천의 사운드스케이프를 녹음하여 제작되었으며,
+                온천천 온천장역에서 장전역까지 걸으며 더 깊은 체험이 가능합니다.
+                """)
                 play_music_btn = gr.Button("온천천의 소리 듣기", variant="secondary")
                 with gr.Row():
                     audio = gr.Audio(
@@ -908,7 +820,6 @@ def create_interface():
 💫 여러분의 소원은 11월 25일 온천천 벽면에 설치될 소원나무에 전시될 예정입니다.
 따뜻한 마음을 담아 작성해주세요.
 """)
-                status_message = gr.Markdown("") 
                 wishes_display = gr.Dataframe(
                     headers=["시간", "소원", "이름"],
                     label="기록된 소원들",
@@ -944,6 +855,21 @@ def create_interface():
                 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)  # 청신 탭으로 이동
 
@@ -1008,29 +934,31 @@ def create_interface():
                     sentiment_text = "분석 불가"
         
                 # DB에 저장
-                reflection_data = db.save_reflection(name, text, sentiment_text)
+                db.save_reflection(name, text, sentiment_text)
                 
-                # 현재 세션의 감상 데이터만 표시
+                # 화면에 표시할 데이터 형식으로 변환
                 display_data = []
-                session_reflections = state.get("reflections", [])
-                session_reflections.append([
-                    current_time,
-                    text,
-                    sentiment_text
-                ])
-                
+                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": session_reflections})
+                state = safe_state_update(state, {"reflections": display_data})
                 
-                return state, session_reflections  # 세션 데이터만 반환
-            
+                return state, display_data
+        
             except Exception as e:
                 print(f"Error saving reflection: {e}")
-                return state, state.get("reflections", [])
+                return state, []
+
 
         def handle_save_wish(text, state):
             if not text.strip():
-                return state, "소원을 입력해주세요.", []
+                return "소원을 입력해주세요.", []
             
             try:
                 name = state.get("user_name", "익명")
@@ -1040,11 +968,10 @@ def create_interface():
                     [wish["timestamp"], wish["wish"], wish["name"]]
                     for wish in wishes
                 ]
-                return state, "소원이 저장되었습니다.", wish_display_data
+                return "소원이 저장되었습니다.", wish_display_data
             except Exception as e:
                 print(f"Error saving wish: {e}")
-                return state, "오류가 발생했습니다.", []
-
+                return "오류가 발생했습니다.", []
 
         # 이벤트 연결
         name_submit_btn.click(
@@ -1057,29 +984,11 @@ def create_interface():
             fn=handle_continue,
             outputs=[story_section, welcome_section, blessing_section, entry_guide_section]
         )
-        
+
         set_baseline_btn.click(
             fn=handle_blessing_complete,
             inputs=[baseline_audio, state],
-            outputs=[
-                state,              # 상태
-                analysis_status,    # 상태 메시지
-                loading_icon,       # 로딩 아이콘
-                voice_features,     # 음성 특성 분석
-                text_sentiment,     # 기본 감정 상태
-                analysis_result,    # 최종 분석 결과
-                next_button,        # 다음 단계 버튼
-                blessing_section,   # 축원 섹션
-                entry_guide_section # 가이드 섹션
-            ]
-        )
-        
-        next_button.click(
-            fn=next_section,
-            outputs=[
-                blessing_section,
-                entry_guide_section
-            ]
+            outputs=[state, baseline_status, blessing_section, entry_guide_section]
         )
 
         enter_btn.click(
@@ -1118,10 +1027,8 @@ def create_interface():
         save_final_btn.click(
             fn=handle_save_wish,
             inputs=[final_reflection, state],
-            outputs=[state, status_message, wishes_display]
+            outputs=[baseline_status, wishes_display]
         )
-
-    
     return app
 
 if __name__ == "__main__":