Update app.py

app.py

@@ -1,29 +1,21 @@
 import gradio as gr
 import requests
 from bs4 import BeautifulSoup
-import urllib.parse # iframe 경로 보정을 위한 모듈
+import urllib.parse  # iframe 경로 보정을 위한 모듈
 import re
 import logging
 import tempfile
 import pandas as pd
-import mecab # python?mecab?ko 라이브러리 사용
+import mecab  # python‑mecab‑ko 라이브러리 사용
 import os
 import time
 import hmac
 import hashlib
 import base64
-from concurrent.futures import ThreadPoolExecutor, as_completed
-
-# --- 병렬 처리 설정 ---
-# API 호출 제한에 맞춰 적절히 조절하세요.
-# 너무 높은 값은 API 제한에 걸릴 수 있습니다.
-MAX_WORKERS_RELATED_KEYWORDS = 5  # fetch_related_keywords 병렬 작업자 수
-MAX_WORKERS_BLOG_COUNT = 10       # fetch_blog_count 병렬 작업자 수
-
 
 # 디버깅(로그)용 함수
 def debug_log(message: str):
-    print(f"[{time.strftime('%Y-%m-%d %H:%M:%S')}] [DEBUG] {message}")
+    print(f"[DEBUG] {message}")
 
 # --- 네이버 블로그 스크래핑 ---
 def scrape_naver_blog(url: str) -> str:
@@ -37,7 +29,7 @@ def scrape_naver_blog(url: str) -> str:
         )
     }
     try:
-        response = requests.get(url, headers=headers, timeout=10)
+        response = requests.get(url, headers=headers)
         debug_log("HTTP GET 요청(메인 페이지) 완료")
         if response.status_code != 200:
             debug_log(f"요청 실패, 상태코드: {response.status_code}")
@@ -47,127 +39,63 @@ def scrape_naver_blog(url: str) -> str:
         iframe = soup.select_one("iframe#mainFrame")
         if not iframe:
             debug_log("iframe#mainFrame 태그를 찾을 수 없습니다.")
-            # 일부 블로그는 mainFrame이 없을 수 있음. 본문 직접 시도
-            content_div_direct = soup.select_one('.se-main-container')
-            if content_div_direct:
-                title_div_direct = soup.select_one('.se-module.se-module-text.se-title-text')
-                title = title_div_direct.get_text(strip=True) if title_div_direct else "제목을 찾을 수 없습니다."
-                content = content_div_direct.get_text("\n", strip=True)
-                debug_log("iframe 없이 본문 직접 추출 완료")
-                return f"[제목]\n{title}\n\n[본문]\n{content}"
-            return "본문 iframe을 찾을 수 없습니다. (본문 직접 추출 실패)"
-
+            return "본문 iframe을 찾을 수 없습니다."
         iframe_src = iframe.get("src")
         if not iframe_src:
             debug_log("iframe src가 존재하지 않습니다.")
             return "본문 iframe의 src를 찾을 수 없습니다."
-        
-        # iframe_src가 절대 URL이 아닌 경우를 대비
-        if iframe_src.startswith("//"):
-            parsed_iframe_url = "https:" + iframe_src
-        elif iframe_src.startswith("/"):
-            parsed_main_url = urllib.parse.urlparse(url)
-            parsed_iframe_url = urllib.parse.urlunparse(
-                (parsed_main_url.scheme, parsed_main_url.netloc, iframe_src, None, None, None)
-            )
-        else:
-            parsed_iframe_url = urllib.parse.urljoin(url, iframe_src)
-            
+        parsed_iframe_url = urllib.parse.urljoin(url, iframe_src)
         debug_log(f"iframe 페이지 요청 URL: {parsed_iframe_url}")
-        iframe_response = requests.get(parsed_iframe_url, headers=headers, timeout=10)
+        iframe_response = requests.get(parsed_iframe_url, headers=headers)
         debug_log("HTTP GET 요청(iframe 페이지) 완료")
         if iframe_response.status_code != 200:
             debug_log(f"iframe 요청 실패, 상태코드: {iframe_response.status_code}")
             return f"iframe에서 오류가 발생했습니다. 상태코드: {iframe_response.status_code}"
         iframe_soup = BeautifulSoup(iframe_response.text, "html.parser")
         debug_log("HTML 파싱(iframe 페이지) 완료")
-        
-        # 제목 추출 (다양한 구조 시도)
-        title_selectors = [
-            '.se-module.se-module-text.se-title-text', # 일반적인 스마트에디터 ONE
-            '.title_text', # 구버전 에디터 또는 다른 구조
-            'div[class*="title"] h3', 
-            'h1', 'h2', 'h3' # 일반적인 제목 태그
-        ]
-        title = "제목을 찾을 수 없습니다."
-        for selector in title_selectors:
-            title_div = iframe_soup.select_one(selector)
-            if title_div:
-                title = title_div.get_text(strip=True)
-                break
+        title_div = iframe_soup.select_one('.se-module.se-module-text.se-title-text')
+        title = title_div.get_text(strip=True) if title_div else "제목을 찾을 수 없습니다."
         debug_log(f"추출된 제목: {title}")
-
-        # 본문 추출 (다양한 구조 시도)
-        content_selectors = [
-            '.se-main-container', # 스마트에디터 ONE
-            'div#content',       # 구버전 에디터
-            'div.post_ct',       # 일부 블로그 구조
-            'article', 'main'    # 시맨틱 태그
-        ]
-        content = "본문을 찾을 수 없습니다."
-        for selector in content_selectors:
-            content_div = iframe_soup.select_one(selector)
-            if content_div:
-                # 불필요한 스크립트, 스타일 태그 제거
-                for s in content_div(['script', 'style']):
-                    s.decompose()
-                content = content_div.get_text("\n", strip=True)
-                break
-        
+        content_div = iframe_soup.select_one('.se-main-container')
+        if content_div:
+            content = content_div.get_text("\n", strip=True)
+        else:
+            content = "본문을 찾을 수 없습니다."
         debug_log("본문 추출 완료")
         result = f"[제목]\n{title}\n\n[본문]\n{content}"
         debug_log("제목과 본문 합침 완료")
         return result
-    except requests.exceptions.Timeout:
-        debug_log(f"요청 시간 초과: {url}")
-        return f"스크래핑 중 시간 초과가 발생했습니다: {url}"
     except Exception as e:
-        debug_log(f"스크래핑 에러 발생: {str(e)}")
+        debug_log(f"에러 발생: {str(e)}")
         return f"스크래핑 중 오류가 발생했습니다: {str(e)}"
 
 # --- 형태소 분석 (참조코드-1) ---
 def analyze_text(text: str):
-    logging.basicConfig(level=logging.INFO) # INFO 레벨로 변경하여 너무 많은 로그 방지
+    logging.basicConfig(level=logging.DEBUG)
     logger = logging.getLogger(__name__)
