Update app.py

app.py

@@ -5,7 +5,6 @@ import time
 import threading
 import tempfile
 import logging
-import random
 import uuid
 import shutil
 import glob
@@ -19,7 +18,7 @@ logging.basicConfig(
     format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
     handlers=[
         logging.StreamHandler(),
-        logging.FileHandler('main_keyword_app.log', mode='a')
+        logging.FileHandler('category_analysis_app.log', mode='a')
     ]
 )
 
@@ -152,8 +151,10 @@ def cleanup_huggingface_temp_folders():
                     # 기존 세션 파일들 정리
                     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, "*category*.xlsx")))
+                    session_files.extend(glob.glob(os.path.join(temp_dir, "*category*.csv")))
+                    session_files.extend(glob.glob(os.path.join(temp_dir, "*analysis*.xlsx")))
+                    session_files.extend(glob.glob(os.path.join(temp_dir, "*analysis*.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")))
                     
@@ -191,13 +192,13 @@ def setup_clean_temp_environment():
         cleanup_huggingface_temp_folders()
         
         # 2. 애플리케이션 전용 임시 디렉토리 생성
-        app_temp_dir = os.path.join(tempfile.gettempdir(), "keyword_app")
+        app_temp_dir = os.path.join(tempfile.gettempdir(), "category_analysis_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['KEYWORD_APP_TEMP'] = app_temp_dir
+        os.environ['CATEGORY_APP_TEMP'] = app_temp_dir
         
         logger.info(f"✅ 애플리케이션 전용 임시 디렉토리 설정: {app_temp_dir}")
         
@@ -209,7 +210,7 @@ def setup_clean_temp_environment():
 
 def get_app_temp_dir():
     """애플리케이션 전용 임시 디렉토리 반환"""
-    return os.environ.get('KEYWORD_APP_TEMP', tempfile.gettempdir())
+    return os.environ.get('CATEGORY_APP_TEMP', tempfile.gettempdir())
 
 def get_session_id():
     """세션 ID 생성"""
@@ -274,7 +275,7 @@ def update_session_activity(session_id):
 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))
+    random_suffix = str(time.time_ns())[-4:]
     
     # 애플리케이션 전용 임시 디렉토리 사용
     temp_dir = get_app_temp_dir()
@@ -288,152 +289,119 @@ def create_session_temp_file(session_id, suffix='.xlsx'):
     register_session_file(session_id, temp_file_path)
     return temp_file_path
 
-def wrapper_modified(keyword, korean_only, apply_main_keyword_option, exclude_zero_volume, session_id):
-    """키워드 검색 및 처리 래퍼 함수 (세션 ID 추가)"""
+def analyze_product_terms_wrapper(product_name, main_keyword, current_state, session_id):
+    """상품명 키워드 분석 래퍼 함수 - 세션 ID 추가"""
     update_session_activity(session_id)
     
-    # 현재 키워드 사용 (세션별로 관리)
-    current_keyword = keyword
+    if not product_name:
+        return "상품명을 입력해주세요.", current_state, None, gr.update(visible=False)
     
-    # 키워드가 비어있는 경우 처리
-    if not keyword:
-        return (gr.update(value=""), gr.update(choices=["전체 보기"]), gr.update(choices=["전체"]), 
-                None, gr.update(choices=["전체 보기"], value="전체 보기"), None, 
-                gr.update(visible=False), gr.update(visible=False), current_keyword)
+    # 분석 수행 - HTML 결과와 키워드 분석 결과 함께 받기
+    result_html, keyword_results = category_analysis.analyze_product_terms(product_name, main_keyword)
     
-    # 네이버 쇼핑 API 검색 수행
-    search_results = product_search.fetch_naver_shopping_data(keyword, korean_only, apply_main_keyword_option == "메인키워드 적용")
+    # 새로운 상태 생성
+    if current_state is None or not isinstance(current_state, dict):
+        current_state = {}
     
-    # 검색 결과가 없는 경우
-    if not search_results.get("product_list"):
-        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), current_keyword)
+    # 분석 결과를 상태에 추가
+    current_state["keyword_analysis_results"] = keyword_results
+    current_state["product_name"] = product_name
+    current_state["main_keyword"] = main_keyword
     
