Update src/streamlit_app.py

src/streamlit_app.py

@@ -4,33 +4,100 @@ 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")
+NLTK_DATA_DIR = os.path.join(DATA_DIR, "nltk_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(NLTK_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")
+# NLTK 설정 - 권한 문제 해결을 위해 사용자 지정 디렉토리 사용
+import nltk
+nltk.data.path.append(NLTK_DATA_DIR)
+
+# 필요한 NLTK 데이터 다운로드 (권한 문제 해결)
+try:
+    # 사용자 지정 디렉토리에 데이터 다운로드
+    try:
+        nltk.data.find('tokenizers/punkt')
+    except LookupError:
+        nltk.download('punkt', download_dir=NLTK_DATA_DIR)
+        
+    try:
+        nltk.data.find('corpora/stopwords')
+    except LookupError:
+        nltk.download('stopwords', download_dir=NLTK_DATA_DIR)
+except Exception as e:
+    st.warning(f"NLTK 데이터 다운로드 중 오류 발생: {str(e)}. 기본 토크나이징 방식을 사용합니다.")
+
+# 한국어 토크나이징을 위한 대체 함수 (KoNLPy 대신 사용)
+def tokenize_korean(text):
+    try:
+        # 1. 먼저 transformers 라이브러리가 설치되어 있는지 확인
+        try:
+            from transformers import AutoTokenizer
+            tokenizer = AutoTokenizer.from_pretrained("klue/bert-base")
+            return tokenizer.tokenize(text)
+        except (ImportError, Exception) as e:
+            st.debug(f"Transformers 토크나이저 로드 실패: {str(e)}")
+            
+        # 2. soynlp 시도
+        try:
+            from soynlp.tokenizer import LTokenizer
+            tokenizer = LTokenizer()
+            return tokenizer.tokenize(text)
+        except (ImportError, Exception) as e:
+            st.debug(f"soynlp 토크나이저 로드 실패: {str(e)}")
+            
+        # 3. kss 시도
+        try:
+            import kss
+            tokens = []
+            for sentence in kss.split_sentences(text):
+                tokens.extend(sentence.split())
+            return tokens
+        except (ImportError, Exception) as e:
+            st.debug(f"kss 토크나이저 로드 실패: {str(e)}")
+    except Exception as e:
+        st.debug(f"한국어 토크나이징 실패: {str(e)}")
+    
+    # 4. 기본 정규식 기반 토크나이저 - 모든 방법이 실패했을 때 폴백
+    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:
-    st.error("wordcloud 패키지를 설치해주세요: pip install wordcloud")
-    WordCloud = None
-
+    wordcloud_available = False
+    
 # 스케줄러 상태 클래스 추가
 class SchedulerState:
     def __init__(self):
@@ -61,31 +128,6 @@ 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")
 
@@ -96,21 +138,17 @@ menu = st.sidebar.radio(
     ["뉴스 기사 크롤링", "기사 분석하기", "새 기사 생성하기", "뉴스 기사 예약하기"]
 )
 
-# 디렉토리 생성 함수
-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
-
+# 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 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)
@@ -122,15 +160,12 @@ 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)
-        # 파일 권한 설정
-        os.chmod(SAVED_ARTICLES_PATH, 0o666)
+        return True
     except Exception as e:
         st.error(f"기사 저장 중 오류 발생: {str(e)}")
         return False
-    return True
 
 @st.cache_data
 def crawl_naver_news(keyword, num_articles=5):
@@ -217,47 +252,89 @@ def get_article_content(url):
     except Exception as e:
         return f"오류 발생: {str(e)}"
 
-# NLTK를 이용한 키워드 분석
+# NLTK를 이용한 키워드 분석 (한국어 대응 추가)
 def analyze_keywords(text, top_n=10):
-    # 한국어 불용어 목록 (직접 정의해야 합니다)
-    korean_stopwords = ['이', '그', '저', '것', '및', '등', '를', '을', '에', '에서', '의', '으로', '로']
+    # 한국어 불용어 목록
+    korean_stopwords = [
+        '이', '그', '저', '것', '및', '등', '를', '을', '에', '에서', '의', '으로', '로',
+        '에게', '뿐', '다', '는', '가', '이다', '에게서', '께', '께서', '부터', '까지'
+    ]
+    
+    # 언어 감지 (간단하게 한글 포함 여부로 체크)
+    is_korean = bool(re.search(r'[가-힣]', text))
+    
+    if is_korean:
+        # 한국어 텍스트인 경우 한국어 토크나이저 사용
+        tokens = tokenize_korean(text)
+    else:
+        # 한글이 없는 경우 NLTK 토크나이저 사용
+        try:
+            from nltk.tokenize import word_tokenize
+            tokens = word_tokenize(text)
+        except Exception:
+            # NLTK가 실패하면 간단한 토크나이저로 대체
+            tokens = re.findall(r'\b\w+\b', text.lower())
     