-    # logger.debug("원본 텍스트: %s", text) # 너무 길 수 있으므로 주석 처리
-    filtered_text = re.sub(r'[^가-힣a-zA-Z0-9\s]', '', text) # 영어, 숫자, 공백 포함
-    # logger.debug("필터링된 텍스트: %s", filtered_text)
-    if not filtered_text.strip():
-        logger.info("유효한 텍스트가 없음 (필터링 후).")
-        return pd.DataFrame(columns=["단어", "빈도수"]), ""
-    try:
-        mecab_instance = mecab.MeCab()
-        tokens = mecab_instance.pos(filtered_text)
-    except Exception as e:
-        logger.error(f"MeCab 형태소 분석 중 오류: {e}")
+    logger.debug("원본 텍스트: %s", text)
+    filtered_text = re.sub(r'[^가-힣]', '', text)
+    logger.debug("필터링된 텍스트: %s", filtered_text)
+    if not filtered_text:
+        logger.debug("유효한 한국어 텍스트가 없음.")
         return pd.DataFrame(columns=["단어", "빈도수"]), ""
-        
-    # logger.debug("형태소 분석 결과: %s", tokens)
+    mecab_instance = mecab.MeCab()
+    tokens = mecab_instance.pos(filtered_text)
+    logger.debug("형태소 분석 결과: %s", tokens)
     freq = {}
     for word, pos in tokens:
-        # 일반명사(NNG), 고유명사(NNP), 외국어(SL), 숫자(SN) 등 포함, 한 글자 단어는 제외 (선택 사항)
-        if word and word.strip() and (pos.startswith("NN") or pos in ["SL", "SH"]) and len(word) > 1 :
+        if word and word.strip() and pos.startswith("NN"):
             freq[word] = freq.get(word, 0) + 1
-            # logger.debug("단어: %s, 품사: %s, 빈도: %d", word, pos, freq[word])
-            
+            logger.debug("단어: %s, 품사: %s, 빈도: %d", word, pos, freq[word])
     sorted_freq = sorted(freq.items(), key=lambda x: x[1], reverse=True)
-    # logger.debug("정렬된 단어 빈도: %s", sorted_freq)
+    logger.debug("정렬된 단어 빈도: %s", sorted_freq)
     df = pd.DataFrame(sorted_freq, columns=["단어", "빈도수"])
-    logger.info(f"형태소 분석 DataFrame 생성됨, shape: {df.shape}")
-    
-    temp_file_path = ""
-    if not df.empty:
-        try:
-            with tempfile.NamedTemporaryFile(delete=False, suffix=".xlsx", mode='w+b') as temp_file:
-                df.to_excel(temp_file.name, index=False, engine='openpyxl')
-                temp_file_path = temp_file.name
-            logger.info(f"Excel 파일 생성됨: {temp_file_path}")
-        except Exception as e:
-            logger.error(f"Excel 파일 저장 중 오류: {e}")
-            temp_file_path = "" # 오류 발생 시 경로 초기화
-
-    return df, temp_file_path
-
+    logger.debug("형태소 분석 DataFrame 생성됨, shape: %s", df.shape)
+    temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=".xlsx")
+    df.to_excel(temp_file.name, index=False, engine='openpyxl')
+    temp_file.close()
+    logger.debug("Excel 파일 생성됨: %s", temp_file.name)
+    return df, temp_file.name
 
 # --- 네이버 검색 및 광고 API 관련 (참조코드-2) ---
 def generate_signature(timestamp, method, uri, secret_key):
@@ -186,483 +114,189 @@ def get_header(method, uri, api_key, secret_key, customer_id):
         "X-Signature": signature
     }
 
-# API 키 환경 변수 확인 함수
-def get_env_variable(var_name):
-    value = os.environ.get(var_name)
-    if value is None:
-        debug_log(f"환경 변수 '{var_name}'가 설정되지 않았습니다. API 호출이 실패할 수 있습니다.")
-        # 필요시 여기서 raise Exception 또는 ���본값 반환
-    return value
-
 def fetch_related_keywords(keyword):
-    debug_log(f"fetch_related_keywords 호출 시작, 키워드: {keyword}")
-    API_KEY = get_env_variable("NAVER_API_KEY")
-    SECRET_KEY = get_env_variable("NAVER_SECRET_KEY")
-    CUSTOMER_ID = get_env_variable("NAVER_CUSTOMER_ID")
-    
-    if not all([API_KEY, SECRET_KEY, CUSTOMER_ID]):
-        debug_log(f"네이버 광고 API 키 정보 부족으로 '{keyword}' 연관 키워드 조회를 건너<0xEB><0x8><0xB5>니다.")
-        return pd.DataFrame()
-
+    debug_log(f"fetch_related_keywords 호출, 키워드: {keyword}")
+    API_KEY = os.environ["NAVER_API_KEY"]
+    SECRET_KEY = os.environ["NAVER_SECRET_KEY"]
+    CUSTOMER_ID = os.environ["NAVER_CUSTOMER_ID"]
     BASE_URL = "https://api.naver.com"
     uri = "/keywordstool"
     method = "GET"
