Update src/streamlit_app.py

src/streamlit_app.py

@@ -11,28 +11,13 @@ from collections import Counter
 import json
 import os
 from datetime import datetime, timedelta
-from openai import OpenAI  # 새로운 import 방식
+import openai  # 구 버전 방식 사용
 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:
@@ -55,52 +40,41 @@ class SchedulerState:
 global_scheduler_state = SchedulerState()
 
 # API 키 관리를 위한 세션 상태 초기화
-if 'openai_client' not in st.session_state:
-    st.session_state.openai_client = None
+if 'openai_api_key' not in st.session_state:
+    st.session_state.openai_api_key = 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 키 확인
-api_key = os.environ.get('OPENAI_API_KEY')
-if api_key:
-    st.session_state.openai_client = init_openai_client(api_key)
+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
 
-# 2. Streamlit secrets에서 API 키 확인
-if not st.session_state.openai_client:
+# 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_client = init_openai_client(st.secrets['OPENAI_API_KEY'])
+            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 데이터 경로 설정
+nltk_data_dir = '/tmp/nltk_data'
+os.makedirs(nltk_data_dir, exist_ok=True)
+nltk.data.path.insert(0, nltk_data_dir)  # 이 경로를 우선 검색하도록 설정
 
-# 필요한 NLTK 데이터 확인
+# 필요한 NLTK 데이터 다운로드
 try:
     nltk.data.find('tokenizers/punkt')
 except LookupError:
-    nltk.download('punkt', download_dir=nltk_data_path)
+    nltk.download('punkt', download_dir=nltk_data_dir)
     
 try:
     nltk.data.find('corpora/stopwords')
 except LookupError:
-    nltk.download('stopwords', download_dir=nltk_data_path)
+    nltk.download('stopwords', download_dir=nltk_data_dir)
 
 # 페이지 설정
 st.set_page_config(page_title="뉴스 기사 도구", page_icon="📰", layout="wide")
@@ -116,12 +90,9 @@ with st.sidebar:
     st.divider()
     api_key = st.text_input("OpenAI API 키 입력", type="password")
     if api_key:
-        client = init_openai_client(api_key)
-        if client:
-            st.session_state.openai_client = client
-            st.success("API 키가 성공적으로 설정되었습니다!")
-        else:
-            st.error("유효하지 않은 API 키입니다.")
+        st.session_state.openai_api_key = api_key
+        openai.api_key = api_key
+        st.success("API 키가 설정되었습니다!")
 
 # 저장된 기사를 불러오는 함수
 def load_saved_articles():
@@ -141,21 +112,16 @@ 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):
@@ -190,68 +156,48 @@ def crawl_naver_news(keyword, num_articles=5):
                     'description': description,
                     'source': source,
                     'date': date,
-                    'content': ""
+                    'content': ""  # 나중에 원문 내용을 저장할 필드
                 })
                 
-                logging.info(f"기사 추출 성공: {title}")
-                
             except Exception as e:
-                logging.error(f"기사 정보 추출 중 오류 발생: {str(e)}", exc_info=True)
+                st.error(f"기사 정보 추출 중 오류 발생: {str(e)}")
                 continue
                 
     except Exception as e:
-        logging.error(f"페이지 요청 중 오류 발생: {str(e)}", exc_info=True)
+        st.error(f"페이지 요청 중 오류 발생: {str(e)}")
         
-    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)
-            logging.info("네이버 뉴스 본문 추출 성공")
+            text = re.sub(r'\s+', ' ', text)  # 여러 공백 제거
             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를 이용한 키워드 분석 (KSS 활용)
+# NLTK를 이용한 키워드 분석
 def analyze_keywords(text, top_n=10):
-    # 한국어 불용어 목록
+    # 한국어 불용어 목록 (직접 정의해야 합니다)
     korean_stopwords = ['이', '그', '저', '것', '및', '등', '를', '을', '에', '에서', '의', '으로', '로']
     
-    # KSS를 사용한 문장 분리 및 토큰화
-    try:
-        sentences = kss.split_sentences(text)
-        tokens = []
-        for sentence in sentences:
-            # 간단한 토큰화 (공백 기준)
-            tokens.extend(sentence.split())
-    except:
-        # KSS 실패시 기본 토큰화
-        tokens = text.split()
-    
+    tokens = word_tokenize(text)
     tokens = [word for word in tokens if word.isalnum() and len(word) > 1 and word not in korean_stopwords]
     
     word_count = Counter(tokens)
@@ -379,55 +325,36 @@ 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_client:
+        if not st.session_state.openai_api_key:
             return "OpenAI API 키가 설정되지 않았습니다."
             