-    tokens = word_tokenize(text)
-    tokens = [word for word in tokens if word.isalnum() and len(word) > 1 and word not in korean_stopwords]
+    # 불용어 필터링
+    tokens = [word for word in tokens if len(word) > 1 and word.lower() not in korean_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:
-        try:
-            tokens = word_tokenize(text.lower())
-        except Exception as e:
-            st.warning(f"{str(e)} 오류발생")
-            tokens = text.lower().split()
+        # 언어 감지 (간단하게 한글 포함 여부로 체크)
+        is_korean = bool(re.search(r'[가-힣]', text))
         
+        if is_korean:
+            # 한국어 텍스트인 경우 한국어 토크나이저 사용
+            tokens = tokenize_korean(text.lower())
+        else:
+            # 영어 또는 기타 언어는 NLTK 사용 시도 
+            try:
+                from nltk.tokenize import word_tokenize
+                tokens = word_tokenize(text.lower())
+            except Exception:
+                # 실패하면 간단한 토크나이징
+                tokens = text.lower().split()
+        
+        # 불용어 설정
         stop_words = set()
+        
+        # 영어 불용어 (NLTK 있으면 사용)
         try:
+            from nltk.corpus import stopwords
             stop_words = set(stopwords.words('english'))
         except Exception:
-            pass
+            # 기본 영어 불용���
+            stop_words = {
+                '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'
+            }
 
+        # 한국어 불용어
         korea_stop_words = {
             '및', '등', '를', '이', '의', '가', '에', '는', '으로', '에서', '그', '또', '또는', '하는', '할', '하고',
-                '있다', '이다', '위해', '것이다', '것은', '대한', '때문', '그리고', '하지만', '그러나', '그래서',
-                '입니다', '합니다', '습니다', '요', '죠', '고', '과', '와', '도', '은', '수', '것', '들', '제', '저',
-                '년', '월', '일', '시', '분', '초', '지난', '올해', '내년', '최근', '현재', '오늘', '내일', '어제',
-                '오전', '오후', '부터', '까지', '에게', '께서', '이라고', '라고', '하며', '하면서', '따라', '통해',
-                '관련', '한편', '특히', '가장', '매우', '더', '덜', '많이', '조금', '항상', '자주', '가끔', '거의',
-                '전혀', '바로', '정말', '만약', '비롯한', '등을', '등이', '등의', '등과', '등도', '등에', '등에서',
-                '기자', '뉴스', '사진', '연합뉴스', '뉴시스', '제공', '무단', '전재', '재배포', '금지', '앵커', '멘트',
-                '일보', '데일리', '경제', '사회', '정치', '세계', '과학', '아이티', '닷컴', '씨넷', '블로터', '전자신문'
+            '있다', '이다', '위해', '것이다', '것은', '대한', '때문', '그리고', '하지만', '그러나', '그래서',
+            '입니다', '합니다', '습니다', '요', '죠', '고', '과', '와', '도', '은', '수', '것', '들', '제', '저',
+            '년', '월', '일', '시', '분', '초', '지난', '올해', '내년', '최근', '현재', '오늘', '내일', '어제',
+            '오전', '오후', '부터', '까지', '에게', '께서', '이라고', '라고', '하며', '하면서', '따라', '통해',
+            '관련', '한편', '특히', '가장', '매우', '더', '덜', '많이', '조금', '항상', '자주', '가끔', '거의',
+            '전혀', '바로', '정말', '만약', '비롯한', '등을', '등이', '등의', '등과', '등도', '등에', '등에서',
+            '기자', '뉴스', '사진', '연합뉴스', '뉴시스', '제공', '무단', '전재', '재배포', '금지', '앵커', '멘트',
+            '일보', '데일리', '경제', '사회', '정치', '세계', '과학', '아이티', '닷컴', '씨넷', '블로터', '전자신문'
         }
         stop_words.update(korea_stop_words)
 
@@ -279,51 +356,45 @@ 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:
-            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)
+    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)
             
-            return wc
+        return wc
         