-    
-    try:
-        headers = get_header(method, uri, API_KEY, SECRET_KEY, CUSTOMER_ID)
-        params = {
-            "hintKeywords": keyword, # 단일 키워드 문자열로 전달
-            "showDetail": "1"
-        }
-        # hintKeywords는 리스트로 받을 수 있으나, 여기서는 단일 키워드 처리를 가정하고 문자열로 전달
-        # 만약 API가 hintKeywords를 리스트로만 받는다면 [keyword]로 수정 필요
-        
-        response = requests.get(BASE_URL + uri, params=params, headers=headers, timeout=10)
-        response.raise_for_status() # 오류 발생 시 예외 발생
-        data = response.json()
-        
-        if "keywordList" not in data or not data["keywordList"]:
-            debug_log(f"'{keyword}'에 대한 연관 키워드 결과 없음.")
-            return pd.DataFrame() # 빈 DataFrame 반환
-            
-        df = pd.DataFrame(data["keywordList"])
-        
-        # API 응답에 해당 컬럼이 없을 경우를 대비
-        df["monthlyPcQcCnt"] = df.get("monthlyPcQcCnt", 0)
-        df["monthlyMobileQcCnt"] = df.get("monthlyMobileQcCnt", 0)
-
-        def parse_count(x):
-            if pd.isna(x) or str(x).lower() == '< 10': # 네이버 API는 10 미만일 때 "< 10"으로 반환
-                return 5 # 또는 0, 또는 다른 대표값 (예: 5)
-            try:
-                return int(str(x).replace(",", ""))
-            except ValueError:
-                return 0
-                
-        df["PC월검색량"] = df["monthlyPcQcCnt"].apply(parse_count)
-        df["모바일월검색량"] = df["monthlyMobileQcCnt"].apply(parse_count)
-        df["토탈월검색량"] = df["PC월검색량"] + df["모바일월검색량"]
-        df.rename(columns={"relKeyword": "정보키워드"}, inplace=True)
-        
-        # 필요한 컬럼만 선택, 없는 경우 대비
-        required_cols = ["정보키워드", "PC월검색량", "모바일월검색량", "토탈월검색량"]
-        result_df = pd.DataFrame(columns=required_cols)
-        for col in required_cols:
-            if col in df.columns:
-                result_df[col] = df[col]
-            else: # 해당 컬럼이 API 응답에 없을 경우 기본값으로 채움
-                 if col == "정보키워드": # 정보키워드는 필수
-                     debug_log(f"API 응답에 'relKeyword'가 없습니다. '{keyword}' 처리 중단.")
-                     return pd.DataFrame()
-                 result_df[col] = 0
-
-        debug_log(f"fetch_related_keywords '{keyword}' 완료, 결과 {len(result_df)}개")
-        return result_df.head(100) # 최대 100개로 제한
-        
-    except requests.exceptions.HTTPError as http_err:
-        debug_log(f"HTTP 오류 발생 (fetch_related_keywords for '{keyword}'): {http_err} - 응답: {response.text if 'response' in locals() else 'N/A'}")
-    except requests.exceptions.RequestException as req_err:
-        debug_log(f"요청 오류 발생 (fetch_related_keywords for '{keyword}'): {req_err}")
-    except Exception as e:
-        debug_log(f"알 수 없는 오류 발생 (fetch_related_keywords for '{keyword}'): {e}")
-    return pd.DataFrame() # 오류 발생 시 빈 DataFrame 반환
-
+    headers = get_header(method, uri, API_KEY, SECRET_KEY, CUSTOMER_ID)
+    params = {
+        "hintKeywords": [keyword],
+        "showDetail": "1"
+    }
+    response = requests.get(BASE_URL + uri, params=params, headers=headers)
+    data = response.json()
+    if "keywordList" not in data:
+        return pd.DataFrame()
+    df = pd.DataFrame(data["keywordList"])
+    if len(df) > 100:
+        df = df.head(100)
+    def parse_count(x):
+        try:
+            return int(str(x).replace(",", ""))
+        except:
+            return 0
+    df["PC월검색량"] = df["monthlyPcQcCnt"].apply(parse_count)
+    df["모바일월검색량"] = df["monthlyMobileQcCnt"].apply(parse_count)
+    df["토탈월검색량"] = df["PC월검색량"] + df["모바일월검색량"]
+    df.rename(columns={"relKeyword": "정보키워드"}, inplace=True)
+    result_df = df[["정보키워드", "PC월검색량", "모바일월검색량", "토탈월검색량"]]
+    debug_log("fetch_related_keywords 완료")
+    return result_df
 
 def fetch_blog_count(keyword):
     debug_log(f"fetch_blog_count 호출, 키워드: {keyword}")
-    client_id = get_env_variable("NAVER_SEARCH_CLIENT_ID")
-    client_secret = get_env_variable("NAVER_SEARCH_CLIENT_SECRET")
-
-    if not client_id or not client_secret:
-        debug_log(f"네이버 검색 API 키 정보 부족으로 '{keyword}' 블로그 수 조회를 건너<0xEB><0x8><0xB5>니다.")
-        return 0
-
+    client_id = os.environ["NAVER_SEARCH_CLIENT_ID"]
+    client_secret = os.environ["NAVER_SEARCH_CLIENT_SECRET"]
     url = "https://openapi.naver.com/v1/search/blog.json"
     headers = {
         "X-Naver-Client-Id": client_id,
         "X-Naver-Client-Secret": client_secret
     }
-    params = {"query": keyword, "display": 1} # display=1로 설정하여 total 값만 빠르게 확인
-    
-    try:
-        response = requests.get(url, headers=headers, params=params, timeout=5)
-        response.raise_for_status() # HTTP 오류 발생 시 예외 발생
+    params = {"query": keyword, "display": 1}
+    response = requests.get(url, headers=headers, params=params)
+    if response.status_code == 200:
         data = response.json()
-        total_count = data.get("total", 0)
-        debug_log(f"fetch_blog_count 결과: {total_count} for '{keyword}'")
-        return total_count
-    except requests.exceptions.HTTPError as http_err:
-        debug_log(f"HTTP 오류 발생 (fetch_blog_count for '{keyword}'): {http_err} - 응답: {response.text}")
-    except requests.exceptions.RequestException as req_err: # Timeout, ConnectionError 등
-        debug_log(f"요청 오류 발생 (fetch_blog_count for '{keyword}'): {req_err}")
-    except Exception as e: # JSONDecodeError 등 기타 예외
-        debug_log(f"알 수 없는 오류 발생 (fetch_blog_count for '{keyword}'): {e}")
-    return 0 # 오류 발생 시 0 반환
+        debug_log(f"fetch_blog_count 결과: {data.get('total', 0)}")
+        return data.get("total", 0)
+    else:
+        debug_log(f"fetch_blog_count 오류, 상태코드: {response.status_code}")
+        return 0
 
 def create_excel_file(df):
-    if df.empty:
-        debug_log("빈 DataFrame으로 Excel 파일을 생성하지 않습니다.")
-        # 빈 파일을 생성하거나, None을 반환하여 Gradio에서 처리하도록 할 수 있음
-        # 여기서는 빈 임시 파일을 생성하여 반환 (Gradio File 컴포넌트가 경로를 기대하므로)
-        with tempfile.NamedTemporaryFile(suffix=".xlsx", delete=False) as tmp:
-            excel_path = tmp.name
-        # 빈 엑셀 파일에 헤더만이라도 써주려면
-        # pd.DataFrame(columns=df.columns).to_excel(excel_path, index=False)
-        # 아니면 그냥 빈 파일을 반환
-        return excel_path
-
-    try:
-        with tempfile.NamedTemporaryFile(suffix=".xlsx", delete=False, mode='w+b') as tmp:
-            excel_path = tmp.name
-        df.to_excel(excel_path, index=False, engine='openpyxl')
-        debug_log(f"Excel 파일 생성됨: {excel_path}")
-        return excel_path
-    except Exception as e:
-        debug_log(f"Excel 파일 생성 중 오류: {e}")
-        # 오류 발생 시 빈 파일 경로라도 반환 (Gradio 호환성)
-        with tempfile.NamedTemporaryFile(suffix=".xlsx", delete=False) as tmp:
-            return tmp.name
-
+    with tempfile.NamedTemporaryFile(suffix=".xlsx", delete=False) as tmp:
+        excel_path = tmp.name
+    df.to_excel(excel_path, index=False)
+    debug_log(f"Excel 파일 생성됨: {excel_path}")
+    return excel_path
 
 def process_keyword(keywords: str, include_related: bool):
