Update src/streamlit_app.py

script_dir = os.path.dirname(os.path.abspath(__file__))
candidate = os.path.join(script_dir, fname)

src/streamlit_app.py

@@ -11,13 +11,28 @@ from collections import Counter
 import json
 import os
 from datetime import datetime, timedelta
-import openai  # 구 버전 방식 사용
+from openai import OpenAI  # 새로운 import 방식
 from dotenv import load_dotenv
 import traceback
 import plotly.graph_objects as go
 import schedule
 import threading
 import matplotlib.pyplot as plt
+import kss  # KoNLPy 대신 KSS 사용
+from PIL import Image
+import base64
+from io import BytesIO
+import logging
+
+# 로깅 설정
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.StreamHandler(),
+        logging.FileHandler('/tmp/crawler.log')
+    ]
+)
 
 # 워드클라우드 추가
 try:
@@ -40,41 +55,52 @@ class SchedulerState:
 global_scheduler_state = SchedulerState()
 
 # API 키 관리를 위한 세션 상태 초기화
-if 'openai_api_key' not in st.session_state:
-    st.session_state.openai_api_key = None
+if 'openai_client' not in st.session_state:
+    st.session_state.openai_client = None
 
 # 여러 방법으로 API 키 로드 시도
 load_dotenv()  # .env 파일에서 로드 시도
 
+# OpenAI 클라이언트 초기화를 위한 함수
+def init_openai_client(api_key=None):
+    try:
+        if api_key:
+            client = OpenAI(api_key=api_key)
+            # 간단한 API 키 유효성 검사
+            client.models.list()  # API 키가 유효한지 테스트
+            return client
+        return None
+    except Exception as e:
+        st.error(f"API 키 초기화 오류: {str(e)}")
+        return None
+
 # 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
+api_key = os.environ.get('OPENAI_API_KEY')
+if api_key:
+    st.session_state.openai_client = init_openai_client(api_key)
 
-# 2. Streamlit secrets에서 API 키 확인 (try-except로 오류 방지)
-if not st.session_state.openai_api_key:
+# 2. Streamlit secrets에서 API 키 확인
+if not st.session_state.openai_client:
     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
+            st.session_state.openai_client = init_openai_client(st.secrets['OPENAI_API_KEY'])
     except Exception as e:
         pass  # secrets 파일이 없어도 오류 발생하지 않음
 
-# 임시 디렉토리를 사용하도록 NLTK 데이터 경로 설정
-nltk_data_dir = '/tmp/nltk_data'
-os.makedirs(nltk_data_dir, exist_ok=True)
-nltk.data.path.insert(0, nltk_data_dir)  # 이 경로를 우선 검색하도록 설정
+# 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 데이터 다운로드
+# 필요한 NLTK 데이터 확인
 try:
     nltk.data.find('tokenizers/punkt')
 except LookupError:
-    nltk.download('punkt', download_dir=nltk_data_dir)
+    nltk.download('punkt', download_dir=nltk_data_path)
     
 try:
     nltk.data.find('corpora/stopwords')
 except LookupError:
-    nltk.download('stopwords', download_dir=nltk_data_dir)
+    nltk.download('stopwords', download_dir=nltk_data_path)
 
 # 페이지 설정
 st.set_page_config(page_title="뉴스 기사 도구", page_icon="📰", layout="wide")
@@ -90,9 +116,12 @@ with st.sidebar:
     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 키가 설정되었습니다!")
+        client = init_openai_client(api_key)
+        if client:
+            st.session_state.openai_client = client
+            st.success("API 키가 성공적으로 설정되었습니다!")
+        else:
+            st.error("유효하지 않은 API 키입니다.")
 
 # 저장된 기사를 불러오는 함수
 def load_saved_articles():
@@ -112,16 +141,21 @@ def crawl_naver_news(keyword, num_articles=5):
     """
     네이버 뉴스 기사를 수집하는 함수
     """
