Update app.py

app.py

@@ -1,4 +1,3 @@
-# Part 1/3 - Setup and Utilities
 import gradio as gr
 import numpy as np
 import librosa
@@ -6,13 +5,51 @@ from transformers import pipeline
 from datetime import datetime
 import os
 import requests
+import json
+import time
 
-# 환경변수에서 토큰 가져오기
+# 데이터 저장을 위한 간단한 파일 기반 DB
+class SimpleDB:
+    def __init__(self, file_path="wishes.json"):
+        self.file_path = file_path
+        self.wishes = self._load_wishes()
+
+    def _load_wishes(self):
+        try:
+            if os.path.exists(self.file_path):
+                with open(self.file_path, 'r', encoding='utf-8') as f:
+                    return json.load(f)
+            return []
+        except Exception as e:
+            print(f"Error loading wishes: {e}")
+            return []
+
+    def save_wish(self, name, wish, timestamp=None):
+        if timestamp is None:
+            timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        
+        wish_data = {
+            "name": name,
+            "wish": wish,
+            "timestamp": timestamp
+        }
+        
+        self.wishes.append(wish_data)
+        
+        try:
+            with open(self.file_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
+
+# 환경변수 설정
 HF_API_TOKEN = os.getenv("roots")
 if not HF_API_TOKEN:
     raise ValueError("roots token not found in environment variables")
 
-# Inference API 설정
+# API 설정
 API_URL = "https://api-inference.huggingface.co/models/stabilityai/stable-diffusion-xl-base-1.0"
 headers = {"Authorization": f"Bearer {HF_API_TOKEN}"}
 
@@ -26,86 +63,30 @@ text_analyzer = pipeline(
     model="nlptown/bert-base-multilingual-uncased-sentiment"
 )
 
-def calculate_baseline_features(audio_path):
-    """기준점 음성 특성 분석"""
-    try:
-        y, sr = librosa.load(audio_path, sr=16000)
-        features = {
-            "energy": float(np.mean(librosa.feature.rms(y=y))),
-            "tempo": float(librosa.beat.tempo(y)[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()
-        }
-        return features
-    except Exception as e:
-        print(f"Error calculating baseline: {str(e)}")
-        return None
-
-def map_acoustic_to_emotion(features, baseline_features=None):
-    """음향학적 특성을 감정으로 매핑 (기준점 대비)"""
-    # 음성 특성 정규화
-    energy_norm = min(features["energy"] * 100, 100)
-    tempo_norm = min(features["tempo"] / 200, 1)
-    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"])
-
-    emotions = {
-        "primary": "",
-        "intensity": energy_norm,
-        "confidence": 0.0,
-        "secondary": "",
-        "characteristics": []
-    }
+# 상수 정의
+IMAGE_DISPLAY_TIME = 30  # 이미지 표시 시간 (초)
+WELCOME_MESSAGE = """
+# 디지털 굿판에 오신 것을 환영합니다
 
-    # 감정 매핑 로직
-    if energy_norm > 70:
-        if tempo_norm > 0.6:
-            emotions["primary"] = "기쁨/열정"
-            emotions["characteristics"].append("빠르고 활기찬 말하기 패턴")
-        else:
-            emotions["primary"] = "분노/강조"
-            emotions["characteristics"].append("강한 음성 강도")
-        emotions["confidence"] = energy_norm / 100
-    elif pitch_norm > 0.6:
-        if energy_norm > 50:
-            emotions["primary"] = "놀람/흥분"
-            emotions["characteristics"].append("높은 음고와 강한 강세")
-        else:
-            emotions["primary"] = "관심/호기심"
-            emotions["characteristics"].append("음고 변화가 큼")
-        emotions["confidence"] = pitch_norm
-    elif energy_norm < 30:
-        if tempo_norm < 0.4:
-            emotions["primary"] = "슬픔/우울"
-            emotions["characteristics"].append("느리고 약한 음성")
-        else:
-            emotions["primary"] = "피로/무기력"
-            emotions["characteristics"].append("낮은 에너지 레벨")
-        emotions["confidence"] = (30 - energy_norm) / 30
-    else:
-        if tempo_norm > 0.5:
-            emotions["primary"] = "평온/안정"
-            emotions["characteristics"].append("균형잡힌 말하기 패턴")
-        else:
-            emotions["primary"] = "차분/진지"
-            emotions["characteristics"].append("안정적인 음성 특성")
-        emotions["confidence"] = 0.5
-
-    emotions["details"] = {
-        "energy_level": f"{energy_norm:.1f}%",
-        "speech_rate": f"{'빠름' if tempo_norm > 0.6 else '보통' if tempo_norm > 0.4 else '느림'}",
-        "pitch_variation": f"{'높음' if pitch_norm > 0.6 else '보통' if pitch_norm > 0.3 else '낮음'}",
-        "voice_volume": f"{'큼' if features['volume'] > 0.7 else '보통' if features['volume'] > 0.3 else '작음'}"
-    }
+디지털 굿판은 현대 도시 속에서 잊혀진 전통 굿의 정수를 담아낸 **디지털 의례의 공간**입니다. 
+이곳에서는 사람들의 목소리와 감정을 통해 **영적 교감**을 나누고, **자연과 도시의 에너지가 연결**됩니다. 
+이제, 평온함과 치유의 여정을 시작해보세요.
+"""
+
+WORLDVIEW_MESSAGE = """
+## 굿판의 세계관 🌌
+
+온천천의 물줄기는 신성한 금샘에서 시작됩니다. 금샘은 생명과 창조의 원천이며, 
+천상의 생명이 지상에서 숨을 틔우는 자리입니다. 도시의 소음 속에서도 신성한 생명력을 느껴보세요. 
+이곳에서 영적인 교감을 경험하며, 자연과 하나 되는 순간을 맞이해 보시기 바랍니다.
+
+이 앱은 온천천의 사운드스케이프를 녹음하여 제작되었으며, 
+온천천 온천장역에서 장전역까지 걸으며 더 깊은 체험이 가능합니다.
+"""
 
-    return emotions
 
-# Part 2/3 - Core Functions
+# Part 2/3 - Core Functions and Image Generation
+
 def generate_image_from_prompt(prompt):
     """이미지 생성 함수"""
     print(f"Generating image with prompt: {prompt}")
@@ -129,14 +110,51 @@ def generate_image_from_prompt(prompt):
         
         if response.status_code == 200:
             print("Image generated successfully")
-            return response.content
+            # 이미지 저장 로직 추가
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            image_path = f"generated_images/{timestamp}.png"
+            os.makedirs("generated_images", exist_ok=True)
+            with open(image_path, "wb") as f:
+                f.write(response.content)
+            return response.content, image_path
         else:
             print(f"Error: {response.status_code}")
             print(f"Response: {response.text}")
-            return None
+            return None, None
     except Exception as e:
         print(f"Error generating image: {str(e)}")
-        return None
+        return None, None
+
+def analyze_voice_with_retry(audio_path, state, max_retries=3):
+    """음성 분석 함수 (재시도 로직 포함)"""
+    for attempt in range(max_retries):
+        try:
+            y, sr = librosa.load(audio_path, sr=16000)
+            
+            acoustic_features = {
+                "energy": float(np.mean(librosa.feature.rms(y=y))),
+                "tempo": float(librosa.beat.tempo(y)[0]),
+                "pitch": float(np.mean(librosa.feature.zero_crossing_rate(y))),
+                "volume": float(np.mean(np.abs(y)))
+            }
+            
+            transcription = speech_recognizer(y)
+            text = transcription["text"]
+            
+            emotions = map_acoustic_to_emotion(acoustic_features, state.get("baseline_features"))
+            text_sentiment = text_analyzer(text)[0]
+            
+            return {
+                "text": text,
+                "emotions": emotions,
+                "sentiment": text_sentiment,
+                "features": acoustic_features
+            }
+        except Exception as e:
+            if attempt == max_retries - 1:
+                raise e
+            print(f"Attempt {attempt + 1} failed, retrying...")
+            continue
 
 def generate_detailed_prompt(text, emotions, text_sentiment):
     """감정 기반 상세 프롬프트 생성"""
@@ -167,86 +185,80 @@ def generate_detailed_prompt(text, emotions, text_sentiment):
 
 def update_final_prompt(state):
     """청신의 감상들을 종합하여 최종 프롬프트 업데이트"""
-    if not state["reflections"]:
-        return ""
+    combined_prompt = "한국 전통 민화 스타일의 추상화, 온천천에서의 감상과 소원을 담아내기:\n\n"
+    
+    if state.get("reflections"):
+        combined_prompt += "청신의 감상들:\n"
+        for time, text, sentiment in state["reflections"]:
+            combined_prompt += f"- {time}: {text} ({sentiment})\n"
     
-    combined_prompt = "한국 전통 민화 스타일의 추상화, 온천천에서의 다음 감상들을 담아내기:\n"
-    for time, text, sentiment in state["reflections"]:
-        combined_prompt += f"- {time}: {text} ({sentiment})\n"
+    if state.get("wish"):
+        combined_prompt += f"\n소원:\n{state['wish']}"
     
     return combined_prompt
 
-def analyze_voice_with_retry(audio_path, state, max_retries=3):
-    """음성 분석 함수 (재시도 로직 포함)"""
-    for attempt in range(max_retries):
-        try:
-            y, sr = librosa.load(audio_path, sr=16000)
-            
-            acoustic_features = {
-                "energy": float(np.mean(librosa.feature.rms(y=y))),
-                "tempo": float(librosa.beat.tempo(y)[0]),
-                "pitch": float(np.mean(librosa.feature.zero_crossing_rate(y))),
-                "volume": float(np.mean(np.abs(y)))
-            }
-            
-            transcription = speech_recognizer(y)
-            text = transcription["text"]
-            
-            emotions = map_acoustic_to_emotion(acoustic_features, state.get("baseline_features"))
-            text_sentiment = text_analyzer(text)[0]
-            
-            return {
-                "text": text,
-                "emotions": emotions,
-                "sentiment": text_sentiment
-            }
-        except Exception as e:
-            if attempt == max_retries - 1:
-                raise e
-            print(f"Attempt {attempt + 1} failed, retrying...")
-            continue
+def handle_image_timeout(result_image, delay=IMAGE_DISPLAY_TIME):
+    """이미지 자동 사라짐 처리"""
+    time.sleep(delay)
+    return gr.update(value=None)
 
 # Part 3/3 - Interface and Main
 def create_interface():
+    # DB 초기화
+    db = SimpleDB()
+    
     with gr.Blocks(theme=gr.themes.Soft()) as app:
         state = gr.State({
             "user_name": "",
             "baseline_features": None,
             "reflections": [],
-            "voice_analysis": None,
-            "final_prompt": ""
+            "wish": None,
+            "final_prompt": "",
+            "image_path": None
         })
 
-        # 헤더 및 네비게이션
+        # 헤더
         header = gr.Markdown("# 디지털 굿판")
         user_display = gr.Markdown("")
 
+        # 탭 구성
         with gr.Tabs() as tabs:
             # 입장
-            with gr.Tab("입장"):
-                gr.Markdown("### 디지털 굿판에 오신 것을 환영합니다")
-                name_input = gr.Textbox(label="이름을 알려주세요", placeholder="이름을 입력해주세요")
+            with gr.Tab("입장", id="intro"):
+                gr.Markdown(WELCOME_MESSAGE)
+                name_input = gr.Textbox(
+                    label="이름을 알려주세요",
+                    placeholder="이름을 입력해주세요"
+                )
+                worldview_display = gr.Markdown(visible=False)
                 start_btn = gr.Button("여정 시작하기")
+                continue_btn = gr.Button("다음 단계로", visible=False)
 
             # 기준 설정
-            with gr.Tab("기준 설정", visible=False) as baseline_tab:
-                gr.Markdown("""### 축원의 문장을 평온한 마음으로 읽어주세요
-                '당신의 건강과 행복이 늘 가득하기를'""")
+            with gr.Tab("기준 설정", id="baseline"):
+                gr.Markdown("""
+                ### 축원의 문장을 평온한 마음으로 읽어주세요
+                
+                먼저, 평온한 마음으로 축원의 문장을 읽어주세요. 
+                이 축원은 당신에게 평화와 안정을 불러일으키며, 
+                감정을 정확히 이해하기 위한 **기준점**이 될 것입니다.
+                """)
+                gr.Markdown("'당신의 건강과 행복이 늘 가득하기를'")
                 baseline_audio = gr.Audio(
                     label="축원 문장 녹음하기",
-                    sources=["microphone"],
-                    type="filepath"
+                    sources=["microphone"]
                 )
                 set_baseline_btn = gr.Button("기준점 설정 완료")
                 baseline_status = gr.Markdown("")
 
             # 청신
-            with gr.Tab("청신", visible=False) as cleansing_tab:
-                gr.Markdown("""## 청신 - 소리로 정화하기
+            with gr.Tab("청신", id="cleansing"):
+                gr.Markdown("""
+                ## 청신 - 소리로 정화하기
                 
-                이 앱은 어디서나 실행 가능하지만, 온천천의 사운드스케이프를 기반으로 제작되었습니다.
-                온천장역에서 장전역까지의 구간을 걸으며 경험하면, 
-                보다 자연과 하나 된 온천천의 신화를 느낄 수 있습니다.
+                온천천의 물소리에 귀 기울이며 **30분간 마음을 정화**해보세요.
+                장전역까지 이어지는 이 여정을 함께하며, 
+                차분히 자연의 소리에 마음을 기울여보세요.
                 """)
                 play_music_btn = gr.Button("온천천의 소리 듣기")
                 with gr.Row():
@@ -259,7 +271,7 @@ def create_interface():
                     )
                     with gr.Column():
                         reflection_input = gr.Textbox(
-                            label="현재 순간의 감상을 적어주세요",
+                            label="지금 이 순간의 감상을 자유롭게 적어보세요",
                             lines=3
                         )
                         save_btn = gr.Button("감상 저장하기")
@@ -267,132 +279,147 @@ def create_interface():
                             headers=["시간", "감상", "감정 분석"],
                             label="기록된 감상들"
                         )
-                continue_to_prayer_btn = gr.Button("기원으로 이동하기")
 
             # 기원
-            with gr.Tab("기원", visible=False) as prayer_tab:
+            with gr.Tab("기원", id="prayer"):
+                gr.Markdown("""
+                ## 기원 - 소원을 전해보세요
+                
+                당신의 소원을 온전히 담아 이곳에 전해주세요.
+                당신의 목소리와 감정이 영적 메시지가 되어 전해지며,
+                이 기원이 당신에게 평화와 안정을 불러오기를 바랍니다.
+                """)
                 with gr.Row():
                     with gr.Column():
                         voice_input = gr.Audio(
-                            label="나누고 싶은 이야기를 들려주세요",
-                            sources=["microphone"],
-                            type="filepath"
+                            label="소원을 나누고 싶은 마음을 말해주세요",
+                            sources=["microphone"]
                         )
-                        clear_btn = gr.Button("녹음 지우기")
-                        analyze_btn = gr.Button("분석하기")
+                        analyze_btn = gr.Button("소원 분석하기")
                     
                     with gr.Column():
-                        transcribed_text = gr.Textbox(label="인식된 텍스트")
-                        voice_emotion = gr.Textbox(label="음성 감정 분석")
-                        text_emotion = gr.Textbox(label="텍스트 감정 분석")
-                        final_prompt = gr.Textbox(label="생성된 프롬프트", lines=3)
+                        transcribed_text = gr.Textbox(
+                            label="인식된 텍스트",
+                            interactive=False
+                        )
+                        voice_emotion = gr.Textbox(
+                            label="음성 감정 분석",
+                            interactive=False
+                        )
+                        text_emotion = gr.Textbox(
+                            label="텍스트 감정 분석",
+                            interactive=False
+                        )
 
             # 송신
-            with gr.Tab("송신", visible=False) as sending_tab:
-                gr.Markdown("## 송신 - 시각화 결과")
-                combined_prompt = gr.Textbox(
-                    label="종합 프롬프트",
+            with gr.Tab("송신", id="sending"):
+                gr.Markdown("""
+                ## 송신 - 마음의 그림을 남기고, 보내기
+                
+                당신의 마음을 시각화하여 그려봅니다. 
+                자연과 영적 교감을 통해 얻은 평온과 치유의 흔적을, 
+                하나의 그림으로 담아보세요.
+                """)
+                final_prompt = gr.Textbox(
+                    label="생성된 프롬프트",
                     interactive=False,
                     lines=3
                 )
-                generate_btn = gr.Button("이미지 생성하기")
                 with gr.Row():
-                    result_image = gr.Image(label="생성된 이미지", type="pil")
-                    with gr.Column():
-                        share_btn = gr.Button("이미지 공유하기")
-                        download_btn = gr.Button("이미지 저장하기")
+                    generate_btn = gr.Button("마음의 그림 그리기")
+                    save_image_btn = gr.Button("이미지 저장하기")
+                result_image = gr.Image(label="생성된 이미지")
+                image_timer = gr.Markdown(
+                    "이미지는 30초 후 자동으로 사라집니다...",
+                    visible=False
+                )
+                
+                # 최종 감상
+                gr.Markdown("""
+                ## 마지막 감상을 남겨주세요
+                
+                이제 당신의 여정이 마무리되었습니다. 
+                마지막으로 느낀 감상을 한 줄로 남겨주세요.
+                """)
+                final_reflection = gr.Textbox(
+                    label="마지막 감상",
+                    placeholder="한 줄로 남겨주세요..."
+                )
+                save_final_btn = gr.Button("감상 남기기")
 
+        # 이벤트 핸들러
         def start_journey(name):
             if not name.strip():
-                return "이름을 입력해주세요", gr.update()
+                return "이름을 입력해주세요", gr.update(), gr.update()
             
-            welcome_text = f"""
-            # 환영합니다, {name}님의 디지털 굿판
-        
-            ## 굿판의 세계관 🌌
-            디지털 굿판은 현대 도시 속에서 잊혀진 전통 굿의 정수를 담아낸 **디지털 의례의 공간**입니다. 
-            이곳에서는 사람들의 목소리와 감정을 통해 **영적 교감**을 나누고, **자연과 도시의 에너지**를 연결하며, 
-            평온함과 치유를 경험하게 됩니다.
-        
-            ## 위치 안내 📍
-            이 앱은 어디서나 실행 가능하지만, 온천천의 사운드스케이프를 녹음하고 이를 기반으로 제작되어,
-            온천천 온천장역에서 장전역까지의 구간을 걸으며 경험하면 
-            보다 자연과 하나 된 온천천의 신화를 느낄 수 있습니다.
-        
-            ## 여정을 시작하며 🚀
-            먼저, 평온한 마음으로 축원의 문장을 읽어주세요. 
-            이는 당신의 감정을 더 정확하게 이해하기 위한 기준점이 될 것입니다.
-            """
-            return welcome_text, gr.update(selected="기준 설정")
+            state = {"user_name": name}
+            return (
+                WORLDVIEW_MESSAGE,
+                gr.update(visible=True),
+                gr.update(visible=True)
+            )
+
+        def save_wish_to_db(text, state):
+            if text and state.get("user_name"):
+                db.save_wish(state["user_name"], text)
+                return "소원이 안전하게 저장되었습니다."
+            return "저장에 실패했습니다."
+
+        def handle_image_generation(prompt):
+            image_content, image_path = generate_image_from_prompt(prompt)
+            if image_content:
+                gr.update(visible=True)  # 타이머 표시
+                return image_content
+            return None
 
-        def play_music():
-            audio_path = os.path.abspath(os.path.join("assets", "main_music.mp3"))
-            return gr.update(value=audio_path, autoplay=True)
+        # 이벤트 연결
+        start_btn.click(
+            fn=start_journey,
+            inputs=[name_input],
+            outputs=[worldview_display, continue_btn, tabs]
+        )
 
+        set_baseline_btn.click(
+            fn=lambda x, s: ({"baseline_features": calculate_baseline_features(x)}, "기준점이 설정되었습니다."),
+            inputs=[baseline_audio, state],
+            outputs=[state, baseline_status]
+        )
 
-        def save_reflection(text, state):
-            if not text.strip():
-                return state, state["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})"]
-                
-                state = state.copy()
-                if "reflections" not in state:
-                    state["reflections"] = []
-                    
-                state["reflections"].append(new_reflection)
-                return state, state["reflections"]
-            except Exception as e:
-                print(f"Error in save_reflection: {str(e)}")
-                return state, []
-
-        def analyze_voice(audio_path, state):
-            if audio_path is None:
-                return state, "음성을 먼저 녹음해주세요.", "", "", ""
-            
-            try:
-                result = analyze_voice_with_retry(audio_path, state)
-                
-                voice_result = (
-                    f"음성 감정: {result['emotions']['primary']} "
-                    f"(강도: {result['emotions']['intensity']:.1f}%, "
-                    f"신뢰도: {result['emotions']['confidence']:.2f})\n"
-                    f"특징: {', '.join(result['emotions']['characteristics'])}"
-                )
-                
-                text_result = f"텍스트 감정: {result['sentiment']['label']} "
-                f"(강도: {result['sentiment']['score']}/5)"
-                
-                prompt = generate_detailed_prompt(
-                    result['text'],
-                    result['emotions'],
-                    result['sentiment']
-                )
-                
-                return state, result['text'], voice_result, text_result, prompt
-            except Exception as e:
-                return state, f"오류 발생: {str(e)}", "", "", ""
+        save_btn.click(
+            fn=save_reflection,
+            inputs=[reflection_input, state],
+            outputs=[state, reflections_display]
+        )
 
-        def update_sending_tab(state):
-            """청신의 감상과 기원의 음성을 종합하여 송신 탭 업데이트"""
-            combined = "청신과 기원의 여정을 담은 이미지:\n\n"
-            combined += update_final_prompt(state)
-            return combined
+        analyze_btn.click(
+            fn=analyze_voice,
+            inputs=[voice_input, state],
+            outputs=[transcribed_text, voice_emotion, text_emotion, state]
+        )
 
-        # 이벤트 연결
-        start_btn.click(fn=start_journey, inputs=[name_input], outputs=[user_display, tabs])
-        play_music_btn.click(fn=play_music, outputs=[audio])
-        save_btn.click(fn=save_reflection, inputs=[reflection_input, state], outputs=[state, reflections_display])
-        analyze_btn.click(fn=analyze_voice, inputs=[voice_input, state], outputs=[state, transcribed_text, voice_emotion, text_emotion, final_prompt])
-        continue_to_prayer_btn.click(fn=lambda: gr.update(selected="기원"), outputs=[tabs])
-        tabs.change(fn=update_sending_tab, inputs=[state], outputs=[combined_prompt])
-        generate_btn.click(fn=generate_image_from_prompt, inputs=[combined_prompt], outputs=[result_image])
+        generate_btn.click(
+            fn=handle_image_generation,
+            inputs=[final_prompt],
+            outputs=[result_image]
+        )
+
+        save_final_btn.click(
+            fn=save_wish_to_db,
+            inputs=[final_reflection, state],
+            outputs=[gr.Markdown("")]  # 저장 상태 메시지
+        )
+
+        # 이미지 자동 사라짐 설정
+        result_image.change(
+            fn=lambda: gr.update(value=None),
+            inputs=[],
+            outputs=[result_image],
+            _js=f"() => setTimeout(() => {{document.querySelector('#result_image image').src = ''}}, {IMAGE_DISPLAY_TIME*1000})"
+        )
 
         return app
 
 if __name__ == "__main__":
     demo = create_interface()
-    demo.launch(debug=True) 
+    demo.launch(debug=True)
+