Update app.py

app.py

@@ -1,76 +1,17 @@
-# 환경 변수가 없는 경우에만 입력창 표시
-            with gr.Row():
-                with gr.Column():
-                    gr.Markdown("### 🔑 임시 API 설정")
-                    api_key_input = gr.Textbox(
-                        label="Google Gemini API Key",
-                        type="password",
-                        placeholder="임시 사용을 위해 API 키를 입력하세요...",
-                        info="⚠️ 보안을 위해 환경 변수 설정을 권장합니다.",
-                        container=True
-                    )def apply_changes_only(original_text, change_request_text, api_key_input):
-    """원본 텍스트에 변경사항만 적용 (고도화된 버전)"""
-    # 환경 변수 우선 확인 및 API 설정
-    if not model:
-        config_result = configure_api(api_key_input)
-        if "❌" in config_result:
-            return config_result, ""
-    
-    if not original_text.strip():
-        return "먼저 이미지에서 텍스트를 추출해주세요.", ""
-    
-    if not change_request_text.strip():
-        return "변경사항 요청을 입력해주세요.", ""
-    
-    try:
-        # 스마트한 변경사항 분석
-        change_type = analyze_change_request(change_request_text)
-        
-        # 변경사항 적용을 위한 고도화된 프롬프트
-        prompt = f"""
-        당신은 전문 텍스트 편집 AI입니다. 다음 원본 텍스트에서 사용자가 요청한 변경사항을 정확하게 적용해주세요.
-
-        **원본 텍스트:**
-        {original_text}
-
-        **변경사항 요청:**
-        {change_request_text}
-
-        **변경 유형 분석:** {change_type}
-
-        **전문 편집 규칙:**
-        1. 요청된 변경사항만 정확히 적용하세요
-        2. 나머지 텍스트는 원본과 완전히 동일하게 유지하세요
-        3. 텍스트의 형식, 구조, 줄바꿈을 원본과 동일하게 보존하세요
-        4. 한국어 맞춤법과 띄어쓰기를 정확히 적용하세요
-        5. 숫자, 날짜, 고유명사는 특히 신중하게 처리하세요
-        6. 변경된 부분이 문맥상 자연스러운지 확인하세요
-        7. 오직 변경된 텍스트만 출력하고 설명이나 주석은 포함하지 마세요
-
-        **품질 보증:**
-        - 변경 전후의 텍스트 길이와 구조가 적절한지 검토
-        - 한국어 문법과 자연스러운 표현 확인
-        - 변경사항이 완전히 반영되었는지 검증
-        """
-        7. 오직 변경된 텍스트만 출력하고 설명이나 주석은 포함하지 마def clear_all_tab2():
-    """탭2의 모든 입력 초기화"""
-    return None, "", "", "", ""import gradio as gr
+import gradio as gr
 import google.generativeai as genai
 import base64
 import io
-from PIL import Image, ImageEnhance, ImageFilter
+from PIL import Image, ImageEnhance
 import difflib
-import re
 import os
-import asyncio
-import threading
 import time
 from datetime import datetime
 
-# 전역 변수로 API 키 저장
+# 전역 변수
 api_key = None
 model = None
-processing_cache = {}  # 이미지 처리 캐시
+processing_cache = {}
 
 # 환경 변수에서 API 키 확인
 GEMINI_API_KEY = os.getenv('GEMINI_API_KEY')
@@ -88,17 +29,38 @@ def initialize_api():
             return False, f"❌ 환경 변수 API 키 설정 실패: {str(e)}"
     return False, ""
 
+def configure_api(api_key_input):
+    """Gemini API 설정"""
+    global api_key, model
+    
+    # 환경 변수 우선 확인
+    if GEMINI_API_KEY and not api_key_input.strip():
+        is_initialized, message = initialize_api()
+        if is_initialized:
+            return message
+    
+    # 수동 입력 API 키 처리
+    try:
+        if not api_key_input.strip():
+            if not GEMINI_API_KEY:
+                return "❌ API 키를 입력하거나 환경 변수 'GEMINI_API_KEY'를 설정해주세요."
+            else:
+                return "❌ 환경 변수의 API 키가 유효하지 않습니다. 직접 입력해주세요."
+        
+        api_key = api_key_input.strip()
+        genai.configure(api_key=api_key)
+        model = genai.GenerativeModel('gemini-2.5-flash')
+        return "✅ 수동 입력된 API 키로 설정이 완료되었습니다!"
+    except Exception as e:
+        return f"❌ API 설정 실패: {str(e)}"
+
 def preprocess_image(image):
     """이미지 전처리로 OCR 정확도 향상"""
     try:
         if image is None:
             return None
         
