Update src/streamlit_app.py

src/streamlit_app.py

@@ -11,38 +11,14 @@ from collections import Counter
 import json
 import os
 from datetime import datetime, timedelta
-import openai
+import openai  # 구 버전 방식 사용
 from dotenv import load_dotenv
 import traceback
 import plotly.graph_objects as go
 import schedule
 import threading
 import matplotlib.pyplot as plt
-
-# /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 데이터 경로 설정 (현재 디렉토리)
-NLTK_DATA_DIR = "nltk_data"
-
-# NLTK 데이터 경로 추가
-nltk.data.path.insert(0, NLTK_DATA_DIR)
-
-# 필요한 NLTK 데이터 확인
-required_nltk_data = {
-    'punkt': 'tokenizers/punkt',
-    'stopwords': 'corpora/stopwords'
-}
-
-for data_name, data_path in required_nltk_data.items():
-    try:
-        nltk.data.find(data_path)
-    except LookupError:
-        st.error(f"NLTK 데이터 '{data_name}'가 필요합니다. 다음 명령어로 다운로드하세요:")
-        st.code(f"python -c \"import nltk; nltk.download('{data_name}', download_dir='nltk_data')\"")
-        st.stop()
+import kss  # KoNLPy 대신 KSS 사용
 
 # 워드클라우드 추가
 try:
@@ -68,73 +44,68 @@ global_scheduler_state = SchedulerState()
 if 'openai_api_key' not in st.session_state:
     st.session_state.openai_api_key = None
 
-# API 키 로드 (허깅페이스 환경변수 우선, 다음으로 Streamlit secrets, 그 다음 .env 파일)
-if st.session_state.openai_api_key is None:
-    st.session_state.openai_api_key = os.getenv('OPENAI_API_KEY')  # Hugging Face
-    if st.session_state.openai_api_key is None:
-        try:
-            if 'OPENAI_API_KEY' in st.secrets: # Streamlit Cloud
-                st.session_state.openai_api_key = st.secrets['OPENAI_API_KEY']
-        except Exception: # st.secrets가 존재하지 않는 환경 (로컬 등)
-            pass
-    if st.session_state.openai_api_key is None:
-        load_dotenv() # 로컬 .env 파일
-        st.session_state.openai_api_key = os.getenv('OPENAI_API_KEY')
+# 여러 방법으로 API 키 로드 시도
+load_dotenv()  # .env 파일에서 로드 시도
 
-# OpenAI API 키 설정
-# openai.api_key 설정은 각 API 호출 직전에 st.session_state.openai_api_key 사용하도록 변경하거나,
-# 앱 시작 시점에 한 번 설정합니다. 여기서는 후자를 선택합니다.
-if st.session_state.openai_api_key:
+# 1. 환경 변수에서 API 키 확인
+if os.environ.get('OPENAI_API_KEY'):
+    st.session_state.openai_api_key = os.environ.get('OPENAI_API_KEY')
     openai.api_key = st.session_state.openai_api_key
-else:
-    # UI 초기에는 키가 없을 수 있으므로, 나중에 키 입력 시 openai.api_key가 설정되도록 유도
-    pass
+
+# 2. Streamlit secrets에서 API 키 확인 (try-except로 오류 방지)
+if not st.session_state.openai_api_key:
+    try:
+        if 'OPENAI_API_KEY' in st.secrets:
+            st.session_state.openai_api_key = st.secrets['OPENAI_API_KEY']
+            openai.api_key = st.session_state.openai_api_key
+    except Exception as e:
+        pass  # secrets 파일이 없어도 오류 발생하지 않음
+
+# NLTK 데이터 경로 설정 - 현재 워크스페이스의 nltk_data 사용
+nltk_data_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'nltk_data')
+nltk.data.path.insert(0, nltk_data_path)
+
+# 필요한 NLTK 데이터 확인
+try:
+    nltk.data.find('tokenizers/punkt')
+except LookupError:
+    nltk.download('punkt', download_dir=nltk_data_path)
+    
+try:
+    nltk.data.find('corpora/stopwords')
+except LookupError:
+    nltk.download('stopwords', download_dir=nltk_data_path)
 
 # 페이지 설정
 st.set_page_config(page_title="뉴스 기사 도구", page_icon="📰", layout="wide")
 
