fix: 2-phase model/space fetch — basic info immediate + LLM best-effort + sort fallback (resolves empty models/spaces issue)

app.py

@@ -1946,25 +1946,69 @@ class AdvancedAIAnalyzer:
         
         return all_news
     
+    def _fallback_model_analysis(self, model_info: Dict) -> str:
+        """LLM 호출 실패/지연 시 사용할 즉시 fallback 설명"""
+        name = model_info['name'].split('/')[-1]
+        task = model_info.get('task', 'N/A') or 'N/A'
+        dl = model_info.get('downloads', 0)
+        task_kr = {
+            'text-generation': '글을 자동으로 만들어주는',
+            'image-to-text': '사진을 보고 설명을 써주는',
+            'text-to-image': '글을 읽고 그림을 그려주는',
+            'image-text-to-text': '이미지와 글을 함께 이해하는 멀티모달',
+            'text-to-speech': '글을 음성으로 변환하는',
+            'automatic-speech-recognition': '음성을 글로 받아쓰는',
+            'translation': '다른 언어로 번역해주는',
+            'question-answering': '질문에 답해주는',
+            'summarization': '긴 글을 짧게 요약해주는',
+            'text-classification': '글을 분류해주는',
+            'feature-extraction': '의미 벡터를 추출하는',
+            'sentence-similarity': '문장 의미 유사도를 비교하는',
+            'fill-mask': '빈칸을 채워주는',
+            'any-to-any': '여러 modality 처리하는',
+        }.get(task, '특별한 기능을 하는')
+        if dl > 10_000_000: pop = '엄청나게 많은'
+        elif dl > 1_000_000: pop = '아주 많은'
+        elif dl > 100_000: pop = '많은'
+        elif dl > 10_000: pop = '꽤 많은'
+        else: pop = '어느 정도'
+        return f"이 모델은 {task_kr} AI예요. {pop} 사람들이 다운로드해서 사용하고 있어요. {name}라는 이름으로 유명해요!"
+
+    def _fallback_space_analysis(self, space_info: Dict) -> Dict:
+        name = space_info.get('name', 'Space')
+        sdk = space_info.get('sdk', 'gradio') or 'gradio'
+        tech = ['Python', sdk.capitalize() if sdk else 'Gradio']
+        return {
+            'simple_explanation': f"{name}는 웹브라우저에서 바로 AI를 체험해볼 수 있는 곳이에요. 설치 없이도 사용할 수 있어서 편리해요!",
+            'tech_stack': tech,
+        }
+
     def fetch_huggingface_models(self, limit: int = 30) -> List[Dict]:
-        """허깅페이스 트렌딩 모델 30개 수집 (실제 API)"""
+        """허깅페이스 트렌딩 모델 수집 — 2-phase (기본정보 즉시 저장 → LLM은 best-effort)"""
         print(f"🤗 허깅페이스 트렌딩 모델 {limit}개 수집 중...")
-        
+
         models_list = []
-        
+
+        # ===== PHASE 1: HF API에서 기본 정보 즉시 수집 =====
         try:
-            # Hugging Face API 사용
             api = HfApi()
-            
-            # trending 순위로 모델 가져오기
-            models = list(api.list_models(
-                sort="trending_score",
-                direction=-1,
-                limit=limit
-            ))
-            
+            try:
+                models = list(api.list_models(
+                    sort="trending_score",
+                    direction=-1,
+                    limit=limit
+                ))
+            except (TypeError, Exception) as e_sort:
+                # trending_score 미지원 huggingface_hub 버전 fallback
+                print(f"  ⚠️ trending_score sort 미지원 ({e_sort}), downloads로 fallback")
+                models = list(api.list_models(
+                    sort="downloads",
+                    direction=-1,
+                    limit=limit
+                ))
+
             print(f"📊 API에서 {len(models)}개 모델 받음")
-            
+
             for idx, model in enumerate(models[:limit], 1):
                 try:
                     model_info = {
@@ -1973,107 +2017,145 @@ class AdvancedAIAnalyzer:
                         'likes': getattr(model, 'likes', 0) or 0,
                         'task': getattr(model, 'pipeline_tag', 'N/A') or 'N/A',
                         'url': f"https://huggingface.co/{model.id}",
-                        'rank': idx
+                        'rank': idx,
+                        'analysis': ''  # PHASE 2에서 채움
                     }
-                    
-                    # LLM 분석 추가 (모델 카드 분석)
-                    print(f"  🔍 {idx}. {model.id} 분석 중...")
-                    model_info['analysis'] = self.llm_analyzer.analyze_model(
-                        model_info['name'],
-                        model_info['task'],
-                        model_info['downloads']
-                    )
-                    
+                    # PHASE 1 즉시 fallback 설명 부여 — 무조건 비어있지 않게
+                    model_info['analysis'] = self._fallback_model_analysis(model_info)
                     models_list.append(model_info)
-                    
-                    # API rate limit 방지를 위한 짧은 대기
-                    time.sleep(0.5)
-                    
-                    # 진행상황 표시
-                    if idx % 5 == 0:
-                        print(f"  ✓ {idx}개 모델 처리 완료...")
-                    
                 except Exception as e:
-                    print(f"  ⚠️ 모델 {idx} 처리 오류: {e}")
+                    print(f"  ⚠️ 모델 {idx} 기본정보 오류: {e}")
                     continue
-            
-            print(f"✅ {len(models_list)}개 트렌딩 모델 수집 완료\n")
-            
-            # DB에 저장
+
+            print(f"✅ PHASE 1 완료: {len(models_list)}개 기본정보 확보")
+
+            # PHASE 1 결과 즉시 DB 저장 (LLM 분석 실패에도 데이터 보존)
             if models_list:
-                save_models_to_db(models_list)
-            
-            return models_list
-            
+                try:
+                    save_models_to_db(models_list)
+                    print(f"💾 DB 저장 완료 (PHASE 1)")
+                except Exception as e:
+                    print(f"  ⚠️ DB 저장 오류 (PHASE 1): {e}")
         except Exception as e:
-            print(f"❌ 모델 수집 오류: {e}")
+            print(f"❌ HF API 모델 fetch 오류: {e}")
             print("💾 DB에서 이전 데이터 로드 시도...\n")
             return load_models_from_db()
-    
+
+        # ===== PHASE 2: LLM 분석 best-effort 보강 (실패해도 fallback 유지) =====
+        if not getattr(self.llm_analyzer, 'api_available', False):
+            print(f"ℹ️ LLM API 미활성 → PHASE 2 건너뜀, fallback 설명만 사용\n")
+            return models_list
+
+        print(f"🔍 PHASE 2: LLM 분석 시도 (best-effort, 실패해도 fallback 유지)")
+        enriched = 0
+        for idx, m in enumerate(models_list, 1):
+            try:
+                llm_result = self.llm_analyzer.analyze_model(m['name'], m['task'], m['downloads'])
+                if llm_result and len(llm_result.strip()) > 10:
+                    m['analysis'] = llm_result
+                    enriched += 1
+                if idx % 5 == 0:
+                    print(f"  ✓ {idx}/{len(models_list)} 처리 ({enriched} 보강 완료)")
+            except Exception as e:
+                # fallback 그대로 유지
+                continue
+        print(f"✅ PHASE 2 완료: {enriched}/{len(models_list)} LLM 보강\n")
+
+        # 최종 DB 갱신
+        try:
+            save_models_to_db(models_list)
+        except Exception as e:
+            print(f"  ⚠️ DB 최종 저장 오류: {e}")
+
+        return models_list
+
     def fetch_huggingface_spaces(self, limit: int = 30) -> List[Dict]:
-        """허깅페이스 트렌딩 스페이스 30개 수집 (실제 API)"""
+        """허깅페이스 트렌딩 스페이스 수집 — 2-phase (기본정보 즉시 저장 → LLM은 best-effort)"""
         print(f"🚀 허깅페이스 트렌딩 스페이스 {limit}개 수집 중...")
-        
+
         spaces_list = []
-        
+
+        # ===== PHASE 1: HF API에서 기본 정보 즉시 수집 =====
         try:
-            # Hugging Face API 사용
             api = HfApi()
-            
-            # trending 순위로 스페이스 가져오기
-            spaces = list(api.list_spaces(
-                sort="trending_score",
-                direction=-1,
-                limit=limit
-            ))
-            
+            try:
+                spaces = list(api.list_spaces(
+                    sort="trending_score",
+                    direction=-1,
+                    limit=limit
+                ))
+            except (TypeError, Exception) as e_sort:
+                print(f"  ⚠️ trending_score sort 미지원 ({e_sort}), likes로 fallback")
+                spaces = list(api.list_spaces(
+                    sort="likes",
+                    direction=-1,
+                    limit=limit
+                ))
+
             print(f"📊 API에서 {len(spaces)}개 스페이스 받음")
-            
+
             for idx, space in enumerate(spaces[:limit], 1):
                 try:
                     space_info = {
                         'space_id': space.id,
                         'name': space.id.split('/')[-1] if '/' in space.id else space.id,
-                        'author': space.author,
+                        'author': space.author if hasattr(space, 'author') and space.author else (space.id.split('/')[0] if '/' in space.id else 'unknown'),
                         'title': getattr(space, 'title', space.id) or space.id,
                         'likes': getattr(space, 'likes', 0) or 0,
                         'url': f"https://huggingface.co/spaces/{space.id}",
                         'sdk': getattr(space, 'sdk', 'gradio') or 'gradio',
                         'rank': idx
                     }
-                    
-                    # LLM 분석 추가 (app.py 분석)
-                    print(f"  🔍 {idx}. {space.id} 분석 중...")
-                    space_analysis = self.llm_analyzer.analyze_space(
-                        space_info['name'],
-                        space_info['space_id'],
-                        space_info['title']
-                    )
-                    
-                    space_info['simple_explanation'] = space_analysis['simple_explanation']
-                    space_info['tech_stack'] = space_analysis['tech_stack']
+                    # PHASE 1 즉시 fallback
+                    fb = self._fallback_space_analysis(space_info)
+                    space_info['simple_explanation'] = fb['simple_explanation']
+                    space_info['tech_stack'] = fb['tech_stack']
                     space_info['description'] = space_info['title']
