Update streamlit_app.py

streamlit_app.py

@@ -1,248 +1,58 @@
-# 네트워크 에러 해결된 슬로레터 검색 앱
+# 최소 테스트 앱 - 네트워크 에러 디버깅용
 import streamlit as st
-import pandas as pd
-import numpy as np
-from rank_bm25 import BM25Okapi
-import pickle
-import json
 import os
+import json
+
+st.title("🔍 슬로레터 검색 - 디버깅")
+
+st.write("## 📁 파일 확인")
+
+# 현재 디렉토리 파일 목록
+files = os.listdir(".")
+st.write("현재 디렉토리 파일들:")
+for file in files:
+    size = os.path.getsize(file) if os.path.isfile(file) else "폴더"
+    st.write(f"- {file}: {size}")
+
+st.write("## 🔍 시스템 파일 테스트")
+
+# 각 파일 개별 테스트
+test_results = {}
+
+# 1. 메타데이터 파일 테스트
+try:
+    with open("system_metadata.json", 'r') as f:
+        metadata = json.load(f)
+    test_results["system_metadata.json"] = f"✅ 성공 - {len(metadata)} 개 항목"
+    st.json(metadata)
+except Exception as e:
+    test_results["system_metadata.json"] = f"❌ 실패: {e}"
+
+# 2. 다른 파일들 크기만 확인
+for file in ["embeddings.npy", "bm25_index.pkl", "processed_data.pkl"]:
+    try:
+        size = os.path.getsize(file)
+        test_results[file] = f"✅ 파일 존재 - {size/1024/1024:.1f}MB"
+    except Exception as e:
+        test_results[file] = f"❌ 파일 없음: {e}"
+
+st.write("## 📊 테스트 결과")
+for file, result in test_results.items():
+    st.write(f"**{file}**: {result}")
 
-# Hugging Face Spaces 설정
-st.set_page_config(
-    page_title="슬로레터 지능형 검색",
-    page_icon="🔍",
-    layout="wide"
-)
+# 간단한 검색 인터페이스 (파일 로딩 없이)
+st.write("## 🧪 기본 기능 테스트")
 
-# 데이터 경로 수정 (루트 디렉토리)
-DATA_PATH = "."
+search_query = st.text_input("테스트 검색어를 입력하세요:")
 
-class HFSlowletterSearch:
-    def __init__(self):
-        self.embeddings = None
-        self.bm25 = None
-        self.processed_data = None
-        self.metadata = {}
-        self.system_loaded = False
-    
-    @st.cache_resource
-    def load_system(_self):
-        """시스템 로드 (HF Spaces 최적화)"""
-        try:
-            # 파일 존재 확인
-            required_files = [
-                'embeddings.npy',
-                'bm25_index.pkl', 
-                'processed_data.pkl',
-                'system_metadata.json'
-            ]
-            
-            missing_files = []
-            for file in required_files:
-                if not os.path.exists(os.path.join(DATA_PATH, file)):
-                    missing_files.append(file)
-            
-            if missing_files:
-                st.error(f"필요한 파일이 없습니다: {missing_files}")
-                return False
-            
-            # 임베딩 로드 (사용은 안하지만 로드는 함)
-            _self.embeddings = np.load(f"{DATA_PATH}/embeddings.npy")
-            
-            # BM25 인덱스 로드
-            with open(f"{DATA_PATH}/bm25_index.pkl", 'rb') as f:
-                _self.bm25 = pickle.load(f)
-            
-            # 데이터 로드
-            with open(f"{DATA_PATH}/processed_data.pkl", 'rb') as f:
-                _self.processed_data = pickle.load(f)
-            
-            # 메타데이터 로드
-            with open(f"{DATA_PATH}/system_metadata.json", 'r') as f:
-                _self.metadata = json.load(f)
-            
-            _self.system_loaded = True
-            st.success("✅ 시스템 로드 완료!")
-            return True
-            
-        except Exception as e:
-            st.error(f"시스템 로드 실패: {e}")
-            return False
-    
-    def tokenize_korean(self, text):
-        import re
-        tokens = re.findall(r'\b\w+\b', str(text).lower())
-        return [token for token in tokens if len(token) > 1]
-    
-    def search(self, query, top_k=10):
-        """BM25 기반 검색 (네트워크 호출 없음)"""
-        if not self.system_loaded:
-            return []
-        
-        # BM25 검색만 사용 (API 호출 제거)
-        tokenized_query = self.tokenize_korean(query)
-        bm25_scores = self.bm25.get_scores(tokenized_query)
-        
-        # 상위 결과 선택
-        top_indices = np.argsort(bm25_scores)[::-1][:top_k]
-        
-        results = []
-        for rank, idx in enumerate(top_indices, 1):
-            if bm25_scores[idx] > 0:  # 관련성 있는 결과만
-                row = self.processed_data.iloc[idx]
-                results.append({
-                    'rank': rank,
-                    'title': row.get('h3_title', ''),
-                    'date': row.get('date', ''),
-                    'newsletter': row.get('h1_title', ''),
-                    'entities': row.get('entities', ''),
-                    'events': row.get('events', ''),
-                    'content': row.get('h3_content_text', ''),
-                    'score': float(bm25_scores[idx])
-                })
-        
-        return results
+if search_query:
+    st.success(f"입력받은 검색어: {search_query}")
+    st.info("파일 로딩은 다음 단계에서 테스트합니다.")
 