-        # 이미지를 PIL Image로 변환 (필요시)
-        if not isinstance(image, Image.Image):
-            image = Image.open(image) if isinstance(image, str) else image
-        
-        # 이미지 크기 최적화 (너무 크면 축소, 너무 작으면 확대)
+        # 이미지 크기 최적화
         width, height = image.size
         if width * height > 4000000:  # 4MP 이상이면 축소
             ratio = (4000000 / (width * height)) ** 0.5
@@ -128,34 +90,8 @@ def preprocess_image(image):
         print(f"이미지 전처리 오류: {e}")
         return image
 
-def configure_api(api_key_input):
-    """Gemini API 설정 (수동 입력 또는 환경 변수)"""
-    global api_key, model
-    
-    # 환경 변수 우선 확인
-    if GEMINI_API_KEY and not api_key_input.strip():
-        is_initialized, message = initialize_api()
-        if is_initialized:
-            return message
-    
-    # 수동 입력 API 키 처리
-    try:
-        if not api_key_input.strip():
-            if not GEMINI_API_KEY:
-                return "❌ API 키를 입력하거나 환경 변수 'GEMINI_API_KEY'를 설정해주세요."
-            else:
-                # 환경 변수가 있지만 실패한 경우
-                return "❌ 환경 변수의 API 키가 유효하지 않습니다. 직접 입력해주세요."
-        
-        api_key = api_key_input.strip()
-        genai.configure(api_key=api_key)
-        model = genai.GenerativeModel('gemini-2.5-flash')
-        return "✅ 수동 입력된 API 키로 설정이 완료되었습니다!"
-    except Exception as e:
-        return f"❌ API 설정 실패: {str(e)}"
-
 def extract_text_from_image(image):
-    """이미지에서 한국어 텍스트 추출 (최적화된 버전)"""
+    """이미지에서 한국어 텍스트 추출"""
     global model, processing_cache
     
     if model is None:
@@ -174,32 +110,21 @@ def extract_text_from_image(image):
         processed_image = preprocess_image(image)
         
         # PIL Image를 bytes로 변환
-        if isinstance(processed_image, str):
-            with open(processed_image, 'rb') as f:
-                image_data = f.read()
-        else:
-            buffer = io.BytesIO()
-            processed_image.save(buffer, format='PNG', optimize=True, quality=95)
-            image_data = buffer.getvalue()
+        buffer = io.BytesIO()
+        processed_image.save(buffer, format='PNG', optimize=True, quality=95)
+        image_data = buffer.getvalue()
         
-        # 고도화된 프롬프트
+        # OCR 프롬프트
         prompt = """
         이 이미지에 있는 모든 한국어 텍스트를 정확하게 추출해주세요. 
 
-        전문 OCR 규칙:
+        규칙:
         1. 텍스트의 읽기 순서와 공간적 배치를 정확히 유지하세요
         2. 줄바꿈, 들여쓰기, 공백을 원본과 동일하게 보존하세요
         3. 한글, 영어, 숫자, 특수문자를 모두 포함하세요
         4. 표나 목록의 구조를 유지하세요
         5. 흐릿하거나 불분명한 글자는 [?]로 표시하세요
-        6. 손글씨와 인쇄체를 구분하여 인식하세요
-        7. 작은 글씨나 워터마크도 놓치지 마세요
-        8. 텍스트만 출력하고 추가 설명은 하지 마세요
-
-        품질 검증:
-        - 문맥상 어색하지 않은지 확인
-        - 일반적인 한국어 맞춤법 규칙 적용
-        - 누락된 글자나 중복된 글자 없는지 검토
+        6. 텍스트만 출력하고 추가 설명은 하지 마세요
         """
         
         # 이미지를 base64로 인코딩
@@ -219,9 +144,6 @@ def extract_text_from_image(image):
                 
                 extracted_text = response.text.strip()
                 
-                # 후처리: 일반적인 OCR 오류 수정
-                extracted_text = post_process_text(extracted_text)
-                
                 # 캐시에 저장
                 processing_cache[image_hash] = extracted_text
                 
@@ -230,45 +152,13 @@ def extract_text_from_image(image):
             except Exception as e:
                 if attempt == max_retries - 1:
                     raise e