-    debug_log(f"process_keyword 호출 시작, 키워드들: '{keywords[:100]}...', 연관검색어 포함: {include_related}")
-    input_keywords_orig = [k.strip() for k in keywords.splitlines() if k.strip()]
-    
-    if not input_keywords_orig:
-        debug_log("입력된 키워드가 없습니다.")
-        return pd.DataFrame(columns=["정보키워드", "PC월검색량", "모바일월검색량", "토탈월검색량", "블로그문서수"]), ""
-
-    all_related_keywords_dfs = []
-    
-    # 1. fetch_related_keywords 병렬 처리
-    debug_log(f"연관 키워드 조회 병렬 처리 시작 (최대 작업자 수: {MAX_WORKERS_RELATED_KEYWORDS})")
-    with ThreadPoolExecutor(max_workers=MAX_WORKERS_RELATED_KEYWORDS) as executor:
-        future_to_keyword_related = {
-            executor.submit(fetch_related_keywords, kw): kw for kw in input_keywords_orig
-        }
-        for i, future in enumerate(as_completed(future_to_keyword_related)):
-            kw = future_to_keyword_related[future]
-            try:
-                df_kw_related = future.result() # DataFrame 반환
-                if not df_kw_related.empty:
-                    # 원본 키워드가 결과에 포함되어 있는지 확인하고, 없으면 추가 시도 (API가 항상 relKeyword로 자신을 주진 않음)
-                    # 하지만 fetch_related_keywords에서 이미 hintKeyword를 기반으로 검색하므로,
-                    # 일반적으로는 해당 키워드 정보가 있거나, 연관 키워드만 나옴.
-                    # 여기서는 API 응답을 그대로 활용.
-                    
-                    # 첫 번째 입력 키워드이고, 연관 키워드 포함 옵션이 켜져 있으면 모든 연관 키워드를 추가
-                    # 그 외의 경우에는 해당 키워드 자체의 정보만 (있다면) 사용하거나, 최상단 키워드 사용
-                    if include_related and kw == input_keywords_orig[0]:
-                         all_related_keywords_dfs.append(df_kw_related)
-                         debug_log(f"첫 번째 키워드 '{kw}'의 모든 연관 키워드 ({len(df_kw_related)}개) 추가됨.")
-                    else:
-                        # 해당 키워드와 일치하는 행을 찾거나, 없으면 API가 반환한 첫번째 행을 사용
-                        row_kw = df_kw_related[df_kw_related["정보키워드"] == kw]
-                        if not row_kw.empty:
-                            all_related_keywords_dfs.append(row_kw)
-                            debug_log(f"키워드 '{kw}'의 직접 정보 추가됨.")
-                        elif not df_kw_related.empty : # 직접 정보는 없지만 연관 키워드는 있을 때
-                            all_related_keywords_dfs.append(df_kw_related.head(1)) # 가장 연관성 높은 키워드 추가
-                            debug_log(f"키워드 '{kw}'의 직접 정보는 없으나, 가장 연관성 높은 키워드 1개 추가됨.")
-                        # else: 키워드 정보도, 연관 정보도 없을 때 (df_kw_related가 비어있음)
-
-                debug_log(f"'{kw}' 연관 키워드 처리 완료 ({i+1}/{len(input_keywords_orig)})")
-            except Exception as e:
-                debug_log(f"'{kw}' 연관 키워드 조회 중 병렬 작업 오류: {e}")
-
-    if not all_related_keywords_dfs:
-        debug_log("연관 키워드 조회 결과가 모두 비어있습니다.")
-        # 빈 DataFrame에 블로그 문서수 컬럼 추가
-        empty_df = pd.DataFrame(columns=["정보키워드", "PC월검색량", "모바일월검색량", "토탈월검색량"])
-        empty_df["블로그문서수"] = None
-        return empty_df, create_excel_file(empty_df)
-
-    result_df = pd.concat(all_related_keywords_dfs, ignore_index=True)
-    result_df.drop_duplicates(subset=["정보키워드"], inplace=True) # 중복 제거
-    debug_log(f"연관 키워드 병렬 처리 완료. 통합된 DataFrame shape: {result_df.shape}")
-
-    # 2. fetch_blog_count 병렬 처리
-    keywords_for_blog_count = result_df["정보키워드"].dropna().unique().tolist()
-    blog_counts_map = {}
-
-    if keywords_for_blog_count:
-        debug_log(f"블로그 문서 수 조회 병렬 처리 시작 (키워드 {len(keywords_for_blog_count)}개, 최대 작업자 수: {MAX_WORKERS_BLOG_COUNT})")
-        with ThreadPoolExecutor(max_workers=MAX_WORKERS_BLOG_COUNT) as executor:
-            future_to_keyword_blog = {
-                executor.submit(fetch_blog_count, kw): kw for kw in keywords_for_blog_count
-            }
-            for i, future in enumerate(as_completed(future_to_keyword_blog)):
-                kw = future_to_keyword_blog[future]
-                try:
-                    count = future.result() # 숫자 반환
-                    blog_counts_map[kw] = count
-                    if (i+1) % 50 == 0: # 너무 많은 로그 방지
-                         debug_log(f"블로그 수 조회 진행 중... ({i+1}/{len(keywords_for_blog_count)})")
-                except Exception as e:
-                    debug_log(f"'{kw}' 블로그 수 조회 중 병렬 작업 오류: {e}")
-                    blog_counts_map[kw] = 0 # 오류 시 0으로 처리
-        
-        result_df["블로그문서수"] = result_df["정보키워드"].map(blog_counts_map).fillna(0).astype(int)
-        debug_log("블로그 문서 수 병렬 처리 완료.")
+    debug_log(f"process_keyword 호출, 키워드들: {keywords}, 연관검색어 포함: {include_related}")
+    input_keywords = [k.strip() for k in keywords.splitlines() if k.strip()]
+    result_dfs = []
+    for idx, kw in enumerate(input_keywords):
+        df_kw = fetch_related_keywords(kw)
+        if df_kw.empty:
+            continue
+        row_kw = df_kw[df_kw["정보키워드"] == kw]
+        if not row_kw.empty:
+            result_dfs.append(row_kw)
+        else:
+            result_dfs.append(df_kw.head(1))
+        if include_related and idx == 0:
+            df_related = df_kw[df_kw["정보키워드"] != kw]
+            if not df_related.empty:
+                result_dfs.append(df_related)
+    if result_dfs:
+        result_df = pd.concat(result_dfs, ignore_index=True)
+        result_df.drop_duplicates(subset=["정보키워드"], inplace=True)
     else:
-        result_df["블로그문서수"] = 0 # 조회할 키워드가 없으면 0으로 채움
-
+        result_df = pd.DataFrame(columns=["정보키워드", "PC월검색량", "모바일월���색량", "토탈월검색량"])
+    result_df["블로그문서수"] = result_df["정보키워드"].apply(fetch_blog_count)
     result_df.sort_values(by="토탈월검색량", ascending=False, inplace=True)
-    debug_log(f"process_keyword 최종 완료. DataFrame shape: {result_df.shape}")
-    
-    # 최종 컬럼 순서 및 존재 여부 확인
-    final_columns = ["정보키워드", "PC월검색량", "모바일월검색량", "토탈월검색량", "블로그문서수"]
-    for col in final_columns:
-        if col not in result_df.columns:
-            result_df[col] = 0 if col != "정보키워드" else "" # 없는 컬럼은 기본값으로 채움
-    
-    result_df = result_df[final_columns] # 컬럼 순서 고정
-
+    debug_log("process_keyword 완료")
     return result_df, create_excel_file(result_df)
 
-
 # --- 형태소 분석과 검색량/블로그문서수 병합 ---
 def morphological_analysis_and_enrich(text: str, remove_freq1: bool):
     debug_log("morphological_analysis_and_enrich 함수 시작")
-    df_freq, _ = analyze_text(text) # 엑셀 파일 경로는 여기선 사용 안 함
-    
+    df_freq, _ = analyze_text(text)
     if df_freq.empty:
         debug_log("형태소 분석 결과가 빈 데이터프레임입니다.")
-        return pd.DataFrame(columns=["단어", "빈도수", "PC월검색량", "모바일월검색량", "토탈월검색량", "블로그문서수"]), ""
-
+        return df_freq, ""
     if remove_freq1:
-        before_count = len(df_freq)
-        df_freq = df_freq[df_freq["빈도수"] > 1].copy() # .copy() 추가
-        debug_log(f"빈도수 1 제거 적용됨. {before_count} -> {len(df_freq)}")
-
-    if df_freq.empty:
-        debug_log("빈도수 1 제거 후 데이터가 없습니다.")
-        return pd.DataFrame(columns=["단어", "빈도수", "PC월검색량", "모바일월검색량", "토탈월검색량", "블로그문서수"]), ""
-
-    keywords_from_morph = "\n".join(df_freq["단어"].tolist())
-    debug_log(f"형태소 분석 기반 키워드 ({len(df_freq['단어'])}개)에 대한 정보 조회 시작")
-    
-    # process_keyword는 연관 키워드를 포함하지 않도록 호출 (include_related=False)
-    df_keyword_info, _ = process_keyword(keywords_from_morph, include_related=False)
-    debug_log("형태소 분석 키워드에 대한 검색량 및 블로그문서수 조회 완료")
-
-    if df_keyword_info.empty:
-        debug_log("형태소 분석 키워드에 대한 API 정보 조회 결과가 없습니다.")
-        # df_freq에 빈 컬럼들 추가
-        for col in ["PC월검색량", "모바일월검색량", "토탈월검색량", "블로그문서수"]:
-            df_freq[col] = None
-        merged_df = df_freq
-    else:
-        merged_df = pd.merge(df_freq, df_keyword_info, left_on="단어", right_on="정보키워드", how="left")
-        if "정보키워드" in merged_df.columns: # merge 후 정보키워드 컬럼이 생겼다면 삭제
-            merged_df.drop(columns=["정보키워드"], inplace=True, errors='ignore')
-
-    # 누락된 컬럼 기본값으로 채우기
-    expected_cols = ["단어", "빈도수", "PC월검색량", "모바일월검색량", "토탈월검색량", "블로그문서수"]
-    for col in expected_cols:
-        if col not in merged_df.columns:
-            merged_df[col] = None if col not in ["빈도수"] else 0
-    
-    merged_df = merged_df[expected_cols] # 컬럼 순서 고정
-
+        before_shape = df_freq.shape
+        df_freq = df_freq[df_freq["빈도수"] != 1]
+        debug_log(f"빈도수 1 제거 적용됨. {before_shape} -> {df_freq.shape}")
+    keywords = "\n".join(df_freq["단어"].tolist())
+    debug_log(f"분석된 키워드: {keywords}")
+    df_keyword_info, _ = process_keyword(keywords, include_related=False)
+    debug_log("검색량 및 블로그문서수 조회 완료")
+    merged_df = pd.merge(df_freq, df_keyword_info, left_on="단어", right_on="정보키워드", how="left")
+    merged_df.drop(columns=["정보키워드"], inplace=True)
     merged_excel_path = create_excel_file(merged_df)
     debug_log("morphological_analysis_and_enrich 함수 완료")
     return merged_df, merged_excel_path
 
-
 # --- 직접 키워드 분석 (단독 분석) ---
 def direct_keyword_analysis(text: str, keyword_input: str):
     debug_log("direct_keyword_analysis 함수 시작")
-    direct_keywords_list = [kw.strip() for kw in re.split(r'[\n,]+', keyword_input) if kw.strip()]
-    debug_log(f"입력된 직접 키워드 목록: {direct_keywords_list}")
-
-    if not direct_keywords_list:
-        debug_log("직접 입력된 키워드가 없습니다.")
-        return pd.DataFrame(columns=["키워드", "빈도수"]), ""
-
-    # 1. 본문 내 빈도수 계산
-    results_freq = []
-    for kw in direct_keywords_list:
-        count = text.count(kw) # 대소문자 구분, 정확한 문자열 카운트
-        results_freq.append({"키워드": kw, "빈도수": count})
-        debug_log(f"직접 키워드 '{kw}'의 본문 내 빈도수: {count}")
-    df_direct_freq = pd.DataFrame(results_freq)
-
-    # 2. API를 통해 검색량 및 블로그 수 조회 (병렬 처리된 process_keyword 사용)
-    # 여기서는 각 직접 키워드에 대한 정보만 필요하므로 include_related=False
-    keywords_for_api = "\n".join(direct_keywords_list)
-    df_direct_api_info, _ = process_keyword(keywords_for_api, include_related=False)
-
-    # 3. 빈도수 결과와 API 결과 병합
-    if not df_direct_api_info.empty:
-        # API 결과의 '정보키워드'를 '키워드'로 변경하여 병합 기준 통일
-        df_direct_api_info.rename(columns={"정보키워드": "키워드"}, inplace=True)
-        merged_df = pd.merge(df_direct_freq, df_direct_api_info, on="키워드", how="left")
-    else:
-        merged_df = df_direct_freq
-        for col in ["PC월검색량", "모바일월검색량", "토탈월검색량", "블로그문서수"]:
-            merged_df[col] = None # API 정보가 없을 경우 빈 컬럼 추가
-
-    # 컬럼 순서 및 기본값 정리
-    final_cols = ["키워드", "빈도수", "PC월검색량", "모바일월검색량", "토탈월검색량", "블로그문서수"]
-    for col in final_cols:
-        if col not in merged_df.columns:
-            merged_df[col] = 0 if col != "키워드" else ""
-    merged_df = merged_df[final_cols]
-
-
-    excel_path = create_excel_file(merged_df)
+    keywords = re.split(r'[\n,]+', keyword_input)
+    keywords = [kw.strip() for kw in keywords if kw.strip()]
+    debug_log(f"입력된 키워드 목록: {keywords}")
+    results = []
+    for kw in keywords:
+        count = text.count(kw)
+        results.append((kw, count))
+        debug_log(f"키워드 '{kw}'의 빈도수: {count}")
+    df = pd.DataFrame(results, columns=["키워드", "빈도수"])
+    excel_path = create_excel_file(df)
     debug_log("direct_keyword_analysis 함수 완료")