-    # 검색 결과 처리 - 키워드 전달 및 검색량 0 키워드 제외 옵션 전달
-    result = keyword_processor.process_search_results(search_results, current_keyword, exclude_zero_volume)
+    # 세션별 엑셀 파일 다운로드 - 자동 다운로드
+    excel_path = download_analysis(current_state, session_id)
     
-    df_products = result["products_df"]
-    df_keywords = result["keywords_df"]
-    category_list = result["categories"]
-    
-    if df_keywords.empty:
-        return (gr.update(value="<p>추출된 키워드가 없습니다. 다른 옵션으로 시도해보세요.</p>"), 
-                gr.update(choices=["전체 보기"]), gr.update(choices=["전체"]), 
-                df_keywords, gr.update(choices=["전체 보기"], value="전체 보기"), None,
-                gr.update(visible=False), gr.update(visible=False), current_keyword)
-    
-    # HTML 테이블 생성
-    html = export_utils.create_table_without_checkboxes(df_keywords)
-    
-    # 필터링을 위한 고유 값 리스트 생성
-    volume_range_choices = ["전체"] + sorted(df_keywords["검색량구간"].unique().tolist())
-    
-    # 분석할 카테고리 드롭다운도 같은 선택지로 업데이트
-    first_category = category_list[0] if category_list else "전체 보기"
+    # 출력 섹션 표시
+    return result_html, current_state, excel_path, gr.update(visible=True)
+
+def download_analysis(result, session_id):
+    """카테고리 분석 결과 다운로드 (세션별)"""
+    update_session_activity(session_id)
     
-    # 세션별 엑셀 파일 생성
-    excel_path = create_session_excel_file(df_keywords, session_id)
+    if not result or not isinstance(result, dict):
+        logger.warning(f"세션 {session_id[:8]}... 분석 결과가 없습니다.")
+        return None
     
-    # 분석 섹션 표시
-    return (gr.update(value=html), gr.update(choices=category_list), gr.update(choices=volume_range_choices),
-            df_keywords, gr.update(choices=category_list, value=first_category), excel_path,
-            gr.update(visible=True), gr.update(visible=True), current_keyword)
-
-def create_session_excel_file(df, session_id):
-    """세션별 엑셀 파일 생성"""
     try:
-        excel_path = create_session_temp_file(session_id, '.xlsx')
-        df.to_excel(excel_path, index=False, engine='openpyxl')
-        logger.info(f"세션 {session_id[:8]}... 엑셀 파일 생성: {excel_path}")
-        return excel_path
+        # 상품명 분석 결과가 있는지 확인
+        if "keyword_analysis_results" in result:
+            logger.info(f"세션 {session_id[:8]}... 키워드 분석 결과 포함하여 다운로드: {len(result['keyword_analysis_results'])}개 키워드")
+            
+            # 세션별 임시 파일 생성
+            temp_filename = create_session_temp_file(session_id, '.xlsx')
+            
+            # 데이터프레임 생성
+            keywords = []
+            pc_volumes = []
+            mobile_volumes = []
+            total_volumes = []
+            ranges = []
+            category_items = []
+            
+            for kw_result in result["keyword_analysis_results"]:
+                keywords.append(kw_result.get("키워드", ""))
+                pc_volumes.append(kw_result.get("PC검색량", 0))
+                mobile_volumes.append(kw_result.get("모바일검색량", 0))
+                total_volumes.append(kw_result.get("총검색량", 0))
+                ranges.append(kw_result.get("검색량구간", ""))
+                category_items.append(kw_result.get("카테고리항목", ""))
+            
+            # 데이터프레임으로 변환
+            df = pd.DataFrame({
+                "키워드": keywords,
+                "PC검색량": pc_volumes,
+                "모바일검색량": mobile_volumes,
+                "총검색량": total_volumes,
+                "검색량구간": ranges,
+                "카테고리항목": category_items
+            })
+            
+            with pd.ExcelWriter(temp_filename, engine="xlsxwriter") as writer:
+                df.to_excel(writer, sheet_name="상품명 검증 결과", index=False)
+            
+                ws = writer.sheets["상품명 검증 결과"]
+            
+                # 줄바꿈 + 위쪽 정렬 서식
+                wrap_fmt = writer.book.add_format({
+                    "text_wrap": True,
+                    "valign":    "top"
+                })
+            
+                # F열('카테고리항목') 전체에 서식 적용 + 열 너비
+                ws.set_column("F:F", 40, wrap_fmt)
+
+                # 열 너비 설정
+                worksheet = writer.sheets['상품명 검증 결과']
+                worksheet.set_column('A:A', 20)  # 키워드
+                worksheet.set_column('B:B', 12)  # PC검색량
+                worksheet.set_column('C:C', 12)  # 모바일검색량
+                worksheet.set_column('D:D', 12)  # 총검색량
+                worksheet.set_column('E:E', 12)  # 검색량구간
+                worksheet.set_column('F:F', 40)  # 카테고리항목
+                
+                # 헤더 서식 지정
+                header_format = writer.book.add_format({
+                    'bold': True,
+                    'bg_color': '#FB7F0D',
+                    'color': 'white',
+                    'border': 1
+                })
+                
+                # 헤더에 서식 적용
+                for col_num, value in enumerate(df.columns.values):
+                    worksheet.write(0, col_num, value, header_format)
+            
+            logger.info(f"세션 {session_id[:8]}... 엑셀 파일 저장 완료: {temp_filename}")
+            return temp_filename
+        else:
+            logger.warning(f"세션 {session_id[:8]}... 키워드 분석 결과가 없습니다.")
+            return None
     except Exception as e:
-        logger.error(f"세션별 엑셀 파일 생성 오류: {e}")
+        logger.error(f"세션 {session_id[:8]}... 다운로드 중 오류 발생: {e}")
+        import traceback
+        logger.error(traceback.format_exc())
         return None
 
-def analyze_with_auto_download(analysis_keywords, selected_category, state_df, session_id):
-    """카테고리 일치 분석 실행 및 자동 다운로드 (세션 ID 추가)"""
-    update_session_activity(session_id)
-    
-    # 분석할 키워드나 카테고리가 없는 경우
-    if not analysis_keywords or not selected_category:
-        return "키워드와 카테고리를 모두 선택해주세요.", None, gr.update(visible=False)
-    
-    # 분석 실행 - 동적 로딩된 category_analysis 모듈 사용
-    analysis_result = category_analysis.analyze_keywords_by_category(analysis_keywords, selected_category, state_df)
-    
-    # 세션별 엑셀 파일 생성
-    excel_path = create_session_excel_file(state_df, session_id)
-    
-    # 분석 결과 출력 섹션 표시
-    return analysis_result, excel_path, gr.update(visible=True)
-
-def filter_and_sort_table(df, selected_cat, keyword_sort, total_volume_sort, usage_count_sort, selected_volume_range, exclude_zero_volume, session_id):
-    """테이블 필터링 및 정렬 함수 (세션 ID 추가)"""
-    update_session_activity(session_id)
-    
-    if df is None or df.empty:
-        return ""
-
-    # 필터링 적용
-    filtered_df = df.copy()
-
-    # 카테고리 필터 적용
-    if selected_cat and selected_cat != "전체 보기":
-        cat_name_to_filter = selected_cat.rsplit(" (", 1)[0]
-        filtered_df = filtered_df[filtered_df["관련 카테고리"].astype(str).str.contains(cat_name_to_filter, case=False, na=False)]
-
-        def get_filtered_category_display(current_categories_str):
-            if pd.isna(current_categories_str):
-                return ""
-
-            categories = str(current_categories_str).split('\n')
-            matched_categories = [cat for cat in categories if cat_name_to_filter.lower() in cat.lower()]
-            if matched_categories:
-                return "\n".join(matched_categories) 
-                                                   
-            return current_categories_str
-
-        filtered_df['관련 카테고리'] = filtered_df['관련 카테고리'].apply(get_filtered_category_display)
-
-    # 검색량 구간 필터 적용
-    if selected_volume_range and selected_volume_range != "전체":
-        filtered_df = filtered_df[filtered_df["검색량구간"] == selected_volume_range]
-
-    # 검색량 0 제외 필터 적용
-    if exclude_zero_volume:
-        filtered_df = filtered_df[filtered_df["총검색량"] > 0]
-        logger.info(f"세션 {session_id[:8]}... 검색량 0 제외 필터 적용 - 남은 키워드 수: {len(filtered_df)}")
-
-    # 정렬 적용
-    if keyword_sort != "정렬 없음":
-        is_ascending = keyword_sort == "오름차순"
-        filtered_df = filtered_df.sort_values(by="조합 키워드", ascending=is_ascending)
-
-    if total_volume_sort != "정렬 없음":
-        is_ascending = total_volume_sort == "오름차순"
-        filtered_df = filtered_df.sort_values(by="총검색량", ascending=is_ascending)
-
-    # 키워드 사용횟수 정렬 적용
-    if usage_count_sort != "정렬 없음":
-        is_ascending = usage_count_sort == "오름차순"
-        filtered_df = filtered_df.sort_values(by="키워드 사용횟수", ascending=is_ascending)
-
-    # 순번을 1부터 순차적으로 유지하기 위해 행 인덱스 재설정
-    filtered_df = filtered_df.reset_index(drop=True)
-
-    # 순번을 포함한 HTML 테이블 생성
-    html = export_utils.create_table_without_checkboxes(filtered_df)
-
-    return html
-
-def update_category_selection(selected_cat, session_id):
-    """카테고리 필터 선택 시 분석할 카테고리도 같은 값으로 업��이트"""
-    update_session_activity(session_id)
-    logger.debug(f"세션 {session_id[:8]}... 카테고리 선택 변경: {selected_cat}")
-    return gr.update(value=selected_cat)
-
 def reset_interface(session_id):
     """인터페이스 리셋 함수 - 세션별 데이터 초기화"""
     update_session_activity(session_id)