-                time.sleep(1)  # 재시도 전 대기
+                time.sleep(1)
         
     except Exception as e:
         return f"❌ 텍스트 추출 실패: {str(e)}"
 
-def post_process_text(text):
-    """OCR 결과 후처리"""
-    if not text:
-        return text
-    
-    # 일반적인 OCR 오류 패턴 수정
-    corrections = {
-        'ㅇ': 'o',  # 한글 ㅇ와 영어 o 혼동
-        'ㅣ': '|',  # 한글 ㅣ와 파이프 혼동
-        '１': '1',  # 전각 숫자를 반각으로
-        '２': '2',
-        '３': '3',
-        '４': '4',
-        '５': '5',
-        '６': '6',
-        '７': '7',
-        '８': '8',
-        '９': '9',
-        '０': '0',
-    }
-    
-    # 패턴별 수정 적용 (너무 공격적이지 않게)
-    for wrong, correct in corrections.items():
-        # 영어/숫자 컨텍스트에서만 수정
-        text = re.sub(f'(?<=[a-zA-Z0-9]){re.escape(wrong)}(?=[a-zA-Z0-9])', correct, text)
-    
-    # 연속된 공백 정리
-    text = re.sub(r'\s+', ' ', text)
-    text = re.sub(r'\n\s*\n', '\n\n', text)  # 빈 줄 정리
-    
-    return text.strip()
-
 def compare_texts(text1, text2):
-    """두 텍스트를 비교하고 차이점을 HTML로 표시 (고도화된 버전)"""
+    """두 텍스트를 비교하고 차이점을 HTML로 표시"""
     if not text1 or not text2:
         return "비교할 텍스트가 없습니다."
     
@@ -280,190 +170,86 @@ def compare_texts(text1, text2):
     total_lines1 = len(lines1)
     total_lines2 = len(lines2)
     
-    # 차이점 분석
-    differ = difflib.unified_diff(lines1, lines2, lineterm='', n=0)
-    added_lines = 0
-    removed_lines = 0
-    
-    for line in differ:
-        if line.startswith('+') and not line.startswith('+++'):
-            added_lines += 1
-        elif line.startswith('-') and not line.startswith('---'):
-            removed_lines += 1
-    
     # 유사도 계산
     similarity = difflib.SequenceMatcher(None, text1, text2).ratio()
     similarity_percent = round(similarity * 100, 1)
     
-    # 단어 레벨 차이점 분석
-    word_changes = analyze_word_changes(text1, text2)
-    
     # 현재 시간
     timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
     
     html_result = f"""
     <div style="font-family: 'Noto Sans KR', sans-serif; line-height: 1.6;">
-        <!-- 분석 헤더 -->
         <div style="background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; padding: 20px; border-radius: 12px; margin-bottom: 20px;">
-            <h2 style="margin: 0 0 10px 0; display: flex; align-items: center;">
-                <span style="font-size: 1.5em; margin-right: 10px;">📊</span>
-                텍스트 비교 분석 결과
-            </h2>
+            <h2 style="margin: 0 0 10px 0;">📊 텍스트 비교 분석 결과</h2>
             <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 15px; margin-top: 15px;">
                 <div style="background: rgba(255,255,255,0.2); padding: 10px; border-radius: 8px;">
-                    <div style="font-size: 0.9em; opacity: 0.9;">유사도</div>
+                    <div style="font-size: 0.9em;">유사도</div>
                     <div style="font-size: 1.5em; font-weight: bold;">{similarity_percent}%</div>
                 </div>
                 <div style="background: rgba(255,255,255,0.2); padding: 10px; border-radius: 8px;">
-                    <div style="font-size: 0.9em; opacity: 0.9;">변경된 라인</div>
-                    <div style="font-size: 1.5em; font-weight: bold; color: #ffeb3b;">{removed_lines + added_lines}</div>
+                    <div style="font-size: 0.9em;">원본 라인 수</div>
+                    <div style="font-size: 1.5em; font-weight: bold;">{total_lines1}</div>
                 </div>
                 <div style="background: rgba(255,255,255,0.2); padding: 10px; border-radius: 8px;">
-                    <div style="font-size: 0.9em; opacity: 0.9;">단어 변경</div>
-                    <div style="font-size: 1.5em; font-weight: bold; color: #4caf50;">{word_changes}</div>
+                    <div style="font-size: 0.9em;">수정된 라인 수</div>
+                    <div style="font-size: 1.5em; font-weight: bold;">{total_lines2}</div>
                 </div>
                 <div style="background: rgba(255,255,255,0.2); padding: 10px; border-radius: 8px;">
-                    <div style="font-size: 0.9em; opacity: 0.9;">분석 시간</div>
+                    <div style="font-size: 0.9em;">분석 시간</div>
                     <div style="font-size: 1em; font-weight: bold;">{timestamp}</div>
                 </div>
             </div>
         </div>
         
-        <!-- 텍스트 비교 -->
-        <div style="display: flex; gap: 20px; margin-bottom: 20px;">
+        <div style="display: flex; gap: 20px;">
             <div style="flex: 1;">
-                <div style="background: linear-gradient(135deg, #ff6b6b, #ee5a52); color: white; padding: 12px; border-radius: 8px 8px 0 0; font-weight: 600; display: flex; align-items: center;">
-                    <span style="margin-right: 8px;">📷</span>
-                    원본 텍스트 ({total_lines1}줄)
+                <div style="background: #ef4444; color: white; padding: 12px; border-radius: 8px 8px 0 0; font-weight: 600;">
+                    📷 원본 텍스트 ({total_lines1}줄)
                 </div>
-                <div style="background-color: #fff5f5; border: 1px solid #fed7d7; padding: 15px; border-radius: 0 0 8px 8px; white-space: pre-wrap; font-family: 'Courier New', monospace; max-height: 400px; overflow-y: auto; font-size: 14px;">
+                <div style="background-color: #fff5f5; border: 1px solid #fed7d7; padding: 15px; border-radius: 0 0 8px 8px; white-space: pre-wrap; font-family: monospace; max-height: 400px; overflow-y: auto;">
     """
     
