Update src/streamlit_app.py

src/streamlit_app.py

@@ -4,73 +4,33 @@ import requests
 from bs4 import BeautifulSoup
 import re
 import time
+import nltk
+from nltk.tokenize import word_tokenize
+from nltk.corpus import stopwords
+from collections import Counter
 import json
 import os
 from datetime import datetime, timedelta
+import openai
+from dotenv import load_dotenv
 import traceback
 import plotly.graph_objects as go
 import schedule
 import threading
 import matplotlib.pyplot as plt
-from pathlib import Path
-import openai
-from dotenv import load_dotenv
-
-# 허깅페이스 Spaces 환경에 맞게 임시 디렉토리 설정
-# /tmp 폴더는 존재할 수 있지만 권한 문제가 있을 수 있으므로 현재 작업 디렉토리 기반으로 변경
-CURRENT_DIR = os.path.dirname(os.path.abspath(__file__)) if "__file__" in globals() else os.getcwd()
-DATA_DIR = os.path.join(CURRENT_DIR, "data")
-SAVED_ARTICLES_PATH = os.path.join(DATA_DIR, "saved_articles.json")
-SCHEDULED_NEWS_DIR = os.path.join(DATA_DIR, "scheduled_news")
-
-# 디렉토리 생성 함수
-def ensure_directory(directory):
-    try:
-        os.makedirs(directory, exist_ok=True)
-        return True
-    except Exception as e:
-        st.error(f"디렉토리 생성 중 오류 발생: {str(e)}")
-        return False
 
-# 필요한 모든 디렉토리 생성
-ensure_directory(DATA_DIR)
-ensure_directory(SCHEDULED_NEWS_DIR)
+# /tmp 경로 설정
+TMP_DIR = "/tmp"
+SAVED_ARTICLES_PATH = os.path.join(TMP_DIR, "saved_articles.json")
+SCHEDULED_NEWS_DIR = os.path.join(TMP_DIR, "scheduled_news")
 
-# 한국어 토크나이징을 위한 KSS 설정
-try:
-    import kss
-    kss_available = True
-except ImportError:
-    st.warning("KSS 라이브러리가 설치되어 있지 않습니다. 'pip install kss'로 설치하세요.")
-    kss_available = False
-
-# 한국어 토크나이징 함수 (KSS 사용)
-def tokenize_korean(text):
-    try:
-        if kss_available:
-            tokens = []
-            # 문장 분리 후 각 문장에서 단어 추출
-            for sentence in kss.split_sentences(text):
-                # 기본 공백 기반 토큰화에 정규식 패턴 추가하여 더 정교하게 처리
-                raw_tokens = sentence.split()
-                for token in raw_tokens:
-                    # 조사, 특수문자 등을 분리
-                    sub_tokens = re.findall(r'[가-힣]+|[a-zA-Z]+|[0-9]+|[^\s가-힣a-zA-Z0-9]+', token)
-                    tokens.extend(sub_tokens)
-            return tokens
-    except Exception as e:
-        st.debug(f"KSS 토크나이징 실패: {str(e)}")
-    
-    # KSS 사용 불가능하거나 오류 발생시 기본 정규식 기반 토크나이저 사용
-    return re.findall(r'[가-힣]+|[a-zA-Z]+|[0-9]+|[^\s가-힣a-zA-Z0-9]+', text)
-
-# 워드클라우드 추가 (선택적 사용)
+# 워드클라우드 추가
 try:
     from wordcloud import WordCloud
-    wordcloud_available = True
 except ImportError:
-    wordcloud_available = False
-    
+    st.error("wordcloud 패키지를 설치해주세요: pip install wordcloud")
+    WordCloud = None
+
 # 스케줄러 상태 클래스 추가
 class SchedulerState:
     def __init__(self):
@@ -101,6 +61,31 @@ if st.session_state.openai_api_key is None:
         load_dotenv() # 로컬 .env 파일
         st.session_state.openai_api_key = os.getenv('OPENAI_API_KEY')
 
+# 필요한 NLTK 데이터 다운로드
+try:
+    nltk.data.find('tokenizers/punkt')
+except LookupError:
+    nltk.download('punkt')
+    
+try:
+    nltk.data.find('tokenizers/punkt_tab')
+except LookupError:
+    nltk.download('punkt_tab')
+    
+try:
+    nltk.data.find('corpora/stopwords')
+except LookupError:
+    nltk.download('stopwords')
+
+# OpenAI API 키 설정
+# openai.api_key 설정은 각 API 호출 직전에 st.session_state.openai_api_key 사용하도록 변경하거나,
+# 앱 시작 시점에 한 번 설정합니다. 여기서는 후자를 선택합니다.
+if st.session_state.openai_api_key:
+    openai.api_key = st.session_state.openai_api_key
+else:
+    # UI 초기에는 키가 없을 수 있으므로, 나중에 키 입력 시 openai.api_key가 설정되도록 유도
+    pass
+
 # 페이지 설정
 st.set_page_config(page_title="뉴스 기사 도구", page_icon="📰", layout="wide")
 