-        except Exception as e:
-            st.error(f"워드클라우드 생성 중 오류 발생: {str(e)}")
-            # traceback.print_exc() # 디버깅 시 사용
-            st.warning("워드클라우드 생성에 실패했습니다. 폰트 문제일 수 있습니다. NanumGothic.ttf 파일이 프로젝트 루트에 있는지 확인해주세요.")
-            return None
+    except Exception as e:
+        st.error(f"워드클라우드 생성 중 오류 발생: {str(e)}")
+        return None
 
 # 뉴스 분석 함수
 def analyze_news_content(news_df):
@@ -331,32 +402,37 @@ 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]}"}
@@ -371,13 +447,17 @@ 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)}"
@@ -409,18 +489,12 @@ 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
@@ -542,8 +616,9 @@ if menu == "뉴스 기사 크롤링":
             articles = crawl_naver_news(keyword, num_articles)
             
             # 기사 내용 가져오기
+            progress_bar = st.progress(0)
             for i, article in enumerate(articles):
-                st.progress((i + 1) / len(articles))
+                progress_bar.progress((i + 1) / len(articles))
                 article['content'] = get_article_content(article['link'])
                 time.sleep(0.5)  # 서버 부하 방지
             
@@ -559,7 +634,7 @@ if menu == "뉴스 기사 크롤링":
                     st.write(f"**요약:** {article['description']}")
                     st.write(f"**링크:** {article['link']}")
                     st.write("**본문 미리보기:**")
-                    st.write(article['content'][:300] + "...")
+                    st.write(article['content'][:300] + "..." if len(article['content']) > 300 else article['content'])
 
 elif menu == "기사 분석하기":
     st.header("기사 분석하기")
@@ -594,7 +669,6 @@ elif menu == "기사 분석하기":
                         keyword_tab1, keyword_tab2 = st.tabs(["키워드 빈도", "워드클라우드"])
 
                         with keyword_tab1:
-
                             keywords = analyze_keywords(selected_article['content'])
                             
                             # 시각화
@@ -604,23 +678,38 @@ 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 wc:
-                                fig, ax = plt.subplots(figsize=(10, 5))
-                                ax.imshow(wc, interpolation='bilinear')
-                                ax.axis('off')
-                                st.pyplot(fig)
+                            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)
+                                    
+                                    # 키워드 상위 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("워드클라우드 기능을 사용할 수 없습니다. 필요한 패키지가 설치되지 않았습니다.")
                                 
-                                # 키워드 상위 20개 표시
-                                st.write("**상위 20개 키워드:**")
-                                top_keywords = sorted(keyword_dict.items(), key=lambda x: x[1], reverse=True)[:20]
+                                # 대신 키워드만 표시
+                                st.write("**상위 키워드:**")
+                                top_keywords = sorted(keyword_dict.items(), key=lambda x: x[1], reverse=True)[:30]
                                 keyword_df = pd.DataFrame(top_keywords, columns=['키워드', '빈도'])
                                 st.dataframe(keyword_df)
-                            else:
-                                st.error("워드클라우드를 생성할 수 없습니다.")
+                                
+                                # 막대 차트로 표시
+                                st.bar_chart(keyword_df.set_index('키워드').head(15))
 
             elif analysis_type == "텍스트 통계":
                 if st.button("텍스트 통계 분석"):
@@ -655,79 +744,87 @@ elif menu == "기사 분석하기":
                     st.write(f"텍스트 복잡성 점수: {complexity_score:.1f}/10")
                         
                     # 출현 빈도 막대 그래프
-                    st.subheader("품사별 분포 (한국어/영어 지원)")
+                    st.subheader("품사별 분포")
+                    
+                    # 언어 감지 (간단하게 한글 포함 여부로 체크)
+                    is_korean = bool(re.search(r'[가-힣]', content))
+                    
                     try:
-                        # KoNLPy 설치 확인
-                        try:
-                            from konlpy.tag import Okt
-                            konlpy_installed = True
-                        except ImportError:
-                            konlpy_installed = False
-                            st.warning("한국어 형태소 분석을 위해 KoNLPy를 설치해주세요: pip install konlpy")
-                        
-                        # 영어 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': '감탄사'
-                            }
-                            
-                            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
+                        # 영어/한국어 토큰화 및 품사 분석
+                        if is_korean:
+                            # 한국어인 경우 (간단한 형태소 유사 분석)
+                            try:
+                                # transformers 토크나이저 시도
+                                try:
+                                    from transformers import AutoTokenizer
+                                    tokenizer = AutoTokenizer.from_pretrained("klue/bert-base")
+                                    tokens = tokenizer.tokenize(content[:5000])  # 너무 긴 텍스트는 잘라서 분석
+                                    
+                                    # 간단한 패턴 매칭으로 품사 추정
+                                    pos_counts = {'명사': 0, '동사': 0, '형용사': 0, '부사': 0, '기타': 0}
                                     