-    # 차이점이 있는 라인 찾기 (개선된 알고리즘)
-    diff_lines1, diff_lines2 = find_detailed_differences(lines1, lines2)
-    
-    # 원본 텍스트 표시 (라인별 하이라이트)
-    for i, line in enumerate(lines1):
-        if i in diff_lines1:
-            html_result += f'<div style="background-color: #fecaca; border-left: 4px solid #ef4444; padding: 8px; margin: 2px 0; border-radius: 4px;"><strong>라인 {i+1}:</strong> {line}</div>'
+    # 차이점이 있는 라인 찾기
+    diff_lines = set()
+    for line in difflib.unified_diff(lines1, lines2, lineterm='', n=0):
+        if line.startswith('-') and not line.startswith('---'):
+            diff_lines.add(line[1:])
+        elif line.startswith('+') and not line.startswith('+++'):
+            diff_lines.add(line[1:])
+    
+    # 원본 텍스트 표시 (차이점 강조)
+    for line in lines1:
+        if line in diff_lines:
+            html_result += f'<span style="background-color: #fecaca; color: #dc2626; padding: 2px 4px; border-radius: 3px;">{line}</span>\n'
         else:
-            html_result += f'<div style="padding: 4px 0; color: #6b7280;">라인 {i+1}: {line}</div>'
+            html_result += f'{line}\n'
     
-    html_result += """
+    html_result += f"""
                 </div>
             </div>
             <div style="flex: 1;">