@@ -111,17 +96,21 @@ menu = st.sidebar.radio(
     ["뉴스 기사 크롤링", "기사 분석하기", "새 기사 생성하기", "뉴스 기사 예약하기"]
 )
 
-# OpenAI API 키 입력 (사이드바)
-openai_api_key = st.sidebar.text_input("OpenAI API 키 (선택사항)", 
-                                      value=st.session_state.openai_api_key if st.session_state.openai_api_key else "", 
-                                      type="password")
-if openai_api_key:
-    st.session_state.openai_api_key = openai_api_key
-    openai.api_key = openai_api_key
-    
+# 디렉토리 생성 함수
+def ensure_directory(directory):
+    try:
+        os.makedirs(directory, mode=0o777, exist_ok=True)
+        # 디렉토리 권한 설정
+        os.chmod(directory, 0o777)
+    except Exception as e:
+        st.error(f"디렉토리 생성 중 오류 발생: {str(e)}")
+        return False
+    return True
+
 # 저장된 기사를 불러오는 함수
 def load_saved_articles():
     try:
+        ensure_directory(TMP_DIR)
         if os.path.exists(SAVED_ARTICLES_PATH):
             with open(SAVED_ARTICLES_PATH, 'r', encoding='utf-8') as f:
                 return json.load(f)
@@ -133,12 +122,15 @@ def load_saved_articles():
 # 기사를 저장하는 함수
 def save_articles(articles):
     try:
+        ensure_directory(TMP_DIR)
         with open(SAVED_ARTICLES_PATH, 'w', encoding='utf-8') as f:
             json.dump(articles, f, ensure_ascii=False, indent=2)
-        return True
+        # 파일 권한 설정
+        os.chmod(SAVED_ARTICLES_PATH, 0o666)
     except Exception as e:
         st.error(f"기사 저장 중 오류 발생: {str(e)}")
         return False
+    return True
 
 @st.cache_data
 def crawl_naver_news(keyword, num_articles=5):
@@ -225,89 +217,49 @@ def get_article_content(url):
     except Exception as e:
         return f"오류 발생: {str(e)}"
 
-# KSS를 이용한 키워드 분석
+# NLTK를 이용한 키워드 분석
 def analyze_keywords(text, top_n=10):
-    # 한국어 불용어 목록 (확장)
-    korean_stopwords = [
-        '이', '그', '저', '것', '및', '등', '를', '을', '에', '에서', '의', '으로', '로',
-        '에게', '뿐', '다', '는', '가', '이다', '에게서', '께', '께서', '부터', '까지',
-        '이런', '저런', '그런', '어떤', '무슨', '이것', '저것', '그것', '이번', '저번', '그번',
-        '이거', '저거', '그거', '하다', '되다', '있다', '없다', '같다', '보다', '이렇다', '그렇다',
-        '하는', '되는', '있는', '없는', '같은', '보는', '이런', '그런', '저런', '했다', '됐다',
-        '있었다', '없었다', '같았다', '봤다', '또', '또한', '그리고', '하지만', '그러나', '그래서',
-        '때문에', '따라서', '하며', '되며', '있으며', '없으며', '같으며', '보며', '하고', '되고',
-        '있고', '없고', '같고', '보고', '통해', '위해', '때', '중', '후'
-    ]
+    # 한국어 불용어 목록 (직접 정의해야 합니다)
+    korean_stopwords = ['이', '그', '저', '것', '및', '등', '를', '을', '에', '에서', '의', '으로', '로']
     
-    # 영어 불용어 목록
-    english_stopwords = [
-        'a', 'an', 'the', 'and', 'or', 'but', 'if', 'because', 'as', 'what',
-        'when', 'where', 'how', 'who', 'which', 'this', 'that', 'these', 'those',
-        'then', 'just', 'so', 'than', 'such', 'both', 'through', 'about', 'for',
-        'is', 'are', 'was', 'were', 'be', 'been', 'being', 'have', 'has', 'had',
-        'having', 'do', 'does', 'did', 'doing', 'would', 'should', 'could', 'might',
-        'will', 'shall', 'can', 'may', 'must', 'ought'
-    ]
+    tokens = word_tokenize(text)
+    tokens = [word for word in tokens if word.isalnum() and len(word) > 1 and word not in korean_stopwords]
     