-    return merged_df, excel_path
-
+    return df, excel_path
 
 # --- 통합 분석 (형태소 분석 + 직접 키워드 분석) ---
 def combined_analysis(blog_text: str, remove_freq1: bool, direct_keyword_input: str):
     debug_log("combined_analysis 함수 시작")
-    
-    # 1. 형태소 분석 기반 결과 (API 정보 포함)
-    df_morph, _ = morphological_analysis_and_enrich(blog_text, remove_freq1)
-    # df_morph 컬럼: "단어", "빈도수", "PC월검색량", "모바일월검색량", "토탈월검색량", "블로그문서수"
-    
-    # 2. 직접 입력 키워드 처리
-    direct_keywords_list = [kw.strip() for kw in re.split(r'[\n,]+', direct_keyword_input) if kw.strip()]
-    debug_log(f"통합 분석 - 입력된 직접 키워드: {direct_keywords_list}")
-
-    if not direct_keywords_list: # 직접 입력 키워드가 없으면 형태소 분석 결과만 반환
-        if "직접입력" not in df_morph.columns and not df_morph.empty:
-             df_morph["직접입력"] = "" # 직접입력 컬럼 추가
-        # 컬럼 순서 조정
-        cols = ["단어", "빈도수", "PC월검색량", "모바일월검색량", "토탈월검색량", "블로그문서수", "직접입력"]
-        for col in cols:
-            if col not in df_morph.columns:
-                 df_morph[col] = "" if col == "직접입력" else (0 if col != "단어" else "")
-        if not df_morph.empty: # df_morph가 비어있지 않을 때만 컬럼 순서 적용
-            df_morph = df_morph[cols]
-        return df_morph, create_excel_file(df_morph)
-
-    # 직접 입력 키워드에 대한 정보 (빈도수, API 정보) 가져오기
-    # direct_keyword_analysis는 "키워드" 컬럼을 사용하므로, df_morph의 "단어"와 통일 필요
-    df_direct_raw, _ = direct_keyword_analysis(blog_text, direct_keyword_input)
-    # df_direct_raw 컬럼: "키워드", "빈도수", "PC월검색량", "모바일월검색량", "토탈월검색량", "블로그문서수"
-    df_direct_raw.rename(columns={"키워드": "단어"}, inplace=True) # 컬럼명 통일
-
-    # 형태소 분석 결과에 '직접입력' 표기
-    if not df_morph.empty:
-        df_morph["직접입력"] = df_morph["단어"].apply(lambda x: "직접입력" if x in direct_keywords_list else "")
-    else: # 형태소 분석 결과가 비어있을 수 있음
-        df_morph = pd.DataFrame(columns=["단어", "빈도수", "PC월검색량", "모바일월검색량", "토탈월검색량", "블로그문서수", "직접입력"])
-
-
-    # 직접 입력된 키워드 중 형태소 분석 결과에 없는 것들을 추가
-    # df_direct_raw에는 모든 직접 입력 키워드의 정보가 있음
-    
-    # df_morph와 df_direct_raw를 합치되, '단어' 기준으로 중복 처리
-    # 먼저 df_direct_raw에 '직접입력' 컬럼을 추가하고 "직접입력"으로 채움
-    df_direct_raw["직접입력"] = "직접입력"
-    
-    # df_morph에 있는 단어는 df_morph 정보를 우선 사용 (직접입력 플래그만 업데이트)
-    # df_direct_raw에서 df_morph에 없는 단어만 골라서 추가
-    
-    # df_morph의 '직접입력' 컬럼은 이미 위에서 처리됨.
-    # 이제 df_direct_raw에만 있��� 키워드를 df_morph에 추가
-    
-    # df_morph에 있는 단어 목록
-    morph_words = df_morph['단어'].tolist() if not df_morph.empty else []
-    
-    rows_to_add = []
-    for idx, row in df_direct_raw.iterrows():
-        if row['단어'] not in morph_words:
-            rows_to_add.append(row)
-            
-    if rows_to_add:
-        df_to_add = pd.DataFrame(rows_to_add)
-        combined_df = pd.concat([df_morph, df_to_add], ignore_index=True)
-    else:
-        combined_df = df_morph.copy() # df_morph가 비어있을 수도 있음
-
-    # 최종 컬럼 정리 및 순서
-    final_cols_combined = ["단어", "빈도수", "PC월검색량", "모바일월검색량", "토탈월검색량", "블로그문서수", "직접입력"]
-    for col in final_cols_combined:
-        if col not in combined_df.columns:
-            # 기본값 설정: '직접입력'은 "", 나머지는 0 또는 None (API 값은 None 허용)
-            if col == "직접입력":
-                combined_df[col] = ""
-            elif col == "빈도수":
-                 combined_df[col] = 0
-            elif col == "단어":
-                 combined_df[col] = ""
-            else: # API 관련 컬럼
-                 combined_df[col] = None # pd.NA도 가능
-
-    # NA 값들을 적절히 처리 (예: 0으로 채우거나 그대로 두기)
-    # API 값들은 숫자가 아닐 수 있으므로 (예: "< 10"), process_keyword에서 처리됨. 여기서는 int형 변환 전이므로 그대로 둠.
-    # Gradio DataFrame은 None을 잘 표시함.
-    # 빈도수는 정수형이어야 함
-    if "빈도수" in combined_df.columns:
-        combined_df["빈도수"] = combined_df["빈도수"].fillna(0).astype(int)
-
-
-    if not combined_df.empty : # 비어있지 않을 때만 정렬 및 중복 제거
-        combined_df = combined_df[final_cols_combined].drop_duplicates(subset=['단어'], keep='first') # 만약을 위한 중복 제거
-        combined_df.sort_values(by=["직접입력", "빈도수"], ascending=[False, False], inplace=True, na_position='last') # 직접입력 우선, 그 다음 빈도수
-        combined_df.reset_index(drop=True, inplace=True)
-
-    combined_excel = create_excel_file(combined_df)
+    merged_df, _ = morphological_analysis_and_enrich(blog_text, remove_freq1)
+    if "직접입력" not in merged_df.columns:
+        merged_df["직접입력"] = ""
+    direct_keywords = re.split(r'[\n,]+', direct_keyword_input)
+    direct_keywords = [kw.strip() for kw in direct_keywords if kw.strip()]
+    debug_log(f"입력된 직접 키워드: {direct_keywords}")
+    for dk in direct_keywords:
+        if dk in merged_df["단어"].values:
+            merged_df.loc[merged_df["단어"] == dk, "직접입력"] = "직접입력"
+        else:
+            freq = blog_text.count(dk)
+            df_direct, _ = process_keyword(dk, include_related=False)
+            if (not df_direct.empty) and (dk in df_direct["정보키워드"].values):
+                row = df_direct[df_direct["정보키워드"] == dk].iloc[0]
+                pc = row.get("PC월검색량", None)
+                mobile = row.get("모바일월검색량", None)
+                total = row.get("토탈월검색량", None)
+                blog_count = row.get("블로그문서수", None)
+            else:
+                pc = mobile = total = blog_count = None
+            new_row = {
+                "단어": dk,
+                "빈도수": freq,
+                "PC월검색량": pc,
+                "모바일월검색량": mobile,
+                "토탈월검색량": total,
+                "블로그문서수": blog_count,
+                "직접입력": "직접입력"
+            }
+            merged_df = pd.concat([merged_df, pd.DataFrame([new_row])], ignore_index=True)
+    merged_df = merged_df.sort_values(by="빈도수", ascending=False).reset_index(drop=True)
+    combined_excel = create_excel_file(merged_df)
     debug_log("combined_analysis 함수 완료")