-                <div style="background: linear-gradient(135deg, #51cf66, #40c057); color: white; padding: 12px; border-radius: 8px 8px 0 0; font-weight: 600; display: flex; align-items: center;">
-                    <span style="margin-right: 8px;">🔄</span>
-                    수정된 텍스트 (""" + f"{total_lines2}줄)"
-    
-    html_result += """
+                <div style="background: #22c55e; color: white; padding: 12px; border-radius: 8px 8px 0 0; font-weight: 600;">
+                    🔄 수정된 텍스트 ({total_lines2}줄)
                 </div>
-                <div style="background-color: #f0fdf4; border: 1px solid #bbf7d0; padding: 15px; border-radius: 0 0 8px 8px; white-space: pre-wrap; font-family: 'Courier New', monospace; max-height: 400px; overflow-y: auto; font-size: 14px;">
+                <div style="background-color: #f0fdf4; border: 1px solid #bbf7d0; padding: 15px; border-radius: 0 0 8px 8px; white-space: pre-wrap; font-family: monospace; max-height: 400px; overflow-y: auto;">
     """
     
-    # 수정된 텍스트 표시 (라인별 하이라이트)
-    for i, line in enumerate(lines2):
-        if i in diff_lines2:
-            html_result += f'<div style="background-color: #dcfce7; border-left: 4px solid #22c55e; padding: 8px; margin: 2px 0; border-radius: 4px;"><strong>라인 {i+1}:</strong> {line}</div>'
+    # 수정된 텍스트 표시 (차이점 강조)
+    for line in lines2:
+        if line in diff_lines:
+            html_result += f'<span style="background-color: #dcfce7; color: #059669; padding: 2px 4px; border-radius: 3px;">{line}</span>\n'
         else:
-            html_result += f'<div style="padding: 4px 0; color: #6b7280;">라인 {i+1}: {line}</div>'
+            html_result += f'{line}\n'
     
     html_result += """
                 </div>
             </div>
         </div>
-        
-        <!-- 상세 변경 사항 -->
-        <div style="background: #f8fafc; border: 1px solid #e2e8f0; border-radius: 12px; padding: 20px;">
-            <h3 style="color: #1e293b; margin: 0 0 15px 0; display: flex; align-items: center;">
-                <span style="margin-right: 8px;">🔍</span>
-                상세 변경 사항
-            </h3>
-            <div style="display: grid; gap: 10px;">
-    """
-    
-    # 상세 변경사항 표시
-    detailed_changes = get_detailed_changes(lines1, lines2)
-    if detailed_changes:
-        for change in detailed_changes[:10]:  # 최대 10개까지만 표시
-            html_result += f"""
-                <div style="background: white; border-radius: 8px; padding: 12px; border-left: 4px solid #3b82f6;">
-                    <div style="font-weight: 600; color: #1e40af; margin-bottom: 4px;">{change['type']}</div>
-                    <div style="font-size: 14px; color: #64748b;">{change['description']}</div>
-                </div>
-            """
-    else:
-        html_result += '<div style="text-align: center; color: #64748b; padding: 20px;">변경사항이 없습니다. ✅</div>'
-    
-    html_result += """
-            </div>
-        </div>
     </div>
     """
     
     return html_result
 
-def find_detailed_differences(lines1, lines2):
-    """라인별 상세 차이점 찾기"""
-    diff_lines1 = set()
-    diff_lines2 = set()
-    
-    # difflib을 사용한 정확한 차이점 분석
-    opcodes = difflib.SequenceMatcher(None, lines1, lines2).get_opcodes()
-    
-    for op, i1, i2, j1, j2 in opcodes:
-        if op == 'delete':
-            diff_lines1.update(range(i1, i2))
-        elif op == 'insert':
-            diff_lines2.update(range(j1, j2))
-        elif op == 'replace':
-            diff_lines1.update(range(i1, i2))
-            diff_lines2.update(range(j1, j2))
-    
-    return diff_lines1, diff_lines2
-
-def analyze_word_changes(text1, text2):
-    """단어 레벨 변경사항 분석"""
-    words1 = text1.split()
-    words2 = text2.split()
-    
-    opcodes = difflib.SequenceMatcher(None, words1, words2).get_opcodes()
-    changes = 0
-    
-    for op, i1, i2, j1, j2 in opcodes:
-        if op in ['delete', 'insert', 'replace']:
-            changes += max(i2-i1, j2-j1)
-    
-    return changes
-
-def get_detailed_changes(lines1, lines2):
-    """상세 변경사항 리스트 생성"""
-    changes = []
-    opcodes = difflib.SequenceMatcher(None, lines1, lines2).get_opcodes()
-    
-    for op, i1, i2, j1, j2 in opcodes:
-        if op == 'delete':
-            for i in range(i1, i2):
-                changes.append({
-                    'type': '🗑️ 삭제됨',
-                    'description': f'라인 {i+1}: "{lines1[i][:50]}..."' if len(lines1[i]) > 50 else f'라인 {i+1}: "{lines1[i]}"'
-                })
-        elif op == 'insert':
-            for j in range(j1, j2):
-                changes.append({
-                    'type': '➕ 추가됨',
-                    'description': f'라인 {j+1}: "{lines2[j][:50]}..."' if len(lines2[j]) > 50 else f'라인 {j+1}: "{lines2[j]}"'
-                })
-        elif op == 'replace':
-            for i, j in zip(range(i1, i2), range(j1, j2)):
-                changes.append({
-                    'type': '✏️ 수정됨',
-                    'description': f'라인 {i+1}: "{lines1[i][:30]}..." → "{lines2[j][:30]}..."'
-                })
-    
-    return changes
-
 def process_images(image1, image2, api_key_input):
     """두 이미지를 처리하고 비교 결과 반환"""
     # 환경 변수 우선 확인 및 API 설정
@@ -499,117 +285,61 @@ def extract_text_only(image, api_key_input):
     
     return extracted_text
 
-        7. 오직 변경된 텍스트만 출력하고 설명이나 주석은 포함하지 마세요
+def apply_changes_only(original_text, change_request_text, api_key_input):
+    """원본 텍스트에 변경사항만 적용"""
+    # 환경 변수 우선 확인 및 API 설정
+    if not model:
+        config_result = configure_api(api_key_input)
+        if "❌" in config_result:
+            return config_result, ""
+    
+    if not original_text.strip():
+        return "먼저 이미지에서 텍스트를 추출해주세요.", ""
+    
+    if not change_request_text.strip():
+        return "변경사항 요청을 입력해주세요.", ""
+    
+    try:
+        # 변경사항 적용을 위한 프롬프트
+        prompt = f"""
+        다음 원본 텍스트에서 사용자가 요청한 변경사항을 정확하게 적용해주세요.
 
-        **품질 보증:**
-        - 변경 전후의 텍스트 길이와 구조가 적절한지 검토
-        - 한국어 문법과 자연스러운 표현 확인
-        - 변경사항이 완전히 반영되었는지 검증
+        원본 텍스트:
+        {original_text}
+
+        변경사항 요청:
+        {change_request_text}
+
+        규칙:
+        1. 요청된 변경사항만 정확히 적용하세요
+        2. 나머지 텍스트는 원본과 완전히 동일하게 유지하세요
+        3. 텍스트의 형식, 구조, 줄바꿈을 원본과 동일하게 보존하세요
+        4. 한국어 맞춤법과 띄어쓰기를 정확히 적용하세요
+        5. 변경된 텍스트만 출력하고 설명이나 주석은 포함하지 마세요
         """
         
-        # 재시도 메커니즘과 품질 검증
-        max_retries = 2
-        best_result = None
-        
-        for attempt in range(max_retries):
-            try:
-                response = model.generate_content(prompt)
-                modified_text = response.text.strip()
-                
-                # 품질 검증
-                quality_score = validate_text_quality(original_text, modified_text, change_request_text)
-                
-                if quality_score > 0.8 or attempt == max_retries - 1:
-                    best_result = modified_text
-                    break
-                    
-            except Exception as e:
-                if attempt == max_retries - 1:
-                    raise e
-                time.sleep(1)
-        
-        # 최종 후처리
-        final_text = post_process_modified_text(best_result, original_text)
+        response = model.generate_content(prompt)
+        modified_text = response.text.strip()
         
         # 비교 결과 생성
-        if original_text and final_text:
-            comparison = compare_texts(original_text, final_text)
+        if original_text and modified_text:
+            comparison = compare_texts(original_text, modified_text)
         else:
             comparison = "텍스트 비교를 위해 원본 텍스트와 변경된 텍스트가 모두 필요합니다."
         
-        return final_text, comparison
+        return modified_text, comparison
         
     except Exception as e:
         return f"❌ 변경사항 적용 실패: {str(e)}", ""
 
-def analyze_change_request(change_request):
-    """변경사항 요청의 유형을 분석"""
-    request_lower = change_request.lower()
-    
-    if any(word in request_lower for word in ['변경', '바꿔', '수정', '교체']):
-        return "텍스트 교체"
-    elif any(word in request_lower for word in ['추가', '넣어', '삽입']):
-        return "텍스트 추가"
-    elif any(word in request_lower for word in ['삭제', '제거', '빼']):
-        return "텍스트 삭제"
-    elif any(word in request_lower for word in ['번역', '영어로', '한국어로']):
-        return "언어 번역"
-    elif any(word in request_lower for word in ['형식', '포맷', '정렬']):
-        return "형식 변경"
-    else:
-        return "일반적인 편집"
-
-def validate_text_quality(original, modified, request):
-    """텍스트 변경 품질을 검증"""
-    if not modified or len(modified.strip()) < 10:
-        return 0.0
-    
-    # 기본 품질 점수
-    score = 0.5
-    
-    # 길이 적절성 검사
-    length_ratio = len(modified) / max(len(original), 1)
-    if 0.5 <= length_ratio <= 2.0:
-        score += 0.2
-    
-    # 구조 유사성 검사
-    orig_lines = len(original.splitlines())
-    mod_lines = len(modified.splitlines())
-    if abs(orig_lines - mod_lines) <= max(2, orig_lines * 0.1):
-        score += 0.2
-    
-    # 한국어 포함 여부
-    if re.search(r'[가-힣]', modified):
-        score += 0.1
-    
-    return min(score, 1.0)
-
-def post_process_modified_text(text, original):
-    """수정된 텍스트 후처리"""
-    if not text:
-        return text
-    
-    # 불필요한 설명 제거
-    lines = text.split('\n')
-    cleaned_lines = []
-    
-    for line in lines:
-        # 설명성 문장 제거
-        if not any(phrase in line.lower() for phrase in ['변경했습니다', '수정했습니다', '다음과 같습니다', '결과입니다']):
-            cleaned_lines.append(line)
-    
-    result = '\n'.join(cleaned_lines)
-    
-    # 공백 정리
-    result = re.sub(r'\n\s*\n\s*\n', '\n\n', result)
-    result = result.strip()
-    
-    return result
-
 def clear_all():
     """모든 입력 초기화"""
     return None, None, "", "", ""
 
+def clear_all_tab2():
+    """탭2의 모든 입력 초기화"""
+    return None, "", "", "", ""
+
 # Gradio 인터페이스 생성
 def create_interface():
     # 앱 시작 시 환경 변수 확인
@@ -622,28 +352,6 @@ def create_interface():
         .gradio-container {
             font-family: 'Noto Sans KR', sans-serif !important;
         }
-        .gr-button {
-            font-weight: 600;
-        }
-        .gr-form {
-            border-radius: 12px;
-        }
-        .env-status {
-            padding: 10px;
-            border-radius: 8px;
-            margin-bottom: 15px;
-            font-weight: 500;
-        }
-        .env-success {
-            background-color: #d1fae5;
-            color: #065f46;
-            border: 1px solid #a7f3d0;
-        }
-        .env-warning {
-            background-color: #fef3c7;
-            color: #92400e;
-            border: 1px solid #fcd34d;
-        }
         """
     ) as demo:
         