-# 사이드바 메뉴 설정
-st.sidebar.title("뉴스 기사 도구")
-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
+# 사이드바에 API 키 입력 필드 추가
+with st.sidebar:
+    st.title("뉴스 기사 도구")
+    menu = st.radio(
+        "메뉴 선택",
+        ["뉴스 기사 크롤링", "기사 분석하기", "새 기사 생성하기", "뉴스 기사 예약하기"]
+    )
+    
+    st.divider()
+    api_key = st.text_input("OpenAI API 키 입력", type="password")
+    if api_key:
+        st.session_state.openai_api_key = api_key
+        openai.api_key = api_key
+        st.success("API 키가 설정되었습니다!")
 
 # 저장된 기사를 불러오는 함수
 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)
-    except Exception as e:
-        st.error(f"기사 로드 중 오류 발생: {str(e)}")
-        return []
+    if os.path.exists('/tmp/saved_articles/articles.json'):
+        with open('/tmp/saved_articles/articles.json', 'r', encoding='utf-8') as f:
+            return json.load(f)
     return []
 
 # 기사를 저장하는 함수
 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)
-    except Exception as e:
-        st.error(f"기사 저장 중 오류 발생: {str(e)}")
-        return False
-    return True
+    os.makedirs('/tmp/saved_articles', exist_ok=True)
+    with open('/tmp/saved_articles/articles.json', 'w', encoding='utf-8') as f:
+        json.dump(articles, f, ensure_ascii=False, indent=2)
 
 @st.cache_data
 def crawl_naver_news(keyword, num_articles=5):
@@ -221,12 +192,22 @@ def get_article_content(url):
     except Exception as e:
         return f"오류 발생: {str(e)}"
 
-# NLTK를 이용한 키워드 분석
+# NLTK를 이용한 키워드 분석 (KSS 활용)
 def analyze_keywords(text, top_n=10):
-    # 한국어 불용어 목록 (직접 정의해야 합니다)
+    # 한국어 불용어 목록
     korean_stopwords = ['이', '그', '저', '것', '및', '등', '를', '을', '에', '에서', '의', '으로', '로']
     
-    tokens = word_tokenize(text)
+    # KSS를 사용한 문장 분리 및 토큰화
+    try:
+        sentences = kss.split_sentences(text)
+        tokens = []
+        for sentence in sentences:
+            # 간단한 토큰화 (공백 기준)
+            tokens.extend(sentence.split())
+    except:
+        # KSS 실패시 기본 토큰화
+        tokens = text.split()
+    
     tokens = [word for word in tokens if word.isalnum() and len(word) > 1 and word not in korean_stopwords]
     
     word_count = Counter(tokens)
@@ -288,45 +269,46 @@ def extract_keywords_for_wordcloud(text, top_n=50):
     
 
 # 워드 클라우드 생성 함수
-
 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)
+            wc= WordCloud(
+                width=800,
+                height=400,
+                background_color = 'white',
+                colormap = 'viridis',
+                max_font_size=150,
+                random_state=42
+            ).generate_from_frequencies(keywords_dict)
+
+            try:
+                possible_font_paths=["NanumGothic.ttf", "이름"]
+
+                font_path = None
+                for path in possible_font_paths:
+                    if os.path.exists(path):
+                        font_path = path
+                        break
+
+                if font_path:
+                    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)
+            except Exception as e:
+                print(f"오류발생 {str(e)}")
             
             return wc
         
         except Exception as e:
-            st.error(f"워드클라우드 생성 중 오류 발생: {str(e)}")
-            # traceback.print_exc() # 디버깅 시 사용
-            st.warning("워드클라우드 생성에 실패했습니다. 폰트 문제일 수 있습니다. NanumGothic.ttf 파일이 프로젝트 루트에 있는지 확인해주세요.")
+            st.error(f"오류발생 {str(e)}")
             return None
 
 # 뉴스 분석 함수