-    # 언어 감지 (간단하게 한글 포함 여부로 체크)
-    is_korean = bool(re.search(r'[가-힣]', text))
-    
-    if is_korean:
-        # 한국어 텍스트인 경우 KSS 기반 토크나이저 사용
-        tokens = tokenize_korean(text)
-    else:
-        # 영어 또는 기타 언어는 간단한 정규식 토큰화
-        tokens = re.findall(r'\b\w+\b', text.lower())
-    
-    # 불용어 필터링 (언어에 따라 다른 불용어 적용)
-    stopwords = korean_stopwords if is_korean else english_stopwords
-    tokens = [word for word in tokens if len(word) > 1 and word.lower() not in stopwords]
-    
-    # 빈도 계산
-    from collections import Counter
     word_count = Counter(tokens)
     top_keywords = word_count.most_common(top_n)
     
     return top_keywords
 
-# 워드 클라우드용 분석
+#워드 클라우드용 분석
 def extract_keywords_for_wordcloud(text, top_n=50):
     if not text or len(text.strip()) < 10:
         return {}
 
     try:
-        # 언어 감지 (간단하게 한글 포함 여부로 체크)
-        is_korean = bool(re.search(r'[가-힣]', text))
-        
-        # 토큰화 (KSS 사용)
-        tokens = tokenize_korean(text.lower())
+        try:
+            tokens = word_tokenize(text.lower())
+        except Exception as e:
+            st.warning(f"{str(e)} 오류발생")
+            tokens = text.lower().split()
         
-        # 불용어 설정
-        # 영어 불용어 목록
-        english_stopwords = {
-            'a', 'an', 'the', 'and', 'or', 'but', 'if', 'because', 'as', 'what',
-            'when', 'where', 'how', 'who', 'which', 'this', 'that', 'these', 'those',
-            'then', 'just', 'so', 'than', 'such', 'both', 'through', 'about', 'for',
-            'is', 'are', 'was', 'were', 'be', 'been', 'being', 'have', 'has', 'had',
-            'having', 'do', 'does', 'did', 'doing', 'would', 'should', 'could', 'might',
-            'will', 'shall', 'can', 'may', 'must', 'ought'
-        }
+        stop_words = set()
+        try:
+            stop_words = set(stopwords.words('english'))
+        except Exception:
+            pass
 