+    logging.info(f"크롤링 시작: 키워드={keyword}, 기사 수={num_articles}")
     url = f"https://search.naver.com/search.naver?where=news&query={keyword}"
     results = []
     
     try:
         # 페이지 요청
+        logging.info(f"요청 URL: {url}")
         response = requests.get(url)
+        logging.info(f"응답 상태 코드: {response.status_code}")
+        
         soup = BeautifulSoup(response.text, 'html.parser')
         
         # 뉴스 아이템 찾기
         news_items = soup.select('div.sds-comps-base-layout.sds-comps-full-layout')
+        logging.info(f"찾은 뉴스 아이템 수: {len(news_items)}")
         
         # 각 뉴스 아이템에서 정보 추출
         for i, item in enumerate(news_items):
@@ -156,48 +190,68 @@ def crawl_naver_news(keyword, num_articles=5):
                     'description': description,
                     'source': source,
                     'date': date,
-                    'content': ""  # 나중에 원문 내용을 저장할 필드
+                    'content': ""
                 })
                 
+                logging.info(f"기사 추출 성공: {title}")
+                
             except Exception as e:
-                st.error(f"기사 정보 추출 중 오류 발생: {str(e)}")
+                logging.error(f"기사 정보 추출 중 오류 발생: {str(e)}", exc_info=True)
                 continue
                 
     except Exception as e:
-        st.error(f"페이지 요청 중 오류 발생: {str(e)}")
+        logging.error(f"페이지 요청 중 오류 발생: {str(e)}", exc_info=True)
         
+    logging.info(f"크롤링 완료: {len(results)}개 기사 수집")
     return results
 
 # 기사 원문 가져오기
 def get_article_content(url):
+    logging.info(f"기사 원문 가져오기 시작: {url}")
     try:
         response = requests.get(url, timeout=5)
+        logging.info(f"원문 요청 상태 코드: {response.status_code}")
+        
         soup = BeautifulSoup(response.text, 'html.parser')
         
         # 네이버 뉴스 본문 찾기
         content = soup.select_one('#dic_area')
         if content:
             text = content.text.strip()
-            text = re.sub(r'\s+', ' ', text)  # 여러 공백 제거
+            text = re.sub(r'\s+', ' ', text)
+            logging.info("네이버 뉴스 본문 추출 성공")
             return text
             
-        # 다른 뉴스 사이트 본문 찾기 (여러 사이트 대응 필요)
+        # 다른 뉴스 사이트 본문 찾기
         content = soup.select_one('.article_body, .article-body, .article-content, .news-content-inner')
         if content:
             text = content.text.strip()
             text = re.sub(r'\s+', ' ', text)
+            logging.info("일반 뉴스 본문 추출 성공")
             return text
             
+        logging.warning("본문을 찾을 수 없음")
         return "본문을 가져올 수 없습니다."
     except Exception as e:
+        logging.error(f"원문 가져오기 오류: {str(e)}", exc_info=True)
         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)
@@ -274,12 +328,15 @@ def generate_wordcloud(keywords_dict):
             ).generate_from_frequencies(keywords_dict)
 
             try:
-                possible_font_paths=["NanumGothic.ttf", "이름"]
+                import os
+                script_dir = os.path.dirname(os.path.abspath(__file__))  
+                possible_font_paths = ["NanumGothic.ttf", "이름"]
 
                 font_path = None
                 for path in possible_font_paths:
-                    if os.path.exists(path):
-                        font_path = path
+                    candidate = os.path.join(script_dir, fname)
+                    if os.path.exists(candidate):
+                        font_path = candidate
                         break
 
                 if font_path:
@@ -325,36 +382,55 @@ def analyze_news_content(news_df):
         results['top_keywords'] = []
     return results
 
-# OpenAI API를 이용한 새 기사 생성 (구 버전 방식)
+# OpenAI API를 이용한 새 기사 생성 (새로운 버전 방식)
 def generate_article(original_content, prompt_text):
     try:
-        if not st.session_state.openai_api_key:
+        if not st.session_state.openai_client:
             return "OpenAI API 키가 설정되지 않았습니다."
             
-        response = openai.ChatCompletion.create(
-            model="gpt-4.1-mini",
+        response = st.session_state.openai_client.chat.completions.create(
+            model="gpt-4",  # 또는 사용 가능한 적절한 모델
             messages=[
                 {"role": "system", "content": "당신은 전문적인 뉴스 기자입니다. 주어진 내용을 바탕으로 새로운 기사를 작성해주세요."},
                 {"role": "user", "content": f"다음 내용을 바탕으로 {prompt_text}\n\n{original_content[:1000]}"}
             ],
             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):
     try:
-        if not st.session_state.openai_api_key:
+        if not st.session_state.openai_client:
             return "OpenAI API 키가 설정되지 않았습니다."
             
-        response = openai.Image.create(
+        # GPT Image 1 모델로 이미지 생성
+        result = st.session_state.openai_client.images.generate(
+            model="gpt-image-1",  # 새로운 모델명 사용
             prompt=prompt,
-            n=1,
             size="1024x1024"
         )
-        return response['data'][0]['url']
+        
+        # base64 이미지 데이터를 디코딩
+        image_base64 = result.data[0].b64_json
+        image_bytes = base64.b64decode(image_base64)
+        
+        # BytesIO 객체로 변환
+        image = BytesIO(image_bytes)
+        
+        # PIL Image로 변환하여 크기 조정 (선택사항)
+        pil_image = Image.open(image)
+        pil_image = pil_image.resize((800, 800), Image.LANCZOS)  # 크기 조정
+        
+        # 다시 BytesIO로 변환
+        output = BytesIO()
+        pil_image.save(output, format="JPEG", quality=80, optimize=True)
+        output.seek(0)
+        
+        return output
+        
     except Exception as e:
         return f"이미지 생성 오류: {str(e)}"
 
@@ -376,11 +452,14 @@ def run_scheduled_task():
         traceback.print_exc()
 
 def perform_news_task(task_type, keyword, num_articles, file_prefix):
+    logging.info(f"스케줄러 작업 시작: {task_type}, 키워드={keyword}")
     try:
         articles = crawl_naver_news(keyword, num_articles)
+        logging.info(f"수집된 기사 수: {len(articles)}")
         
         # 기사 내용 가져오기
-        for article in articles:
+        for i, article in enumerate(articles):
+            logging.info(f"기사 {i+1}/{len(articles)} 원문 가져오기: {article['title']}")
             article['content'] = get_article_content(article['link'])
             time.sleep(0.5)  # 서버 부하 방지
         
@@ -392,10 +471,12 @@ def perform_news_task(task_type, keyword, num_articles, file_prefix):
         with open(filename, 'w', encoding='utf-8') as f:
             json.dump(articles, f, ensure_ascii=False, indent=2)
         
+        logging.info(f"결과 저장 완료: {filename}")
+        
         global_scheduler_state.last_run = datetime.now()
         print(f"{datetime.now()} - {task_type} 뉴스 기사 수집 완료: {keyword}")
         
-        # 전역 상태에 수집 결과를 저장 (UI 업데이트용)
+        # 전역 상태에 수집 결과를 저장
         result_item = {
             'task_type': task_type,
             'keyword': keyword,
@@ -406,7 +487,7 @@ def perform_news_task(task_type, keyword, num_articles, file_prefix):
         global_scheduler_state.scheduled_results.append(result_item)
         
     except Exception as e:
-        print(f"작업 실행 중 오류 발생: {e}")
+        logging.error(f"작업 실행 중 오류 발생: {str(e)}", exc_info=True)
         traceback.print_exc()
 
 def start_scheduler(daily_tasks, interval_tasks):
@@ -563,9 +644,25 @@ elif menu == "기사 분석하기":
                         with keyword_tab1:
                             keywords = analyze_keywords(selected_article['content'])
                             
-                            # 시각화
+                            # Plotly를 사용한 시각화
                             df = pd.DataFrame(keywords, columns=['단어', '빈도수'])
-                            st.bar_chart(df.set_index('단어'))
+                            fig = go.Figure(data=[
+                                go.Bar(
+                                    x=df['단어'],
+                                    y=df['빈도수'],
+                                    marker_color='rgb(55, 83, 109)'
+                                )
+                            ])
+                            
+                            fig.update_layout(
+                                title='키워드 빈도 분석',
+                                xaxis_title='키워드',
+                                yaxis_title='빈도수',
+                                height=500,
+                                margin=dict(l=50, r=50, t=80, b=50)
+                            )
+                            
+                            st.plotly_chart(fig, use_container_width=True)
                             
                             st.write("**주요 키워드:**")
                             for word, count in keywords:
@@ -595,7 +692,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
                     
@@ -615,136 +719,50 @@ 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', download_dir=nltk_data_dir)
-                        
-                        # 언어 감지 (간단한 방식)
-                        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:
+                    if st.session_state.openai_client:
                         with st.spinner("기사의 감정을 분석 중입니다..."):
                             try:
-                                # 감정 분석 프롬프트 설정 (구 버전 방식)
-                                prompt = """
-                                다음 뉴스 기사의 감정과 논조를 분석하고, 아래 예시처럼 JSON만 반환하세요. 
-                                불필요한 설명, 인사말, 기타 텍스트 없이 반드시 JSON만 출력하세요.
-
-                                예시:
-                                {
-                                  "sentiment": "긍정적",
-                                  "reason": "이 기사에서는 긍정적인 단어와 표현이 많이 사용되었습니다.",
-                                  "keywords": [
-                                    {"word": "희망", "score": 8},
-                                    {"word": "성공", "score": 7},
-                                    {"word": "기대", "score": 6},
-                                    {"word": "성장", "score": 7},
-                                    {"word": "혁신", "score": 8}
-                                  ]
-                                }
-
-                                분석할 기사:
-                                제목: {title}
-                                내용: {content}
-                                """
-                                
-                                # 감정 분석
-                                response = openai.ChatCompletion.create(
+                                response = st.session_state.openai_client.chat.completions.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": prompt.format(title=selected_article['title'], content=selected_article['content'][:1500])}
+                                        {"role": "system", "content": """당신은 텍스트의 감정과 논조를 분석하는 전문가입니다. 
+                                        다음 뉴스 기사의 감정과 논조를 분석하고, 반드시 아래 형식의 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
+                                    max_tokens=800,
+                                    response_format={ "type": "json_object" }  # JSON 응답 형식 강제
                                 )
                                 
-                                # JSON 파싱 (구 버전 방식)
-                                analysis_result = json.loads(response.choices[0].message['content'])
+                                # 응답 내용 확인 및 디버깅
+                                content = response.choices[0].message.content
+                                logging.info(f"API 응답: {content}")
+                                
+                                # JSON 파싱
+                                try:
+                                    analysis_result = json.loads(content)
+                                except json.JSONDecodeError as e:
+                                    logging.error(f"JSON 파싱 오류: {str(e)}")
+                                    logging.error(f"파싱 시도한 내용: {content}")
+                                    st.error("API 응답을 파싱하는 중 오류가 발생했습니다. 응답 형식이 올바르지 않습니다.")
+                                    st.stop()  # return 대신 st.stop() 사용
                                 
                                 # 결과 시각화
                                 st.subheader("감정 분석 결과")
@@ -893,9 +911,9 @@ elif menu == "기사 분석하기":
                                 
                             except Exception as e:
                                 st.error(f"감정 분석 오류: {str(e)}")
-                                st.code(traceback.format_exc())
+                                st.error(traceback.format_exc())
                     else:
-                        st.warning("OpenAI API 키가 설정되어 있지 않습니다. 사이드바에서 API 키를 설정해주세요.")
+                        st.warning("OpenAI API 키를 사이드바에서 설정해주세요.")
 
 elif menu == "새 기사 생성하기":
     st.header("새 기사 생성하기")
@@ -930,7 +948,7 @@ elif menu == "새 기사 생성하기":
             generate_image_too = st.checkbox("기사 생성 후 이미지도 함께 생성하기", value=True)
             
             if st.button("새 기사 생성하기"):
-                if st.session_state.openai_api_key:
+                if st.session_state.openai_client:
                     with st.spinner("기사를 생성 중입니다..."):
                         new_article = generate_article(selected_article['content'], prompt_text)
                         
@@ -940,7 +958,6 @@ elif menu == "새 기사 생성하기":
                         # 이미지 생성하기 (옵션이 선택된 경우)
                         if generate_image_too:
                             with st.spinner("기사 관련 이미지를 생성 중입니다..."):
-                                # 이미지 생성 프롬프트 준비
                                 image_prompt = f"""신문기사 제목 "{selected_article['title']}" 을 보고 이미지를 만들어줘 
                                 이미지에는 다음 요소가 포함되어야 합니다:
                                 - 기사를 이해할 수 있는 도식
@@ -949,13 +966,13 @@ elif menu == "새 기사 생성하기":
                                 """
                                 
                                 # 이미지 생성
-                                image_url = generate_image(image_prompt)
+                                image = generate_image(image_prompt)
                                 
-                                if image_url and not image_url.startswith("이미지 생성 오류"):
+                                if isinstance(image, BytesIO):
                                     st.subheader("생성된 이미지:")
-                                    st.image(image_url)
+                                    st.image(image, use_column_width=True)
                                 else:
-                                    st.error(image_url)
+                                    st.error(image)
                         
                         # 생성된 기사 저장 옵션
                         if st.button("생성된 기사 저장"):
@@ -973,8 +990,6 @@ elif menu == "새 기사 생성하기":
                 else:
                     st.warning("OpenAI API 키를 사이드바에서 설정해주세요.")
 
-
-
 elif menu == "뉴스 기사 예약하기":
     st.header("뉴스 기사 예약하기")
     
@@ -1061,6 +1076,30 @@ elif menu == "뉴스 기사 예약하기":
     with tab3:
         st.subheader("스케줄러 제어 및 상태")
         
+        # 로그 뷰어를 상단에 배치
+        st.subheader("실시간 로그")
+        log_container = st.empty()
+        
+        def update_logs():
+            try:
+                with open('/tmp/crawler.log', 'r') as f:
+                    logs = f.readlines()
+                return ''.join(logs[-100:])  # 최근 100줄만 표시
+            except Exception as e:
+                return f"로그 파일을 읽을 수 없습니다: {str(e)}"
+        
+        # 로그 자동 업데이트
+        if st.checkbox("로그 자동 업데이트", value=True):
+            log_content = update_logs()
+            log_container.text_area("최근 로그", value=log_content, height=400)
+        else:
+            if st.button("로그 새로고침"):
+                log_content = update_logs()
+                log_container.text_area("최근 로그", value=log_content, height=400)
+        
+        st.divider()
+        
+        # 스케줄러 제어
         col1, col2 = st.columns(2)
         
         with col1:
@@ -1144,20 +1183,4 @@ elif menu == "뉴스 기사 예약하기":
 
 # 푸터
 st.markdown("---")
-st.markdown("© 뉴스 기사 도구 @conanssam")
-
-def extract_json_from_response(response_text):
-    # JSON 객체 부분만 추출 (가장 먼저 나오는 중괄호 쌍)
-    match = re.search(r'\{.*\}', response_text, re.DOTALL)
-    if match:
-        json_str = match.group(0)
-        try:
-            return json.loads(json_str)
-        except Exception as e:
-            st.error(f"JSON 파싱 오류: {str(e)}")
-            st.code(json_str)
-            return None
-    else:
-        st.error("응답에서 JSON을 찾을 수 없습니다.")
-        st.code(response_text)
-        return None
+st.markdown("© 뉴스 기사 도구 @conanssam")