@@ -353,13 +335,13 @@ def analyze_news_content(news_df):
         results['top_keywords'] = []
     return results
 
-# OpenAI API를 이용한 새 기사 생성
+# 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:
-        response = openai.chat.completions.create(
+        if not st.session_state.openai_api_key:
+            return "OpenAI API 키가 설정되지 않았습니다."
+            
+        response = openai.ChatCompletion.create(
             model="gpt-4.1-mini",
             messages=[
                 {"role": "system", "content": "당신은 전문적인 뉴스 기자입니다. 주어진 내용을 바탕으로 새로운 기사를 작성해주세요."},
@@ -367,22 +349,22 @@ def generate_article(original_content, prompt_text):
             ],
             max_tokens=2000
         )
-        return response.choices[0].message.content
+        return response.choices[0].message['content']
     except Exception as e:
         return f"기사 생성 오류: {str(e)}"
 
-# OpenAI API를 이용한 이미지 생성
+# OpenAI API를 이용한 이미지 생성 (구 버전 방식)
 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:
-        response = openai.images.generate(
-            model="gpt-image-1",
-            prompt=prompt
+        if not st.session_state.openai_api_key:
+            return "OpenAI API 키가 설정되지 않았습니다."
+            
+        response = openai.Image.create(
+            prompt=prompt,
+            n=1,
+            size="1024x1024"
         )
-        image_base64=response.data[0].b64_json
-        return f"data:image/png;base64,{image_base64}"
+        return response['data'][0]['url']
     except Exception as e:
         return f"이미지 생성 오류: {str(e)}"
 
@@ -413,21 +395,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
-            
+        os.makedirs('/tmp/scheduled_news', exist_ok=True)
         timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-        filename = os.path.join(SCHEDULED_NEWS_DIR, f"{file_prefix}_{task_type}_{timestamp}.json")
+        filename = f"/tmp/scheduled_news/{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
+        with open(filename, 'w', encoding='utf-8') as f:
+            json.dump(articles, f, ensure_ascii=False, indent=2)
         
         global_scheduler_state.last_run = datetime.now()
         print(f"{datetime.now()} - {task_type} 뉴스 기사 수집 완료: {keyword}")
@@ -563,7 +536,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("기사 분석하기")
@@ -598,7 +571,6 @@ elif menu == "기사 분석하기":
                         keyword_tab1, keyword_tab2 = st.tabs(["키워드 빈도", "워드클라우드"])
 
                         with keyword_tab1:
-
                             keywords = analyze_keywords(selected_article['content'])
                             
                             # 시각화
@@ -633,7 +605,14 @@ elif menu == "기사 분석하기":
                     # 텍스트 통계 계산
                     word_count = len(re.findall(r'\b\w+\b', content))
                     char_count = len(content)
-                    sentence_count = len(re.split(r'[.!?]+', content))
+                    try:
+                        # KSS로 문장 분리
+                        sentences = kss.split_sentences(content)
+                        sentence_count = len(sentences)
+                    except:
+                        # KSS 실패시 기본 문장 분리
+                        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
                     
@@ -653,127 +632,31 @@ elif menu == "기사 분석하기":
                     with col2:
                         st.metric("평균 문장 길이", f"{avg_sentence_length:.1f}단어")
                     
-                    # 텍스트 복잡성 점수 (간단한 예시)
+                    # 텍스트 복잡성 점수
                     complexity_score = min(10, (avg_sentence_length / 10) * 5 + (avg_word_length / 5) * 5)
                     st.progress(complexity_score / 10)
                     st.write(f"텍스트 복잡성 점수: {complexity_score:.1f}/10")
-                        
-                    # 출현 빈도 막대 그래프
-                    st.subheader("품사별 분포 (한국어/영어 지원)")
-                    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
-                                    
-                        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
-                        
-                        # 결과 시각화
-                        pos_df = pd.DataFrame({
-                            '품사': list(pos_counts.keys()),
-                            '빈도': list(pos_counts.values())
-                        })
-                        
-                        st.bar_chart(pos_df.set_index('품사'))
-                        
-                        if is_korean:
-                            st.info("한국어 텍스트가 감지되었습니다.")
-                        else:
-                            st.info("영어 텍스트가 감지되었습니다.")
-                    except Exception as e:
-                        st.error(f"품사 분석 중 오류 발생: {str(e)}")
-                        st.error(traceback.format_exc())
+                    
+                    # 품사 분석 부분 제거 (KoNLPy 의존성 제거)
+                    st.info("상세 품사 분석은 현재 지원되지 않습니다.")
 
             elif analysis_type == "감정 분석":
                 if st.button("감정 분석하기"):
                     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()
-
-                                response = openai.chat.completions.create(
+                                # 감정 분석 프롬프트 설정 (구 버전 방식)
+                                response = openai.ChatCompletion.create(
                                     model="gpt-4.1-mini",
                                     messages=[
                                         {"role": "system", "content": "당신은 텍스트의 감정과 논조를 분석하는 전문가입니다. 다음 뉴스 기사의 감정과 논조를 분석하고, '긍정적', '부정적', '중립적' 중 하나로 분류해 주세요. 또한 기사에서 드러나는 핵심 감정 키워드를 5개 추출하고, 각 키워드별로 1-10 사이의 강도 점수를 매겨주세요. JSON 형식으로 다음과 같이 응답해주세요: {'sentiment': '긍정적/부정적/중립적', 'reason': '이유 설명...', 'keywords': [{'word': '키워드1', 'score': 8}, {'word': '키워드2', 'score': 7}, ...]}"},
                                         {"role": "user", "content": f"다음 뉴스 기사를 분석해 주세요:\n\n제목: {selected_article['title']}\n\n내용: {selected_article['content'][:1500]}"}
                                     ],
-                                    max_tokens=800,
-                                    response_format={"type": "json_object"}
+                                    max_tokens=800
                                 )
                                 
-                                # JSON 파싱
-                                analysis_result = json.loads(response.choices[0].message.content)
+                                # JSON 파싱 (구 버전 방식)
+                                analysis_result = json.loads(response.choices[0].message['content'])
                                 
                                 # 결과 시각화
                                 st.subheader("감정 분석 결과")
@@ -960,7 +843,6 @@ elif menu == "새 기사 생성하기":
             
             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)
                         
@@ -979,16 +861,9 @@ 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 키가 설정되지 않았습니다."):
+                                if image_url and not image_url.startswith("이미지 생성 오류"):
                                     st.subheader("생성된 이미지:")
                                     st.image(image_url)
                                 else:
@@ -1010,6 +885,8 @@ elif menu == "새 기사 생성하기":
                 else:
                     st.warning("OpenAI API 키를 사이드바에서 설정해주세요.")
 
+
+
 elif menu == "뉴스 기사 예약하기":
     st.header("뉴스 기사 예약하기")
     
@@ -1157,13 +1034,13 @@ elif menu == "뉴스 기사 예약하기":
                 )
         
         # 수집된 파일 보기
-        if os.path.exists(SCHEDULED_NEWS_DIR):
-            files = [f for f in os.listdir(SCHEDULED_NEWS_DIR) if f.endswith('.json')]
+        if os.path.exists('/tmp/scheduled_news'):
+            files = [f for f in os.listdir('/tmp/scheduled_news') 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 selected_file and st.button("파일 내용 보기"):
-                    with open(os.path.join(SCHEDULED_NEWS_DIR, selected_file), 'r', encoding='utf-8') as f:
+                    with open(os.path.join('/tmp/scheduled_news', selected_file), 'r', encoding='utf-8') as f:
                         articles = json.load(f)
                     
                     st.write(f"**파일명:** {selected_file}")
@@ -1179,4 +1056,4 @@ elif menu == "뉴스 기사 예약하기":
 
 # 푸터
 st.markdown("---")
-st.markdown("© 뉴스 기사 도구 @conanssam")
+st.markdown("© 뉴스 기사 도구 @conanssam")