Update app.py

app.py

@@ -1,4 +1,4 @@
-# Part 1/4 - Imports and Initial Setup
+# 라이브러리 임포트 및 초기 설정
 import gradio as gr
 import numpy as np
 import librosa
@@ -81,13 +81,20 @@ WORLDVIEW_MESSAGE = """
 온천천 온천장역에서 장전역까지 걸으며 더 깊은 체험이 가능합니다.
 """
 
-def calculate_baseline_features(audio_path):
+def calculate_baseline_features(audio_data):
     """기준점 음성 특성 분석"""
     try:
-        y, sr = librosa.load(audio_path, sr=16000)
+        if isinstance(audio_data, tuple):
+            sr, y = audio_data
+        elif isinstance(audio_data, str):
+            y, sr = librosa.load(audio_data, sr=16000)
+        else:
+            print("Unsupported audio format")
+            return None
+
         features = {
             "energy": float(np.mean(librosa.feature.rms(y=y))),
-            "tempo": float(librosa.beat.tempo(y)[0]),
+            "tempo": float(librosa.beat.tempo(y, sr=sr)[0]),
             "pitch": float(np.mean(librosa.feature.zero_crossing_rate(y))),
             "volume": float(np.mean(np.abs(y))),
             "mfcc": librosa.feature.mfcc(y=y, sr=sr, n_mfcc=13).mean(axis=1).tolist()
@@ -158,32 +165,38 @@ def map_acoustic_to_emotion(features, baseline_features=None):
 
     return emotions
 
-def analyze_voice(audio_path, state):
+def analyze_voice(audio_data, state):
     """통합 음성 분석"""
-    if audio_path is None:
+    if audio_data is None:
         return state, "음성을 먼저 녹음해주세요.", "", "", ""
-    
+
     try:
-        y, sr = librosa.load(audio_path, sr=16000)
-        
+        if isinstance(audio_data, tuple):
+            sr, y = audio_data
+        elif isinstance(audio_data, str):
+            y, sr = librosa.load(audio_data, sr=16000)
+        else:
+            print("Unsupported audio format")
+            return state, "오디오 형식을 지원하지 않습니다.", "", "", ""
+
         # 음향학적 특성 분석
         acoustic_features = {
             "energy": float(np.mean(librosa.feature.rms(y=y))),
-            "tempo": float(librosa.beat.tempo(y)[0]),
+            "tempo": float(librosa.beat.tempo(y, sr=sr)[0]),
             "pitch": float(np.mean(librosa.feature.zero_crossing_rate(y))),
             "volume": float(np.mean(np.abs(y)))
         }
 
         # 음성 감정 분석
         voice_emotion = map_acoustic_to_emotion(acoustic_features, state.get("baseline_features"))
-        
+
         # 음성 인식
-        transcription = speech_recognizer(y)
+        transcription = speech_recognizer(y, sampling_rate=sr)
         text = transcription["text"]
-        
+
         # 텍스트 감정 분석
         text_sentiment = text_analyzer(text)[0]
-        
+
         # 결과 포맷팅
         voice_result = (
             f"음성 감정: {voice_emotion['primary']} "
@@ -195,12 +208,15 @@ def analyze_voice(audio_path, state):
             f"- 음높이 변화: {voice_emotion['details']['pitch_variation']}\n"
             f"- 음성 크기: {voice_emotion['details']['voice_volume']}"
         )
-        
-        text_result = f"텍스트 감정 분석 (1-5): {text_sentiment['score']}"
-        
+
+        text_result = f"텍스트 감정 분석 (1-5): {text_sentiment['label']} (점수: {text_sentiment['score']:.2f})"
+
         # 프롬프트 생성
         prompt = generate_detailed_prompt(text, voice_emotion, text_sentiment)
-        
+
+        # 상태 업데이트
+        state = {**state, "final_prompt": prompt}
+
         return state, text, voice_result, text_result, prompt
     except Exception as e:
         return state, f"오류 발생: {str(e)}", "", "", ""
@@ -228,8 +244,8 @@ def generate_detailed_prompt(text, emotions, text_sentiment):
     prompt = f"한국 전통 민화 스타일의 추상화, {emotion_colors.get(emotions['primary'], '자연스러운 색상')} 기반. "
     prompt += f"{visual_style}로 표현된 {emotions['primary']}의 감정. "
     prompt += f"음성의 특징({', '.join(emotions['characteristics'])})을 화면의 동적 요소로 표현. "
-    prompt += f"발화 내용 '{text}'에서 느껴지는 감정(강도: {text_sentiment['score']}/5)을 은유적 이미지로 담아내기."
-    
+    prompt += f"발화 내용 '{text}'에서 느껴지는 감정({text_sentiment['label']} - 점수: {text_sentiment['score']:.2f})을 은유적 이미지로 담아내기."
+
     return prompt
 
 def generate_image_from_prompt(prompt):
@@ -238,8 +254,8 @@ def generate_image_from_prompt(prompt):
     try:
         if not prompt:
             print("No prompt provided")
-            return None
-        
+            return None, None
+
         response = requests.post(
             API_URL,
             headers=headers,
@@ -252,7 +268,7 @@ def generate_image_from_prompt(prompt):
                 }
             }
         )
-        
+
         if response.status_code == 200:
             print("Image generated successfully")
             timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
@@ -269,33 +285,27 @@ def generate_image_from_prompt(prompt):
         print(f"Error generating image: {str(e)}")
         return None, None
 
-def handle_image_timeout(result_image):
-    """이미지 자동 사라짐을 처리하는 함수"""
-    time.sleep(IMAGE_DISPLAY_TIME)
-    result_image.update(value=None)
-
 def save_reflection(text, state):
     """감상 저장"""
     if not text.strip():