@@ -658,21 +366,12 @@ def create_interface():
         - **⚡ 캐싱 시스템**: 동일 이미지 재처리 방지로 속도 향상
         - **🔍 정밀 비교 분석**: 라인별, 단어별 상세 차이점 분석
         - **📊 실시간 통계**: 유사도, 변경사항 수치화
-        - **✨ 품질 검증**: 자동 후처리 및 품질 보증 시스템
-        
-        ### 📋 사용 방법:
-        1. **API 키 설정**: 아래 방법 중 하나를 선택하세요
-           - **🔒 권장**: 허깅페이스 환경설정에서 `GEMINI_API_KEY` 변수 설정
-           - **⚡ 대안**: 아래 입력창에 직접 API 키 입력
-        2. **탭 선택**: 용도에 맞는 탭을 선택하세요
-        3. **이미지/텍스트 처리**: 고품질 결과를 위해 선명한 이미지 사용
-        4. **결과 분석**: 상세한 분석 리포트 확인
         """)
         
-        # 환경 변수 상태 표시 (개선된 UI)
+        # 환경 변수 상태 표시
         if env_initialized:
             gr.HTML(f"""
-            <div style="background: linear-gradient(135deg, #10b981, #059669); color: white; padding: 15px; border-radius: 12px; margin: 15px 0; box-shadow: 0 4px 6px rgba(0,0,0,0.1);">
+            <div style="background: linear-gradient(135deg, #10b981, #059669); color: white; padding: 15px; border-radius: 12px; margin: 15px 0;">
                 <div style="display: flex; align-items: center; font-weight: 600; font-size: 1.1em;">
                     <span style="font-size: 1.5em; margin-right: 10px;">✅</span>
                     {env_message}