-    return combined_df, combined_excel
-
+    return merged_df, combined_excel
 
 # --- 분석 핸들러 ---
 def analysis_handler(blog_text: str, remove_freq1: bool, direct_keyword_input: str, direct_keyword_only: bool):
-    debug_log(f"analysis_handler 함수 시작. 직접 키워드만 분석: {direct_keyword_only}")
-    start_time = time.time()
-
-    if not blog_text or blog_text.strip() == "스크래핑된 블로그 내용이 여기에 표시됩니다." or blog_text.strip() == "":
-        debug_log("분석할 블로그 내용이 없습니다.")
-        # 빈 결과를 반환하기 위한 DataFrame 구조 명시
-        empty_cols_direct = ["키워드", "빈도수", "PC월검색량", "모바일월검색량", "토탈월검색량", "블로그문서수"]
-        empty_cols_combined = ["단어", "빈도수", "PC월검색량", "모바일월검색량", "토탈월검색량", "블로그문서수", "직접입력"]
-        df_empty = pd.DataFrame(columns=empty_cols_direct if direct_keyword_only else empty_cols_combined)
-        return df_empty, create_excel_file(df_empty)
-
-
+    debug_log("analysis_handler 함수 시작")
     if direct_keyword_only:
         # "직접 키워드 입력만 분석" 선택 시 단독 분석 수행
-        if not direct_keyword_input or not direct_keyword_input.strip():
-            debug_log("직접 키워드만 분석 선택되었으나, 입력된 직접 키워드가 없습니다.")
-            empty_cols_direct = ["키워드", "빈도수", "PC월검색량", "모바일월검색량", "토탈월검색량", "블로그문서수"]
-            df_empty = pd.DataFrame(columns=empty_cols_direct)
-            return df_empty, create_excel_file(df_empty)
-        
-        result_df, excel_path = direct_keyword_analysis(blog_text, direct_keyword_input)
+        return direct_keyword_analysis(blog_text, direct_keyword_input)
     else:
         # 기본 통합 분석 수행
-        result_df, excel_path = combined_analysis(blog_text, remove_freq1, direct_keyword_input)
-    
-    end_time = time.time()
-    debug_log(f"analysis_handler 총 실행 시간: {end_time - start_time:.2f} 초")
-    return result_df, excel_path
-
+        return combined_analysis(blog_text, remove_freq1, direct_keyword_input)
 
 # --- 스크래핑 실행 ---
 def fetch_blog_content(url: str):
     debug_log("fetch_blog_content 함수 시작")
-    if not url or not url.strip():
-        return "블로그 URL을 입력해주세요."
-    if not url.startswith("http://") and not url.startswith("https://"):
-        return "유효한 URL 형식(http:// 또는 https://)으로 입력해주세요."
-    
-    start_time = time.time()
     content = scrape_naver_blog(url)
-    end_time = time.time()
-    debug_log(f"fetch_blog_content 총 실행 시간: {end_time - start_time:.2f} 초. 내용 길이: {len(content)}")
+    debug_log("fetch_blog_content 함수 완료")
     return content
 
 # --- Custom CSS ---
 custom_css = """
 /* 전체 컨테이너 스타일 */
 .gradio-container {
-    max-width: 1080px; /* 너비 확장 */
+    max-width: 960px;
     margin: auto;
     font-family: 'Helvetica Neue', Arial, sans-serif;
     background: #f5f7fa;
@@ -696,12 +330,7 @@ custom_css = """
     padding: 0.6rem 1.2rem;
     font-size: 1rem;
     cursor: pointer;
-    min-width: 150px; /* 버튼 최소 너비 */
 }