-        response = st.session_state.openai_client.chat.completions.create(
-            model="gpt-4",  # 또는 사용 가능한 적절한 모델
+        response = openai.ChatCompletion.create(
+            model="gpt-4.1-mini",
             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_client:
+        if not st.session_state.openai_api_key:
             return "OpenAI API 키가 설정되지 않았습니다."
             
-        # GPT Image 1 모델로 이미지 생성
-        result = st.session_state.openai_client.images.generate(
-            model="gpt-image-1",  # 새로운 모델명 사용
+        response = openai.Image.create(
             prompt=prompt,
+            n=1,
             size="1024x1024"
         )
-        
-        # 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
-        
+        return response['data'][0]['url']
     except Exception as e:
         return f"이미지 생성 오류: {str(e)}"
 
@@ -449,14 +376,11 @@ 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 i, article in enumerate(articles):
-            logging.info(f"기사 {i+1}/{len(articles)} 원문 가져오기: {article['title']}")
+        for article in articles:
             article['content'] = get_article_content(article['link'])
             time.sleep(0.5)  # 서버 부하 방지
         
@@ -468,12 +392,10 @@ 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,
@@ -484,7 +406,7 @@ def perform_news_task(task_type, keyword, num_articles, file_prefix):
         global_scheduler_state.scheduled_results.append(result_item)
         
     except Exception as e:
-        logging.error(f"작업 실행 중 오류 발생: {str(e)}", exc_info=True)
+        print(f"작업 실행 중 오류 발생: {e}")
         traceback.print_exc()
 
 def start_scheduler(daily_tasks, interval_tasks):
@@ -641,25 +563,9 @@ elif menu == "기사 분석하기":
                         with keyword_tab1:
                             keywords = analyze_keywords(selected_article['content'])
                             
-                            # Plotly를 사용한 시각화
+                            # 시각화
                             df = pd.DataFrame(keywords, columns=['단어', '빈도수'])
-                            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.bar_chart(df.set_index('단어'))
                             
                             st.write("**주요 키워드:**")
                             for word, count in keywords:
@@ -689,14 +595,7 @@ elif menu == "기사 분석하기":
                     # 텍스트 통계 계산
                     word_count = len(re.findall(r'\b\w+\b', content))
                     char_count = len(content)
-                    try:
-                        # KSS로 문장 분리
-                        sentences = kss.split_sentences(content)
-                        sentence_count = len(sentences)
-                    except:
-                        # KSS 실패시 기본 문장 분리
-                        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
                     
@@ -716,50 +615,136 @@ 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")
-                    
-                    # 품사 분석 부분 제거 (KoNLPy 의존성 제거)
-                    st.info("상세 품사 분석은 현재 지원되지 않습니다.")
+                        
+                    # 출현 빈도 막대 그래프
+                    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())
 
             elif analysis_type == "감정 분석":
                 if st.button("감정 분석하기"):
-                    if st.session_state.openai_client:
+                    if st.session_state.openai_api_key:
                         with st.spinner("기사의 감정을 분석 중입니다..."):
                             try:
-                                response = st.session_state.openai_client.chat.completions.create(
-                                    model="gpt-4",
+                                # 감정 분석 프롬프트 설정 (구 버전 방식)
+                                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(
+                                    model="gpt-4.1-mini",
                                     messages=[
-                                        {"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]}"}
+                                        {"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])}
                                     ],
-                                    max_tokens=800,
-                                    response_format={ "type": "json_object" }  # JSON 응답 형식 강제
+                                    max_tokens=800
                                 )
                                 
-                                # 응답 내용 확인 및 디버깅
-                                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() 사용
+                                # JSON 파싱 (구 버전 방식)
+                                analysis_result = json.loads(response.choices[0].message['content'])
                                 
                                 # 결과 시각화
                                 st.subheader("감정 분석 결과")
@@ -908,9 +893,9 @@ elif menu == "기사 분석하기":
                                 
                             except Exception as e:
                                 st.error(f"감정 분석 오류: {str(e)}")
-                                st.error(traceback.format_exc())
+                                st.code(traceback.format_exc())
                     else:
-                        st.warning("OpenAI API 키를 사이드바에서 설정해주세요.")
+                        st.warning("OpenAI API 키가 설정되어 있지 않습니다. 사이드바에서 API 키를 설정해주세요.")
 
 elif menu == "새 기사 생성하기":
     st.header("새 기사 생성하기")
@@ -945,7 +930,7 @@ elif menu == "새 기사 생성하기":
             generate_image_too = st.checkbox("기사 생성 후 이미지도 함께 생성하기", value=True)
             
             if st.button("새 기사 생성하기"):
-                if st.session_state.openai_client:
+                if st.session_state.openai_api_key:
                     with st.spinner("기사를 생성 중입니다..."):
                         new_article = generate_article(selected_article['content'], prompt_text)
                         
@@ -955,6 +940,7 @@ elif menu == "새 기사 생성하기":
                         # 이미지 생성하기 (옵션이 선택된 경우)
                         if generate_image_too:
                             with st.spinner("기사 관련 이미지를 생성 중입니다..."):
+                                # 이미지 생성 프롬프트 준비
                                 image_prompt = f"""신문기사 제목 "{selected_article['title']}" 을 보고 이미지를 만들어줘 
                                 이미지에는 다음 요소가 포함되어야 합니다:
                                 - 기사를 이해할 수 있는 도식
@@ -963,13 +949,13 @@ elif menu == "새 기사 생성하기":
                                 """
                                 
                                 # 이미지 생성
-                                image = generate_image(image_prompt)
+                                image_url = generate_image(image_prompt)
                                 
-                                if isinstance(image, BytesIO):
+                                if image_url and not image_url.startswith("이미지 생성 오류"):
                                     st.subheader("생성된 이미지:")
-                                    st.image(image, use_column_width=True)
+                                    st.image(image_url)
                                 else:
-                                    st.error(image)
+                                    st.error(image_url)
                         
                         # 생성된 기사 저장 옵션
                         if st.button("생성된 기사 저장"):
@@ -987,6 +973,8 @@ elif menu == "새 기사 생성하기":
                 else:
                     st.warning("OpenAI API 키를 사이드바에서 설정해주세요.")
 
+
+
 elif menu == "뉴스 기사 예약하기":
     st.header("뉴스 기사 예약하기")
     
@@ -1073,30 +1061,6 @@ 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:
@@ -1180,4 +1144,20 @@ elif menu == "뉴스 기사 예약하기":
 
 # 푸터
 st.markdown("---")
-st.markdown("© 뉴스 기사 도구 @conanssam")
+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