-        # 한국어 불용어
-        korean_stopwords = {
+        korea_stop_words = {
             '및', '등', '를', '이', '의', '가', '에', '는', '으로', '에서', '그', '또', '또는', '하는', '할', '하고',
-            '있다', '이다', '위해', '것이다', '것은', '대한', '때문', '그리고', '하지만', '그러나', '그래서',
-            '입니다', '합니다', '습니다', '요', '죠', '고', '과', '와', '도', '은', '수', '것', '들', '제', '저',
-            '년', '월', '일', '시', '분', '초', '지난', '올해', '내년', '최근', '현재', '오늘', '내일', '어제',
-            '오전', '오후', '부터', '까지', '에게', '께서', '이라고', '라고', '하며', '하면서', '따라', '통해',
-            '관련', '한편', '특히', '가장', '매우', '더', '덜', '많이', '조금', '항상', '자주', '가끔', '거의',
-            '전혀', '바로', '정말', '만약', '비롯한', '등을', '등이', '등의', '등과', '등도', '등에', '등에서',
-            '기자', '뉴스', '사진', '연합뉴스', '뉴시스', '제공', '무단', '전재', '재배포', '금지', '앵커', '멘트',
-            '일보', '데일리', '경제', '사회', '정치', '세계', '과학', '아이티', '닷컴', '씨넷', '블로터', '전자신문'
+                '있다', '이다', '위해', '것이다', '것은', '대한', '때문', '그리고', '하지만', '그러나', '그래서',
+                '입니다', '합니다', '습니다', '요', '죠', '고', '과', '와', '도', '은', '수', '것', '들', '제', '저',
+                '년', '월', '일', '시', '분', '초', '지난', '올해', '내년', '최근', '현재', '오늘', '내일', '어제',
+                '오전', '오후', '부터', '까지', '에게', '께서', '이라고', '라고', '하며', '하면서', '따라', '통해',
+                '관련', '한편', '특히', '가장', '매우', '더', '덜', '많이', '조금', '항상', '자주', '가끔', '거의',
+                '전혀', '바로', '정말', '만약', '비롯한', '등을', '등이', '등의', '등과', '등도', '등에', '등에서',
+                '기자', '뉴스', '사진', '연합뉴스', '뉴시스', '제공', '무단', '전재', '재배포', '금지', '앵커', '멘트',
+                '일보', '데일리', '경제', '사회', '정치', '세계', '과학', '아이티', '닷컴', '씨넷', '블로터', '전자신문'
         }
-        
-        # 언어에 따라 불용어 선택
-        stop_words = korean_stopwords if is_korean else english_stopwords
+        stop_words.update(korea_stop_words)
 
         # 1글자 이상이고 불용어가 아닌 토큰만 필터링
         filtered_tokens = [word for word in tokens if len(word) > 1 and word not in stop_words]
@@ -327,45 +279,51 @@ def extract_keywords_for_wordcloud(text, top_n=50):
         return dict(sorted_words[:top_n])
     
     except Exception as e:
-        st.error(f"키워드 추출 중 오류발생 {str(e)}")
+        st.error(f"오류발생 {str(e)}")
         return {"data": 1, "analysis": 1, "news": 1}
+    
 
 # 워드 클라우드 생성 함수
+
 def generate_wordcloud(keywords_dict):
-    if not wordcloud_available:
-        st.warning("워드클라우드를 위한 라이브러리가 설치되지 않았습니다.")
-        return None
-        
-    try:
-        # 나눔고딕 폰트 확인 (없으면 기본 폰트 사용)
-        font_path = os.path.join(CURRENT_DIR, "NanumGothic.ttf") 
-        if not os.path.exists(font_path):
-            # 기본 폰트 사용
-            wc = WordCloud(
-                width=800,
-                height=400,
-                background_color='white',
-                colormap='viridis',
-                max_font_size=150,
-                random_state=42
-            ).generate_from_frequencies(keywords_dict)
-        else:
-            # 나눔고딕 폰트 사용
-            wc = WordCloud(
-                font_path=font_path,
-                width=800,
-                height=400,
-                background_color='white',
-                colormap='viridis',
-                max_font_size=150,
-                random_state=42
-            ).generate_from_frequencies(keywords_dict)
+        if not WordCloud:
+            st.warning("워드클라우드 설치안되어 있습니다.")
+            return None
+        try:
+            # 프로젝트 루트에 NanumGothic.ttf가 있다고 가정
+            font_path = "NanumGothic.ttf" 
+            
+            # 로컬에 폰트 파일이 있는지 확인, 없으면 기본으로 시도
+            if not os.path.exists(font_path):
+                st.warning(f"폰트 파일({font_path})을 찾을 수 없습니다. 기본 폰트로 워드클라우드를 생성합니다. 한글이 깨질 수 있습니다.")
+                # font_path = None # 또는 시스템 기본 폰트 경로를 지정 (플랫폼���다 다름)
+                # WordCloud 생성자에서 font_path를 None으로 두면 시스템 기본값을 시도하거나, 아예 빼고 호출
+                wc = WordCloud(
+                    width=800,
+                    height=400,
+                    background_color='white',
+                    colormap='viridis',
+                    max_font_size=150,
+                    random_state=42
+                ).generate_from_frequencies(keywords_dict)
+            else:
+                 wc= WordCloud(
+                    font_path=font_path,
+                    width=800,
+                    height=400,
+                    background_color = 'white',
+                    colormap = 'viridis',
+                    max_font_size=150,
+                    random_state=42
+                ).generate_from_frequencies(keywords_dict)
             
-        return wc
+            return wc
         
-    except Exception as e:
-        st.error(f"워드클라우드 생성 중 오류 발생: {str(e)}")
-        return None
+        except Exception as e:
+            st.error(f"워드클라우드 생성 중 오류 발생: {str(e)}")
+            # traceback.print_exc() # 디버깅 시 사용
+            st.warning("워드클라우드 생성에 실패했습니다. 폰트 문제일 수 있습니다. NanumGothic.ttf 파일이 프로젝트 루트에 있는지 확인해주세요.")
+            return None
 
 # 뉴스 분석 함수
 def analyze_news_content(news_df):
@@ -373,37 +331,32 @@ def analyze_news_content(news_df):
         return "데이터가 없습니다"
     
     results = {}
-    
-    # 카테고리별 분석
+    #카테고리별
     if 'source' in news_df.columns:
-        results['source_counts'] = news_df['source'].value_counts().to_dict()
+            results['source_counts'] = news_df['source'].value_counts().to_dict()
+    #카테고리별
     if 'date' in news_df.columns:
-        results['date_counts'] = news_df['date'].value_counts().to_dict()
+            results['date_counts'] = news_df['date'].value_counts().to_dict()
 
-    # 키워드 분석
+    #키워드분석
     all_text = " ".join(news_df['title'].fillna('') + " " + news_df['content'].fillna(''))
 
     if len(all_text.strip()) > 0:
-        results['top_keywords_for_wordcloud'] = extract_keywords_for_wordcloud(all_text, top_n=50)
+        results['top_keywords_for_wordcloud']= extract_keywords_for_wordcloud(all_text, top_n=50)
         results['top_keywords'] = analyze_keywords(all_text)
     else:
-        results['top_keywords_for_wordcloud'] = {}
+        results['top_keywords_for_wordcloud']={}
         results['top_keywords'] = []
-        
     return results
 
 # OpenAI API를 이용한 새 기사 생성
 def generate_article(original_content, prompt_text):
     if not st.session_state.openai_api_key:
         return "오류: OpenAI API 키가 설정되지 않았습니다. 사이드바에서 키를 입력하거나 환경 변수를 설정해주세요."
-        
+    openai.api_key = st.session_state.openai_api_key
     try:
-        # API 키 설정
-        openai.api_key = st.session_state.openai_api_key
-        
-        # API 호출
         response = openai.chat.completions.create(
-            model="gpt-4.1-mini",  # 또는 다른 사용 가능한 모델
+            model="gpt-4.1-mini",
             messages=[
                 {"role": "system", "content": "당신은 전문적인 뉴스 기자입니다. 주어진 내용을 바탕으로 새로운 기사를 작성해주세요."},
                 {"role": "user", "content": f"다음 내용을 바탕으로 {prompt_text}\n\n{original_content[:1000]}"}
@@ -418,17 +371,13 @@ def generate_article(original_content, prompt_text):
 def generate_image(prompt):
     if not st.session_state.openai_api_key:
         return "오류: OpenAI API 키가 설정되지 않았습니다. 사이드바에서 키를 입력하거나 환경 변수를 설정해주세요."
-        
+    openai.api_key = st.session_state.openai_api_key
     try:
-        # API 키 설정
-        openai.api_key = st.session_state.openai_api_key
-        
-        # API 호출
         response = openai.images.generate(
             model="gpt-image-1",
             prompt=prompt
         )
-        image_base64 = response.data[0].b64_json
+        image_base64=response.data[0].b64_json
         return f"data:image/png;base64,{image_base64}"
     except Exception as e:
         return f"이미지 생성 오류: {str(e)}"
@@ -460,12 +409,18 @@ def perform_news_task(task_type, keyword, num_articles, file_prefix):
             time.sleep(0.5)  # 서버 부하 방지
         
         # 결과 저장
+        if not ensure_directory(SCHEDULED_NEWS_DIR):
+            print(f"스케줄된 뉴스 디렉토리 생성 실패")
+            return
+            
         timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
         filename = os.path.join(SCHEDULED_NEWS_DIR, f"{file_prefix}_{task_type}_{timestamp}.json")
         
         try:
             with open(filename, 'w', encoding='utf-8') as f:
                 json.dump(articles, f, ensure_ascii=False, indent=2)
+            # 파일 권한 설정
+            os.chmod(filename, 0o666)
         except Exception as e:
             print(f"파일 저장 중 오류 발생: {e}")
             return
@@ -587,9 +542,8 @@ if menu == "뉴스 기사 크롤링":
             articles = crawl_naver_news(keyword, num_articles)
             
             # 기사 내용 가져오기
-            progress_bar = st.progress(0)
             for i, article in enumerate(articles):
-                progress_bar.progress((i + 1) / len(articles))
+                st.progress((i + 1) / len(articles))
                 article['content'] = get_article_content(article['link'])
                 time.sleep(0.5)  # 서버 부하 방지
             
@@ -605,7 +559,7 @@ if menu == "뉴스 기사 크롤링":
                     st.write(f"**요약:** {article['description']}")
                     st.write(f"**링크:** {article['link']}")
                     st.write("**본문 미리보기:**")
-                    st.write(article['content'][:300] + "..." if len(article['content']) > 300 else article['content'])
+                    st.write(article['content'][:300] + "...")
 
 elif menu == "기사 분석하기":
     st.header("기사 분석하기")
@@ -640,6 +594,7 @@ elif menu == "기사 분석하기":
                         keyword_tab1, keyword_tab2 = st.tabs(["키워드 빈도", "워드클라우드"])
 
                         with keyword_tab1:
+
                             keywords = analyze_keywords(selected_article['content'])
                             
                             # 시각화
@@ -649,38 +604,23 @@ elif menu == "기사 분석하기":
                             st.write("**주요 키워드:**")
                             for word, count in keywords:
                                 st.write(f"- {word}: {count}회")
-                                
                         with keyword_tab2:
                             keyword_dict = extract_keywords_for_wordcloud(selected_article['content'])
+                            wc = generate_wordcloud(keyword_dict)
                             
-                            if wordcloud_available:
-                                wc = generate_wordcloud(keyword_dict)
+                            if wc:
+                                fig, ax = plt.subplots(figsize=(10, 5))
+                                ax.imshow(wc, interpolation='bilinear')
+                                ax.axis('off')
+                                st.pyplot(fig)
                                 
-                                if wc:
-                                    fig, ax = plt.subplots(figsize=(10, 5))
-                                    ax.imshow(wc, interpolation='bilinear')
-                                    ax.axis('off')
-                                    st.pyplot(fig)
-                                    
-                                    # 키워드 상위 20개 표시
-                                    st.write("**상위 20개 키워드:**")
-                                    top_keywords = sorted(keyword_dict.items(), key=lambda x: x[1], reverse=True)[:20]
-                                    keyword_df = pd.DataFrame(top_keywords, columns=['키워드', '빈도'])
-                                    st.dataframe(keyword_df)
-                                else:
-                                    st.error("워드클라우드를 생성할 수 없습니다.")
-                            else:
-                                # 워드클라우드를 사용할 수 없는 경우 대체 표시
-                                st.warning("워드클라우드 기능을 사용할 수 없습니다. 필요한 패키지가 설치되지 않았습니다.")
-                                
-                                # 대신 키워드만 표시
-                                st.write("**상위 키워드:**")
-                                top_keywords = sorted(keyword_dict.items(), key=lambda x: x[1], reverse=True)[:30]
+                                # 키워드 상위 20개 표시
+                                st.write("**상위 20개 키워드:**")
+                                top_keywords = sorted(keyword_dict.items(), key=lambda x: x[1], reverse=True)[:20]
                                 keyword_df = pd.DataFrame(top_keywords, columns=['키워드', '빈도'])
                                 st.dataframe(keyword_df)
-                                
-                                # 막대 차트로 표시
-                                st.bar_chart(keyword_df.set_index('키워드').head(15))
+                            else:
+                                st.error("워드클라우드를 생성할 수 없습니다.")
 
             elif analysis_type == "텍스트 통계":
                 if st.button("텍스트 통계 분석"):
@@ -689,18 +629,7 @@ elif menu == "기사 분석하기":
                     # 텍스트 통계 계산
                     word_count = len(re.findall(r'\b\w+\b', content))
                     char_count = len(content)
-                    
-                    # KSS를 사용하여 문장 분리
-                    if kss_available:
-                        try:
-                            sentences = kss.split_sentences(content)
-                            sentence_count = len(sentences)
-                        except Exception:
-                            # KSS 실패 시 간단한 문장 분리
-                            sentence_count = len(re.split(r'[.!?]+', content))
-                    else:
-                        sentence_count = len(re.split(r'[.!?]+', content))
-                        
+                    sentence_count = len(re.split(r'[.!?]+', content))
                     avg_word_length = sum(len(word) for word in re.findall(r'\b\w+\b', content)) / word_count if word_count > 0 else 0
                     avg_sentence_length = word_count / sentence_count if sentence_count > 0 else 0
                     
@@ -726,38 +655,79 @@ elif menu == "기사 분석하기":
                     st.write(f"텍스트 복잡성 점수: {complexity_score:.1f}/10")
                         
                     # 출현 빈도 막대 그래프
-                    st.subheader("품사별 분포")
-                    
-                    # 언어 감지 (간단하게 한글 포함 여부로 체크)
-                    is_korean = bool(re.search(r'[가-힣]', content))
-                    
+                    st.subheader("품사별 분포 (한국어/영어 지원)")
                     try:
-                        # KSS를 사용하여 간단한 품사 유사 분석
-                        tokens = tokenize_korean(content[:5000])  # 너무 긴 텍스트는 잘라서 분석
+                        # KoNLPy 설치 확인
+                        try:
+                            from konlpy.tag import Okt
+                            konlpy_installed = True
+                        except ImportError:
+                            konlpy_installed = False
+                            st.warning("한국어 형태소 분석을 위해 KoNLPy를 설치해주세요: pip install konlpy")
                         
-                        if is_korean:
-                            # 한국어인 경우 간단한 패턴 매칭으로 품사 추정
-                            pos_counts = {'명사/대명사': 0, '동사/형용사': 0, '부사/조사': 0, '기타': 0}
+                        # 영어 POS tagger 준비
+                        from nltk import pos_tag
+                        try:
+                            nltk.data.find('taggers/averaged_perceptron_tagger')
+                        except LookupError:
+                            nltk.download('averaged_perceptron_tagger')
+                        
+                        # Try using the correct resource name as shown in the error message
+                        try:
+                            nltk.data.find('averaged_perceptron_tagger_eng')
+                        except LookupError:
+                            nltk.download('averaged_perceptron_tagger_eng')
+                        
+                        # 언어 감지 (간단한 방식)
+                        is_korean = bool(re.search(r'[가-힣]', content))
+                        
+                        if is_korean and konlpy_installed:
+                            # 한국어 형태소 분석
+                            okt = Okt()
+                            tagged = okt.pos(content)
+                            
+                            # 한국어 품사 매핑
+                            pos_dict = {
+                                'Noun': '명사', 'NNG': '명사', 'NNP': '고유명사', 
+                                'Verb': '동사', 'VV': '동사', 'VA': '형용사',
+                                'Adjective': '형용사', 
+                                'Adverb': '부사',
+                                'Josa': '조사', 'Punctuation': '구두점',
+                                'Determiner': '관형사', 'Exclamation': '감탄사'
+                            }
                             
-                            for token in tokens:
-                                if token.endswith(("다", "요", "까", "죠", "네", "군", "니다", "세요")):
-                                    pos_counts['동사/형용사'] += 1
-                                elif token.endswith(("게", "히", "이", "지")):
-                                    pos_counts['부사/조사'] += 1
-                                elif token.endswith(("은", "는", "이", "가", "을", "를", "에", "의")):
-                                    pos_counts['부사/조사'] += 1
-                                elif len(token) > 1:
-                                    pos_counts['명사/대명사'] += 1
+                            pos_counts = {'명사': 0, '동사': 0, '형용사': 0, '부사': 0, '조사': 0, '구두점': 0, '관형사': 0, '감탄사': 0, '기타': 0}
+                            
+                            for _, pos in tagged:
+                                if pos in pos_dict:
+                                    pos_counts[pos_dict[pos]] += 1
+                                elif pos.startswith('N'):  # 기타 명사류
+                                    pos_counts['명사'] += 1
+                                elif pos.startswith('V'):  # 기타 동사류
+                                    pos_counts['동사'] += 1
                                 else:
                                     pos_counts['기타'] += 1
+                                    
                         else:
-                            # 영어 문서인 경우 간단한 패턴 매칭
-                            pos_counts = {
-                                '명사/대명사': len([t for t in tokens if not t.lower().endswith(('ly', 'ing', 'ed'))]),
-                                '동사': len([t for t in tokens if t.lower().endswith(('ing', 'ed', 's'))]),
-                                '부사/형용사': len([t for t in tokens if t.lower().endswith('ly')]),
-                                '기타': len([t for t in tokens if len(t) <= 2])
+                            # 영어 POS 태깅
+                            tokens = word_tokenize(content.lower())
+                            tagged = pos_tag(tokens)
+                            
+                            # 영어 품사 매핑
+                            pos_dict = {
+                                'NN': '명사', 'NNS': '명사', 'NNP': '고유명사', 'NNPS': '고유명사', 
+                                'VB': '동사', 'VBD': '동사', 'VBG': '동사', 'VBN': '동사', 'VBP': '동사', 'VBZ': '동사',
+                                'JJ': '형용사', 'JJR': '형용사', 'JJS': '형용사',
+                                'RB': '부사', 'RBR': '부사', 'RBS': '부사'
                             }
+                            
+                            pos_counts = {'명사': 0, '동사': 0, '형용사': 0, '부사': 0, '기타': 0}
+                            
+                            for _, pos in tagged:
+                                if pos in pos_dict:
+                                    pos_counts[pos_dict[pos]] += 1
+                                else:
+                                    pos_counts['기타'] += 1
                         
                         # 결과 시각화
                         pos_df = pd.DataFrame({
@@ -780,10 +750,14 @@ elif menu == "기사 분석하기":
                     if st.session_state.openai_api_key:
                         with st.spinner("기사의 감정을 분석 중입니다..."):
                             try:
-                                # API 키 설정
-                                openai.api_key = st.session_state.openai_api_key
-                                
-                                # API 호출
+                                # 감정 분석 API 호출 전에 키 확인 및 설정
+                                if not openai.api_key:
+                                     if st.session_state.openai_api_key:
+                                         openai.api_key = st.session_state.openai_api_key
+                                     else:
+                                         st.error("OpenAI API 키가 설정되지 않았습니다.")
+                                         st.stop()
+
                                 response = openai.chat.completions.create(
                                     model="gpt-4.1-mini",
                                     messages=[
@@ -855,7 +829,7 @@ elif menu == "기사 분석하기":
                                         fill_color = 'rgba(158, 158, 158, 0.3)' # 연한 회색
                                         line_color = 'rgba(158, 158, 158, 1)'   # 진한 회색
                                     
-                                    # 레이더 차트 데이터 준비 
+                                    # 레이더 차트 데이터 준비 - 마지막 점이 첫 점과 연결되도록 데이터 추가
                                     radar_keywords = keyword_names.copy()
                                     radar_scores = keyword_scores.copy()
                                     
@@ -967,8 +941,7 @@ elif menu == "새 기사 생성하기":
             with st.expander("원본 기사 내용"):
                 st.write(selected_article['content'])
             
-            prompt_text = st.text_area("생성 지침", 
-            """다음 기사 양식을 따라서 다시 작성해줘. 
+            prompt_text ="""다음 기사 양식을 따라서 다시 작성해줘. 
 역할: 당신은 신문사의 기자입니다.
 작업: 최근 일어난 사건에 대한 보도자료를 작성해야 합니다. 자료는 사실을 기반으로 하며, 객관적이고 정확해야 합니다.
 지침:
@@ -976,13 +949,14 @@ elif menu == "새 기사 생성하기":
 기사 제목은 주제를 명확히 반영하고 독자의 관심을 끌 수 있도록 작성합니다.
 기사 내용은 정확하고 간결하며 설득력 있는 문장으로 구성합니다.
 관련자의 인터뷰를 인용 형태로 넣어주세요.
-위의 정보와 지침을 참고하여 신문 보도자료 형식의 기사를 작성해 주세요""", height=200)
+위의 정보와 지침을 참고하여 신문 보도자료 형식의 기사를 작성해 주세요"""
             
             # 이미지 생성 여부 선택 옵션 추가
             generate_image_too = st.checkbox("기사 생성 후 이미지도 함께 생성하기", value=True)
             
             if st.button("새 기사 생성하기"):
                 if st.session_state.openai_api_key:
+                    # openai.api_key = st.session_state.openai_api_key # 이미 상단에서 설정됨 또는 각 함수 호출 시 설정
                     with st.spinner("기사를 생성 중입니다..."):
                         new_article = generate_article(selected_article['content'], prompt_text)
                         
@@ -1001,6 +975,13 @@ elif menu == "새 기사 생성하기":
                                 """
                                 
                                 # 이미지 생성
+                                # 이미지 생성 API 호출 전에 키 확인 및 설정
+                                if not openai.api_key:
+                                     if st.session_state.openai_api_key:
+                                         openai.api_key = st.session_state.openai_api_key
+                                     else:
+                                         st.error("OpenAI API 키가 설정되지 않았습니다.")
+                                         st.stop()
                                 image_url = generate_image(image_prompt)
                                 
                                 if image_url and not image_url.startswith("이미지 생성 오류") and not image_url.startswith("오류: OpenAI API 키가 설정되지 않았습니다."):
@@ -1176,7 +1157,7 @@ elif menu == "뉴스 기사 예약하기":
             files = [f for f in os.listdir(SCHEDULED_NEWS_DIR) if f.endswith('.json')]
             if files:
                 st.subheader("수집된 파일 열기")
-                selected_file = st.selectbox("파일 선택", files, index=len(files)-1 if files else 0)
+                selected_file = st.selectbox("파일 선택", files, index=len(files)-1 if files else 0) # files가 비어있을 경우 대비
                 if selected_file and st.button("파일 내용 보기"):
                     with open(os.path.join(SCHEDULED_NEWS_DIR, selected_file), 'r', encoding='utf-8') as f:
                         articles = json.load(f)
@@ -1194,4 +1175,4 @@ elif menu == "뉴스 기사 예약하기":
 
 # 푸터
 st.markdown("---")
-st.markdown("© 뉴스 기사 도구 @conanssam")
+st.markdown("© 뉴스 기사 도구 @conanssam")