-                    
                     spaces_list.append(space_info)
-                    
-                    # API rate limit 방지를 위한 짧은 대기
-                    time.sleep(0.5)
-                    
-                    # 진행상황 표시
-                    if idx % 5 == 0:
-                        print(f"  ✓ {idx}개 스페이스 처리 완료...")
-                    
                 except Exception as e:
-                    print(f"  ⚠️ 스페이스 {idx} 처리 오류: {e}")
+                    print(f"  ⚠️ 스페이스 {idx} 기본정보 오류: {e}")
                     continue
-            
-            print(f"✅ {len(spaces_list)}개 트렌딩 스페이스 수집 완료\n")
-            
-            # DB에 저장
+
+            print(f"✅ PHASE 1 완료: {len(spaces_list)}개 기본정보 확보")
+
             if spaces_list:
-                save_spaces_to_db(spaces_list)
-            
+                try:
+                    save_spaces_to_db(spaces_list)
+                    print(f"💾 DB 저장 완료 (PHASE 1)")
+                except Exception as e:
+                    print(f"  ⚠️ DB 저장 오류 (PHASE 1): {e}")
+        except Exception as e:
+            print(f"❌ HF API 스페이스 fetch 오류: {e}")
+            print("💾 DB에서 이전 데이터 로드 시도...\n")
+            return load_spaces_from_db()
+
+        # ===== PHASE 2: LLM 분석 best-effort 보강 =====
+        if not getattr(self.llm_analyzer, 'api_available', False):
+            print(f"ℹ️ LLM API 미활성 → PHASE 2 건너뜀, fallback 설명만 사용\n")
             return spaces_list
+
+        print(f"🔍 PHASE 2: LLM 분석 시도 (best-effort)")
+        enriched = 0
+        for idx, s in enumerate(spaces_list, 1):
+            try:
+                llm = self.llm_analyzer.analyze_space(s['name'], s['space_id'], s['title'])
+                if llm and llm.get('simple_explanation') and len(llm['simple_explanation'].strip()) > 10:
+                    s['simple_explanation'] = llm['simple_explanation']
+                    if llm.get('tech_stack'):
+                        s['tech_stack'] = llm['tech_stack']
+                    enriched += 1
+                if idx % 5 == 0:
+                    print(f"  ✓ {idx}/{len(spaces_list)} 처리 ({enriched} 보강 완료)")
+            except Exception as e:
+                continue
+        print(f"✅ PHASE 2 완료: {enriched}/{len(spaces_list)} LLM 보강\n")
+
+        try:
+            save_spaces_to_db(spaces_list)
+        except Exception as e:
+            print(f"  ⚠️ DB 최종 저장 오류: {e}")
+
+        return spaces_list
             
         except Exception as e:
             print(f"❌ 스페이스 수집 오류: {e}")
@@ -2132,7 +2214,7 @@ class AdvancedAIAnalyzer:
             analyzed_spaces = self.fetch_huggingface_spaces(30)
         else:
             print("💾 DB 우선 로드 모드\n")
-            
+
             # DB에서 먼저 로드
             analyzed_news = load_news_from_db()
             if not analyzed_news:
@@ -2140,18 +2222,24 @@ class AdvancedAIAnalyzer:
                 analyzed_news = self.analyze_all_news()
             else:
                 print(f"✅ DB에서 {len(analyzed_news)}개 뉴스 로드\n")
-            
+
+            # 모델: DB가 비었거나 모델 수가 비정상적으로 적으면 새로 수집
             analyzed_models = load_models_from_db()
-            if not analyzed_models:
-                print("🤗 DB에 모델 없음 → 새로 수집")
-                analyzed_models = self.fetch_huggingface_models(30)
+            if len(analyzed_models) < 5:
+                print(f"🤗 DB 모델 {len(analyzed_models)}개 (부족) → 새로 수집")
+                fresh_models = self.fetch_huggingface_models(30)
+                if fresh_models:
+                    analyzed_models = fresh_models
             else:
                 print(f"✅ DB에서 {len(analyzed_models)}개 모델 로드\n")
-            
+
+            # 스페이스: DB가 비었거나 스페이스 수가 비정상적으로 적으면 새로 수집
             analyzed_spaces = load_spaces_from_db()
-            if not analyzed_spaces:
-                print("🚀 DB에 스페이스 없음 → 새로 수집")
-                analyzed_spaces = self.fetch_huggingface_spaces(30)
+            if len(analyzed_spaces) < 5:
+                print(f"🚀 DB 스페이스 {len(analyzed_spaces)}개 (부족) → 새로 수집")
+                fresh_spaces = self.fetch_huggingface_spaces(30)
+                if fresh_spaces:
+                    analyzed_spaces = fresh_spaces
             else:
                 print(f"✅ DB에서 {len(analyzed_spaces)}개 스페이스 로드\n")