-        return state, state["reflections"]
-    
+        return state, state.get("reflections", [])
+
     try:
         current_time = datetime.now().strftime("%H:%M:%S")
         sentiment = text_analyzer(text)[0]
         new_reflection = [current_time, text, f"{sentiment['label']} ({sentiment['score']:.2f})"]
-        
-        if "reflections" not in state:
-            state["reflections"] = []
-            
-        state["reflections"].append(new_reflection)
-        return state, state["reflections"]
+
+        reflections = state.get("reflections", [])
+        reflections.append(new_reflection)
+        state = {**state, "reflections": reflections}
+        return state, reflections
     except Exception as e:
         print(f"Error in save_reflection: {str(e)}")
         return state, []
 
 def create_interface():
     db = SimpleDB()
-    
+
     with gr.Blocks(theme=gr.themes.Soft()) as app:
         state = gr.State({
             "user_name": "",
@@ -324,7 +334,8 @@ def create_interface():
                 gr.Markdown("'당신의 건강과 행복이 늘 가득하기를'")
                 baseline_audio = gr.Audio(
                    label="축원 문장 녹음하기",
-                   sources=["microphone"]
+                   source="microphone",
+                   type="numpy"
                 )
                 set_baseline_btn = gr.Button("기준점 설정 완료")
                 baseline_status = gr.Markdown("")
@@ -334,7 +345,7 @@ def create_interface():
                 play_music_btn = gr.Button("온천천의 소리 듣기")
                 with gr.Row():
                     audio = gr.Audio(
-                        value=None,
+                        value="oncheoncheon_sound.wav",
                         type="filepath",
                         label="온천천의 소리",
                         interactive=False,
@@ -348,7 +359,10 @@ def create_interface():
                         save_btn = gr.Button("감상 저장하기")
                         reflections_display = gr.Dataframe(
                             headers=["시간", "감상", "감정 분석"],
-                            label="기록된 감상들"
+                            label="기록된 감상들",
+                            datatype=["str", "str", "str"],
+                            row_count=(0, "dynamic"),
+                            col_count=(3, "fixed")
                         )
 
             with gr.Tab("기원"):
@@ -357,11 +371,12 @@ def create_interface():
                     with gr.Column():
                         voice_input = gr.Audio(
                             label="소원을 나누고 싶은 마음을 말해주세요",
-                            sources=["microphone"]
+                            source="microphone",
+                            type="numpy"
                         )
                         clear_btn = gr.Button("녹음 지우기")
                         analyze_btn = gr.Button("소원 분석하기")
-                    
+
                     with gr.Column():
                         transcribed_text = gr.Textbox(label="인식된 텍스트")
                         voice_emotion = gr.Textbox(label="음성 감정 분석")
@@ -376,40 +391,28 @@ def create_interface():
                 )
                 generate_btn = gr.Button("마음의 그림 그리기")
                 result_image = gr.Image(label="생성된 이미지")
-                
+
                 gr.Markdown("## 마지막 감상을 남겨주세요")
                 final_reflection = gr.Textbox(
                     label="마지막 감상",
                     placeholder="한 줄로 남겨주세요..."
                 )
                 save_final_btn = gr.Button("감상 남기기")
-
-        def delayed_image_clear():
-            time.sleep(IMAGE_DISPLAY_TIME)
-            return gr.update(value=None)
-
-        def on_image_generated(prompt):
-            image_content = generate_image_from_prompt(prompt)
-            if image_content:
-                # Start a timer to clear the image
-                timer = threading.Timer(IMAGE_DISPLAY_TIME, lambda: result_image.update(value=None))
-                timer.start()
-                return image_content
-            return None
+                save_final_status = gr.Markdown("")
 
         # 이벤트 연결
         start_btn.click(
-            fn=lambda name: (
+            fn=lambda name, state: (
                 WORLDVIEW_MESSAGE if name.strip() else "이름을 입력해주세요",
                 gr.update(visible=True) if name.strip() else gr.update(),
-                {"user_name": name} if name.strip() else state
+                {**state, "user_name": name} if name.strip() else state
             ),
-            inputs=[name_input],
+            inputs=[name_input, state],
             outputs=[worldview_display, tabs, state]
         )
 
         set_baseline_btn.click(
-            fn=lambda x, s: ({"baseline_features": calculate_baseline_features(x)}, "기준점이 설정되었습니다."),
+            fn=lambda x, s: ({**s, "baseline_features": calculate_baseline_features(x)}, "기준점이 설정되었습니다."),
             inputs=[baseline_audio, state],
             outputs=[state, baseline_status]
         )
@@ -432,19 +435,29 @@ def create_interface():
         )
 
         generate_btn.click(
-            fn=on_image_generated,
+            fn=lambda prompt: generate_image_from_prompt(prompt)[0],
             inputs=[final_prompt],
             outputs=[result_image]
         )
 
         save_final_btn.click(
-            fn=lambda t, s: (db.save_wish(s["user_name"], t), "감상이 저장되었습니다."),
+            fn=lambda t, s: (
+                db.save_wish(s.get("user_name", "익명"), t),
+                "감상이 저장되었습니다."
+            ),
             inputs=[final_reflection, state],
-            outputs=[gr.Markdown("")]
+            outputs=[save_final_status]
         )
 
-        return app
+        play_music_btn.click(
+            fn=lambda: "oncheoncheon_sound.wav",
+            outputs=[audio]
+        )
+
+    return app
 
+# 파일 맨 아래 부분
 if __name__ == "__main__":
     demo = create_interface()
-    demo.launch(debug=True)
+    demo.launch(debug=True, share=True)
+