Update app.py

app.py

@@ -3,150 +3,202 @@ import numpy as np
 import librosa
 from transformers import pipeline
 import json
+import time
+from datetime import datetime
 
-# Initialize AI models
-emotion_analyzer = pipeline("audio-classification", model="MIT/ast-finetuned-speech-commands-v2")
+# 전역 상수
+STAGES = {
+    "INTRO": "입장",
+    "CLEANSING": "청신",
+    "PRAYER": "기원",
+    "SHARING": "송신"
+}
+
+# AI 모델 초기화
 speech_recognizer = pipeline("automatic-speech-recognition", 
                            model="kresnik/wav2vec2-large-xlsr-korean")
+emotion_classifier = pipeline("audio-classification", 
+                            model="MIT/ast-finetuned-speech-commands-v2")
+text_analyzer = pipeline("sentiment-analysis", 
+                        model="nlptown/bert-base-multilingual-uncased-sentiment")
 
-# Global state management
-current_stage = "intro"
-session_data = {}
+class DigitalGutApp:
+    def __init__(self):
+        self.current_stage = "INTRO"
+        self.user_name = ""
+        self.session_data = {
+            "reflections": [],
+            "voice_analysis": None,
+            "generated_prompts": [],
+            "current_location": "온천장역"
+        }
 
-def create_interface():
-    with gr.Blocks(theme=gr.themes.Soft()) as app:
-        # State management
-        state = gr.State(value={"stage": "intro", "session_data": {}})
-        
-        # Header
-        gr.Markdown("# 디지털 굿판")
-        
-        # Navigation tabs
-        with gr.Tabs() as tabs:
-            # Intro/세계관 Stage
-            with gr.Tab("입장", id="intro"):
-                gr.Markdown("""
-                # 디지털 굿판에 오신 것을 환영합니다
-                온천천의 디지털 치유 공간으로 들어가보세요.
-                """)
-                intro_next = gr.Button("여정 시작하기")
+    def create_interface(self):
+        with gr.Blocks(theme=gr.themes.Soft()) as app:
+            # 상태 관리
+            state = gr.State(self.session_data)
+            current_stage = gr.State(self.current_stage)
             
-            # 청신 Stage (Sound Purification)
-            with gr.Tab("청신", id="cleansing", visible=False):
-                with gr.Row():
-                    audio_player = gr.Audio(
-                        value="path_to_default_sound.mp3",  # 기본 사운드 파일
-                        type="filepath",
-                        label="온천천의 소리"
-                    )
-                    location_info = gr.Textbox(
-                        label="현재 위치",
-                        value="온천장역",
-                        interactive=False
-                    )
-                cleansing_next = gr.Button("다음 단계로")
+            # 헤더
+            with gr.Column(visible=True) as header:
+                gr.Markdown("# 디지털 굿판")
+                stage_indicator = gr.Markdown(self._get_stage_description())
             
