Update app.py

app.py

@@ -10,115 +10,105 @@ import uuid
 import shutil
 import glob
 from datetime import datetime
-import requests
-import json
-from dotenv import load_dotenv
+from gradio_client import Client
 
-# 환경변수 로드
-load_dotenv()
+# 로깅 설정
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.StreamHandler(),
+        logging.FileHandler('control_tower_app.log', mode='a')
+    ]
+)
 
-# 로깅 설정 (API 정보 완전 차단)
-logging.basicConfig(level=logging.WARNING)
 logger = logging.getLogger(__name__)
 
-# 세션별 임시 파일 관리를 위한 딕셔너리
-session_temp_files = {}
-session_data = {}
-
+# API 클라이언트 설정
 def get_api_client():
-    """환경변수에서 API 엔드포인트를 가져와 요청 함수 생성"""
+    """환경변수에서 API 엔드포인트를 가져와 클라이언트 생성"""
     endpoint = os.getenv('API_ENDPOINT')
     if not endpoint:
-        raise ValueError("API_ENDPOINT 환경변수가 필요합니다.")
-    
-    def make_request(api_name, **kwargs):
-        try:
-            # gradio_client와 동일한 방식으로 API 호출
-            if not endpoint.startswith('http'):
-                base_url = f"https://{endpoint}.hf.space"
-            else:
-                base_url = endpoint
-            
-            # Gradio API 엔드포인트 형식 맞추기
-            url = f"{base_url}/call{api_name}"
-            
-            # 매개변수를 순서대로 배열로 변환
-            if api_name == "/process_search_results":
-                data = [kwargs.get('keyword', ''), kwargs.get('korean_only', True), 
-                       kwargs.get('apply_main_keyword', '메인키워드 적용'), kwargs.get('exclude_zero_volume', False)]
-            elif api_name == "/search_with_loading":
-                data = [kwargs.get('keyword', ''), kwargs.get('korean_only', True), 
-                       kwargs.get('apply_main_keyword', '메인키워드 적용'), kwargs.get('exclude_zero_volume', False)]
-            elif api_name == "/filter_and_sort_table":
-                data = [kwargs.get('selected_cat', '전체 보기'), kwargs.get('keyword_sort', '정렬 없음'),
-                       kwargs.get('total_volume_sort', '정렬 없음'), kwargs.get('usage_count_sort', '정렬 없음'),
-                       kwargs.get('selected_volume_range', '전체'), kwargs.get('exclude_zero_volume', False)]
-            elif api_name == "/update_category_selection":
-                data = [kwargs.get('selected_cat', '전체 보기')]
-            elif api_name == "/process_analyze_results":
-                data = [kwargs.get('analysis_keywords', ''), kwargs.get('selected_category', '전체 보기')]
-            elif api_name == "/analyze_with_loading":
-                data = [kwargs.get('analysis_keywords', ''), kwargs.get('selected_category', '전체 보기')]
-            elif api_name == "/reset_interface":
-                data = []
-            elif api_name == "/get_session_id":
-                data = []
-            else:
-                data = []
-            
-            response = requests.post(url, json={"data": data}, timeout=60)
-            
-            if response.status_code == 200:
-                result = response.json()
-                return result.get('data', [])
-            else:
-                raise Exception(f"API 호출 실패: {response.status_code}")
-                
-        except Exception as e:
-            raise Exception(f"API 연결 오류: {str(e)}")
-    
-    return type('APIClient', (), {'predict': lambda self, **kwargs: make_request(kwargs.pop('api_name'), **kwargs)})()
+        raise ValueError("API_ENDPOINT 환경변수가 설정되지 않았습니다.")
+    return Client(endpoint)
+
+# 세션별 임시 파일 관리를 위한 딕셔너리
+session_temp_files = {}
+session_data = {}
 
 def cleanup_huggingface_temp_folders():
     """허깅페이스 임시 폴더 초기 정리"""
     try:
-        temp_dirs = [tempfile.gettempdir(), "/tmp", "/var/tmp"]
+        # 일반적인 임시 디렉토리들
+        temp_dirs = [
+            tempfile.gettempdir(),
+            "/tmp",
+            "/var/tmp",
+            os.path.join(os.getcwd(), "temp"),
+            os.path.join(os.getcwd(), "tmp"),
+            "/gradio_cached_examples",
+            "/flagged"
+        ]
+        
         cleanup_count = 0
         
         for temp_dir in temp_dirs:
             if os.path.exists(temp_dir):
                 try:
+                    # 기존 세션 파일들 정리
                     session_files = glob.glob(os.path.join(temp_dir, "session_*.xlsx"))
                     session_files.extend(glob.glob(os.path.join(temp_dir, "session_*.csv")))
+                    session_files.extend(glob.glob(os.path.join(temp_dir, "*keyword*.xlsx")))
+                    session_files.extend(glob.glob(os.path.join(temp_dir, "*keyword*.csv")))
+                    session_files.extend(glob.glob(os.path.join(temp_dir, "tmp*.xlsx")))
+                    session_files.extend(glob.glob(os.path.join(temp_dir, "tmp*.csv")))
                     
                     for file_path in session_files:
                         try:
+                            # 파일이 1시간 이상 오래된 경우만 삭제
                             if os.path.getmtime(file_path) < time.time() - 3600:
                                 os.remove(file_path)
                                 cleanup_count += 1
-                        except Exception:
-                            pass
-                except Exception:
-                    pass
+                                logger.info(f"초기 정리: 오래된 임시 파일 삭제 - {file_path}")
+                        except Exception as e:
+                            logger.warning(f"파일 삭제 실패 (무시됨): {file_path} - {e}")
+                            
+                except Exception as e:
+                    logger.warning(f"임시 디렉토리 정리 실패 (무시됨): {temp_dir} - {e}")
+        
+        logger.info(f"✅ 허깅페이스 임시 폴더 초기 정리 완료 - {cleanup_count}개 파일 삭제")
         
-        logger.info(f"✅ 임시 폴더 정리 완료 - {cleanup_count}개 파일 삭제")
+        # Gradio 캐시 폴더도 정리
+        try:
+            gradio_temp_dir = os.path.join(os.getcwd(), "gradio_cached_examples")
+            if os.path.exists(gradio_temp_dir):
+                shutil.rmtree(gradio_temp_dir, ignore_errors=True)
+                logger.info("Gradio 캐시 폴더 정리 완료")
+        except Exception as e:
+            logger.warning(f"Gradio 캐시 폴더 정리 실패 (무시됨): {e}")
+            
     except Exception as e:
-        logger.error(f"임시 폴더 정리 중 오류: {e}")
+        logger.error(f"초기 임시 폴더 정리 중 오류 (계속 진행): {e}")
 
 def setup_clean_temp_environment():
     """깨끗한 임시 환경 설정"""
     try:
+        # 1. 기존 임시 파일들 정리
         cleanup_huggingface_temp_folders()
         
+        # 2. 애플리케이션 전용 임시 디렉토리 생성
         app_temp_dir = os.path.join(tempfile.gettempdir(), "control_tower_app")
         if os.path.exists(app_temp_dir):
             shutil.rmtree(app_temp_dir, ignore_errors=True)
         os.makedirs(app_temp_dir, exist_ok=True)
         
+        # 3. 환경 변수 설정 (임시 디렉토리 지정)
         os.environ['CONTROL_TOWER_TEMP'] = app_temp_dir
         
         logger.info(f"✅ 애플리케이션 전용 임시 디렉토리 설정: {app_temp_dir}")
+        
         return app_temp_dir
+        
     except Exception as e:
         logger.error(f"임시 환경 설정 실패: {e}")
         return tempfile.gettempdir()
@@ -129,12 +119,7 @@ def get_app_temp_dir():
 
 def get_session_id():
     """세션 ID 생성"""
-    try:
-        client = get_api_client()
-        result = client.predict(api_name="/get_session_id")
-        return result[0] if result else str(uuid.uuid4())
-    except Exception:
-        return str(uuid.uuid4())
+    return str(uuid.uuid4())
 
 def cleanup_session_files(session_id, delay=300):
     """세션별 임시 파일 정리 함수"""
@@ -166,10 +151,11 @@ def cleanup_old_sessions():
     sessions_to_remove = []
     
     for session_id, data in session_data.items():
-        if current_time - data.get('last_activity', 0) > 3600:
+        if current_time - data.get('last_activity', 0) > 3600:  # 1시간 초과
             sessions_to_remove.append(session_id)
     
     for session_id in sessions_to_remove:
+        # 파일 정리
         if session_id in session_temp_files:
             for file_path in session_temp_files[session_id]:
                 try:
@@ -180,6 +166,7 @@ def cleanup_old_sessions():
                     logger.error(f"오래된 세션 파일 삭제 오류: {e}")
             del session_temp_files[session_id]
         
+        # 세션 데이터 정리
         if session_id in session_data:
             del session_data[session_id]
             logger.info(f"오래된 세션 데이터 삭제: {session_id[:8]}...")
@@ -191,79 +178,101 @@ def update_session_activity(session_id):
     session_data[session_id]['last_activity'] = time.time()
 
 def create_session_temp_file(session_id, suffix='.xlsx'):
-    """세션별 임시 파일 생성"""
+    """세션별 임시 파일 생성 (전용 디렉토리 사용)"""
     timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
     random_suffix = str(random.randint(1000, 9999))
     
+    # 애플리케이션 전용 임시 디렉토리 사용
     temp_dir = get_app_temp_dir()
     filename = f"session_{session_id[:8]}_{timestamp}_{random_suffix}{suffix}"
     temp_file_path = os.path.join(temp_dir, filename)
     
+    # 빈 파일 생성
     with open(temp_file_path, 'w') as f:
         pass
     
     register_session_file(session_id, temp_file_path)
     return temp_file_path
 
-def search_with_loading(keyword, korean_only, apply_main_keyword, exclude_zero_volume):
-    """원본 API: /search_with_loading"""
+def wrapper_modified(keyword, korean_only, apply_main_keyword_option, exclude_zero_volume, session_id):
+    """키워드 검색 및 처리 래퍼 함수 (API 클라이언트 사용)"""
+    update_session_activity(session_id)
+    
     try:
         client = get_api_client()
         result = client.predict(
             keyword=keyword,
             korean_only=korean_only,
-            apply_main_keyword=apply_main_keyword,
+            apply_main_keyword=apply_main_keyword_option,
             exclude_zero_volume=exclude_zero_volume,
-            api_name="/search_with_loading"
+            api_name="/process_search_results"
         )
-        return result[0] if result else ""
+        
+        # API 결과 처리
+        table_html, cat_choices, vol_choices, selected_cat, download_file = result
+        
+        # 로컬 파일로 다운로드 파일 복사
+        local_file = None
+        if download_file:
+            local_file = create_session_temp_file(session_id, '.xlsx')
+            shutil.copy(download_file, local_file)
+        
+        return (
+            gr.update(value=table_html), 
+            gr.update(choices=cat_choices), 
+            gr.update(choices=vol_choices),
+            None,  # DataFrame은 클라이언트에서 관리하지 않음
+            gr.update(choices=cat_choices, value=selected_cat), 
+            local_file,
+            gr.update(visible=True), 
+            gr.update(visible=True), 
+            keyword
+        )
+        
     except Exception as e:
-        logger.error(f"search_with_loading API 호출 오류: {e}")
-        return ""
+        logger.error(f"API 호출 오류: {e}")
+        return (
+            gr.update(value="<p>검색 중 오류가 발생했습니다. 다시 시도해주세요.</p>"), 
+            gr.update(choices=["전체 보기"]), 
+            gr.update(choices=["전체"]), 
+            None, 
+            gr.update(choices=["전체 보기"], value="전체 보기"), 
+            None, 
+            gr.update(visible=False), 
+            gr.update(visible=False), 
+            keyword
+        )
 
-def process_search_results(keyword, korean_only, apply_main_keyword, exclude_zero_volume):
-    """원본 API: /process_search_results"""
+def analyze_with_auto_download(analysis_keywords, selected_category, state_df, session_id):
+    """카테고리 일치 분석 실행 및 자동 다운로드 (API 클라이언트 사용)"""
+    update_session_activity(session_id)
+    
     try:
         client = get_api_client()
         result = client.predict(
-            keyword=keyword,
-            korean_only=korean_only,
-            apply_main_keyword=apply_main_keyword,
-            exclude_zero_volume=exclude_zero_volume,
-            api_name="/process_search_results"
+            analysis_keywords=analysis_keywords,
+            selected_category=selected_category,
+            api_name="/process_analyze_results"
         )
         