@@ -685,25 +384,31 @@ def create_interface():
             api_key_input = gr.Textbox(visible=False)
         else:
             gr.HTML("""
-            <div style="background: linear-gradient(135deg, #f59e0b, #d97706); color: white; padding: 20px; border-radius: 12px; margin: 15px 0; box-shadow: 0 4px 6px rgba(0,0,0,0.1);">
-                <div style="font-weight: 600; font-size: 1.1em; margin-bottom: 10px; display: flex; align-items: center;">
-                    <span style="font-size: 1.5em; margin-right: 10px;">⚠️</span>
-                    환경 변수 설정 필요
+            <div style="background: linear-gradient(135deg, #f59e0b, #d97706); color: white; padding: 20px; border-radius: 12px; margin: 15px 0;">
+                <div style="font-weight: 600; font-size: 1.1em; margin-bottom: 10px;">
+                    ⚠️ 환경 변수 설정 필요
                 </div>
                 <div style="background: rgba(255,255,255,0.2); padding: 15px; border-radius: 8px; margin: 10px 0;">
                     <div style="font-weight: 600; margin-bottom: 8px;">🔧 허깅페이스 설정 방법:</div>
                     <div style="font-size: 0.9em; line-height: 1.6;">
                         <div>1️⃣ 스페이스 설정(Settings) → Variables 탭</div>
-                        <div>2️⃣ Name: <code style="background: rgba(0,0,0,0.3); padding: 2px 6px; border-radius: 4px;">GEMINI_API_KEY</code></div>
+                        <div>2️⃣ Name: GEMINI_API_KEY</div>
                         <div>3️⃣ Value: 여러분의 Google Gemini API 키</div>
                         <div>4️⃣ 스페이스 재시작으로 적용</div>
                     </div>
                 </div>
-                <div style="font-size: 0.9em; opacity: 0.9;">
-                    💡 환경 변수 설정 시 보안성과 편의성이 크게 향상됩니다!
-                </div>
             </div>
             """)
