Update app.py

app.py

@@ -6,8 +6,6 @@ from datetime import datetime
 import os
 import requests
 import json
-import time
-import threading
 from dotenv import load_dotenv
 
 # 환경변수 로드
@@ -116,8 +114,8 @@ def calculate_baseline_features(audio_data):
 
         features = {
             "energy": float(np.mean(librosa.feature.rms(y=y))),
-            "tempo": float(librosa.beat.tempo(y, sr=sr)[0]),
-            "pitch": float(np.mean(librosa.feature.zero_crossing_rate(y))),
+            "tempo": float(librosa.beat.tempo(y=y, sr=sr)[0]),
+            "pitch": float(np.mean(librosa.feature.zero_crossing_rate(y=y))),
             "volume": float(np.mean(np.abs(y))),
             "mfcc": librosa.feature.mfcc(y=y, sr=sr, n_mfcc=13).mean(axis=1).tolist()
         }
@@ -148,9 +146,12 @@ def map_acoustic_to_emotion(features, baseline_features=None):
     pitch_norm = min(features["pitch"] * 2, 1)
 
     if baseline_features:
-        energy_norm = (features["energy"] / baseline_features["energy"]) * 50
-        tempo_norm = (features["tempo"] / baseline_features["tempo"])
-        pitch_norm = (features["pitch"] / baseline_features["pitch"])
+        if baseline_features["energy"] == 0 or baseline_features["tempo"] == 0 or baseline_features["pitch"] == 0:
+            print("Invalid baseline features")
+        else:
+            energy_norm = (features["energy"] / baseline_features["energy"]) * 50
+            tempo_norm = (features["tempo"] / baseline_features["tempo"])
+            pitch_norm = (features["pitch"] / baseline_features["pitch"])
 
     emotions = {
         "primary": "",
@@ -218,7 +219,7 @@ def analyze_voice(audio_data, state):
             return state, "오디오 형식을 지원하지 않습니다.", "", "", ""
 
         # 음향학적 특성 분석
-        acoustic_features = calculate_baseline_features(audio_data)
+        acoustic_features = calculate_baseline_features((sr, y))
         if acoustic_features is None:
             return state, "음성 분석에 실패했습니다.", "", "", ""
 
@@ -294,7 +295,7 @@ def generate_image_from_prompt(prompt):
     """이미지 생성 함수"""
     if not prompt:
         print("No prompt provided")
-        return None, None
+        return None
 
     try:
         response = requests.post(
@@ -311,18 +312,15 @@ def generate_image_from_prompt(prompt):
         )
 
         if response.status_code == 200:
-            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-            image_path = f"generated_images/{timestamp}.png"
-            with open(image_path, "wb") as f:
-                f.write(response.content)
-            return response.content, image_path
+            image_content = response.content
+            return image_content
         else:
             print(f"Error: {response.status_code}")
             print(f"Response: {response.text}")
-            return None, None
+            return None
     except Exception as e:
         print(f"Error generating image: {str(e)}")
-        return None, None
+        return None
 
 def save_reflection(text, state):
     """감상 저장"""
@@ -331,9 +329,13 @@ def save_reflection(text, state):
 
     try:
         current_time = datetime.now().strftime("%H:%M:%S")
-        sentiment = text_analyzer(text)[0] if text_analyzer else {"label": "unknown", "score": 0.0}
-        new_reflection = [current_time, text, f"{sentiment['label']} ({sentiment['score']:.2f})"]
+        if text_analyzer:
+            sentiment = text_analyzer(text)[0]
+            sentiment_text = f"{sentiment['label']} ({sentiment['score']:.2f})"
+        else:
+            sentiment_text = "분석 불가"
 
+        new_reflection = [current_time, text, sentiment_text]
         reflections = state.get("reflections", [])
         reflections.append(new_reflection)
         state = {**state, "reflections": reflections}
@@ -351,34 +353,36 @@ def create_interface():
         "reflections": [],
         "wish": None,
         "final_prompt": "",
-        "image_path": None
+        "image_path": None,
+        "current_tab": 0  # 탭 상태 추가
     }
 
     with gr.Blocks(theme=gr.themes.Soft()) as app:
         state = gr.State(value=initial_state)
         
         gr.Markdown("# 디지털 굿판")
+        gr.Markdown("""
+1. 입장 → 2. 축원(기준 설정) → 3. 청신 → 4. 기원 → 5. 송신 
+순서대로 진행해주세요.
+""")
 
-        with gr.Tabs(selected=0) as tabs:
+        with gr.Tabs() as tabs:
             with gr.TabItem("입장") as tab_entrance:
-                name_display = gr.Markdown(WELCOME_MESSAGE)  # worldview_display 대신 하나의 Markdown 사용
+                gr.Markdown(WELCOME_MESSAGE)
                 name_input = gr.Textbox(
                     label="이름을 알려주세요",
                     placeholder="이름을 입력해주세요",
                     interactive=True
                 )
-                start_btn = gr.Button("여정 시작하기", variant="primary")  
-                
-                
-# variant 추가
+                worldview_display = gr.Markdown(visible=False)
+                start_btn = gr.Button("여정 시작하기", variant="primary")
 
-            with gr.TabItem("기준 설정") as tab_baseline:
-                gr.Markdown("""### 축원의 문장을 평온한 마음으로 읽어주세요""")
+            with gr.TabItem("축원") as tab_baseline:
+                gr.Markdown("### 축원의 문장을 평온한 마음으로 읽어주세요")
                 gr.Markdown("'당신의 건강과 행복이 늘 가득하기를'")
                 baseline_audio = gr.Audio(
                     label="축원 문장 녹음하기",
-                    sources="microphone",  # source -> sources
-                    streaming=False,
+                    source="microphone",
                     type="numpy"
                 )
                 set_baseline_btn = gr.Button("기준점 설정 완료", variant="primary")
@@ -389,26 +393,26 @@ def create_interface():
                 play_music_btn = gr.Button("온천천의 소리 듣기", variant="secondary")
                 with gr.Row():
                     audio = gr.Audio(
-                        value="oncheoncheon_sound.wav",
+                        value="assets/main_music.mp3",  # 음악 파일 경로 수정
                         type="filepath",
                         label="온천천의 소리",
                         interactive=False,
-                        show_download_button=True,  # 다운로드 버튼 추가
+                        show_download_button=True,
                         visible=True
                     )
                     with gr.Column():
                         reflection_input = gr.Textbox(
                             label="지금 이 순간의 감상을 자유롭게 적어보세요",
                             lines=3,
-                            max_lines=5  # 최대 라인 수 지정
+                            max_lines=5
                         )
                         save_btn = gr.Button("감상 저장하기", variant="secondary")
                         reflections_display = gr.Dataframe(
                             headers=["시간", "감상", "감정 분석"],
                             label="기록된 감상들",
-                            value=[[]],
+                            value=[],
                             interactive=False,
-                            wrap=True  # 긴 텍스트 wrap 처리
+                            wrap=True
                         )
 
             with gr.TabItem("기원") as tab_wish:
@@ -417,8 +421,7 @@ def create_interface():
                     with gr.Column():
                         voice_input = gr.Audio(
                             label="소원을 나누고 싶은 마음을 말해주세요",
-                            sources="microphone",
-                            streaming=False,
+                            source="microphone",
                             type="numpy"
                         )
                         with gr.Row():
@@ -449,59 +452,125 @@ def create_interface():
                 generate_btn = gr.Button("마음의 그림 그리기", variant="primary")
                 result_image = gr.Image(
                     label="생성된 이미지",
-                    show_download_button=True  # 다운로드 버튼 추가
+                    show_download_button=True
                 )
-
-                gr.Markdown("## 마지막 감상을 남겨주세요")
+            
+                gr.Markdown("## 온천천에 전하고 싶은 소원을 남겨주세요")
                 final_reflection = gr.Textbox(
-                    label="마지막 감상",
-                    placeholder="한 줄로 남겨주세요...",
+                    label="소원",
+                    placeholder="당신의 소원을 한 줄로 남겨주세요...",
                     max_lines=3
                 )
-                save_final_btn = gr.Button("감상 남기기", variant="primary")
-                save_final_status = gr.Markdown("")
+                save_final_btn = gr.Button("소원 전하기", variant="primary")
+                gr.Markdown("""
+💫 여러분의 소원은 11월 25일 온천천 벽면에 설치될 소원나무에 전시될 예정입니다.
+따뜻한 마음을 담아 작성해주세요.
+""")
+                wishes_display = gr.Dataframe(
+                    headers=["시간", "소원", "감정 분석"],
+                    label="기록된 소원들",
+                    value=[],
+                    interactive=False,
+                    wrap=True
+                )
 
-        # 이벤트 연결 - gr.on 사용
+        # 이벤트 연결
         def handle_start(name, current_state):
             if not name.strip():
-                return "이름을 입력해주세요", gr.update(selected=0), current_state
+                return (
+                    "이름을 입력해주세요", 
+                    gr.update(visible=False), 
+                    current_state
+                )
             current_state = {**current_state, "user_name": name}
-            return WORLDVIEW_MESSAGE, gr.update(selected=1), current_state
-
-        def handle_baseline(audio_data, current_state):
+            return (
+                WORLDVIEW_MESSAGE,
+                gr.update(visible=True),
+                current_state
+            )
+
+        def handle_baseline(audio, current_state):
+            if audio is None:
+                return current_state, "음성을 먼저 녹음해주세요."
+            
             try:
-                features = calculate_baseline_features(audio_data)
+                sr, y = audio
+                features = calculate_baseline_features((sr, y))
                 if features:
                     current_state = {**current_state, "baseline_features": features}
-                    return current_state, "기준점이 설정되었습니다."
-                return current_state, "기준점 설정에 실패했습니다."
+                    return current_state, "기준점이 설정되었습니다. 다음 단계로 진행해주세요."
+                return current_state, "기준점 설정에 실패했습니다. 다시 시도해주세요."
             except Exception as e:
-                return current_state, f"오류 발생: {str(e)}"
+                print(f"Baseline error: {str(e)}")
+                return current_state, "오류가 발생했습니다. 다시 시도해주세요."
 
-        def handle_analysis(audio_data, current_state):
+        # 음악 재생 이벤트 핸들러 수정
+        def play_music():
             try:
-                result = analyze_voice(audio_data, current_state)
-                if isinstance(result, tuple) and len(result) == 5:
-                    return result
-                return current_state, "분석 실패", "", "", ""
+                return "assets/main_music.mp3"
             except Exception as e:
-                return current_state, f"오류 발생: {str(e)}", "", "", ""
+                print(f"Error playing music: {e}")
+                return None
+
+        def handle_analysis(audio, current_state):
+            state, text, voice_result, text_result, prompt = analyze_voice(audio, current_state)
+            return state, text, voice_result, text_result, prompt
 
         def handle_image_generation(prompt):
-            if not prompt:
-                return None
+            image_content = generate_image_from_prompt(prompt)
+            return image_content
+
+        def save_reflection_fixed(text, state):
+            if not text.strip():
+                return state, []
+            
             try:
-                image_data = generate_image_from_prompt(prompt)
-                return image_data[0] if image_data else None
+                current_time = datetime.now().strftime("%H:%M:%S")
+                if text_analyzer:
+                    sentiment = text_analyzer(text)[0]
+                    sentiment_text = f"{sentiment['label']} ({sentiment['score']:.2f})"
+                else:
+                    sentiment_text = "분석 불가"
+
+                new_reflection = [current_time, text, sentiment_text]
+                reflections = state.get("reflections", [])
+                reflections.append(new_reflection)
+                state = {**state, "reflections": reflections}
+                return state, reflections
             except Exception as e:
-                print(f"Image generation error: {str(e)}")
-                return None
+                print(f"Error saving reflection: {e}")
+                return state, state.get("reflections", [])
 
-        # 이벤트 연결
+        def save_wish(text, state):
+            if not text.strip():
+                return "소원을 입력해주세요.", []
+            
+            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})"
+                else:
+                    sentiment_text = "분석 불가"
+
+                new_wish = [current_time, text, sentiment_text]
+                wishes = state.get("wishes", [])
+                wishes.append(new_wish)
+                state = {**state, "wishes": wishes}
+
+                # DB에 저장
+                db.save_wish(state.get("user_name", "익명"), text)
+
+                return "소원이 저장되었습니다.", wishes
+            except Exception as e:
+                print(f"Error saving wish: {e}")
+                return "오류가 발생했습니다.", state.get("wishes", [])
+
+        # 버튼 이벤트 연결
         start_btn.click(
             fn=handle_start,
             inputs=[name_input, state],
-            outputs=[name_display, tabs, state]
+            outputs=[worldview_display, worldview_display, state]
         )
 
         set_baseline_btn.click(
@@ -510,6 +579,11 @@ def create_interface():
             outputs=[state, baseline_status]
         )
 
+        play_music_btn.click(
+            fn=play_music,
+            outputs=[audio]
+        )
+
         analyze_btn.click(
             fn=handle_analysis,
             inputs=[voice_input, state],
@@ -522,15 +596,16 @@ def create_interface():
             outputs=[result_image]
         )
 
-        save_final_btn.click(
-            fn=lambda t, s: "감상이 저장되었습니다." if db.save_wish(s.get("user_name", "익명"), t) else "저장 실패",
-            inputs=[final_reflection, state],
-            outputs=[save_final_status]
+        save_btn.click(
+            fn=save_reflection_fixed,
+            inputs=[reflection_input, state],
+            outputs=[state, reflections_display]
         )
 
-        play_music_btn.click(
-            fn=lambda: "oncheoncheon_sound.wav",
-            outputs=[audio]
+        save_final_btn.click(
+            fn=save_wish,
+            inputs=[final_reflection, state],
+            outputs=[baseline_status, wishes_display]
         )
 
     return app
@@ -541,4 +616,4 @@ if __name__ == "__main__":
         debug=True,
         server_name="0.0.0.0",
         server_port=7860
-    )
+    )