-        # 결과 안전하게 처리
-        if len(result) >= 5:
-            table_html, cat_choices, vol_choices, selected_cat, download_file = result[:5]
-            
-            # 다운로드 파일이 있는 경우 로컬로 복사
-            local_download_file = None
-            if download_file:
-                session_id = get_session_id()
-                local_download_file = create_session_temp_file(session_id, '.xlsx')
-                try:
-                    shutil.copy2(download_file, local_download_file)
-                except Exception as e:
-                    logger.error(f"파일 복사 오류: {e}")
-                    local_download_file = None
-            
-            return table_html, cat_choices, vol_choices, selected_cat, local_download_file
-        else:
-            return (
-                "<p>검색 결과가 없습니다.</p>",
-                ["전체 보기"], ["전체"], "전체 보기", None
-            )
+        analysis_result, download_file = result
+        
+        # 로컬 파일로 다운로드 파일 복사
+        local_file = None
+        if download_file:
+            local_file = create_session_temp_file(session_id, '.xlsx')
+            shutil.copy(download_file, local_file)
+        
+        return analysis_result, local_file, gr.update(visible=True)
         
     except Exception as e:
-        logger.error(f"process_search_results API 호출 오류: {e}")
-        return (
-            "<p>서비스 연결에 문제가 발생했습니다. 잠시 후 다시 시도해주세요.</p>",
-            ["전체 보기"], ["전체"], "전체 보기", None
-        )
+        logger.error(f"분석 API 호출 오류: {e}")
+        return "분석 중 오류가 발생했습니다. 다시 시도해주세요.", None, gr.update(visible=False)
 