+            
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("### 🔑 임시 API 설정")
+                    api_key_input = gr.Textbox(
+                        label="Google Gemini API Key",
+                        type="password",
+                        placeholder="임시 사용을 위해 API 키를 입력하세요...",
+                        info="⚠️ 보안을 위해 환경 변수 설정을 권장합니다."
+                    )
         
         with gr.Tabs():
             with gr.TabItem("📷 이미지 비교"):
@@ -820,43 +525,6 @@ def create_interface():
                         size="lg"
                     )
         
-        with gr.Row():
-            analyze_btn = gr.Button(
-                "🚀 분석 시작", 
-                variant="primary",
-                size="lg"
-            )
-            clear_btn = gr.Button(
-                "🗑️ 초기화",
-                variant="secondary",
-                size="lg"
-            )
-        
-        with gr.Row():
-            with gr.Column():
-                gr.Markdown("### 📄 추출된 텍스트")
-                with gr.Row():
-                    text1_output = gr.Textbox(
-                        label="이미지 1 텍스트",
-                        lines=10,
-                        max_lines=15,
-                        show_copy_button=True
-                    )
-                    text2_output = gr.Textbox(
-                        label="이미지 2 텍스트", 
-                        lines=10,
-                        max_lines=15,
-                        show_copy_button=True
-                    )
-        
-        with gr.Row():
-            with gr.Column():
-                gr.Markdown("### 📊 텍스트 차이점 분석")
-                comparison_output = gr.HTML(
-                    label="텍스트 비교 결과",
-                    show_label=False
-                )
-        
         # 이벤트 연결 - 탭1 (이미지 비교)
         analyze_btn.click(
             fn=process_images,
@@ -892,26 +560,7 @@ def create_interface():
         - **🖼️ 이미지 최적화**: 자동 전처리로 800x600 이상 해상도 권장
         - **🔍 정확도 향상**: 선명하고 대비가 높은 이미지 사용
         - **⚡ 성능 최적화**: 캐싱 시스템으로 동일 이미지 재처리 방지
-        - **📊 상세 분석**: 라인별, 단어별 변경사항 추적
         - **🔒 보안 강화**: 환경 변수 사용으로 API 키 보안 강화
-        
-        ### 🎯 고급 기능:
-        - **스마트 OCR**: AI 기반 이미지 품질 향상 및 오류 자동 수정
-        - **실시간 통계**: 유사도, 변경 라인 수, 단어 변경 수 실시간 표시
-        - **품질 검증**: 변경사항 적용 후 자동 품질 검증 시스템
-        - **상세 리포트**: 변경사항 유형별 분류 및 상세 분석
-        
-        ### 🔧 기술 스펙:
-        - **AI 모델**: Google Gemini 2.5 Flash
-        - **지원 형식**: PNG, JPEG, WEBP, HEIC, HEIF
-        - **최대 해상도**: 자동 최적화 (4MP 기준)
-        - **처리 속도**: 캐싱으로 50% 향상
-        
-        ### ⚠️ 사용 주의사항:
-        - 한국어 텍스트 인식에 특화 최적화
-        - 대용량 이미지는 자동으로 최적 크기로 조정
-        - API 사용량에 따른 비용 발생 가능
-        - 개인정보가 포함된 이미지 처리 시 주의 필요
         """)
     
     return demo