-            # 기원 Stage (Voice Analysis)
-            with gr.Tab("기원", id="voice", visible=False):
-                with gr.Row():
-                    # Voice input component
-                    voice_input = gr.Audio(
-                        label="목소리로 전하기",
-                        sources=["microphone", "upload"],
-                        type="filepath"
-                    )
-                    
-                    # Analysis results
-                    with gr.Column():
-                        emotion_output = gr.JSON(
-                            label="감정 분석 결과",
-                            visible=True
+            # 메인 컨텐츠 영역
+            with gr.Column() as main_content:
+                # 1. 입장 화면
+                with gr.Column(visible=lambda: self.current_stage == "INTRO") as intro_screen:
+                    gr.Markdown("""
+                    # 디지털 굿판에 오신 것을 환영합니다
+                    온천천의 디지털 치유 공간으로 들어가보세요.
+                    """)
+                    name_input = gr.Textbox(label="이름을 알려주세요")
+                    start_button = gr.Button("여정 시작하기")
+                
+                # 2. 청신 화면 (음악 감상)
+                with gr.Column(visible=lambda: self.current_stage == "CLEANSING") as cleansing_screen:
+                    with gr.Row():
+                        # 음악 플레이어
+                        audio_player = gr.Audio(
+                            value="assets/main_music.mp3",
+                            type="filepath",
+                            label="온천천의 소리"
                         )
-                        text_output = gr.Textbox(
-                            label="음성 텍스트",
-                            visible=True
+                        # 감상 입력
+                        with gr.Column():
+                            reflection_input = gr.Textbox(
+                                label="현재 순간의 감상을 적어주세요",
+                                lines=3
+                            )
+                            save_reflection = gr.Button("감상 저장")
+                            reflections_display = gr.Dataframe(
+                                headers=["시간", "감상", "감정"],
+                                label="기록된 감상들"
+                            )
+                
+                # 3. 기원 화면 (음성 분석)
+                with gr.Column(visible=lambda: self.current_stage == "PRAYER") as prayer_screen:
+                    with gr.Row():
+                        # 음성 입력
+                        voice_input = gr.Audio(
+                            label="나누고 싶은 이야기를 들려주세요",
+                            sources=["microphone"],
+                            type="filepath"
                         )
-                voice_next = gr.Button("다음 단계로")
+                        # 분석 결과
+                        analysis_output = gr.JSON(label="분석 결과")
+                
+                # 4. 송신 화면 (결과 공유)
+                with gr.Column(visible=lambda: self.current_stage == "SHARING") as sharing_screen:
+                    final_prompt = gr.Textbox(label="생성된 프롬프트")
+                    gallery = gr.Gallery(label="시각화 결과")
             
-            # 송신 Stage (Sharing)
-            with gr.Tab("송신", id="sharing", visible=False):
-                with gr.Row():
-                    gr.Gallery(
-                        label="생성된 이미지",
-                        show_label=True,
-                        elem_id="gallery"
-                    )
-                    gr.Markdown("## 공동체와 함께 나누기")
-                complete_button = gr.Button("완료")
+            # 플로팅 메뉴
+            with gr.Column(visible=True) as floating_menu:
+                gr.Button("🏠", scale=1)
+                gr.Button("🎵", scale=1)
+                gr.Button("🎤", scale=1)
+                gr.Button("🖼️", scale=1)
 
-        # Floating navigation menu
-        with gr.Row(visible=True) as float_menu:
-            gr.Button("🏠", scale=1)
-            gr.Button("🎵", scale=1)
-            gr.Button("🎤", scale=1)
-            gr.Button("🖼️", scale=1)
+            # 이벤트 핸들러 정의
+            def start_journey(name):
+                self.user_name = name
+                self.current_stage = "CLEANSING"
+                return self._update_visibility()
 
-        # Voice analysis function
-        def analyze_voice(audio_file, state):
-            try:
-                if audio_file is None:
-                    return {"error": "No audio input provided"}, state
-                
-                # Load audio
-                y, sr = librosa.load(audio_file)
+            def save_reflection(text, state):
+                if not text.strip():
+                    return state, gr.update()
                 
-                # Emotion analysis
-                emotions = emotion_analyzer(y)
-                primary_emotion = emotions[0]
+                current_time = datetime.now().strftime("%H:%M:%S")
+                sentiment = text_analyzer(text)[0]
+                new_reflection = [current_time, text, sentiment["label"]]
                 
-                # Speech to text
-                text_result = speech_recognizer(y)
-                
-                # Update state
-                state["voice_analysis"] = {
-                    "emotion": primary_emotion['label'],
-                    "probability": float(primary_emotion['score']),
-                    "text": text_result['text']
-                }
+                state["reflections"].append(new_reflection)
+                return state, state["reflections"]
+
+            def analyze_voice(audio, state):
+                if audio is None:
+                    return {"error": "음성 입력이 없습니다."}
                 
-                return {
-                    "emotion": primary_emotion['label'],
-                    "emotion_probability": f"{primary_emotion['score']:.2f}",
-                    "transcribed_text": text_result['text'],
-                    "status": "Analysis complete"
-                }, state
-            except Exception as e:
-                return {"error": str(e), "status": "Error occurred"}, state
+                result = self._comprehensive_voice_analysis(audio)
+                state["voice_analysis"] = result
+                return result, state
+
+            # 이벤트 연결
+            start_button.click(
+                fn=start_journey,
+                inputs=[name_input],
+                outputs=[intro_screen, cleansing_screen, prayer_screen, sharing_screen]
+            )
+
+            save_reflection.click(
+                fn=save_reflection,
+                inputs=[reflection_input, state],
+                outputs=[state, reflections_display]
+            )
 
-        # Event handlers
-        voice_input.change(
-            fn=analyze_voice,
-            inputs=[voice_input, state],
-            outputs=[emotion_output, state]
-        )
+            voice_input.change(
+                fn=analyze_voice,
+                inputs=[voice_input, state],
+                outputs=[analysis_output, state]
+            )
+
+        return app
+
+    def _comprehensive_voice_analysis(self, audio_path):
+        """종합적인 음성 분석 수행"""
+        try:
+            y, sr = librosa.load(audio_path)
+            
+            # 1. 음향학적 특성 분석
+            acoustic_features = {
+                "energy": float(np.mean(librosa.feature.rms(y=y))),
+                "pitch_mean": float(np.mean(librosa.pitch_tuning(y))),
+                "tempo": float(librosa.beat.tempo(y)[0]),
+                "mfcc": librosa.feature.mfcc(y=y, sr=sr, n_mfcc=13).mean(axis=1).tolist()
+            }
+            
+            # 2. 음성 감정 분석
+            emotion_result = emotion_classifier(y)
+            
+            # 3. 음성-텍스트 변환
+            text_result = speech_recognizer(y)
+            
+            # 4. 텍스트 감정 분석
+            text_sentiment = text_analyzer(text_result["text"])[0]
+            
+            return {
+                "acoustic_analysis": acoustic_features,
+                "emotion": emotion_result[0],
+                "transcription": text_result["text"],
+                "text_sentiment": text_sentiment
+            }
+            
+        except Exception as e:
+            return {"error": str(e)}
 
-        # Stage navigation
-        intro_next.click(
-            fn=lambda s: {"stage": "cleansing", **s},
-            inputs=[state],
-            outputs=[state],
-        )
-        
-        cleansing_next.click(
-            fn=lambda s: {"stage": "voice", **s},
-            inputs=[state],
-            outputs=[state],
-        )
-        
-        voice_next.click(
-            fn=lambda s: {"stage": "sharing", **s},
-            inputs=[state],
-            outputs=[state],
-        )
+    def _get_stage_description(self):
+        """현재 단계에 대한 설명 반환"""
+        descriptions = {
+            "INTRO": "디지털 굿판에 오신 것을 환영합니다",
+            "CLEANSING": "청신 - 소리로 정화하기",
+            "PRAYER": "기원 - 목소리로 전하기",
+            "SHARING": "송신 - 함께 나누기"
+        }
+        return descriptions.get(self.current_stage, "")
 
-    return app
+    def _update_visibility(self):
+        """현재 단계에 따른 화면 가시성 업데이트"""
+        return {
+            "intro_screen": self.current_stage == "INTRO",
+            "cleansing_screen": self.current_stage == "CLEANSING",
+            "prayer_screen": self.current_stage == "PRAYER",
+            "sharing_screen": self.current_stage == "SHARING"
+        }
 
-# Launch the application
+# 앱 실행
 if __name__ == "__main__":
-    app = create_interface()
-    app.launch()
+    app = DigitalGutApp()
+    interface = app.create_interface()
+    interface.launch()