@@ -450,69 +418,24 @@ def reset_interface(session_id):
         session_temp_files[session_id] = []
     
     return (
-        "", # 검색 키워드
-        True, # 한글만 추출
-        False, # 검색량 0 키워드 제외
-        "메인키워드 적용", # 조합 방식
-        "", # HTML 테이블
-        ["전체 보기"], # 카테고리 필터
-        "전체 보기", # 카테고리 필터 선택
-        ["전체"], # 검색량 구간 필터
-        "전체", # 검색량 구간 선택
-        "정렬 없음", # 총검색량 정렬
-        "정렬 없음", # 키워드 사용횟수 정렬
-        None, # 상태 DataFrame
-        ["전체 보기"], # 분석할 카테고리
-        "전체 보기", # 분석할 카테고리 선택
-        "", # 키워드 입력
-        "", # 분석 결과
-        None, # 다운로드 파일
-        gr.update(visible=False), # 키워드 분석 섹션
-        gr.update(visible=False), # 분석 결과 출력 섹션
-        "" # 키워드 상태
-    )
-
-# 래퍼 함수들도 세션 ID 추가
-def search_with_loading(keyword, korean_only, apply_main_keyword, exclude_zero_volume, session_id):
-    update_session_activity(session_id)
-    return (
-        gr.update(visible=True),
-        gr.update(visible=False)
-    )
-
-def process_search_results(keyword, korean_only, apply_main_keyword, exclude_zero_volume, session_id):
-    update_session_activity(session_id)
-    
-    result = wrapper_modified(keyword, korean_only, apply_main_keyword, exclude_zero_volume, session_id)
-    
-    table_html, cat_choices, vol_choices, df, selected_cat, excel, keyword_section_vis, cat_section_vis, new_keyword_state = result
-    
-    if not isinstance(df, type(None)) and not df.empty:
-        empty_placeholder_vis = False
-        keyword_section_visibility = True
-        execution_section_visibility = True
-    else:
-        empty_placeholder_vis = True
-        keyword_section_visibility = False
-        execution_section_visibility = False
-    
-    return (
-        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
+        "",  # 메인 키워드 입력
+        "",  # 상품명 입력
+        "",  # 분석 결과 출력
+        None,  # 다운로드 파일
+        None,  # 상태 변수
+        gr.update(visible=False)  # 분석 결과 섹션
     )
 
-def analyze_with_loading(analysis_keywords, selected_category, state_df, session_id):
+def product_analyze_with_loading(product_name, main_keyword, current_state, session_id):
+    """로딩 표시 함수"""
     update_session_activity(session_id)
     return gr.update(visible=True)
 