-def filter_and_sort_table(selected_cat, keyword_sort, total_volume_sort, usage_count_sort, selected_volume_range, exclude_zero_volume):
-    """원본 API: /filter_and_sort_table"""
+def filter_and_sort_table(df, selected_cat, keyword_sort, total_volume_sort, usage_count_sort, selected_volume_range, exclude_zero_volume, session_id):
+    """테이블 필터링 및 정렬 함수 (API 클라이언트 사용)"""
+    update_session_activity(session_id)
+    
     try:
         client = get_api_client()
         result = client.predict(
@@ -275,147 +284,148 @@ def filter_and_sort_table(selected_cat, keyword_sort, total_volume_sort, usage_c
             exclude_zero_volume=exclude_zero_volume,
             api_name="/filter_and_sort_table"
         )
-        return result[0] if result else ""
+        
+        return result
+        
     except Exception as e:
-        logger.error(f"filter_and_sort_table API 호출 오류: {e}")
-        return "<p>필터링 서비스 연결에 문제가 발생했습니다.</p>"
+        logger.error(f"필터링 API 호출 오류: {e}")
+        return ""
 
-def update_category_selection(selected_cat):
-    """원본 API: /update_category_selection"""
+def update_category_selection(selected_cat, session_id):
+    """카테고리 필터 선택 시 분석할 카테고리도 같은 값으로 업데이트"""
+    update_session_activity(session_id)
+    
     try:
         client = get_api_client()
         result = client.predict(
             selected_cat=selected_cat,
             api_name="/update_category_selection"
         )
-        return gr.update(value=result[0] if result else selected_cat)
+        
+        return gr.update(value=result)
+        
     except Exception as e:
-        logger.error(f"update_category_selection API 호출 오류: {e}")
+        logger.error(f"카테고리 선택 API 호출 오류: {e}")
         return gr.update(value=selected_cat)
 
-def analyze_with_loading(analysis_keywords, selected_category):
-    """원본 API: /analyze_with_loading"""
+def reset_interface(session_id):
+    """인터페이스 리셋 함수 - 세션별 데이터 초기화"""
+    update_session_activity(session_id)
+    
+    # 세션별 임시 파일 정리
+    if session_id in session_temp_files:
+        for file_path in session_temp_files[session_id]:
+            try:
+                if os.path.exists(file_path):
+                    os.remove(file_path)
+                    logger.info(f"세션 {session_id[:8]}... 리셋 시 파일 삭제: {file_path}")
+            except Exception as e:
+                logger.error(f"세션 {session_id[:8]}... 리셋 시 파일 삭제 오류: {e}")
+        session_temp_files[session_id] = []
+    
     try:
         client = get_api_client()
         result = client.predict(
-            analysis_keywords=analysis_keywords,
-            selected_category=selected_category,
-            api_name="/analyze_with_loading"
+            api_name="/reset_interface"
         )
-        return result[0] if result else ""
+        
+        # API 결과를 그대로 반환
+        return result
+        
     except Exception as e:
-        logger.error(f"analyze_with_loading API 호출 오류: {e}")
-        return ""
+        logger.error(f"리셋 API 호출 오류: {e}")
+        return (
+            "", # 검색 키워드
+            True, # 한글만 추출
+            False, # 검색량 0 키워드 제외
+            "메인키워드 적용", # 조합 방식
+            "", # HTML 테이블
+            ["전체 보기"], # 카테고리 필터
+            "전체 보기", # 카테고리 필터 선택
+            ["전체"], # 검색량 구간 필터
+            "전체", # 검색량 구간 선택
+            "정렬 없음", # 총검색량 정렬
+            "정렬 없음", # 키워드 사용횟수 정렬
+            ["전체 보기"], # 분석할 카테고리
+            "전체 보기", # 분석할 카테고리 선택
+            "", # 키워드 입력
+            "", # 분석 결과
+            None # 다운로드 파일
+        )
 
-def process_analyze_results(analysis_keywords, selected_category):
-    """원본 API: /process_analyze_results"""
+# 래퍼 함수들
+def search_with_loading(keyword, korean_only, apply_main_keyword, exclude_zero_volume, session_id):
+    update_session_activity(session_id)
+    
     try:
         client = get_api_client()
         result = client.predict(
-            analysis_keywords=analysis_keywords,
-            selected_category=selected_category,
-            api_name="/process_analyze_results"
+            keyword=keyword,
+            korean_only=korean_only,
+            apply_main_keyword=apply_main_keyword,
+            exclude_zero_volume=exclude_zero_volume,
+            api_name="/search_with_loading"
         )
         
-        if len(result) >= 2:
-            analysis_result, download_file = result[:2]
-            
-            # 다운로드 파일이 있는 경우 로컬로 복사
-            local_download_file = None
-            if download_file:
-                session_id = get_session_id()
-                local_download_file = create_session_temp_file(session_id, '.xlsx')
-                try:
-                    shutil.copy2(download_file, local_download_file)
-                except Exception as e:
-                    logger.error(f"분��� 결과 파일 복사 오류: {e}")
-                    local_download_file = None
-            
-            return analysis_result, local_download_file
-        else:
-            return "분석 결과가 없습니다.", None
+        return (
+            gr.update(visible=True),
+            gr.update(visible=False)
+        )
         
     except Exception as e:
-        logger.error(f"process_analyze_results API 호출 오류: {e}")
-        return "분석 서비스 연결에 문제가 발생했습니다. 잠시 후 다시 시도해주세요.", None
-
-def reset_interface():
-    """원본 API: /reset_interface"""
-    try:
-        client = get_api_client()
-        result = client.predict(api_name="/reset_interface")
-        return result if result else get_default_reset_values()
-    except Exception as e:
-        logger.error(f"reset_interface API 호출 오류: {e}")
-        return get_default_reset_values()
-
-def get_default_reset_values():
-    """기본 리셋 값 반환"""
-    return (
-        "", True, False, "메인키워드 적용", "", ["전체 보기"], "전체 보기",
-        ["전체"], "전체", "정렬 없음", "정렬 없음", ["전체 보기"], "전체 보기",
-        "", "", None
-    )
-
-# UI 처리 래퍼 함수들
-def wrapper_search_with_loading(keyword, korean_only, apply_main_keyword, exclude_zero_volume):
-    """검색 로딩 UI 처리"""
-    search_with_loading(keyword, korean_only, apply_main_keyword, exclude_zero_volume)
-    return (
-        gr.update(visible=True),  # progress_section
-        gr.update(visible=False)  # empty_table_html
-    )
+        logger.error(f"검색 로딩 API 호출 오류: {e}")
+        return (
+            gr.update(visible=False),
+            gr.update(visible=True)
+        )
 
-def wrapper_process_search_results(keyword, korean_only, apply_main_keyword, exclude_zero_volume):
-    """검색 결과 처리 UI"""
-    result = process_search_results(keyword, korean_only, apply_main_keyword, exclude_zero_volume)
+def process_search_results(keyword, korean_only, apply_main_keyword, exclude_zero_volume, session_id):
+    update_session_activity(session_id)
     
-    table_html, cat_choices, vol_choices, selected_cat, download_file = result
+    result = wrapper_modified(keyword, korean_only, apply_main_keyword, exclude_zero_volume, session_id)
     
-    # UI 표시 여부 결정
-    if table_html and "검색 결과가 없습니다" not in table_html and "문제가 발생했습니다" not in table_html:
-        keyword_section_visibility = True
-        category_section_visibility = True
+    table_html, cat_choices, vol_choices, df, selected_cat, excel, keyword_section_vis, cat_section_vis, new_keyword_state = result
+    
+    if excel is not None:
         empty_placeholder_vis = False
+        keyword_section_visibility = True
         execution_section_visibility = True
     else:
-        keyword_section_visibility = False
-        category_section_visibility = False
         empty_placeholder_vis = True
+        keyword_section_visibility = False
         execution_section_visibility = False
     
-    # 가상의 state_df
-    state_df = pd.DataFrame()
-    
     return (
-        table_html,  # table_output
-        cat_choices,  # category_filter choices
-        vol_choices,  # search_volume_filter choices
-        state_df,  # state_df
-        selected_cat,  # selected_category value
-        download_file,  # download_output
-        gr.update(visible=keyword_section_visibility),  # keyword_analysis_section
-        gr.update(visible=category_section_visibility),  # category_analysis_section
-        gr.update(visible=False),  # progress_section
-        gr.update(visible=empty_placeholder_vis),  # empty_table_html
-        gr.update(visible=execution_section_visibility),  # execution_section
-        keyword  # keyword_state
+        table_html, cat_choices, vol_choices, df, selected_cat, excel,
+        gr.update(visible=keyword_section_visibility),
+        gr.update(visible=cat_section_vis),
+        gr.update(visible=False),
+        gr.update(visible=empty_placeholder_vis),
+        gr.update(visible=execution_section_visibility),
+        new_keyword_state
     )
 
-def wrapper_analyze_with_loading(analysis_keywords, selected_category, state_df):
-    """분석 로딩 UI 처리"""
-    analyze_with_loading(analysis_keywords, selected_category)
-    return gr.update(visible=True)  # progress_section
+def analyze_with_loading(analysis_keywords, selected_category, state_df, session_id):
+    update_session_activity(session_id)
+    
+    try:
+        client = get_api_client()
+        result = client.predict(
+            analysis_keywords=analysis_keywords,
+            selected_category=selected_category,
+            api_name="/analyze_with_loading"
+        )
+        
+        return gr.update(visible=True)
+        
+    except Exception as e:
+        logger.error(f"분석 로딩 API 호출 오류: {e}")
+        return gr.update(visible=False)
 
-def wrapper_process_analyze_results(analysis_keywords, selected_category, state_df):
-    """분석 결과 처리 UI"""
-    analysis_result, download_file = process_analyze_results(analysis_keywords, selected_category)
-    return (
-        analysis_result,  # analysis_result
-        download_file,  # download_output
-        gr.update(visible=True),  # analysis_output_section
-        gr.update(visible=False)  # progress_section
-    )
+def process_analyze_results(analysis_keywords, selected_category, state_df, session_id):
+    update_session_activity(session_id)
+    results = analyze_with_auto_download(analysis_keywords, selected_category, state_df, session_id)
+    return results + (gr.update(visible=False),)
 
 # 세션 정리 스케줄러
 def start_session_cleanup_scheduler():
@@ -424,6 +434,7 @@ def start_session_cleanup_scheduler():
         while True:
             time.sleep(600)  # 10분마다 실행
             cleanup_old_sessions()
+            # 추가로 허깅페이스 임시 폴더도 주기적 정리
             cleanup_huggingface_temp_folders()
     
     threading.Thread(target=cleanup_scheduler, daemon=True).start()
@@ -432,14 +443,19 @@ def cleanup_on_startup():
     """애플리케이션 시작 시 전체 정리"""
     logger.info("🧹 컨트롤 타워 애플리케이션 시작 - 초기 정리 작업 시작...")
     
+    # 1. 허깅페이스 임시 폴더 정리
     cleanup_huggingface_temp_folders()
+    
+    # 2. 깨끗한 임시 환경 설정
     app_temp_dir = setup_clean_temp_environment()
     
+    # 3. 전역 변수 초기화
     global session_temp_files, session_data
     session_temp_files.clear()
     session_data.clear()
     
     logger.info(f"✅ 초기 정리 작업 완료 - 앱 전용 디렉토리: {app_temp_dir}")
+    
     return app_temp_dir
 
 # Gradio 인터페이스 생성
@@ -455,21 +471,7 @@ def create_app():
         with open('style.css', 'r', encoding='utf-8') as f:
             custom_css = f.read()
     except:
-        custom_css = """
-        :root {
-            --primary-color: #FB7F0D;
-            --secondary-color: #ff9a8b;
-        }
-        .custom-button {
-            background: linear-gradient(135deg, var(--primary-color), var(--secondary-color)) !important;
-            color: white !important;
-            border-radius: 30px !important;
-            height: 45px !important;
-            font-size: 16px !important;
-            font-weight: bold !important;
-            width: 100% !important;
-        }
-        """
+        custom_css = ""
     
     with gr.Blocks(css=custom_css, theme=gr.themes.Default(
         primary_hue="orange",
@@ -478,6 +480,9 @@ def create_app():
     )) as demo:
         gr.HTML(fontawesome_html)
         
+        # 세션 ID 상태 (각 사용자별로 고유)
+        session_id = gr.State(get_session_id)
+        
         # 키워드 상태 관리
         keyword_state = gr.State("")
         
@@ -650,14 +655,14 @@ def create_app():
         # 상태 저장용 변수
         state_df = gr.State()
         
-        # 이벤트 연결
+        # 이벤트 연결 - 모든 함수에 session_id 추가
         search_btn.click(
-            fn=wrapper_search_with_loading,
-            inputs=[keyword, korean_only, apply_main_keyword, exclude_zero_volume],
+            fn=search_with_loading,
+            inputs=[keyword, korean_only, apply_main_keyword, exclude_zero_volume, session_id],
             outputs=[progress_section, empty_table_html]
         ).then(
-            fn=wrapper_process_search_results,
-            inputs=[keyword, korean_only, apply_main_keyword, exclude_zero_volume],
+            fn=process_search_results,
+            inputs=[keyword, korean_only, apply_main_keyword, exclude_zero_volume, session_id],
             outputs=[
                 table_output, category_filter, search_volume_filter, 
                 state_df, selected_category, download_output,
@@ -667,29 +672,29 @@ def create_app():
             ]
         )
         
-        # 필터 및 정렬 변경 이벤트 연결
+        # 필터 및 정렬 변경 이벤트 연결 - session_id 추가
         category_filter.change(
             fn=filter_and_sort_table, 
             inputs=[
-                category_filter, gr.Textbox(value="정렬 없음", visible=False), 
+                state_df, category_filter, gr.Textbox(value="정렬 없음", visible=False), 
                 total_volume_sort, usage_count_sort, 
-                search_volume_filter, exclude_zero_volume
+                search_volume_filter, exclude_zero_volume, session_id
             ], 
             outputs=[table_output]
         )
         
         category_filter.change(
             fn=update_category_selection,
-            inputs=[category_filter],
+            inputs=[category_filter, session_id],
             outputs=[selected_category]
         )
         
         total_volume_sort.change(
             fn=filter_and_sort_table, 
             inputs=[
-                category_filter, gr.Textbox(value="정렬 없음", visible=False), 
+                state_df, category_filter, gr.Textbox(value="정렬 없음", visible=False), 
                 total_volume_sort, usage_count_sort, 
-                search_volume_filter, exclude_zero_volume
+                search_volume_filter, exclude_zero_volume, session_id
             ], 
             outputs=[table_output]
         )
@@ -697,9 +702,9 @@ def create_app():
         usage_count_sort.change(
             fn=filter_and_sort_table, 
             inputs=[
-                category_filter, gr.Textbox(value="정렬 없음", visible=False), 
+                state_df, category_filter, gr.Textbox(value="정렬 없음", visible=False), 
                 total_volume_sort, usage_count_sort, 
-                search_volume_filter, exclude_zero_volume
+                search_volume_filter, exclude_zero_volume, session_id
             ], 
             outputs=[table_output]
         )
@@ -707,9 +712,9 @@ def create_app():
         search_volume_filter.change(
             fn=filter_and_sort_table, 
             inputs=[
-                category_filter, gr.Textbox(value="정렬 없음", visible=False), 
+                state_df, category_filter, gr.Textbox(value="정렬 없음", visible=False), 
                 total_volume_sort, usage_count_sort, 
-                search_volume_filter, exclude_zero_volume
+                search_volume_filter, exclude_zero_volume, session_id
             ], 
             outputs=[table_output]
         )
@@ -717,28 +722,28 @@ def create_app():
         exclude_zero_volume.change(
             fn=filter_and_sort_table, 
             inputs=[
-                category_filter, gr.Textbox(value="정렬 없음", visible=False), 
+                state_df, category_filter, gr.Textbox(value="정렬 없음", visible=False), 
                 total_volume_sort, usage_count_sort, 
-                search_volume_filter, exclude_zero_volume
+                search_volume_filter, exclude_zero_volume, session_id
             ], 
             outputs=[table_output]
         )
         
-        # 카테고리 분석 버튼 이벤트
+        # 카테고리 분석 버튼 이벤트 - session_id 추가
         analyze_btn.click(
-            fn=wrapper_analyze_with_loading,
-            inputs=[analysis_keywords, selected_category, state_df],
+            fn=analyze_with_loading,
+            inputs=[analysis_keywords, selected_category, state_df, session_id],
             outputs=[progress_section]
         ).then(
-            fn=wrapper_process_analyze_results,
-            inputs=[analysis_keywords, selected_category, state_df],
+            fn=process_analyze_results,
+            inputs=[analysis_keywords, selected_category, state_df, session_id],
             outputs=[analysis_result, download_output, analysis_output_section, progress_section]
         )
         
-        # 리셋 버튼 이벤트 연결
+        # 리셋 버튼 이벤트 연결 - session_id 추가
         reset_btn.click(
             fn=reset_interface,
-            inputs=[],
+            inputs=[session_id],
             outputs=[
                 keyword, korean_only, exclude_zero_volume, apply_main_keyword, 
                 table_output, category_filter, category_filter, 
@@ -753,7 +758,6 @@ def create_app():
 
 if __name__ == "__main__":
     # ========== 시작 시 전체 초기화 ==========
-    print("===== Application Startup at %s =====" % time.strftime("%Y-%m-%d %H:%M:%S"))
     logger.info("🚀 컨트롤 타워 애플리케이션 시작...")
     
     # 1. 첫 번째: 허깅페이스 임시 폴더 정리 및 환경 설정
@@ -762,24 +766,20 @@ if __name__ == "__main__":
     # 2. 세션 정리 스케줄러 시작
     start_session_cleanup_scheduler()
     
-    # 3. API 연결 테스트
+    # 3. API 엔드포인트 확인
     try:
-        test_client = get_simple_api_client()
-        logger.info("✅ API 연결 테스트 성공")
+        client = get_api_client()
+        logger.info("✅ API 클라이언트 연결 확인 완료")
     except Exception as e:
-        logger.error("❌ API 연결 실패 - 환경변수 API_ENDPOINT를 확인하세요")
-        print("❌ API_ENDPOINT 환경변수가 설정되지 않았습니다.")
-        print("💡 .env 파일에 다음과 같이 설정하세요:")
-        print("API_ENDPOINT=your-endpoint-here")
-        raise SystemExit(1)
+        logger.error(f"❌ API 클라이언트 연결 실패: {e}")
+        raise
     
-    logger.info("===== 컨트롤 타워 애플리케이션 시작 완료 at %s =====", time.strftime("%Y-%m-%d %H:%M:%S"))
+    logger.info("===== 컨트롤 타워 Application Startup at %s =====", time.strftime("%Y-%m-%d %H:%M:%S"))
     logger.info(f"📁 임시 파일 저장 위치: {app_temp_dir}")
     
     # ========== 앱 실행 ==========
     try:
         app = create_app()
-        print("🚀 Gradio 애플리케이션이 시작됩니다...")
         app.launch(
             share=False,  # 보안을 위해 share 비활성화
             server_name="0.0.0.0",  # 모든 IP에서 접근 허용
@@ -789,14 +789,11 @@ if __name__ == "__main__":
             show_error=True,  # 에러 표시
             quiet=False,  # 로그 표시
             favicon_path=None,  # 파비콘 설정
-            ssl_verify=False,  # SSL 검증 비활성화 (개발용)
-            inbrowser=False,  # 자동 브라우저 열기 비활성화
-            prevent_thread_lock=False  # 스레드 잠금 방지 비활성화
+            ssl_verify=False  # SSL 검증 비활성화 (개발용)
         )
     except Exception as e:
         logger.error(f"애플리케이션 실행 실패: {e}")
-        print(f"❌ 애플리케이션 실행 실패: {e}")
-        raise SystemExit(1)
+        raise
     finally:
         # 애플리케이션 종료 시 정리
         logger.info("🧹 컨트롤 타워 애플리케이션 종료 - 최종 정리 작업...")