+                                    for token in tokens:
+                                        if token.endswith("다") or token.endswith("요"):
+                                            pos_counts['동사'] += 1
+                                        elif token.endswith("게") or token.endswith("히"):
+                                            pos_counts['부사'] += 1
+                                        elif token.endswith("은") or token.endswith("는") or token.endswith("이") or token.endswith("가"):
+                                            pos_counts['명사'] += 1
+                                        else:
+                                            if len(token) > 1:
+                                                pos_counts['명사'] += 1
+                                            else:
+                                                pos_counts['기타'] += 1
+                                                
+                                except Exception:
+                                    # 실패하면 간단한 토큰화로 대체
+                                    tokens = tokenize_korean(content[:5000])
+                                    pos_counts = {
+                                        '명사류': len([t for t in tokens if len(t) > 1 and not any(t.endswith(s) for s in ["다", "요", "게", "히", "은", "는"])]),
+                                        '기타': len([t for t in tokens if len(t) <= 1 or any(t.endswith(s) for s in ["다", "요", "게", "히", "은", "는"])])
+                                    }
+                            except Exception as e:
+                                st.error(f"한국어 품사 분석 실패: {str(e)}")
+                                pos_counts = {'데이터': len(content) // 10, '분석': len(content) // 15, '오류': len(content) // 20}
                         else:
-                            # 영어 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
+                            # 영어 문서인 경우 (NLTK 시도)
+                            try:
+                                from nltk import pos_tag
+                                from nltk.tokenize import word_tokenize
+                                
+                                # 필요한 데이터 다운로드
+                                try:
+                                    nltk.download('averaged_perceptron_tagger', download_dir=NLTK_DATA_DIR)
+                                except Exception:
+                                    pass
+                                
+                                tokens = word_tokenize(content[:5000])
+                                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
+                            except Exception:
+                                # 실패하면 간단한 규칙으로 품사 유추
+                                tokens = re.findall(r'\b\w+\b', content.lower())
+                                pos_counts = {
+                                    '명사': len([t for t in tokens if not t.endswith(('ly', 'ing', 'ed'))]),
+                                    '동사': len([t for t in tokens if t.endswith(('ing', 'ed', 's'))]),
+                                    '부사': len([t for t in tokens if t.endswith('ly')]),
+                                    '기타': len([t for t in tokens if len(t) <= 2])
+                                }
                         
                         # 결과 시각화
                         pos_df = pd.DataFrame({
@@ -750,14 +847,10 @@ elif menu == "기사 분석하기":
                     if st.session_state.openai_api_key:
                         with st.spinner("기사의 감정을 분석 중입니다..."):
                             try:
-                                # 감정 분석 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()
-
+                                # API 키 설정
+                                openai.api_key = st.session_state.openai_api_key
+                                
+                                # API 호출
                                 response = openai.chat.completions.create(
                                     model="gpt-4.1-mini",
                                     messages=[
@@ -829,7 +922,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()
                                     
@@ -941,7 +1034,8 @@ elif menu == "새 기사 생성하기":
             with st.expander("원본 기사 내용"):
                 st.write(selected_article['content'])
             
-            prompt_text ="""다음 기사 양식을 따라서 다시 작성해줘. 
+            prompt_text = st.text_area("생성 지침", 
+            """다음 기사 양식을 따라서 다시 작성해줘. 
 역할: 당신은 신문사의 기자입니다.
 작업: 최근 일어난 사건에 대한 보도자료를 작성해야 합니다. 자료는 사실을 기반으로 하며, 객관적이고 정확해야 합니다.
 지침:
@@ -949,14 +1043,13 @@ 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)
                         
@@ -975,13 +1068,6 @@ 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 키가 설정되지 않았습니다."):
@@ -1157,7 +1243,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) # files가 비어있을 경우 대비
+                selected_file = st.selectbox("파일 선택", files, index=len(files)-1 if files else 0)
                 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)
@@ -1175,4 +1261,4 @@ elif menu == "뉴스 기사 예약하기":
 
 # 푸터
 st.markdown("---")
-st.markdown("© 뉴스 기사 도구 @conanssam")
+st.markdown("© 뉴스 기사 도구 @conanssam")