-def process_analyze_results(analysis_keywords, selected_category, state_df, session_id):
+def process_product_analyze(product_name, main_keyword, current_state, session_id):
+    """실제 분석 수행"""
     update_session_activity(session_id)
-    results = analyze_with_auto_download(analysis_keywords, selected_category, state_df, session_id)
+    results = analyze_product_terms_wrapper(product_name, main_keyword, current_state, session_id)
+    # 로딩 인디케이터 숨기기
     return results + (gr.update(visible=False),)
 
 # 세션 정리 스케줄러
@@ -529,7 +452,7 @@ def start_session_cleanup_scheduler():
 
 def cleanup_on_startup():
     """애플리케이션 시작 시 전체 정리"""
-    logger.info("🧹 애플리케이션 시작 - 초기 정리 작업 시작...")
+    logger.info("🧹 카테고리 분석 애플리케이션 시작 - 초기 정리 작업 시작...")
     
     # 1. 허깅페이스 임시 폴더 정리
     cleanup_huggingface_temp_folders()
@@ -548,6 +471,7 @@ def cleanup_on_startup():
 
 # Gradio 인터페이스 생성
 def create_app():
+    # FontAwesome 아이콘 포함
     fontawesome_html = """
     <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.0.0/css/all.min.css">
     <link rel="stylesheet" href="https://cdn.jsdelivr.net/gh/orioncactus/pretendard/dist/web/static/pretendard.css">
@@ -559,6 +483,7 @@ def create_app():
         with open('style.css', 'r', encoding='utf-8') as f:
             custom_css = f.read()
     except:
+        # CSS 파일이 없는 경우 기본 스타일 사용
         custom_css = """
         :root {
             --primary-color: #FB7F0D;
@@ -631,30 +556,6 @@ def create_app():
             50% { width: 70%; }
             100% { width: 10%; }
         }
