Update app.py

app.py

@@ -10,127 +10,115 @@ import uuid
 import shutil
 import glob
 from datetime import datetime
-from gradio_client import Client
+import requests
+import json
 from dotenv import load_dotenv
 
 # 환경변수 로드
 load_dotenv()
 
-# 로깅 설정 (API 엔드포인트 정보는 제외)
-class SecureFilter(logging.Filter):
-    """API 엔드포인트 정보를 로그에서 제거하는 필터"""
-    def filter(self, record):
-        # API 엔드포인트 관련 로그 필터링
-        message = record.getMessage()
-        if any(keyword in message.lower() for keyword in ['hf.space', 'happydoggg', 'gradio_api', 'http request']):
-            return False
-        return True
-
-# 보안 필터 적용
-secure_filter = SecureFilter()
-
-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__)
-logger.addFilter(secure_filter)
 
-# HTTP 요청 로그도 숨김
-logging.getLogger("httpx").setLevel(logging.WARNING)
-logging.getLogger("gradio_client").setLevel(logging.WARNING)
+# 세션별 임시 파일 관리를 위한 딕셔너리
+session_temp_files = {}
+session_data = {}
 
-# API 클라이언트 초기화
 def get_api_client():
-    """환경변수에서 API 엔드포인트를 가져와 클라이언트 생성"""
+    """환경변수에서 API 엔드포인트를 가져와 요청 함수 생성"""
     endpoint = os.getenv('API_ENDPOINT')
     if not endpoint:
-        logger.error("API_ENDPOINT 환경변수가 설정되지 않았습니다.")
         raise ValueError("API_ENDPOINT 환경변수가 필요합니다.")
-    return Client(endpoint)
-
-# 세션별 임시 파일 관리를 위한 딕셔너리
-session_temp_files = {}
-session_data = {}
+    
+    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)})()
 
 def cleanup_huggingface_temp_folders():
     """허깅페이스 임시 폴더 초기 정리"""
     try:
-        # 일반적인 임시 디렉토리들
-        temp_dirs = [
-            tempfile.gettempdir(),
-            "/tmp",
-            "/var/tmp",
-            os.path.join(os.getcwd(), "temp"),
-            os.path.join(os.getcwd(), "tmp"),
-            "/gradio_cached_examples",
-            "/flagged"
-        ]
-        
+        temp_dirs = [tempfile.gettempdir(), "/tmp", "/var/tmp"]
         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
-                                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}개 파일 삭제")
+                        except Exception:
+                            pass
+                except Exception:
+                    pass
         
-        # 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}")
-            
+        logger.info(f"✅ 임시 폴더 정리 완료 - {cleanup_count}개 파일 삭제")
     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()
@@ -140,13 +128,12 @@ def get_app_temp_dir():
     return os.environ.get('CONTROL_TOWER_TEMP', tempfile.gettempdir())
 
 def get_session_id():
-    """세션 ID 생성 - 원본 API와 동일"""
+    """세션 ID 생성"""
     try:
         client = get_api_client()
         result = client.predict(api_name="/get_session_id")
-        return result
-    except Exception as e:
-        logger.error(f"세션 ID 생성 API 호출 오류: {e}")
+        return result[0] if result else str(uuid.uuid4())
+    except Exception:
         return str(uuid.uuid4())
 
 def cleanup_session_files(session_id, delay=300):
@@ -179,11 +166,10 @@ def cleanup_old_sessions():
     sessions_to_remove = []
     
     for session_id, data in session_data.items():
-        if current_time - data.get('last_activity', 0) > 3600:  # 1시간 초과
+        if current_time - data.get('last_activity', 0) > 3600:
             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:
@@ -194,7 +180,6 @@ 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]}...")
@@ -206,26 +191,22 @@ 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
 
-# ========== 원본 API와 정확히 동일한 함수들 ==========
-
 def search_with_loading(keyword, korean_only, apply_main_keyword, exclude_zero_volume):