-def main():
-    # 제목 및 설명
-    st.title("🔍 슬로레터 지능형 검색")
-    st.markdown("**2년간의 슬로레터 아카이브를 검색하세요!**")
-    st.info("💡 키워드 기반 BM25 검색을 사용합니다 (API 키 불필요)")
-    
-    # 시스템 초기화
-    search_system = HFSlowletterSearch()
-    
-    # 시스템 로드
-    with st.spinner("🔄 시스템 로딩 중..."):
-        system_loaded = search_system.load_system()
-    
-    if system_loaded:
-        # 시스템 정보
-        col1, col2, col3 = st.columns(3)
-        with col1:
-            st.metric("📊 총 문서", f"{search_system.metadata.get('total_documents', 0):,}개")
-        with col2:
-            st.metric("📅 생성일", search_system.metadata.get('created_at', 'Unknown')[:10])
-        with col3:
-            st.metric("🔄 업데이트", search_system.metadata.get('last_updated', 'Unknown')[:10])
-        
-        st.divider()
-        
-        # 빠른 검색 버튼
-        st.subheader("🚀 빠른 검색")
-        
-        quick_queries = [
-            "윤석열 대통령",
-            "이재명 대통령", 
-            "명태균 사건",
-            "탄핵",
-            "경제 정책",
-            "북한"
-        ]
-        
-        cols = st.columns(3)
-        selected_query = None
-        
-        for i, query in enumerate(quick_queries):
-            col = cols[i % 3]
-            if col.button(query, key=f"quick_{i}"):
-                selected_query = query
-        
-        # 검색창
-        search_query = st.text_input(
-            "검색어를 입력하세요:",
-            value=selected_query or "",
-            placeholder="예: 윤석열 대통령 최근 논란"
-        )
-        
-        # 검색 설정
-        col1, col2 = st.columns([3, 1])
-        with col2:
-            top_k = st.selectbox("결과 개수", [5, 10, 20, 30], index=1)
-        
-        # 검색 실행
-        if search_query:
-            with st.spinner("🔍 검색 중..."):
-                results = search_system.search(search_query, top_k=top_k)
-            
-            if results:
-                st.success(f"🎉 {len(results)}개 결과를 찾았습니다!")
-                
-                # 결과 표시
-                for result in results:
-                    with st.expander(
-                        f"🏆 {result['rank']}. {result['title']} ({result['date']})", 
-                        expanded=result['rank'] <= 3
-                    ):
-                        col1, col2 = st.columns([3, 1])
-                        
-                        with col1:
-                            if result['entities']:
-                                entities = result['entities'].split(';')[:5]
-                                entities = [e.strip() for e in entities if e.strip()]
-                                if entities:
-                                    st.write("**👥 관련 인물/기관:**", ", ".join(entities))
-                            
-                            if result['events']:
-                                events = result['events'].split(';')[:3]
-                                events = [e.strip() for e in events if e.strip()]  
-                                if events:
-                                    st.write("**📋 주요 사건:**", ", ".join(events))
-                            
-                            if result['content']:
-                                st.write("**📝 내용:**")
-                                content = result['content']
-                                if len(content) > 300:
-                                    st.write(content[:300] + "...")
-                                else:
-                                    st.write(content)
-                        
-                        with col2:
-                            st.metric("검색 점수", f"{result['score']:.2f}")
-                            if result['newsletter']:
-                                st.write(f"**📄** {result['newsletter']}")
-            else:
-                st.warning("🔍 검색 결과가 없습니다. 다른 키워드로 시도해보세요.")
-                st.info("💡 팁: 더 간단한 키워드로 검색해보세요 (예: '윤석열', '이재명', '탄핵')")
-        
-        # 사용법 안내
-        with st.expander("💡 사용법 안내"):
-            st.markdown("""
-            ### 🔍 검색 팁
-            - **인물명**: "윤석열", "이재명", "명태균"
-            - **사건명**: "탄핵", "특검", "드론"  
-            - **주제**: "경제 정책", "북한 관련"
-            - **복합 검색**: "윤석열 탄핵 가능성"
-            
-            ### ⚡ 시스템 정보
-            - **검색 방식**: BM25 키워드 매칭
-            - **데이터 범위**: 2023년 4월 ~ 2025년 7월
-            - **총 문서 수**: 13,000+ 개 슬로레터 ���사
-            - **업데이트**: 정기적으로 새로운 기사 추가
-            
-            ### 🎯 기능
-            - 🔍 **정확한 키워드 매칭**: 입력한 단어와 정확히 일치하는 기사 우선
-            - 📊 **관련도 순 정렬**: 가장 관련성 높은 결과 먼저 표시
-            - 📅 **시간순 추적**: 사건의 시간적 흐름 파악 가능
-            - 👥 **인물/사건 연결**: 관련 인물과 사건 자동 표시
-            
-            ---
-            💻 **기술 스택**: BM25 + Contextual Retrieval | 🏗️ **플랫폼**: Hugging Face Spaces
-            """)
-    
-    else:
-        st.error("❌ 시스템을 로드할 수 없습니다.")
-        st.info("🔧 필요한 데이터 파일들이 업로드되지 않았을 수 있습니다.")
-        
-        # 디버깅 정보
-        with st.expander("🔍 디버깅 정보"):
-            st.write("필요한 파일들:")
-            files_status = {}
-            for file in ['embeddings.npy', 'bm25_index.pkl', 'processed_data.pkl', 'system_metadata.json']:
-                exists = os.path.exists(file)
-                files_status[file] = "✅" if exists else "❌"
-            
-            st.json(files_status)
+# 시스템 정보
+st.write("## ⚙️ 시스템 정보")
+st.write(f"Python 버전: {st.__version__}")
 
-if __name__ == "__main__":
-    main()
+# 네트워크 테스트 제거
+st.write("## ✅ 네트워크 호출 없음")
+st.success("이 앱은 어떤 외부 네트워크 호출도 하지 않습니다.")