-        .empty-table {
-            width: 100%;
-            border-collapse: collapse;
-            font-size: 14px;
-            margin-top: 20px;
-        }
-        .empty-table th {
-            background-color: #FB7F0D;
-            color: white;
-            text-align: left;
-            padding: 12px;
-            border: 1px solid #ddd;
-        }
-        .empty-table td {
-            padding: 10px;
-            border: 1px solid #ddd;
-            text-align: center;
-            color: #999;
-        }
-        .button-container {
-            margin-top: 20px;
-            display: flex;
-            gap: 15px;
-        }
         .execution-section {
             margin-top: 20px;
             background-color: #f9f9f9;
@@ -683,56 +584,47 @@ def create_app():
         # 세션 ID 상태 (각 사용자별로 고유)
         session_id = gr.State(get_session_id)
         
-        # 키워드 상태 관리
-        keyword_state = gr.State("")
-        
         # 입력 섹션
         with gr.Column(elem_classes="custom-frame fade-in"):
-            gr.HTML('<div class="section-title"><i class="fas fa-search"></i> 검색 입력</div>')
+            gr.HTML('<div class="section-title"><i class="fas fa-tag"></i> 상품명 분석 입력</div>')
             
+            # 메인 키워드와 상품명 입력을 한 줄에 배치
             with gr.Row():
                 with gr.Column(scale=1):
-                    keyword = gr.Textbox(
+                    main_keyword = gr.Textbox(
                         label="메인 키워드", 
                         placeholder="예: 오징어"
                     )
                 with gr.Column(scale=1):
-                    search_btn = gr.Button(
-                        "메인키워드 분석", 
-                        elem_classes="custom-button"
+                    product_name = gr.Textbox(
+                        label="상품명", 
+                        placeholder="예: 손질 오징어 촉촉한 진미채"
+                    )
+        
+        # 실행 섹션 - 버튼 통합
+        with gr.Column(elem_classes="execution-section"):
+            gr.HTML('<div class="section-title"><i class="fas fa-play-circle"></i> 실행</div>')
+            with gr.Row():
+                with gr.Column(scale=1):
+                    analyze_product_btn = gr.Button(
+                        "상품명 분석", 
+                        elem_classes=["execution-button", "primary-button"]
+                    )
+                with gr.Column(scale=1):
+                    reset_btn = gr.Button(
+                        "모든 입력 초기화", 
+                        elem_classes=["execution-button", "secondary-button"]
                     )
-            
-            with gr.Accordion("옵션 설정", open=False):
-                with gr.Row():
-                    with gr.Column(scale=1):
-                        korean_only = gr.Checkbox(
-                            label="한글만 추출", 
-                            value=True
-                        )
-                    with gr.Column(scale=1):
-                        exclude_zero_volume = gr.Checkbox(
-                            label="검색량 0 키워드 제외", 
-                            value=False
-                        )
-                
-                with gr.Row():
-                    with gr.Column(scale=1):
-                        apply_main_keyword = gr.Radio(
-                            ["메인키워드 적용", "메인키워드 미적용"], 
-                            label="조합 방식", 
-                            value="메인키워드 적용"
-                        )
-                    with gr.Column(scale=1):
-                        gr.HTML("")
         
-        # 진행 상태 표시 섹션
+        # 진행 상태 표시 섹션 (초기에는 숨김)
         with gr.Column(elem_classes="custom-frame fade-in", visible=False) as progress_section:
             gr.HTML('<div class="section-title"><i class="fas fa-spinner"></i> 분석 진행 상태</div>')
+            # 사용자 친화적인 진행 상태 표시
             progress_html = gr.HTML("""
             <div style="padding: 15px; background-color: #f9f9f9; border-radius: 5px; margin: 10px 0; border: 1px solid #ddd;">
                 <div style="margin-bottom: 10px; display: flex; align-items: center;">
                     <i class="fas fa-spinner fa-spin" style="color: #FB7F0D; margin-right: 10px;"></i>
-                    <span>키워드 데이터를 분석중입니다. 잠시만 기다려주세요...</span>
+                    <span>상품명 분석중입니다. 잠시만 기다려주세요...</span>
                 </div>
                 <div style="background-color: #e9ecef; height: 10px; border-radius: 5px; overflow: hidden;">
                     <div class="progress-bar"></div>
@@ -740,219 +632,43 @@ def create_app():
             </div>
             """)
         
-        # 메인키워드 분석 결과 섹션
-        with gr.Column(elem_classes="custom-frame fade-in") as main_keyword_section:
-            gr.HTML('<div class="section-title"><i class="fas fa-table"></i> 메인키워드 분석 결과</div>')
-            
-            empty_table_html = gr.HTML("""
-            <table class="empty-table">
-                <thead>
-                    <tr>
-                        <th>순번</th>
-                        <th>조합 키워드</th>
-                        <th>PC검색량</th>
-                        <th>모바일검색량</th>
-                        <th>총검색량</th>
-                        <th>검색량구간</th>
-                        <th>키워드 사용자순위</th>
-                        <th>키워드 사용횟수</th>
-                        <th>상품 등록 카테고리</th>
-                    </tr>
-                </thead>
-                <tbody>
-                    <tr>
-                        <td colspan="9" style="padding: 30px; text-align: center;">
-                            검색을 실행하면 여기에 결과가 표시됩니다
-                        </td>
-                    </tr>
-                </tbody>
-            </table>
-            """)
-            
-            with gr.Column(visible=False) as keyword_analysis_section:
-                with gr.Row():
-                    with gr.Column(scale=1):
-                        category_filter = gr.Dropdown(
-                            choices=["전체 보기"], 
-                            label="카테고리 필터", 
-                            value="전체 보기", 
-                            interactive=True
-                        )
-                    with gr.Column(scale=1):
-                        total_volume_sort = gr.Dropdown(
-                            choices=["정렬 없음", "오름차순", "내림차순"],
-                            label="총검색량 정렬",
-                            value="정렬 없음",
-                            interactive=True
-                        )
-                
-                with gr.Row():
-                    with gr.Column(scale=1):
-                        search_volume_filter = gr.Dropdown(
-                            choices=["전체"], 
-                            label="검색량 구간 필터", 
-                            value="전체",
-                            interactive=True
-                        )
-                    with gr.Column(scale=1):
-                        usage_count_sort = gr.Dropdown(
-                            choices=["정렬 없음", "오름차순", "내림차순"],
-                            label="키워드 사용횟수 정렬",
-                            value="정렬 없음",
-                            interactive=True
-                        )
-                
-                gr.HTML("<div class='data-container' id='table_container'></div>")
-                table_output = gr.HTML(elem_classes="fade-in")
-        
-        # 카테고리 분석 섹션
-        with gr.Column(elem_classes="custom-frame fade-in", visible=False) as category_analysis_section:
-            gr.HTML('<div class="section-title"><i class="fas fa-chart-bar"></i> 키워드 분석</div>')
-            
-            with gr.Row():
-                with gr.Column(scale=1):
-                    analysis_keywords = gr.Textbox(
-                        label="키워드 입력 (최대 20개, 쉼표 또는 엔터로 구분)", 
-                        placeholder="예: 오징어볶음, 오징어 손질, 오징어 요리...",
-                        lines=5
-                    )
-                    
-                with gr.Column(scale=1):
-                    selected_category = gr.Dropdown(
-                        label="분석할 카테고리(분석 전 반드시 선택해주세요)", 
-                        choices=["전체 보기"],
-                        value="전체 보기",
-                        interactive=True
-                    )
-        
-        # 실행 섹션
-        with gr.Column(elem_classes="execution-section", visible=False) as execution_section:
-            gr.HTML('<div class="section-title"><i class="fas fa-play-circle"></i> 실행</div>')
-            with gr.Row():
-                with gr.Column(scale=1):
-                    analyze_btn = gr.Button(
-                        "카테고리 일치 분석", 
-                        elem_classes=["execution-button", "primary-button"]
-                    )
-                with gr.Column(scale=1):
-                    reset_btn = gr.Button(
-                        "모든 입력 초기화", 
-                        elem_classes=["execution-button", "secondary-button"]
-                    )
-        
-        # 분석 결과 출력 섹션
-        with gr.Column(elem_classes="custom-frame fade-in", visible=False) as analysis_output_section:
-            gr.HTML('<div class="section-title"><i class="fas fa-list-ul"></i> 분석 결과 요약</div>')
+        # 상품명 키워드 분석 결과 섹션 (초기에는 숨김)
+        with gr.Column(elem_classes="custom-frame fade-in", visible=False) as product_analysis_section:
+            gr.HTML('<div class="section-title"><i class="fas fa-table"></i> 상품명 키워드 분석 결과</div>')
             
-            analysis_result = gr.HTML(elem_classes="fade-in")
+            # 상품명 분석 결과 
+            product_analysis_result = gr.HTML(elem_classes="fade-in")
             
-            with gr.Row():
-                download_output = gr.File(
-                    label="키워드 목록 다운로드", 
-                    visible=True
-                )
-        
-        # 상태 저장용 변수
-        state_df = gr.State()
-        
-        # 이벤트 연결 - 모든 함수에 session_id 추가
-        search_btn.click(
-            fn=search_with_loading,
-            inputs=[keyword, korean_only, apply_main_keyword, exclude_zero_volume, session_id],
-            outputs=[progress_section, empty_table_html]
+            # 엑셀 다운로드 파일
+            download_file = gr.File(
+                label="분석 결과 다운로드", 
+                visible=True
+            )
+        
+        # 상태 저장용 변수 - 분석 결과 저장
+        analysis_result_state = gr.State()
+        
+        # 상품명 분석 버튼 연결 - 로딩 표시 후 자동 다운로드 (세션 ID 추가)
+        analyze_product_btn.click(
+            fn=product_analyze_with_loading,
+            inputs=[product_name, main_keyword, analysis_result_state, session_id],
+            outputs=[progress_section]
         ).then(
-            fn=process_search_results,
-            inputs=[keyword, korean_only, apply_main_keyword, exclude_zero_volume, session_id],
+            fn=process_product_analyze,
+            inputs=[product_name, main_keyword, analysis_result_state, session_id],
             outputs=[
-                table_output, category_filter, search_volume_filter, 
-                state_df, selected_category, download_output,
-                keyword_analysis_section, category_analysis_section,
-                progress_section, empty_table_html, execution_section,
-                keyword_state
+                product_analysis_result, analysis_result_state, 
+                download_file, product_analysis_section, progress_section
             ]
         )
         
-        # 필터 및 정렬 변경 이벤트 연결 - session_id 추가
-        category_filter.change(
-            fn=filter_and_sort_table, 
-            inputs=[
-                state_df, category_filter, gr.Textbox(value="정렬 없음", visible=False), 
-                total_volume_sort, usage_count_sort, 
-                search_volume_filter, exclude_zero_volume, session_id
-            ], 
-            outputs=[table_output]
-        )
-        
-        category_filter.change(
-            fn=update_category_selection,
-            inputs=[category_filter, session_id],
-            outputs=[selected_category]
-        )
-        
-        total_volume_sort.change(
-            fn=filter_and_sort_table, 
-            inputs=[
-                state_df, category_filter, gr.Textbox(value="정렬 없음", visible=False), 
-                total_volume_sort, usage_count_sort, 
-                search_volume_filter, exclude_zero_volume, session_id
-            ], 
-            outputs=[table_output]
-        )
-        
-        usage_count_sort.change(
-            fn=filter_and_sort_table, 
-            inputs=[
-                state_df, category_filter, gr.Textbox(value="정렬 없음", visible=False), 
-                total_volume_sort, usage_count_sort, 
-                search_volume_filter, exclude_zero_volume, session_id
-            ], 
-            outputs=[table_output]
-        )
-        
-        search_volume_filter.change(
-            fn=filter_and_sort_table, 
-            inputs=[
-                state_df, category_filter, gr.Textbox(value="정렬 없음", visible=False), 
-                total_volume_sort, usage_count_sort, 
-                search_volume_filter, exclude_zero_volume, session_id
-            ], 
-            outputs=[table_output]
-        )
-        
-        exclude_zero_volume.change(
-            fn=filter_and_sort_table, 
-            inputs=[
-                state_df, category_filter, gr.Textbox(value="정렬 없음", visible=False), 
-                total_volume_sort, usage_count_sort, 
-                search_volume_filter, exclude_zero_volume, session_id
-            ], 
-            outputs=[table_output]
-        )
-        
-        # 카테고리 분석 버튼 이벤트 - session_id 추가
-        analyze_btn.click(
-            fn=analyze_with_loading,
-            inputs=[analysis_keywords, selected_category, state_df, session_id],
-            outputs=[progress_section]
-        ).then(
-            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 추가
+        # 리셋 버튼 이벤트 연결 (세션 ID 추가)
         reset_btn.click(
             fn=reset_interface,
             inputs=[session_id],
             outputs=[
-                keyword, korean_only, exclude_zero_volume, apply_main_keyword, 
-                table_output, category_filter, category_filter, 
-                search_volume_filter, search_volume_filter, 
-                total_volume_sort, usage_count_sort, 
-                state_df, selected_category, selected_category, 
-                analysis_keywords, analysis_result, download_output,
-                keyword_analysis_section, analysis_output_section,
-                keyword_state
+                main_keyword, product_name, product_analysis_result, 
+                download_file, analysis_result_state, product_analysis_section
             ]
         )
                 
@@ -960,7 +676,7 @@ def create_app():
 
 if __name__ == "__main__":
     # ========== 시작 시 전체 초기화 ==========
-    logger.info("🚀 메인키워드 분석 애플리케이션 시작...")
+    logger.info("🚀 카테고리 분석 애플리케이션 시작...")
     
     # 1. 첫 번째: 허깅페이스 임시 폴더 정리 및 환경 설정
     app_temp_dir = cleanup_on_startup()
@@ -969,18 +685,12 @@ if __name__ == "__main__":
     start_session_cleanup_scheduler()
     
     # 3. API 설정 초기화
-    try:
-        api_utils.initialize_api_configs()
-    except Exception as e:
-        logger.warning(f"API 설정 초기화 중 오류 (계속 진행): {e}")
+    api_utils.initialize_api_configs()
     
     # 4. Gemini 모델 초기화
-    try:
-        gemini_model = text_utils.get_gemini_model()
-    except Exception as e:
-        logger.warning(f"Gemini 모델 초기화 중 오류 (계속 진행): {e}")
+    gemini_model = text_utils.get_gemini_model()
     
-    logger.info("===== 멀티유저 메인키워드 분석 Application Startup 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}")
     
     # ========== 앱 실행 ==========