-.custom-button:hover {
-    background-color: #0056b3;
-}
-
 
 /* 체크박스 스타일 */
 .custom-checkbox {
@@ -722,97 +351,39 @@ custom_css = """
 """
 
 # --- Gradio 인터페이스 구성 ---
-with gr.Blocks(title="네이버 블로그 키워드 분석 서비스", css=custom_css) as demo:
-    gr.HTML("<div class='custom-header'>네이버 블로그 키워드 분석 서비스</div>")
+with gr.Blocks(title="네이버 블로그 형태소 분석 서비스", css=custom_css) as demo:
+    gr.HTML("<div class='custom-header'>네이버 블로그 형태소 분석 서비스</div>")
+    # 블로그 링크와 스크래핑 실행 버튼을 한 그룹 내에 배치 (버튼은 가운데 정렬)
+    with gr.Group(elem_classes="custom-group"):
+        with gr.Row():
+            blog_url_input = gr.Textbox(label="네이버 블로그 링크", placeholder="예: https://blog.naver.com/ssboost/222983068507", lines=1)
+        with gr.Row(elem_classes="centered"):
+            scrape_button = gr.Button("스크래핑 실행", elem_classes="custom-button")
+    with gr.Group(elem_classes="custom-group"):
+        blog_content_box = gr.Textbox(label="블로그 내용 (수정 가능)", lines=10, placeholder="스크래핑된 블로그 내용이 여기에 표시됩니다.")
+    with gr.Group(elem_classes="custom-group"):
+        with gr.Row():
+            remove_freq_checkbox = gr.Checkbox(label="빈도수1 제거", value=True, elem_classes="custom-checkbox")
+        with gr.Row():
+            # "빈도수1 제거" 아래에 "직접 키워드 입력만 분석" 체크박스 배치
+            direct_keyword_only_checkbox = gr.Checkbox(label="직접 키워드 입력만 분석", value=False, elem_classes="custom-checkbox")
+        with gr.Row():
+            direct_keyword_box = gr.Textbox(label="직접 키워드 입력 (엔터 또는 ','로 구분)", lines=2, placeholder="예: 키워드1, 키워드2\n키워드3")
+    with gr.Group(elem_classes="custom-group"):
+        with gr.Row(elem_classes="centered"):
+            analyze_button = gr.Button("분석 실행", elem_classes="custom-button")
+    with gr.Group(elem_classes="custom-group custom-result"):
+        result_df = gr.Dataframe(label="통합 분석 결과 (단어, 빈도수, 검색량, 블로그문서수, 직접입력)", interactive=True)
+    with gr.Group(elem_classes="custom-group"):
+        excel_file = gr.File(label="Excel 다운로드")
     
-    with gr.Row():
-        with gr.Column(scale=2): # 왼쪽 컬럼 (입력 영역)
-            with gr.Group(elem_classes="custom-group"):
-                blog_url_input = gr.Textbox(
-                    label="네이버 블로그 링크", 
-                    placeholder="예: https://blog.naver.com/아이디/글번호", 
-                    lines=1,
-                    info="분석할 네이버 블로그 게시물 URL을 입력하세요."
-                )
-                with gr.Row(elem_classes="centered"):
-                    scrape_button = gr.Button("블로그 내용 가져오기", elem_classes="custom-button", variant="primary")
-            
-            with gr.Group(elem_classes="custom-group"):
-                blog_content_box = gr.Textbox(
-                    label="블로그 내용 (수정 가능)", 
-                    lines=10, 
-                    placeholder="스크래핑된 블로그 내용이 여기에 표시됩니다. 직접 수정하거나 붙여넣을 수 있습니다."
-                )
-            
-            with gr.Group(elem_classes="custom-group"):
-                gr.Markdown("### 분석 옵션 설정")
-                with gr.Row():
-                    remove_freq_checkbox = gr.Checkbox(
-                        label="빈도수 1인 단어 제거 (형태소 분석 시)", 
-                        value=True, 
-                        elem_classes="custom-checkbox",
-                        info="형태소 분석 결과에서 빈도수가 1인 단어를 제외합니다."
-                    )
-                with gr.Row():
-                    direct_keyword_only_checkbox = gr.Checkbox(
-                        label="직접 키워드만 분석", 
-                        value=False, 
-                        elem_classes="custom-checkbox",
-                        info="이 옵션을 선택하면 아래 입력한 직접 키워드에 대해서만 분석을 수행합니다 (형태소 분석 생략)."
-                    )
-                with gr.Row():
-                    direct_keyword_box = gr.Textbox(
-                        label="직접 키워드 입력 (엔터 또는 ','로 구분)", 
-                        lines=3, 
-                        placeholder="예: 키워드1, 키워드2\n키워드3\n...\n(형태소 분석 결과와 별도로 분석하거나, 통합 분석에 추가할 키워드)",
-                        info="분석에 포함하거나 단독으로 분석할 키워드를 직접 입력합니다."
-                    )
-            
-            with gr.Group(elem_classes="custom-group"):
-                with gr.Row(elem_classes="centered"):
-                    analyze_button = gr.Button("키워드 분석 실행", elem_classes="custom-button", variant="primary")
-
-        with gr.Column(scale=3): # 오른쪽 컬럼 (결과 영역)
-            with gr.Group(elem_classes="custom-group custom-result"):
-                gr.Markdown("### 분석 결과")
-                result_df_display = gr.DataFrame(  # gr.Dataframe -> gr.DataFrame 으로 변경
-                    label="통합 분석 결과 (단어, 빈도수, 검색량, 블로그문서수, 직접입력 여부)", 
-                    interactive=False, 
-                    # height=600,  # Gradio 버전 호환성을 위해 height 파라미터 제거 또는 주석 처리
-                    wrap=True 
-                )
-            with gr.Group(elem_classes="custom-group"):
-                gr.Markdown("### 결과 다운로드")
-                excel_file_display = gr.File(label="분석 결과 Excel 파일 다운로드")
-
     # 이벤트 연결
     scrape_button.click(fn=fetch_blog_content, inputs=blog_url_input, outputs=blog_content_box)
-    analyze_button.click(
-        fn=analysis_handler,
-        inputs=[blog_content_box, remove_freq_checkbox, direct_keyword_box, direct_keyword_only_checkbox],
-        outputs=[result_df_display, excel_file_display]
-    )
+    analyze_button.click(fn=analysis_handler, 
+                         inputs=[blog_content_box, remove_freq_checkbox, direct_keyword_box, direct_keyword_only_checkbox],
+                         outputs=[result_df, excel_file])
 
 if __name__ == "__main__":
-    # 환경 변수 설정 예시 (실제 실행 시에는 시스템 환경 변수로 설정하거나, .env 파일 등을 사용)
-    # os.environ["NAVER_API_KEY"] = "YOUR_NAVER_API_KEY"
-    # os.environ["NAVER_SECRET_KEY"] = "YOUR_NAVER_SECRET_KEY"
-    # os.environ["NAVER_CUSTOMER_ID"] = "YOUR_NAVER_CUSTOMER_ID"
-    # os.environ["NAVER_SEARCH_CLIENT_ID"] = "YOUR_NAVER_SEARCH_CLIENT_ID"
-    # os.environ["NAVER_SEARCH_CLIENT_SECRET"] = "YOUR_NAVER_SEARCH_CLIENT_SECRET"
-
-    # 환경 변수 설정 확인
-    required_env_vars = [
-        "NAVER_API_KEY", "NAVER_SECRET_KEY", "NAVER_CUSTOMER_ID",
-        "NAVER_SEARCH_CLIENT_ID", "NAVER_SEARCH_CLIENT_SECRET"
-    ]
-    missing_vars = [var for var in required_env_vars if not os.environ.get(var)]
-    if missing_vars:
-        debug_log(f"경고: 다음 필수 환경 변수가 설정되지 않았습니다 - {', '.join(missing_vars)}")
-        debug_log("API 호출 기능이 정상적으로 동작하지 않을 수 있습니다.")
-        debug_log("스크립트 실행 전에 해당 환경 변수를 설정해주세요.")
-        # Gradio 앱은 실행하되, API 호출 시 오류가 발생할 수 있음을 사용자에게 알림.
-
     debug_log("Gradio 앱 실행 시작")
-    demo.launch(debug=True) # 개발 중에는 debug=True로 설정하여 오류 확인 용이
-    debug_log("Gradio 앱 실행 종료")
+    demo.launch()
+    debug_log("Gradio 앱 실행 종료")