-    """원본 API: /search_with_loading (4개 매개변수, 1개 반환값)"""
+    """원본 API: /search_with_loading"""
     try:
         client = get_api_client()
         result = client.predict(
@@ -235,13 +216,13 @@ def search_with_loading(keyword, korean_only, apply_main_keyword, exclude_zero_v
             exclude_zero_volume=exclude_zero_volume,
             api_name="/search_with_loading"
         )
-        return result
+        return result[0] if result else ""
     except Exception as e:
         logger.error(f"search_with_loading API 호출 오류: {e}")
-        return gr.update(visible=True)
+        return ""
 
 def process_search_results(keyword, korean_only, apply_main_keyword, exclude_zero_volume):
-    """원본 API: /process_search_results (4개 매개변수, 6개 반환값)"""
+    """원본 API: /process_search_results"""
     try:
         client = get_api_client()
         result = client.predict(
@@ -252,42 +233,37 @@ def process_search_results(keyword, korean_only, apply_main_keyword, exclude_zer
             api_name="/process_search_results"
         )
         
-        # 원본 API 문서에 따르면 6개 반환값이지만 실제로는 5개일 수 있음
-        # 안전하게 처리
-        if len(result) == 6:
-            table_html, cat_choices, vol_choices, selected_cat, download_file, progress_html = result
-        elif len(result) == 5:
-            table_html, cat_choices, vol_choices, selected_cat, download_file = result
-            progress_html = ""
+        # 결과 안전하게 처리
+        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:
-            logger.error(f"예상과 다른 반환값 개수: {len(result)}")
             return (
-                "<p>서비스 응답 형식에 문제가 발생했습니다.</p>",
-                ["전체 보기"], ["전체"], "전체 보기", None, ""
+                "<p>검색 결과가 없습니다.</p>",
+                ["전체 보기"], ["전체"], "전체 보기", None
             )
         
-        # 다운로드 파일이 있는 경우 로컬로 복사
-        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, progress_html
-        
     except Exception as e:
-        logger.error(f"API 호출 오류: {e}")
+        logger.error(f"process_search_results API 호출 오류: {e}")
         return (
             "<p>서비스 연결에 문제가 발생했습니다. 잠시 후 다시 시도해주세요.</p>",
-            ["전체 보기"], ["전체"], "전체 보기", None, ""
+            ["전체 보기"], ["전체"], "전체 보기", None
         )
 
 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 (6개 매개변수, 1개 반환값)"""
+    """원본 API: /filter_and_sort_table"""
     try:
         client = get_api_client()
         result = client.predict(
@@ -299,98 +275,26 @@ 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
+        return result[0] if result else ""
     except Exception as e:
         logger.error(f"filter_and_sort_table API 호출 오류: {e}")
         return "<p>필터링 서비스 연결에 문제가 발생했습니다.</p>"
 
-def filter_and_sort_table_1(selected_cat, keyword_sort, total_volume_sort, usage_count_sort, selected_volume_range, exclude_zero_volume):
-    """원본 API: /filter_and_sort_table_1"""
-    try:
-        client = get_api_client()
-        result = client.predict(
-            selected_cat=selected_cat,
-            keyword_sort=keyword_sort,
-            total_volume_sort=total_volume_sort,
-            usage_count_sort=usage_count_sort,
-            selected_volume_range=selected_volume_range,
-            exclude_zero_volume=exclude_zero_volume,
-            api_name="/filter_and_sort_table_1"
-        )
-        return result
-    except Exception as e:
-        logger.error(f"filter_and_sort_table_1 API 호출 오류: {e}")
-        return "<p>필터링 서비스 연결에 문제가 발생했습니다.</p>"
-
-def filter_and_sort_table_2(selected_cat, keyword_sort, total_volume_sort, usage_count_sort, selected_volume_range, exclude_zero_volume):
-    """원본 API: /filter_and_sort_table_2"""
-    try:
-        client = get_api_client()
-        result = client.predict(
-            selected_cat=selected_cat,
-            keyword_sort=keyword_sort,
-            total_volume_sort=total_volume_sort,
-            usage_count_sort=usage_count_sort,
-            selected_volume_range=selected_volume_range,
-            exclude_zero_volume=exclude_zero_volume,
-            api_name="/filter_and_sort_table_2"
-        )
-        return result
-    except Exception as e:
-        logger.error(f"filter_and_sort_table_2 API 호출 오류: {e}")
-        return "<p>필터링 서비스 연결에 문제가 발생했습니다.</p>"
-
-def filter_and_sort_table_3(selected_cat, keyword_sort, total_volume_sort, usage_count_sort, selected_volume_range, exclude_zero_volume):
-    """원본 API: /filter_and_sort_table_3"""
-    try:
-        client = get_api_client()
-        result = client.predict(
-            selected_cat=selected_cat,
-            keyword_sort=keyword_sort,
-            total_volume_sort=total_volume_sort,
-            usage_count_sort=usage_count_sort,
-            selected_volume_range=selected_volume_range,
-            exclude_zero_volume=exclude_zero_volume,
-            api_name="/filter_and_sort_table_3"
-        )
-        return result
-    except Exception as e:
-        logger.error(f"filter_and_sort_table_3 API 호출 오류: {e}")
-        return "<p>필터링 서비스 연결에 문제가 발생했습니다.</p>"
-
-def filter_and_sort_table_4(selected_cat, keyword_sort, total_volume_sort, usage_count_sort, selected_volume_range, exclude_zero_volume):
-    """원본 API: /filter_and_sort_table_4"""
-    try:
-        client = get_api_client()
-        result = client.predict(
-            selected_cat=selected_cat,
-            keyword_sort=keyword_sort,
-            total_volume_sort=total_volume_sort,
-            usage_count_sort=usage_count_sort,
-            selected_volume_range=selected_volume_range,
-            exclude_zero_volume=exclude_zero_volume,
-            api_name="/filter_and_sort_table_4"
-        )
-        return result
-    except Exception as e:
-        logger.error(f"filter_and_sort_table_4 API 호출 오류: {e}")
-        return "<p>필터링 서비스 연결에 문제가 발생했습니다.</p>"
-
 def update_category_selection(selected_cat):
-    """원본 API: /update_category_selection (1개 매개변수, 1개 반환값)"""
+    """원본 API: /update_category_selection"""
     try:
         client = get_api_client()
         result = client.predict(
             selected_cat=selected_cat,
             api_name="/update_category_selection"
         )
-        return gr.update(value=result)
+        return gr.update(value=result[0] if result else selected_cat)
     except Exception as e:
         logger.error(f"update_category_selection API 호출 오류: {e}")
         return gr.update(value=selected_cat)
 
 def analyze_with_loading(analysis_keywords, selected_category):
-    """원본 API: /analyze_with_loading (2개 매개변수, 1개 반환값)"""
+    """원본 API: /analyze_with_loading"""
     try:
         client = get_api_client()
         result = client.predict(
@@ -398,13 +302,13 @@ def analyze_with_loading(analysis_keywords, selected_category):
             selected_category=selected_category,
             api_name="/analyze_with_loading"
         )
-        return result
+        return result[0] if result else ""
     except Exception as e:
         logger.error(f"analyze_with_loading API 호출 오류: {e}")
-        return gr.update(visible=True)
+        return ""
 
 def process_analyze_results(analysis_keywords, selected_category):
-    """원본 API: /process_analyze_results (2개 매개변수, 2개 반환��)"""
+    """원본 API: /process_analyze_results"""
     try:
         client = get_api_client()
         result = client.predict(
@@ -413,58 +317,50 @@ def process_analyze_results(analysis_keywords, selected_category):
             api_name="/process_analyze_results"
         )
         
-        analysis_result, download_file = result
-        
-        # 다운로드 파일이 있는 경우 로컬로 복사
-        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
+        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
         
     except Exception as e:
         logger.error(f"process_analyze_results API 호출 오류: {e}")
         return "분석 서비스 연결에 문제가 발생했습니다. 잠시 후 다시 시도해주세요.", None
 
 def reset_interface():
-    """원본 API: /reset_interface (0개 매개변수, 16개 반환값)"""
+    """원본 API: /reset_interface"""
     try:
         client = get_api_client()
         result = client.predict(api_name="/reset_interface")
-        return result
+        return result if result else get_default_reset_values()
     except Exception as e:
         logger.error(f"reset_interface API 호출 오류: {e}")
-        # 기본 리셋 값 반환 (16개)
-        return (
-            "", # 검색 키워드
-            True, # 한글만 추출
-            False, # 검색량 0 키워드 제외
-            "메인키워드 적용", # 조합 방식
-            "", # HTML 테이블
-            ["전체 보기"], # 카테고리 필터 choices
-            "전체 보기", # 카테고리 필터 value
-            ["전체"], # 검색량 구간 필터 choices
-            "전체", # 검색량 구간 필터 value
-            "정렬 없음", # 총검색량 정렬
-            "정렬 없음", # 키워드 사용횟수 정렬
-            ["전체 보기"], # 분석할 카테고리 choices
-            "전체 보기", # 분석할 카테고리 value
-            "", # 키워드 입력
-            "", # 분석 결과
-            None # 다운로드 파일
-        )
+        return get_default_reset_values()
 
-# ========== UI 처리 래퍼 함수들 ==========
+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 처리"""
-    result = search_with_loading(keyword, korean_only, apply_main_keyword, exclude_zero_volume)
+    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
@@ -474,18 +370,7 @@ def wrapper_process_search_results(keyword, korean_only, apply_main_keyword, exc
     """검색 결과 처리 UI"""
     result = process_search_results(keyword, korean_only, apply_main_keyword, exclude_zero_volume)
     
-    # 안전하게 결과 처리
-    if len(result) >= 5:
-        table_html, cat_choices, vol_choices, selected_cat, download_file = result[:5]
-        progress_html = result[5] if len(result) > 5 else ""
-    else:
-        logger.error(f"검색 결과 처리 오류: 예상보다 적은 반환값 {len(result)}")
-        table_html = "<p>검색 결과 처리에 문제가 발생했습니다.</p>"
-        cat_choices = ["전체 보기"]
-        vol_choices = ["전체"]
-        selected_cat = "전체 보기"
-        download_file = None
-        progress_html = ""
+    table_html, cat_choices, vol_choices, selected_cat, download_file = result
     
     # UI 표시 여부 결정
     if table_html and "검색 결과가 없습니다" not in table_html and "문제가 발생했���니다" not in table_html:
@@ -499,7 +384,7 @@ def wrapper_process_search_results(keyword, korean_only, apply_main_keyword, exc
         empty_placeholder_vis = True
         execution_section_visibility = False
     
-    # 가상의 state_df (원본과 호환성을 위해)
+    # 가상의 state_df
     state_df = pd.DataFrame()
     
     return (
@@ -519,7 +404,7 @@ def wrapper_process_search_results(keyword, korean_only, apply_main_keyword, exc
 
 def wrapper_analyze_with_loading(analysis_keywords, selected_category, state_df):
     """분석 로딩 UI 처리"""
-    result = analyze_with_loading(analysis_keywords, selected_category)
+    analyze_with_loading(analysis_keywords, selected_category)
     return gr.update(visible=True)  # progress_section
 
 def wrapper_process_analyze_results(analysis_keywords, selected_category, state_df):
@@ -547,19 +432,14 @@ 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 인터페이스 생성
@@ -588,10 +468,6 @@ def create_app():
             font-size: 16px !important;
             font-weight: bold !important;
             width: 100% !important;
-            text-align: center !important;
-            display: flex !important;
-            align-items: center !important;
-            justify-content: center !important;
         }
         """
     
@@ -873,4 +749,61 @@ def create_app():
             ]
         )
                 
-    return demo
+    return demo
+
+if __name__ == "__main__":
+    # ========== 시작 시 전체 초기화 ==========
+    print("===== Application Startup at %s =====" % time.strftime("%Y-%m-%d %H:%M:%S"))
+    logger.info("🚀 컨트롤 타워 애플리케이션 시작...")
+    
+    # 1. 첫 번째: 허깅페이스 임시 폴더 정리 및 환경 설정
+    app_temp_dir = cleanup_on_startup()
+    
+    # 2. 세션 정리 스케줄러 시작
+    start_session_cleanup_scheduler()
+    
+    # 3. API 연결 테스트
+    try:
+        test_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.info("===== 컨트롤 타워 애플리케이션 시작 완료 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에서 접근 허용
+            server_port=7860,  # 포트 지정
+            max_threads=40,  # 멀티유저를 위한 스레드 수 증가
+            auth=None,  # 필요시 인증 추가 가능
+            show_error=True,  # 에러 표시
+            quiet=False,  # 로그 표시
+            favicon_path=None,  # 파비콘 설정
+            ssl_verify=False,  # SSL 검증 비활성화 (개발용)
+            inbrowser=False,  # 자동 브라우저 열기 비활성화
+            prevent_thread_lock=False  # 스레드 잠금 방지 비활성화
+        )
+    except Exception as e:
+        logger.error(f"애플리케이션 실행 실패: {e}")
+        print(f"❌ 애플리케이션 실행 실패: {e}")
+        raise SystemExit(1)
+    finally:
+        # 애플리케이션 종료 시 정리
+        logger.info("🧹 컨트롤 타워 애플리케이션 종료 - 최종 정리 작업...")
+        try:
+            cleanup_huggingface_temp_folders()
+            if os.path.exists(app_temp_dir):
+                shutil.rmtree(app_temp_dir, ignore_errors=True)
+            logger.info("✅ 최종 정리 완료")
+        except Exception as e:
+            logger.error(f"최종 정리 중 오류: {e}")