Initial commit: Gradio text-based speaker separation app for Hugging Face Spaces

.gitignore

@@ -0,0 +1,122 @@
+# 대용량 파일들
+data/*.wav
+data/*.mp3
+data/*.mp4
+docs/
+*.pdf
+
+# 환경 파일들
+.env
+.env.local
+.env.production
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyTorch
+*.pth
+*.pt
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+Pipfile.lock
+
+# poetry
+poetry.lock
+
+# celery beat schedule file
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Environment variables
+.env
+
+# Log files
+*.log
+
+# Temporary files
+temp_segment_*.wav
+
+# Data and Output folders (keep structure but ignore contents)
+output/*.txt
+output/*.json
+
+# Keep folder structure
+!data/.gitkeep
+!output/.gitkeep

README.md

@@ -0,0 +1,60 @@
+---
+title: 2인 대화 화자 분리기 (AI)
+emoji: 💬
+colorFrom: blue
+colorTo: purple
+sdk: gradio
+sdk_version: 4.44.0
+app_file: app.py
+pinned: false
+license: mit
+---
+
+# 2인 대화 화자 분리기 (AI)
+
+Gemini 2.0 Flash AI를 사용하여 텍스트 대화를 화자별로 자동 분리하고 맞춤법을 교정하는 웹 애플리케이션입니다.
+
+## 🎯 주요 기능
+
+1. **WAV 파일 업로드**: 웹 인터페이스를 통한 간편한 파일 업로드
+2. **고정밀 음성 인식**: OpenAI Whisper를 사용한 음성-텍스트 변환
+3. **AI 화자 분리**: Google Gemini를 사용한 텍스트 기반 2인 대화 분리
+4. **실시간 결과**: 웹에서 즉시 결과 확인 및 다운로드
+
+## 🛠 기술 스택
+
+- **UI Framework**: Gradio (웹 인터페이스)
+- **음성 인식**: OpenAI Whisper
+- **AI 화자 분리**: Google Gemini Pro
+- **호스팅**: Hugging Face Spaces
+
+## 📝 사용 방법
+
+1. WAV 파일을 업로드하세요
+2. "처리 시작" 버튼을 클릭하세요
+3. 처리 완료 후 결과를 확인하세요:
+   - 원본 텍스트
+   - 화자별 분리 결과
+   - 맞춤법 교정 결과
+
+## ⚙️ API 설정
+
+이 애플리케이션은 Google AI API를 사용합니다. Hugging Face Spaces의 Settings에서 다음 환경 변수를 설정해야 합니다:
+
+- `GOOGLE_API_KEY`: Google AI Studio에서 발급받은 API 키
+
+## 🎤 화자 분리 정확도
+
+Gemini AI의 텍스트 기반 화자 분리는 다음 요소들을 분석합니다:
+
+- **대화 맥락**: 질문과 답변의 패턴
+- **말투 변화**: 존댓말/반말, 어조 변화
+- **주제 전환**: 화자별 관심사나 역할
+- **언어 패턴**: 개인별 표현 습관
+
+## ⚠️ 주의사항
+
+- WAV 형식의 오디오 파일만 지원됩니다
+- 2인 대화에 최적화되어 있습니다
+- 처리 시간은 파일 길이에 따라 달라집니다
+- Google AI API 사용량에 따라 제한이 있을 수 있습니다 

README_backup.md

@@ -0,0 +1,152 @@
+# 2인 대화 STT 처리기 (AI 화자 분리)
+
+Whisper STT + Gemini AI를 결합하여 오디오 파일을 텍스트로 변환하고 화자별로 자동 분리하는 애플리케이션입니다.
+
+## 주요 기능
+
+1. **WAV 파일 자동 감지**: data 폴더의 모든 WAV 파일을 자동으로 감지
+2. **고정밀 음성 인식**: OpenAI Whisper를 사용한 음성-텍스트 변환
+3. **AI 화자 분리**: Google Gemini를 사용한 텍스트 기반 2인 대화 분리
+4. **결과 저장**: 
+   - 전체 대화 (원본 + 화자 분리)
+   - 화자별 개별 대화
+   - JSON 형태 상세 데이터
+
+## 기술 스택
+
+- **UI Framework**: tkinter (Python GUI)
+- **음성 인식**: OpenAI Whisper
+- **AI 화자 분리**: Google Gemini Pro
+- **로깅**: Python logging
+
+## 폴더 구조
+
+```
+sttUsingAPI/
+├── data/           # WAV 파일을 여기에 넣으세요
+├── output/         # 처리 결과가 저장됩니다
+├── logs/           # 로그 파일이 저장됩니다
+├── .env            # API 키 설정
+├── audio_summarizer.py  # 메인 애플리케이션
+└── test_stt.py     # 테스트 스크립트
+```
+
+## 설치 및 설정
+
+### 1. 의존성 설치
+
+```bash
+pip install torch torchaudio python-dotenv google-generativeai
+pip install git+https://github.com/openai/whisper.git
+```
+
+### 2. API 키 설정
+
+`.env` 파일에 Google AI API 키를 설정하세요:
+
+```env
+# Google AI API 키 (https://aistudio.google.com/app/apikey)
+GOOGLE_API_KEY=your_google_api_key_here
+```
+
+### 3. WAV 파일 준비
+
+처리할 WAV 파일을 `data/` 폴더에 넣으세요.
+
+### 4. 실행
+
+```bash
+# GUI 애플리케이션
+python audio_summarizer.py
+
+# 또는 테스트 스크립트
+python test_stt.py
+```
+
+## 사용 방법
+
+1. 애플리케이션 실행
+2. `.env` 파일에 Google API 키 설정 확인
+3. WAV 파일이 `data/` 폴더에 있는지 확인
+4. "파일 목록 새로고침" 버튼으로 파일 목록 업데이트
+5. 개별 파일 처리: 파일 선택 후 "선택된 파일 처리" 클릭
+6. 전체 파일 처리: "모든 파일 처리" 클릭
+7. `output/` 폴더에서 결과 확인
+
+## 처리 과정
+
+1. **음성 인식**: Whisper가 WAV 파일을 텍스트로 변환
+2. **화자 분리**: Gemini가 텍스트 분석으로 화자별 발언 구분
+3. **결과 저장**: 다양한 형태로 결과 파일 생성
+
+## 출력 파일 형식
+
+각 WAV 파일에 대해 다음 파일들이 생성됩니다:
+
+- `{파일명}_전체대화_{타임스탬프}.txt`: 원본 + 화자 분리 결과
+- `{파일명}_화자1_{타임스탬프}.txt`: 화자1의 발언만
+- `{파일명}_화자2_{타임스탬프}.txt`: 화자2의 발언만
+- `{파일명}_data_{타임스탬프}.json`: JSON 형태 상세 데이터
+
+### 화자 분리 결과 예시
+
+```
+원본 텍스트:
+안녕하세요, 오늘 회의에 참석해주셔서 감사합니다. 네, 안녕하세요. 준비된 자료가 있나요? 네, 프레젠테이션 자료를 준비했습니다.
+
+화자별 분리 결과:
+[화자1] 안녕하세요, 오늘 회의에 참석해주셔서 감사합니다.
+[화자2] 네, 안녕하세요. 준비된 자료가 있나요?
+[화자1] 네, 프레젠테이션 자료를 준비했습니다.
+```
+
+## API 키 발급
+
+### Google AI API 키
+1. [Google AI Studio](https://aistudio.google.com/app/apikey) 방문
+2. 구글 계정으로 로그인
+3. "Create API Key" 클릭
+4. 생성된 키를 `.env` 파일에 추가
+
+## 로그
+
+- 모든 처리 과정과 오류는 `logs/stt_processor.log` 파일에 기록됩니다.
+
+## 화자 분리 정확도
+
+Gemini AI의 텍스트 기반 화자 분리는 다음 요소들을 분석합니다:
+
+- **대화 맥락**: 질문과 답변의 패턴
+- **말투 변화**: 존댓말/반말, 어조 변화
+- **주제 전환**: 화자별 관심사나 역할
+- **언어 패턴**: 개인별 표현 습관
+
+## 주의사항
+
+- WAV 형식의 오디오 파일만 지원됩니다.
+- 최초 실행 시 Whisper 모델 다운로드로 인해 시간이 소요될 수 있습니다.
+- 인터넷 연결이 필요합니다 (모델 다운로드 및 API 호출).
+- Google AI API 사용량에 따라 비용이 발생할 수 있습니다.
+- 2인 대화에 최적화되어 있습니다.
+
+## 화자 분리 정확도 향상 팁
+
+1. **명확한 역할 구분**: 인터뷰어-인터뷰이, 강사-학생 등
+2. **대화 흐름**: 자연스러운 질문과 답변 형태
+3. **말투 차이**: 존댓말/반말, 전문용어 사용 차이
+4. **음질**: 깨끗하고 명확한 음성
+5. **화자 간 중복 발언 최소화**: 동시에 말하는 구간 최소화
+
+## 문제 해결
+
+### API 키 오류
+- `.env` 파일에 올바른 Google AI API 키가 설정되어 있는지 확인
+- API 키의 권한 및 할당량 확인
+
+### 화자 분리 정확도 문제
+- 대화 내용이 너무 짧거나 단조로운 경우 정확도 저하 가능
+- 두 명 이상의 화자가 있는 경우 부정확할 수 있음
+
+### 모델 로딩 오류
+- 인터넷 ���결 상태 확인
+- 가상환경 및 패키지 설치 상태 확인

app.py

@@ -0,0 +1,251 @@
+import gradio as gr
+import os
+import logging
+from datetime import datetime
+from stt_processor import TextProcessor
+
+# 로깅 설정
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.StreamHandler()
+    ]
+)
+logger = logging.getLogger(__name__)
+
+# 전역 변수
+text_processor = None
+
+def initialize_processor():
+    """텍스트 프로세서를 초기화합니다."""
+    global text_processor
+    try:
+        # 환경 변수 또는 Hugging Face Secrets에서 API 키 읽기
+        google_api_key = os.getenv("GOOGLE_API_KEY")
+        
+        if not google_api_key:
+            return False, "❌ Google API 키가 설정되지 않았습니다. Hugging Face Spaces의 Settings에서 GOOGLE_API_KEY를 설정해주세요."
+        
+        text_processor = TextProcessor(google_api_key)
+        return True, "✅ 텍스트 프로세서가 초기화되었습니다."
+        
+    except Exception as e:
+        logger.error(f"텍스트 프로세서 초기화 실패: {e}")
+        return False, f"❌ 초기화 실패: {str(e)}"
+
+def process_text_input(input_text, progress=gr.Progress()):
+    """
+    입력된 텍스트를 처리합니다.
+    
+    Args:
+        input_text: 처리할 텍스트
+        progress: Gradio 진행률 객체
+        
+    Returns:
+        tuple: (처리 상태, 원본 텍스트, 화자 분리 결과, 교정 결과, 화자1 대화, 화자2 대화)
+    """
+    global text_processor
+    
+    if not input_text or not input_text.strip():
+        return "❌ 처리할 텍스트를 입력해주세요.", "", "", "", "", ""
+    
+    try:
+        # 텍스트 프로세서 초기화 (필요한 경우)
+        if text_processor is None:
+            progress(0.1, desc="텍스트 프로세서 초기화 중...")
+            success, message = initialize_processor()
+            if not success:
+                return message, "", "", "", "", ""
+        
+        # 모델 로딩
+        progress(0.2, desc="AI 모델 로딩 중...")
+        if not text_processor.models_loaded:
+            text_processor.load_models()
+        
+        # 진행 상황 콜백 함수
+        def progress_callback(status, current, total):
+            progress_value = 0.2 + (current / total) * 0.7  # 0.2~0.9 범위
+            progress(progress_value, desc=f"{status} ({current}/{total})")
+        
+        # 텍스트 처리
+        progress(0.3, desc="텍스트 처리 시작...")
+        result = text_processor.process_text(input_text, progress_callback=progress_callback)
+        
+        if not result.get("success", False):
+            return f"❌ 처리 실패: {result.get('error', 'Unknown error')}", "", "", "", "", ""
+        
+        # 결과 추출
+        progress(0.95, desc="결과 정리 중...")
+        original_text = result["original_text"]
+        separated_text = result["separated_text"]
+        corrected_text = result["corrected_text"]
+        
+        # 화자별 대화 추출
+        conversations = result["conversations_by_speaker_corrected"]
+        speaker1_text = "\n\n".join([f"{i+1}. {utterance}" for i, utterance in enumerate(conversations.get("화자1", []))])
+        speaker2_text = "\n\n".join([f"{i+1}. {utterance}" for i, utterance in enumerate(conversations.get("화자2", []))])
+        
+        progress(1.0, desc="처리 완료!")
+        
+        status_message = f"""
+✅ **처리 완료!**
+- 텍스트명: {result['text_name']}
+- 처리 시간: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
+- 화자1 발언 수: {len(conversations.get('화자1', []))}개
+- 화자2 발언 수: {len(conversations.get('화자2', []))}개
+"""
+        
+        return status_message, original_text, separated_text, corrected_text, speaker1_text, speaker2_text
+        
+    except Exception as e:
+        logger.error(f"텍스트 처리 중 오류: {e}")
+        return f"❌ 처리 중 오류가 발생했습니다: {str(e)}", "", "", "", "", ""
+
+def create_interface():
+    """Gradio 인터페이스를 생성합니다."""
+    
+    # CSS 스타일링
+    css = """
+    .gradio-container {
+        font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+    }
+    .status-box {
+        padding: 15px;
+        border-radius: 8px;
+        margin: 10px 0;
+    }
+    .main-header {
+        text-align: center;
+        color: #2c3e50;
+        margin-bottom: 20px;
+    }
+    """
+    
+    with gr.Blocks(css=css, title="2인 대화 STT 처리기") as interface:
+        
+        # 헤더
+        gr.HTML("""
+        <div class="main-header">
+            <h1>💬 2인 대화 화자 분리기 (AI)</h1>
+            <p>Gemini 2.0 Flash AI를 사용한 텍스트 화자 분리 및 맞춤법 교정</p>
+        </div>
+        """)
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                # 텍스트 입력 섹션
+                gr.Markdown("### 📝 텍스트 입력")
+                text_input = gr.Textbox(
+                    label="2인 대화 텍스트를 입력하세요",
+                    placeholder="두 명이 나누는 대화 내용을 여기에 붙여넣기하세요...\n\n예시:\n안녕하세요, 오늘 회의에 참석해주셔서 감사합니다. 네, 안녕하세요. 준비된 자료가 있나요? 네, 프레젠테이션 자료를 준비했습니다.",
+                    lines=8,
+                    max_lines=15
+                )
+                
+                process_btn = gr.Button(
+                    "🚀 처리 시작",
+                    variant="primary",
+                    size="lg"
+                )
+                
+                # 상태 표시
+                status_output = gr.Markdown(
+                    "### 📊 처리 상태\n준비 완료. 2인 대화 텍스트를 입력하고 '처리 시작' 버튼을 클릭하세요.",
+                    elem_classes=["status-box"]
+                )
+            
+            with gr.Column(scale=2):
+                # 결과 표시 섹션
+                with gr.Tabs():
+                    with gr.TabItem("📝 원본 텍스트"):
+                        original_output = gr.Textbox(
+                            label="입력된 원본 텍스트",
+                            lines=10,
+                            max_lines=20,
+                            placeholder="처리 후 원본 텍스트가 여기에 표시됩니다..."
+                        )
+                    
+                    with gr.TabItem("👥 화자 분리 (원본)"):
+                        separated_output = gr.Textbox(
+                            label="AI 화자 분리 결과 (원본)",
+                            lines=10,
+                            max_lines=20,
+                            placeholder="처리 후 화자별로 분리된 대화가 여기에 표시됩니다..."
+                        )
+                    
+                    with gr.TabItem("✏️ 화자 분리 (교정)"):
+                        corrected_output = gr.Textbox(
+                            label="AI 화자 분리 결과 (맞춤법 교정)",
+                            lines=10,
+                            max_lines=20,
+                            placeholder="처리 후 맞춤법이 교정된 화자 분리 결과가 여기에 표시됩니다..."
+                        )
+                    
+                    with gr.TabItem("👤 화자1 대화"):
+                        speaker1_output = gr.Textbox(
+                            label="화자1의 모든 발언",
+                            lines=10,
+                            max_lines=20,
+                            placeholder="처리 후 화자1의 발언들이 여기에 표시됩니다..."
+                        )
+                    
+                    with gr.TabItem("👤 화자2 대화"):
+                        speaker2_output = gr.Textbox(
+                            label="화자2의 모든 발언",
+                            lines=10,
+                            max_lines=20,
+                            placeholder="처리 후 화자2의 발언들이 여기에 표시됩니다..."
+                        )
+        
+        # 사용법 안내
+        gr.Markdown("""
+        ### 📖 사용법
+        1. **텍스트 입력**: 2인 대화 텍스트를 입력란에 붙여넣기하세요
+        2. **처리 시작**: '🚀 처리 시작' 버튼을 클릭하여 화자 분리를 시작하세요
+        3. **결과 확인**: 각 탭에서 원본 텍스트, 화자 분리 결과, 개별 화자 대화를 확인하세요
+        
+        ### ⚙️ 기술 정보
+        - **화자 분리**: Google Gemini 2.0 Flash
+        - **맞춤법 교정**: 고급 AI 기반 한국어 교정
+        - **지원 언어**: 한국어 최적화
+        - **최적 환경**: 2인 대화, 명확한 문맥
+        
+        ### ⚠️ 주의사항
+        - 처리 시간은 텍스트 길이에 따라 달라집니다 (보통 30초-2분)
+        - Google AI API 사용량 제한이 있을 수 있습니다
+        - 2인 대화에 최적화되어 있습니다
+        - 대화 맥락이 명확할수록 분리 정확도가 높아집니다
+        """)
+        
+        # 이벤트 연결
+        process_btn.click(
+            fn=process_text_input,
+            inputs=[text_input],
+            outputs=[
+                status_output,
+                original_output,
+                separated_output,
+                corrected_output,
+                speaker1_output,
+                speaker2_output
+            ],
+            show_progress=True
+        )
+    
+    return interface
+
+# 메인 실행
+if __name__ == "__main__":
+    logger.info("Gradio 앱을 시작합니다...")
+    
+    # 인터페이스 생성
+    app = create_interface()
+    
+    # 앱 실행
+    app.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=True,
+        show_error=True
+    ) 

audio_summarizer.py

@@ -0,0 +1,491 @@
+import tkinter as tk
+from tkinter import scrolledtext, messagebox, ttk
+import threading
+import os
+import torch
+import whisper
+import google.generativeai as genai
+from dotenv import load_dotenv
+import logging
+import json
+from datetime import datetime
+import glob
+import re
+
+# 환경 변수 로드
+load_dotenv()
+
+# --- 설정: .env 파일에서 API 키를 읽어옵니다 ---
+GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
+
+# logs 폴더 생성
+if not os.path.exists("logs"):
+    os.makedirs("logs")
+
+# output 폴더 생성
+if not os.path.exists("output"):
+    os.makedirs("output")
+
+# data 폴더 생성
+if not os.path.exists("data"):
+    os.makedirs("data")
+
+# 로깅 설정
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('logs/stt_processor.log', encoding='utf-8'),
+        logging.StreamHandler()
+    ]
+)
+logger = logging.getLogger(__name__)
+
+# -----------------------------------------
+
+class STTProcessorApp:
+    def __init__(self, root):
+        self.root = root
+        self.root.title("2인 대화 STT 처리기 (AI 화자 분리)")
+        self.root.geometry("1000x750")
+
+        # 모델 로딩 상태 변수
+        self.models_loaded = False
+        self.whisper_model = None
+        self.gemini_model = None
+
+        # UI 요소 생성
+        self.main_frame = tk.Frame(root, padx=10, pady=10)
+        self.main_frame.pack(fill=tk.BOTH, expand=True)
+
+        # 제목
+        title_label = tk.Label(self.main_frame, text="2인 대화 STT 처리기 (AI 화자 분리)", font=("Arial", 16, "bold"))
+        title_label.pack(pady=5)
+
+        # 설명
+        desc_label = tk.Label(self.main_frame, text="Whisper STT + Gemini AI 화자 분리로 2명의 대화를 자동으로 구분합니다", font=("Arial", 10))
+        desc_label.pack(pady=2)
+
+        # WAV 파일 목록 프레임
+        files_frame = tk.LabelFrame(self.main_frame, text="data 폴더의 WAV 파일 목록", padx=5, pady=5)
+        files_frame.pack(fill=tk.BOTH, expand=True, pady=5)
+
+        # 파일 목록과 스크롤바
+        list_frame = tk.Frame(files_frame)
+        list_frame.pack(fill=tk.BOTH, expand=True)
+
+        scrollbar = tk.Scrollbar(list_frame)
+        scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
+
+        self.file_listbox = tk.Listbox(list_frame, yscrollcommand=scrollbar.set, selectmode=tk.SINGLE)
+        self.file_listbox.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
+        scrollbar.config(command=self.file_listbox.yview)
+
+        # 버튼 프레임
+        button_frame = tk.Frame(self.main_frame)
+        button_frame.pack(fill=tk.X, pady=5)
+
+        self.refresh_button = tk.Button(button_frame, text="파일 목록 새로고침", command=self.refresh_file_list)
+        self.refresh_button.pack(side=tk.LEFT, padx=5)
+
+        self.process_button = tk.Button(button_frame, text="선택된 파일 처리", command=self.start_processing,
+                                        state=tk.DISABLED)
+        self.process_button.pack(side=tk.LEFT, padx=5)
+
+        self.process_all_button = tk.Button(button_frame, text="모든 파일 처리", command=self.start_processing_all,
+                                           state=tk.DISABLED)
+        self.process_all_button.pack(side=tk.LEFT, padx=5)
+
+        # 진행률 표시
+        progress_frame = tk.Frame(self.main_frame)
+        progress_frame.pack(fill=tk.X, pady=5)
+
+        tk.Label(progress_frame, text="진행률:").pack(side=tk.LEFT)
+        self.progress_var = tk.StringVar(value="대기 중")
+        tk.Label(progress_frame, textvariable=self.progress_var).pack(side=tk.LEFT, padx=10)
+
+        self.progress_bar = ttk.Progressbar(progress_frame, mode='determinate')
+        self.progress_bar.pack(side=tk.RIGHT, fill=tk.X, expand=True, padx=10)
+
+        # 상태 표시줄
+        self.status_label = tk.Label(self.main_frame, text="준비 완료. Google API 키를 설정하고 '처리' 버튼을 누르세요.", bd=1,
+                                     relief=tk.SUNKEN, anchor=tk.W)
+        self.status_label.pack(side=tk.BOTTOM, fill=tk.X)
+
+        # 결과 출력 영역
+        result_frame = tk.LabelFrame(self.main_frame, text="처리 결과", padx=5, pady=5)
+        result_frame.pack(fill=tk.BOTH, expand=True, pady=5)
+
+        self.result_text = scrolledtext.ScrolledText(result_frame, wrap=tk.WORD, state=tk.DISABLED, height=15)
+        self.result_text.pack(fill=tk.BOTH, expand=True)
+
+        # 초기 파일 목록 로드
+        self.refresh_file_list()
+
+    def refresh_file_list(self):
+        """data 폴더의 WAV 파일 목록을 새로고침합니다."""
+        self.file_listbox.delete(0, tk.END)
+        
+        wav_files = glob.glob("data/*.wav")
+        if wav_files:
+            for file_path in wav_files:
+                filename = os.path.basename(file_path)
+                self.file_listbox.insert(tk.END, filename)
+            self.process_button.config(state=tk.NORMAL)
+            self.process_all_button.config(state=tk.NORMAL)
+            logger.info(f"{len(wav_files)}개의 WAV 파일을 발견했습니다.")
+        else:
+            self.file_listbox.insert(tk.END, "WAV 파일이 없습니다. data 폴더에 WAV 파일을 넣어주세요.")
+            self.process_button.config(state=tk.DISABLED)
+            self.process_all_button.config(state=tk.DISABLED)
+            logger.warning("data 폴더에 WAV 파일이 없습니다.")
+
+    def update_status(self, message):
+        """UI의 상태 메시지를 업데이트합니다."""
+        self.status_label.config(text=message)
+        self.root.update_idletasks()
+
+    def update_progress(self, current, total, message=""):
+        """진행률을 업데이트합니다."""
+        if total > 0:
+            progress = (current / total) * 100
+            self.progress_bar.config(value=progress)
+            if message:
+                self.progress_var.set(f"{message} ({current}/{total})")
+            else:
+                self.progress_var.set(f"{current}/{total}")
+        self.root.update_idletasks()
+
+    def show_result(self, content):
+        """결과 텍스트 영역에 내용을 표시합니다."""
+        self.result_text.config(state=tk.NORMAL)
+        self.result_text.insert(tk.END, content + "\n\n")
+        self.result_text.see(tk.END)
+        self.result_text.config(state=tk.DISABLED)
+
+    def load_models(self):
+        """필요한 AI 모델들을 로드합니다."""
+        try:
+            if not GOOGLE_API_KEY or GOOGLE_API_KEY == "your_google_api_key_here":
+                messagebox.showerror("API 키 오류", ".env 파일에 올바른 Google AI API 키를 입력해주세요.")
+                logger.error("Google API 키가 설정되지 않았습니다.")
+                return False
+
+            logger.info("모델 로딩을 시작합니다.")
+            self.update_status("모델 로딩 중... (최초 실행 시 시간이 걸릴 수 있습니다)")
+
+            # Whisper 모델 로딩
+            self.update_status("음성 인식 모델(Whisper) 로딩 중...")
+            logger.info("Whisper 모델 로딩을 시작합니다.")
+            self.whisper_model = whisper.load_model("base")  # "small", "medium", "large" 등으로 변경 가능
+            logger.info("Whisper 모델 로딩이 완료되었습니다.")
+
+            # Gemini 모델 설정
+            self.update_status("AI 화자 분리 모델(Gemini) 설정 중...")
+            logger.info("Gemini 모델 설정을 시작합니다.")
+            genai.configure(api_key=GOOGLE_API_KEY)
+            # gemini-2.0-flash: 최신 Gemini 2.0 모델, 빠르고 정확한 처리
+            self.gemini_model = genai.GenerativeModel('gemini-2.0-flash')
+            logger.info("Gemini 2.0 Flash 모델 설정이 완료되었습니다.")
+
+            self.models_loaded = True
+            self.update_status("모든 모델 로딩 완료. 처리 준비 완료.")
+            logger.info("모든 모델 로딩이 완료되었습니다.")
+            return True
+        except Exception as e:
+            error_msg = f"모델을 로딩하는 중 오류가 발생했습니다: {e}"
+            messagebox.showerror("모델 로딩 오류", error_msg)
+            logger.error(error_msg)
+            self.update_status("오류: 모델 로딩 실패")
+            return False
+
+    def start_processing(self):
+        """선택된 파일 처리 시작."""
+        selection = self.file_listbox.curselection()
+        if not selection:
+            messagebox.showwarning("파일 미선택", "처리할 파일을 선택해주세요.")
+            return
+        
+        filename = self.file_listbox.get(selection[0])
+        if filename == "WAV 파일이 없습니다. data 폴더에 WAV 파일을 넣어주세요.":
+            return
+            
+        self.process_files([filename])
+
+    def start_processing_all(self):
+        """모든 파일 처리 시작."""
+        wav_files = glob.glob("data/*.wav")
+        if not wav_files:
+            messagebox.showwarning("파일 없음", "data 폴더에 처리할 WAV 파일이 없습니다.")
+            return
+            
+        filenames = [os.path.basename(f) for f in wav_files]
+        self.process_files(filenames)
+
+    def process_files(self, filenames):
+        """파일 처리 시작."""
+        # 모델이 로드되지 않았으면 먼저 로드
+        if not self.models_loaded:
+            if not self.load_models():
+                return  # 모델 로딩 실패 시 중단
+
+        # UI 비활성화 및 처리 스레드 시작
+        self.refresh_button.config(state=tk.DISABLED)
+        self.process_button.config(state=tk.DISABLED)
+        self.process_all_button.config(state=tk.DISABLED)
+
+        processing_thread = threading.Thread(target=self.process_audio_files, args=(filenames,))
+        processing_thread.start()
+
+    def process_audio_files(self, filenames):
+        """백그라운드에서 여러 오디오 파일을 처리하는 메인 로직."""
+        try:
+            total_files = len(filenames)
+            logger.info(f"{total_files}개의 파일 처리를 시작합니다.")
+            
+            for idx, filename in enumerate(filenames):
+                file_path = os.path.join("data", filename)
+                self.update_progress(idx, total_files, f"처리 중: {filename}")
+                
+                result = self.process_single_audio_file(file_path, filename)
+                if result:
+                    self.show_result(f"✅ {filename} 처리 완료")
+                else:
+                    self.show_result(f"❌ {filename} 처리 실패")
+            
+            self.update_progress(total_files, total_files, "완료")
+            self.update_status("모든 파일 처리 완료!")
+            logger.info("모든 파일 처리가 완료되었습니다.")
+
+        except Exception as e:
+            error_msg = f"파일 처리 중 오류가 발생했습니다: {e}"
+            logger.error(error_msg)
+            self.update_status(f"오류: {e}")
+        finally:
+            # UI 다시 활성화
+            self.refresh_button.config(state=tk.NORMAL)
+            self.process_button.config(state=tk.NORMAL)
+            self.process_all_button.config(state=tk.NORMAL)
+
+    def process_single_audio_file(self, file_path, filename):
+        """단일 오디오 파일을 처리합니다."""
+        try:
+            logger.info(f"파일 처리 시작: {file_path}")
+            base_name = os.path.splitext(filename)[0]
+            
+            # 1단계: Whisper로 음성 인식
+            self.update_status(f"1/4: 음성 인식 진행 중: {filename}")
+            logger.info(f"음성 인식 시작: {filename}")
+            
+            result = self.whisper_model.transcribe(file_path)
+            full_text = result['text'].strip()
+            
+            if not full_text:
+                logger.warning(f"파일 {filename}에서 텍스트를 추출할 수 없습니다.")
+                return False
+            
+            # 2단계: Gemini로 화자 분리
+            self.update_status(f"2/4: AI 화자 분리 진행 중: {filename}")
+            logger.info(f"AI 화자 분리 시작: {filename}")
+            
+            speaker_separated_text = self.separate_speakers_with_gemini(full_text)
+            
+            # 3단계: 맞춤법 교정
+            self.update_status(f"3/4: 맞춤법 교정 진행 중: {filename}")
+            logger.info(f"맞춤법 교정 시작: {filename}")
+            
+            corrected_text = self.correct_spelling_with_gemini(speaker_separated_text)
+            
+            # 4단계: 결과 저장
+            self.update_status(f"4/4: 결과 저장 중: {filename}")
+            self.save_separated_conversations(base_name, full_text, speaker_separated_text, corrected_text, result)
+            
+            logger.info(f"파일 처리 완료: {filename}")
+            return True
+
+        except Exception as e:
+            logger.error(f"파일 {filename} 처리 중 오류: {e}")
+            return False
+
+    def separate_speakers_with_gemini(self, text):
+        """Gemini API를 사용하여 텍스트를 화자별로 분리합니다."""
+        try:
+            prompt = f"""
+당신은 2명의 화자가 나누는 대화를 분석하는 전문가입니다. 
+주어진 텍스트를 분석하여 각 발언을 화자별로 구분해주세요.
+
+분석 지침:
+1. 대화의 맥락과 내용을 기반으로 화자를 구분하세요
+2. 말투, 주제 전환, 질문과 답변의 패턴을 활용하세요
+3. 화자1과 화자2로 구분하여 표시하세요
+4. 각 발언 앞에 [화자1] 또는 [화자2]를 붙여주세요
+5. 발언이 너무 길 경우 자연스러운 지점에서 나누어주세요
+
+출력 형식:
+[화자1] 첫 번째 발언 내용
+[화자2] 두 번째 발언 내용
+[화자1] 세 번째 발언 내용
+...
+
+분석할 텍스트:
+{text}
+"""
+
+            response = self.gemini_model.generate_content(prompt)
+            separated_text = response.text.strip()
+            
+            logger.info("Gemini를 통한 화자 분리가 완료되었습니다.")
+            return separated_text
+            
+        except Exception as e:
+            logger.error(f"Gemini 화자 분리 중 오류: {e}")
+            return f"[오류] 화자 분리 실패: {str(e)}"
+
+    def correct_spelling_with_gemini(self, separated_text):
+        """Gemini API를 사용하여 화자별 분리된 텍스트의 맞춤법을 교정합니다."""
+        try:
+            prompt = f"""
+당신은 한국어 맞춤법 교정 전문가입니다. 
+주어진 텍스트에서 맞춤법 오류, 띄어쓰기 오류, 오타를 수정해주세요.
+
+교정 지침:
+1. 자연스러운 한국어 표현으로 수정하되, 원본의 의미와 말투는 유지하세요
+2. [화자1], [화자2] 태그는 그대로 유지하세요
+3. 전문 용어나 고유명사는 가능한 정확하게 수정하세요
+4. 구어체 특성은 유���하되, 명백한 오타만 수정하세요
+5. 문맥에 맞는 올바른 단어로 교체하세요
+
+수정이 필요한 예시:
+- "치특기" → "치트키"
+- "실점픽" → "실전 픽"  
+- "복사부천억" → "복사 붙여넣기"
+- "핵심같이가" → "핵심 가치가"
+- "재활" → "재활용"
+- "저정할" → "저장할"
+- "플레일" → "플레어"
+- "서벌 수" → "서버리스"
+- "커리" → "쿼리"
+- "전력" → "전략"
+- "클라클라" → "클라크"
+- "가인만" → "가입만"
+- "M5U" → "MAU"
+- "나온 로도" → "다운로드"
+- "무시무치" → "무시무시"
+- "송신유금" → "송신 요금"
+- "10지가" → "10GB"
+- "유금" → "요금"
+- "전 색을" → "전 세계"
+- "도무원은" → "도구들은"
+- "골차품데" → "골치 아픈데"
+- "변원해" → "변환해"
+- "f 운영" → "서비스 운영"
+- "오류추저개" → "오류 추적기"
+- "f 늘려질" → "서비스가 늘어날"
+- "캐시칭" → "캐싱"
+- "플레이어" → "플레어"
+- "업스테시" → "업스태시"
+- "원시근을" → "웬지슨"
+- "부각이릉도" → "부각들도"
+- "컴포넌트" → "컴포넌트"
+- "본이터링" → "모니터링"
+- "번뜨기는" → "번뜩이는"
+- "사용적 경험" → "사용자 경험"
+
+교정할 텍스트:
+{separated_text}
+"""
+
+            response = self.gemini_model.generate_content(prompt)
+            corrected_text = response.text.strip()
+            
+            logger.info("Gemini를 통한 맞춤법 교정이 완료되었습니다.")
+            return corrected_text
+            
+        except Exception as e:
+            logger.error(f"Gemini 맞춤법 교정 중 오류: {e}")
+            return separated_text  # 오류 발생 시 원본 반환
+
+    def parse_separated_text(self, separated_text):
+        """화자별로 분리된 텍스트를 파싱하여 구조화합니다."""
+        conversations = {
+            "화자1": [],
+            "화자2": []
+        }
+        
+        # 정규표현식으로 화자별 발언 추출
+        pattern = r'\[화자([12])\]\s*(.+?)(?=\[화자[12]\]|$)'
+        matches = re.findall(pattern, separated_text, re.DOTALL)
+        
+        for speaker_num, content in matches:
+            speaker = f"화자{speaker_num}"
+            content = content.strip()
+            if content:
+                conversations[speaker].append(content)
+        
+        return conversations
+
+    def save_separated_conversations(self, base_name, original_text, separated_text, corrected_text, whisper_result):
+        """화자별로 분리되고 맞춤법이 교정된 대화 내용을 파일로 저장합니다."""
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        
+        # 교정된 텍스트에서 화자별 대화 파싱
+        corrected_conversations = self.parse_separated_text(corrected_text)
+        
+        # 원본 화자별 대화 파싱 (비교용)
+        original_conversations = self.parse_separated_text(separated_text)
+        
+        # 1. 전체 대화 저장 (원본, 화자 분리, 맞춤법 교정 포함)
+        all_txt_path = f"output/{base_name}_전체대화_{timestamp}.txt"
+        with open(all_txt_path, 'w', encoding='utf-8') as f:
+            f.write(f"파일명: {base_name}\n")
+            f.write(f"처리 시간: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
+            f.write(f"언어: {whisper_result.get('language', 'unknown')}\n")
+            f.write("="*50 + "\n\n")
+            f.write("원본 텍스트:\n")
+            f.write(original_text + "\n\n")
+            f.write("="*50 + "\n\n")
+            f.write("화자별 분리 결과 (원본):\n")
+            f.write(separated_text + "\n\n")
+            f.write("="*50 + "\n\n")
+            f.write("화자별 분리 결과 (맞춤법 교정):\n")
+            f.write(corrected_text + "\n")
+        
+        # 2. 교정된 화자별 개별 파일 저장
+        for speaker, utterances in corrected_conversations.items():
+            if utterances:
+                speaker_txt_path = f"output/{base_name}_{speaker}_교정본_{timestamp}.txt"
+                with open(speaker_txt_path, 'w', encoding='utf-8') as f:
+                    f.write(f"파일명: {base_name}\n")
+                    f.write(f"화자: {speaker}\n")
+                    f.write(f"처리 시간: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
+                    f.write(f"발언 수: {len(utterances)}\n")
+                    f.write("="*50 + "\n\n")
+                    
+                    for idx, utterance in enumerate(utterances, 1):
+                        f.write(f"{idx}. {utterance}\n\n")
+        
+        # 3. JSON 형태로도 저장 (분석용)
+        json_path = f"output/{base_name}_data_{timestamp}.json"
+        json_data = {
+            "filename": base_name,
+            "processed_time": datetime.now().isoformat(),
+            "language": whisper_result.get("language", "unknown"),
+            "original_text": original_text,
+            "separated_text": separated_text,
+            "corrected_text": corrected_text,
+            "conversations_by_speaker_original": original_conversations,
+            "conversations_by_speaker_corrected": corrected_conversations,
+            "segments": whisper_result.get("segments", [])
+        }
+        
+        with open(json_path, 'w', encoding='utf-8') as f:
+            json.dump(json_data, f, ensure_ascii=False, indent=2)
+        
+        logger.info(f"결과 저장 완료: {all_txt_path}, {json_path}")
+        logger.info(f"교정된 화자별 파일도 저장되었습니다.")
+
+
+if __name__ == "__main__":
+    root = tk.Tk()
+    app = STTProcessorApp(root)
+    root.mainloop()

check_models.py

@@ -0,0 +1,33 @@
+import google.generativeai as genai
+from dotenv import load_dotenv
+import os
+
+def list_available_models():
+    """사용 가능한 Gemini 모델 목록을 확인합니다"""
+    
+    load_dotenv()
+    GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
+    
+    if not GOOGLE_API_KEY or GOOGLE_API_KEY == "your_google_api_key_here":
+        print("ERROR: Please set GOOGLE_API_KEY in .env file")
+        return
+    
+    try:
+        genai.configure(api_key=GOOGLE_API_KEY)
+        
+        print("Available Gemini models:")
+        print("=" * 50)
+        
+        models = genai.list_models()
+        for model in models:
+            if 'generateContent' in model.supported_generation_methods:
+                print(f"[OK] {model.name}")
+                print(f"   Display name: {model.display_name}")
+                print(f"   Description: {model.description}")
+                print()
+        
+    except Exception as e:
+        print(f"Error: {e}")
+
+if __name__ == "__main__":
+    list_available_models()

data/.gitkeep

@@ -0,0 +1,2 @@
+# 이 파일은 data 폴더 구조를 유지하기 위한 파일입니다.
+# WAV 파일을 이 폴더에 넣어주세요.

deployment_guide.md

@@ -0,0 +1,154 @@
+# 🚀 허깅페이스 Spaces 배포 가이드
+
+## 📋 배포 준비사항
+
+### 1. 필수 파일 확인
+- `app.py` (메인 애플리케이션)
+- `stt_processor.py` (STT 처리 모듈)
+- `requirements.txt` (의존성)
+- `README.md` (허깅페이스용 설명)
+
+### 2. Google AI API 키 준비
+1. [Google AI Studio](https://aistudio.google.com/app/apikey) 접속
+2. Google 계정으로 로그인
+3. "Create API Key" 클릭
+4. 생성된 API 키 복사 (나중에 Hugging Face에서 사용)
+
+## 🔧 허깅페이스 Spaces 배포 단계
+
+### 1단계: Hugging Face 계정 생성
+1. [Hugging Face](https://huggingface.co/) 접속
+2. 계정 생성 또는 로그인
+
+### 2단계: 새 Space 생성
+1. 프로필 페이지에서 "Spaces" 탭 클릭
+2. "Create new Space" 버튼 클릭
+3. 설정:
+   - **Space name**: `stt-speaker-separation` (또는 원하는 이름)
+   - **License**: MIT
+   - **SDK**: Gradio
+   - **Hardware**: CPU basic (무료)
+   - **Visibility**: Public
+
+### 3단계: 코드 업로드
+다음 방법 중 하나 선택:
+
+#### 방법 A: 웹 인터페이스 사용
+1. Space 페이지에서 "Files" 탭 클릭
+2. "Upload files" 클릭
+3. 다음 파일들을 업로드:
+   - `app.py`
+   - `stt_processor.py`
+   - `requirements.txt`
+   - `README.md`
+
+#### 방법 B: Git 사용
+```bash
+# Space 복제
+git clone https://huggingface.co/spaces/YOUR_USERNAME/YOUR_SPACE_NAME
+cd YOUR_SPACE_NAME
+
+# 파일 복사
+copy app.py .
+copy stt_processor.py .
+copy requirements.txt .
+copy README.md .
+
+# 커밋 및 푸시
+git add .
+git commit -m "Initial upload of STT speaker separation app"
+git push
+```
+
+### 4단계: 환경 변수 설정
+1. Space 페이지에서 "Settings" 탭 클릭
+2. "Repository secrets" 섹션 찾기
+3. "New secret" 클릭
+4. 다음 입력:
+   - **Name**: `GOOGLE_API_KEY`
+   - **Value**: 앞서 복사한 Google AI API 키
+5. "Add secret" 클릭
+
+### 5단계: 앱 빌드 및 실행 확인
+1. Space가 자동으로 빌드 시작됨
+2. 빌드 로그에서 오류 확인
+3. 빌드 완료 후 앱 인터페이스 확인
+
+## 🔍 빌드 로그 확인 포인트
+
+### 정상 빌드 시 나타나는 로그:
+```
+Installing dependencies from requirements.txt...
+✓ torch
+✓ torchaudio
+✓ openai-whisper
+✓ google-generativeai
+✓ gradio
+✓ spaces
+```
+
+### 주의해야 할 오류:
+- **ModuleNotFoundError**: requirements.txt 확인
+- **API Key Error**: 환경 변수 설정 확인
+- **CUDA/GPU 오류**: CPU 빌드 환경이므로 정상
+
+## 📊 성능 최적화
+
+### CPU 환경 최적화:
+1. Whisper 모델을 "base"로 유지 (더 작은 모델 사용)
+2. 배치 처리 대신 단일 파일 처리 사용
+3. 메모리 사용량 모니터링
+
+### 사용자 경험 개선:
+1. 파일 크기 제한 안내
+2. 처리 시간 예상 안내
+3. 에러 메시지 명확화
+
+## 🌐 배포 후 공유
+
+### Space URL:
+`https://huggingface.co/spaces/YOUR_USERNAME/YOUR_SPACE_NAME`
+
+### 임베드 코드:
+```html
+<iframe
+    src="https://your-username-your-space-name.hf.space"
+    frameborder="0"
+    width="850"
+    height="450"
+></iframe>
+```
+
+## 🛠 문제 해결
+
+### 자주 발생하는 문제:
+
+#### 1. API 키 인식 불가
+- Settings → Repository secrets에서 `GOOGLE_API_KEY` 확인
+- 키에 특수문자나 공백이 없는지 확인
+
+#### 2. 모델 로딩 시간 초과
+- Whisper 모델 크기 조정 (`base` → `tiny`)
+- 타임아웃 설정 증가
+
+#### 3. 메모리 부족
+- 동시 처리 요청 수 제한
+- 파일 크기 제한 설정
+
+#### 4. 빌드 실패
+- requirements.txt의 패키지 버전 호환성 확인
+- Python 버전 호환성 확인
+
+## 📞 지원
+
+- [Hugging Face 포럼](https://discuss.huggingface.co/)
+- [Gradio 문서](https://gradio.app/docs/)
+- [OpenAI Whisper GitHub](https://github.com/openai/whisper)
+
+## 🎉 배포 완료!
+
+배포가 성공적으로 완료되면:
+1. 공개 URL을 통해 누구나 접근 가능
+2. 자동으로 SSL 인증서 적용
+3. CDN을 통한 전세계 접근 가능
+4. 사용량 통계 확인 가능 

env_example.txt

@@ -0,0 +1,17 @@
+# 환경 변수 설정 가이드
+
+## 로컬 개발 시 (.env 파일 생성)
+GOOGLE_API_KEY=your_google_api_key_here
+
+## 허깅페이스 Spaces 배포 시
+1. Hugging Face Space 페이지 접속
+2. Settings 탭 클릭
+3. Repository secrets 섹션에서 추가:
+   - Name: GOOGLE_API_KEY
+   - Value: 실제 API 키 값
+
+## Google AI API 키 발급
+1. https://aistudio.google.com/app/apikey 접속
+2. Google 계정으로 로그인
+3. "Create API Key" 클릭
+4. 생성된 키를 복사하여 사용 

output/.gitkeep

@@ -0,0 +1,2 @@
+# 이 파일은 output 폴더 구조를 유지하기 위한 파일입니다.
+# 처리 결과 파일들이 이 폴더에 저장됩니다.

requirements.txt

@@ -0,0 +1,4 @@
+python-dotenv
+google-generativeai
+gradio
+spaces

stt_processor.py

@@ -0,0 +1,294 @@
+import os
+import google.generativeai as genai
+from dotenv import load_dotenv
+import logging
+import json
+from datetime import datetime
+import re
+
+# 환경 변수 로드
+load_dotenv()
+
+# 로깅 설정
+logger = logging.getLogger(__name__)
+
+class TextProcessor:
+    """
+    텍스트를 AI를 통한 화자 분리 및 맞춤법 교정을 수행하는 클래스
+    """
+    
+    def __init__(self, google_api_key=None):
+        """
+        TextProcessor 초기화
+        
+        Args:
+            google_api_key (str): Google AI API 키. None인 경우 환경 변수에서 읽음
+        """
+        self.google_api_key = google_api_key or os.getenv("GOOGLE_API_KEY")
+        self.gemini_model = None
+        self.models_loaded = False
+        
+        if not self.google_api_key or self.google_api_key == "your_google_api_key_here":
+            raise ValueError("Google AI API 키가 설정되지 않았습니다. 환경 변수 GOOGLE_API_KEY를 설정하거나 매개변수로 전달하세요.")
+    
+    def load_models(self):
+        """Gemini AI 모델을 로드합니다."""
+        try:
+            logger.info("Gemini 모델 로딩을 시작합니다.")
+            
+            # Gemini 모델 설정
+            genai.configure(api_key=self.google_api_key)
+            self.gemini_model = genai.GenerativeModel('gemini-2.0-flash')
+            logger.info("Gemini 2.0 Flash 모델 설정이 완료되었습니다.")
+            
+            self.models_loaded = True
+            logger.info("Gemini 모델 로딩이 완료되었습니다.")
+            return True
+            
+        except Exception as e:
+            error_msg = f"Gemini 모델을 로딩하는 중 오류가 발생했습니다: {e}"
+            logger.error(error_msg)
+            raise Exception(error_msg)
+    
+    def process_text(self, input_text, text_name=None, progress_callback=None):
+        """
+        텍스트를 처리하여 화자 분리 및 맞춤법 교정을 수행합니다.
+        
+        Args:
+            input_text (str): 처리할 텍스트
+            text_name (str): 텍스트 이름 (선택사항)
+            progress_callback (function): 진행 상황을 알려주는 콜백 함수
+            
+        Returns:
+            dict: 처리 결과 딕셔너리
+        """
+        if not self.models_loaded:
+            self.load_models()
+        
+        try:
+            text_name = text_name or f"text_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
+            logger.info(f"텍스트 처리 시작: {text_name}")
+            
+            # 입력 텍스트 검증
+            if not input_text or not input_text.strip():
+                raise ValueError("처리할 텍스트가 비어 있습니다.")
+            
+            full_text = input_text.strip()
+            
+            # 1단계: Gemini로 화자 분리
+            if progress_callback:
+                progress_callback("AI 화자 분리 중...", 1, 3)
+            logger.info(f"AI 화자 분리 시작: {text_name}")
+            
+            speaker_separated_text = self.separate_speakers_with_gemini(full_text)
+            
+            # 2단계: 맞춤법 교정
+            if progress_callback:
+                progress_callback("맞춤법 교정 중...", 2, 3)
+            logger.info(f"맞춤법 교정 시작: {text_name}")
+            
+            corrected_text = self.correct_spelling_with_gemini(speaker_separated_text)
+            
+            # 3단계: 결과 파싱
+            if progress_callback:
+                progress_callback("결과 정리 중...", 3, 3)
+            
+            # 교정된 텍스트에서 화자별 대화 파싱
+            corrected_conversations = self.parse_separated_text(corrected_text)
+            original_conversations = self.parse_separated_text(speaker_separated_text)
+            
+            # 결과 딕셔너리 생성
+            processing_result = {
+                "text_name": text_name,
+                "processed_time": datetime.now().isoformat(),
+                "original_text": full_text,
+                "separated_text": speaker_separated_text,
+                "corrected_text": corrected_text,
+                "conversations_by_speaker_original": original_conversations,
+                "conversations_by_speaker_corrected": corrected_conversations,
+                "success": True
+            }
+            
+            logger.info(f"텍스트 처리 완료: {text_name}")
+            return processing_result
+            
+        except Exception as e:
+            logger.error(f"텍스트 {text_name} 처리 중 오류: {e}")
+            return {
+                "text_name": text_name or "unknown",
+                "success": False,
+                "error": str(e)
+            }
+    
+    def separate_speakers_with_gemini(self, text):
+        """Gemini API를 사용하여 텍스트를 화자별로 분리합니다."""
+        try:
+            prompt = f"""
+당신은 2명의 화자가 나누는 대화를 분석하는 전문��입니다. 
+주어진 텍스트를 분석하여 각 발언을 화자별로 구분해주세요.
+
+분석 지침:
+1. 대화의 맥락과 내용을 기반으로 화자를 구분하세요
+2. 말투, 주제 전환, 질문과 답변의 패턴을 활용하세요
+3. 화자1과 화자2로 구분하여 표시하세요
+4. 각 발언 앞에 [화자1] 또는 [화자2]를 붙여주세요
+5. 발언이 너무 길 경우 자연스러운 지점에서 나누어주세요
+
+출력 형식:
+[화자1] 첫 번째 발언 내용
+[화자2] 두 번째 발언 내용
+[화자1] 세 번째 발언 내용
+...
+
+분석할 텍스트:
+{text}
+"""
+
+            response = self.gemini_model.generate_content(prompt)
+            separated_text = response.text.strip()
+            
+            logger.info("Gemini를 통한 화자 분리가 완료되었습니다.")
+            return separated_text
+            
+        except Exception as e:
+            logger.error(f"Gemini 화자 분리 중 오류: {e}")
+            return f"[오류] 화자 분리 실패: {str(e)}"
+
+    def correct_spelling_with_gemini(self, separated_text):
+        """Gemini API를 사용하여 화자별 분리된 텍스트의 맞춤법을 교정합니다."""
+        try:
+            prompt = f"""
+당신은 한국어 맞춤법 교정 전문가입니다. 
+주어진 텍스트에서 맞춤법 오류, 띄어쓰기 오류, 오타를 수정해주세요.
+
+교정 지침:
+1. 자연스러운 한국어 표현으로 수정하되, 원본의 의미와 말투는 유지하세요
+2. [화자1], [화자2] 태그는 그대로 유지하세요
+3. 전문 용어나 고유명사는 가능한 정확하게 수정하세요
+4. 구어체 특성은 유지하되, 명백한 오타만 수정하세요
+5. 문맥에 맞는 올바른 단어로 교체하세요
+
+수정이 필요한 예시:
+- "치특기" → "치트키"
+- "실점픽" → "실전 픽"  
+- "복사부천억" → "복사 붙여넣기"
+- "핵심같이가" → "핵심 가치가"
+- "재활" → "재활용"
+- "저정할" → "저장할"
+- "플레일" → "플레어"
+- "서벌 수" → "서버리스"
+- "커리" → "쿼리"
+- "전력" → "전략"
+- "클라클라" → "클라크"
+- "가인만" → "가입만"
+- "M5U" → "MAU"
+- "나온 로도" → "다운로드"
+- "무시무치" → "무시무시"
+- "송신유금" → "송신 요금"
+- "10지가" → "10GB"
+- "유금" → "요금"
+- "전 색을" → "전 세계"
+- "도무원은" → "도구들은"
+- "골차품데" → "골치 아픈데"
+- "변원해" → "변환해"
+- "f 운영" → "서비스 운영"
+- "오류추저개" → "오류 추적기"
+- "f 늘려질" → "서비스가 늘어날"
+- "캐시칭" → "캐싱"
+- "플레이어" → "플레어"
+- "업스테시" → "업스태시"
+- "원시근을" → "웬지슨"
+- "부각이릉도" → "부각들도"
+- "컴포넌트" → "컴포넌트"
+- "본이터링" → "모니터링"
+- "번뜨기는" → "번뜩이는"
+- "사용적 경험" → "사용자 경험"
+
+교정할 텍스트:
+{separated_text}
+"""
+
+            response = self.gemini_model.generate_content(prompt)
+            corrected_text = response.text.strip()
+            
+            logger.info("Gemini를 통한 맞춤법 교정이 완료되었습니다.")
+            return corrected_text
+            
+        except Exception as e:
+            logger.error(f"Gemini 맞춤법 교정 중 오류: {e}")
+            return separated_text  # 오류 발생 시 원본 반환
+
+    def parse_separated_text(self, separated_text):
+        """화자별로 분리된 텍스트를 파싱하여 구조화합니다."""
+        conversations = {
+            "화자1": [],
+            "화자2": []
+        }
+        
+        # 정규표현식으로 화자별 발언 추출
+        pattern = r'\[화자([12])\]\s*(.+?)(?=\[화자[12]\]|$)'
+        matches = re.findall(pattern, separated_text, re.DOTALL)
+        
+        for speaker_num, content in matches:
+            speaker = f"화자{speaker_num}"
+            content = content.strip()
+            if content:
+                conversations[speaker].append(content)
+        
+        return conversations
+    
+    def save_results_to_files(self, result, output_dir="output"):
+        """처리 결과를 파일로 저장합니다."""
+        if not result.get("success", False):
+            logger.error(f"결과 저장 실패: {result.get('error', 'Unknown error')}")
+            return False
+        
+        try:
+            # output 폴더 생성
+            if not os.path.exists(output_dir):
+                os.makedirs(output_dir)
+            
+            base_name = result["base_name"]
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            
+            # 1. 전체 대화 저장 (원본, 화자 분리, 맞춤법 교정 포함)
+            all_txt_path = f"{output_dir}/{base_name}_전체대화_{timestamp}.txt"
+            with open(all_txt_path, 'w', encoding='utf-8') as f:
+                f.write(f"파일명: {base_name}\n")
+                f.write(f"처리 ��간: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
+                f.write(f"언어: {result['language']}\n")
+                f.write("="*50 + "\n\n")
+                f.write("원본 텍스트:\n")
+                f.write(result['original_text'] + "\n\n")
+                f.write("="*50 + "\n\n")
+                f.write("화자별 분리 결과 (원본):\n")
+                f.write(result['separated_text'] + "\n\n")
+                f.write("="*50 + "\n\n")
+                f.write("화자별 분리 결과 (맞춤법 교정):\n")
+                f.write(result['corrected_text'] + "\n")
+            
+            # 2. 교정된 화자별 개별 파일 저장
+            for speaker, utterances in result['conversations_by_speaker_corrected'].items():
+                if utterances:
+                    speaker_txt_path = f"{output_dir}/{base_name}_{speaker}_교정본_{timestamp}.txt"
+                    with open(speaker_txt_path, 'w', encoding='utf-8') as f:
+                        f.write(f"파일명: {base_name}\n")
+                        f.write(f"화자: {speaker}\n")
+                        f.write(f"처리 시간: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
+                        f.write(f"발언 수: {len(utterances)}\n")
+                        f.write("="*50 + "\n\n")
+                        
+                        for idx, utterance in enumerate(utterances, 1):
+                            f.write(f"{idx}. {utterance}\n\n")
+            
+            # 3. JSON 형태로도 저장 (분석용)
+            json_path = f"{output_dir}/{base_name}_data_{timestamp}.json"
+            with open(json_path, 'w', encoding='utf-8') as f:
+                json.dump(result, f, ensure_ascii=False, indent=2)
+            
+            logger.info(f"결과 파일 저장 완료: {output_dir}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"결과 파일 저장 중 오류: {e}")
+            return False 

test_gradio.py

@@ -0,0 +1,135 @@
+#!/usr/bin/env python3
+"""
+Gradio 앱 기본 기능 테스트 스크립트
+"""
+
+import os
+import sys
+import logging
+
+# 로깅 설정
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+def test_imports():
+    """필수 모듈 import 테스트"""
+    try:
+        import gradio as gr
+        logger.info(f"✓ Gradio 버전: {gr.__version__}")
+        
+        import torch
+        logger.info(f"✓ PyTorch 버전: {torch.__version__}")
+        
+        import whisper
+        logger.info("✓ OpenAI Whisper 가져오기 성공")
+        
+        import google.generativeai as genai
+        logger.info("✓ Google Generative AI 가져오기 성공")
+        
+        from stt_processor import STTProcessor
+        logger.info("✓ STTProcessor 모듈 가져오기 성공")
+        
+        return True
+        
+    except ImportError as e:
+        logger.error(f"❌ 모듈 import 실패: {e}")
+        return False
+
+def test_stt_processor_init():
+    """STTProcessor 초기화 테스트 (API 키 없이)"""
+    try:
+        from stt_processor import STTProcessor
+        
+        # API 키 없이 초기화 시도 (예상되는 오류)
+        try:
+            processor = STTProcessor()
+            logger.error("❌ API 키 없이 초기화 성공 (예상되지 않음)")
+            return False
+        except ValueError as e:
+            logger.info(f"✓ API 키 검증 로직 정상 작동: {e}")
+            return True
+        
+    except Exception as e:
+        logger.error(f"❌ STTProcessor 테스트 실패: {e}")
+        return False
+
+def test_gradio_interface():
+    """Gradio 인터페이스 생성 테스트"""
+    try:
+        from app import create_interface
+        
+        # 인터페이스 생성 테스트
+        interface = create_interface()
+        logger.info("✓ Gradio 인터페이스 생성 성공")
+        
+        # 인터페이스 구성 요소 확인
+        if hasattr(interface, 'blocks'):
+            logger.info("✓ Gradio Blocks 구조 확인")
+        
+        return True
+        
+    except Exception as e:
+        logger.error(f"❌ Gradio 인터페이스 테스트 실패: {e}")
+        return False
+
+def test_file_structure():
+    """필수 파일 구조 확인"""
+    required_files = [
+        'app.py',
+        'stt_processor.py', 
+        'requirements.txt',
+        'README.md',
+        'deployment_guide.md'
+    ]
+    
+    missing_files = []
+    for file in required_files:
+        if not os.path.exists(file):
+            missing_files.append(file)
+    
+    if missing_files:
+        logger.error(f"❌ 누락된 파일: {missing_files}")
+        return False
+    else:
+        logger.info("✓ 모든 필수 파일 존재 확인")
+        return True
+
+def main():
+    """테스트 실행"""
+    logger.info("🧪 Gradio STT 앱 테스트 시작")
+    logger.info("=" * 50)
+    
+    tests = [
+        ("필수 모듈 import", test_imports),
+        ("파일 구조 확인", test_file_structure),
+        ("STTProcessor 초기화", test_stt_processor_init),
+        ("Gradio 인터페이스", test_gradio_interface)
+    ]
+    
+    passed = 0
+    total = len(tests)
+    
+    for test_name, test_func in tests:
+        logger.info(f"\n🔍 {test_name} 테스트...")
+        try:
+            if test_func():
+                passed += 1
+                logger.info(f"✅ {test_name} 통과")
+            else:
+                logger.error(f"❌ {test_name} 실패")
+        except Exception as e:
+            logger.error(f"❌ {test_name} 오류: {e}")
+    
+    logger.info("\n" + "=" * 50)
+    logger.info(f"📊 테스트 결과: {passed}/{total} 통과")
+    
+    if passed == total:
+        logger.info("🎉 모든 테스트 통과! 앱이 배포 준비되었습니다.")
+        return True
+    else:
+        logger.warning("⚠️ 일부 테스트가 실패했습니다. 문제를 확인해주세요.")
+        return False
+
+if __name__ == "__main__":
+    success = main()
+    sys.exit(0 if success else 1) 

test_stt.py

@@ -0,0 +1,208 @@
+import whisper
+import google.generativeai as genai
+import os
+import json
+from datetime import datetime
+import re
+
+def test_speaker_separation():
+    """Gemini를 사용한 화자 분리 테스트"""
+    
+    # API 키 로드
+    from dotenv import load_dotenv
+    load_dotenv()
+    
+    GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
+    
+    if not GOOGLE_API_KEY or GOOGLE_API_KEY == "your_google_api_key_here":
+        print("ERROR: Please set GOOGLE_API_KEY in .env file")
+        return
+    
+    print("Loading models...")
+    
+    try:
+        # Whisper 모델 로드
+        whisper_model = whisper.load_model("base")
+        print("Whisper model loaded!")
+        
+        # Gemini 모델 설정
+        genai.configure(api_key=GOOGLE_API_KEY)
+        # gemini-2.0-flash: 최신 Gemini 2.0 모델, 빠르고 정확한 화자 분리
+        gemini_model = genai.GenerativeModel('gemini-2.0-flash')
+        print("Gemini 2.0 Flash model configured!")
+        
+        # WAV 파일 찾기
+        wav_files = []
+        if os.path.exists("data"):
+            for file in os.listdir("data"):
+                if file.endswith(".wav"):
+                    wav_files.append(os.path.join("data", file))
+        
+        if not wav_files:
+            print("No WAV files found in data folder.")
+            return
+        
+        print(f"Found {len(wav_files)} WAV file(s)")
+        
+        for wav_file in wav_files[:1]:  # 첫 번째 파일만 테스트
+            print(f"\nProcessing: {os.path.basename(wav_file)}")
+            
+            # 1단계: 음성 인식
+            print("Step 1: Speech recognition...")
+            result = whisper_model.transcribe(wav_file)
+            full_text = result['text'].strip()
+            
+            print(f"Language detected: {result['language']}")
+            print(f"Text length: {len(full_text)} characters")
+            print(f"Text preview: {full_text[:200]}...")
+            
+            # 2단계: 화자 분리
+            print("\nStep 2: Speaker separation with Gemini...")
+            
+            prompt = f"""
+당신은 2명의 화자가 나누는 대화를 분석하는 전문가입니다. 
+주어진 텍스트를 분석하여 각 발언을 화자별로 구분해주세요.
+
+분석 지침:
+1. 대화의 맥락과 내용을 기반으로 화자를 구분하세요
+2. 말투, 주제 전환, 질문과 답변의 패턴을 활용하세요
+3. 화자1과 화자2로 구분하여 표시하세요
+4. 각 발언 앞에 [화자1] 또는 [화자2]를 붙여주세요
+5. 발언이 너무 길 경우 자연스러운 지점에서 나누어주세요
+
+출력 형식:
+[화자1] 첫 번째 발언 내용
+[화자2] 두 번째 발언 내용
+[화자1] 세 번째 발언 내용
+...
+
+분석할 텍스트:
+{full_text}
+"""
+
+            response = gemini_model.generate_content(prompt)
+            separated_text = response.text.strip()
+            
+            print("Speaker separation completed!")
+            
+            # 3단계: 맞춤법 교정
+            print("\nStep 3: Spell checking with Gemini...")
+            
+            spelling_prompt = f"""
+당신은 한국어 맞춤법 교정 전문가입니다. 
+주어진 텍스트에서 맞춤법 오류, 띄어쓰기 오류, 오타를 수정해주세요.
+
+교정 지침:
+1. 자연스러운 한국어 표현으로 수정하되, 원본의 의미와 말투는 유지하세요
+2. [화자1], [화자2] 태그는 그대로 유지하세요
+3. 전문 용어나 고유명사는 가능한 정확하게 수정하세요
+4. 구어체 특성은 유지하되, 명백한 오타만 수정하세요
+5. 문맥에 맞는 올바른 단어로 교체하세요
+
+교정할 텍스트:
+{separated_text}
+"""
+
+            corrected_response = gemini_model.generate_content(spelling_prompt)
+            corrected_text = corrected_response.text.strip()
+            
+            print("Spell checking completed!")
+            
+            # 4단계: 결과 저장
+            print("\nStep 4: Saving results...")
+            
+            base_name = os.path.splitext(os.path.basename(wav_file))[0]
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            
+            # output 폴더 생성
+            if not os.path.exists("output"):
+                os.makedirs("output")
+            
+            # 전체 결과 저장 (원본 + 분리 + 교정)
+            result_path = f"output/{base_name}_complete_result_{timestamp}.txt"
+            with open(result_path, 'w', encoding='utf-8') as f:
+                f.write(f"Filename: {base_name}\n")
+                f.write(f"Processing time: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
+                f.write(f"Language: {result['language']}\n")
+                f.write("="*50 + "\n\n")
+                f.write("Original text:\n")
+                f.write(full_text + "\n\n")
+                f.write("="*50 + "\n\n")
+                f.write("Speaker separated text (original):\n")
+                f.write(separated_text + "\n\n")
+                f.write("="*50 + "\n\n")
+                f.write("Speaker separated text (spell corrected):\n")
+                f.write(corrected_text + "\n")
+            
+            # 교정된 텍스트에서 화자별 분리 결과 파싱
+            corrected_conversations = {"화자1": [], "화자2": []}
+            pattern = r'\[화자([12])\]\s*(.+?)(?=\[화자[12]\]|$)'
+            matches = re.findall(pattern, corrected_text, re.DOTALL)
+            
+            for speaker_num, content in matches:
+                speaker = f"화자{speaker_num}"
+                content = content.strip()
+                if content:
+                    corrected_conversations[speaker].append(content)
+            
+            # 원본 화자별 분리 결과도 파싱 (비교용)
+            original_conversations = {"화자1": [], "화자2": []}
+            matches = re.findall(pattern, separated_text, re.DOTALL)
+            
+            for speaker_num, content in matches:
+                speaker = f"화자{speaker_num}"
+                content = content.strip()
+                if content:
+                    original_conversations[speaker].append(content)
+            
+            # 교정된 화자별 개별 파일 저장
+            for speaker, utterances in corrected_conversations.items():
+                if utterances:
+                    speaker_path = f"output/{base_name}_{speaker}_교정본_{timestamp}.txt"
+                    with open(speaker_path, 'w', encoding='utf-8') as f:
+                        f.write(f"Filename: {base_name}\n")
+                        f.write(f"Speaker: {speaker}\n")
+                        f.write(f"Processing time: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
+                        f.write(f"Number of utterances: {len(utterances)}\n")
+                        f.write("="*50 + "\n\n")
+                        
+                        for idx, utterance in enumerate(utterances, 1):
+                            f.write(f"{idx}. {utterance}\n\n")
+            
+            # JSON 저장 (원본과 교정본 모두 포함)
+            json_path = f"output/{base_name}_complete_data_{timestamp}.json"
+            json_data = {
+                "filename": base_name,
+                "processed_time": datetime.now().isoformat(),
+                "language": result['language'],
+                "original_text": full_text,
+                "separated_text": separated_text,
+                "corrected_text": corrected_text,
+                "conversations_by_speaker_original": original_conversations,
+                "conversations_by_speaker_corrected": corrected_conversations,
+                "segments": result.get("segments", [])
+            }
+            
+            with open(json_path, 'w', encoding='utf-8') as f:
+                json.dump(json_data, f, ensure_ascii=False, indent=2)
+            
+            print(f"Results saved:")
+            print(f"  - Complete result: {result_path}")
+            print(f"  - JSON data: {json_path}")
+            for speaker in corrected_conversations:
+                if corrected_conversations[speaker]:
+                    print(f"  - {speaker} (교정본): {len(corrected_conversations[speaker])} utterances")
+            
+            print("\nProcessing completed successfully!")
+            print("✓ Speech recognition with Whisper")
+            print("✓ Speaker separation with Gemini 2.0")
+            print("✓ Spell checking with Gemini 2.0")
+            print("✓ Results saved (original + corrected versions)")
+            
+    except Exception as e:
+        print(f"Error occurred: {e}")
+        import traceback
+        traceback.print_exc()
+
+if __name__ == "__main__":
+    test_speaker_separation()