Update app-backup.py

app-backup.py

@@ -292,97 +292,94 @@ target_models = {
     "sel303/llama3-diverce-ver1.6": "https://huggingface.co/sel303/llama3-diverce-ver1.6"    
 }
 
-
 def get_models_data(progress=gr.Progress()):
     """모델 데이터 가져오기"""
     def normalize_model_id(model_id):
         """모델 ID를 정규화"""
         return model_id.strip().lower()
         
-    url = "https://huggingface.co/api/models"
-    
     try:
-        progress(0, desc="Fetching models data...")
-        params = {
+        progress(0, desc="Fetching global rankings...")
+        
+        # 전체 모델 목록 가져오기 (좋아요 순으로 정렬)
+        global_params = {
             'full': 'true',
-            'limit': 3000,  # 3000개로 증가
+            'limit': 10000,  # 10000위까지 확장
             'sort': 'likes',
             'direction': -1
         }
         
-        headers = {'Accept': 'application/json'}
-        
-        response = requests.get(url, params=params, headers=headers)
-        if response.status_code != 200:
-            print(f"API 요청 실패: {response.status_code}")
-            print(f"Response: {response.text}")
-            return create_error_plot(), "<div>모델 데이터를 가져오는데 실패했습니다.</div>", pd.DataFrame()
-        
-        models = response.json()
+        global_response = requests.get(
+            "https://huggingface.co/api/models",
+            headers={'Accept': 'application/json'},
+            params=global_params
+        )
         
-        # 전체 순위 정보 저장 (다운로드 수 기준)
-        model_ranks = {}
-        model_data = {}  # 모든 모델의 상세 데이터 저장
+        if global_response.status_code != 200:
+            print(f"Failed to fetch global rankings: {global_response.status_code}")
+            return create_error_plot(), "<div>전체 순위 데이터를 가져오는데 실패했습니다.</div>", pd.DataFrame()
+            
+        all_global_models = global_response.json()
+        print(f"Fetched {len(all_global_models)} models")
         
-        for idx, model in enumerate(models, 1):
+        # 전체 순위 맵 생성
+        global_ranks = {}
+        for idx, model in enumerate(all_global_models, 1):
             model_id = normalize_model_id(model.get('id', ''))
-            model_data[model_id] = {
+            global_ranks[model_id] = {
                 'rank': idx,
                 'downloads': model.get('downloads', 0),
                 'likes': model.get('likes', 0),
                 'title': model.get('title', 'No Title')
             }
         
-        # target_models 중 순위권 내 모델 필터링
+        # target_models의 상세 정보 가져오기
         filtered_models = []
-        for target_id in target_models.keys():
-            normalized_target_id = normalize_model_id(target_id)
-            
-            # 먼저 전체 순위에서 찾기
-            if normalized_target_id in model_data:
-                model_info = {
-                    'id': target_id,
-                    'rank': model_data[normalized_target_id]['rank'],
-                    'downloads': model_data[normalized_target_id]['downloads'],
-                    'likes': model_data[normalized_target_id]['likes'],
-                    'title': model_data[normalized_target_id]['title']
-                }
-            else:
-                # 순위권 밖의 모델은 개별 API 호출로 정보 가져오기
-                try:
-                    model_url = f"https://huggingface.co/api/models/{target_id}"
-                    model_response = requests.get(model_url, headers=headers)
-                    if model_response.status_code == 200:
-                        model_info = model_response.json()
-                        model_info['id'] = target_id
-                        model_info['rank'] = 'Not in top 3000'
-                    else:
-                        model_info = {
-                            'id': target_id,
-                            'rank': 'Not in top 3000',
-                            'downloads': 0,
-                            'likes': 0,
-                            'title': 'No Title'
-                        }
-                except Exception as e:
-                    print(f"Error fetching data for model {target_id}: {str(e)}")
+        for model_id in target_models.keys():
+            try:
+                # 개별 모델 API 호출로 정확한 정보 가져오기
+                model_url_api = f"https://huggingface.co/api/models/{model_id}"
+                response = requests.get(model_url_api, headers={'Accept': 'application/json'})
+                
+                if response.status_code == 200:
+                    model_data = response.json()
+                    normalized_id = normalize_model_id(model_id)
+                    
+                    # 전체 순위 정보와 개별 모델 정보 결합
+                    rank_info = global_ranks.get(normalized_id, {})
                     model_info = {
-                        'id': target_id,
-                        'rank': 'Not in top 3000',
+                        'id': model_id,
+                        'global_rank': rank_info.get('rank', 'Not in top 10000'),
+                        'downloads': model_data.get('downloads', 0),
+                        'likes': model_data.get('likes', 0),
+                        'title': model_data.get('title', 'No Title')
+                    }
+                    filtered_models.append(model_info)
+                    print(f"Model {model_id}: Rank={model_info['global_rank']}, Likes={model_info['likes']}, Downloads={model_info['downloads']}")
+                else:
+                    print(f"Failed to fetch data for {model_id}: {response.status_code}")
+                    filtered_models.append({
+                        'id': model_id,
+                        'global_rank': 'Not in top 10000',
                         'downloads': 0,
                         'likes': 0,
                         'title': 'No Title'
-                    }
-            
-            filtered_models.append(model_info)
-        
-        # 순위로 정렬 (순위가 숫자인 경우만)
-        filtered_models.sort(key=lambda x: (
-            float('inf') if x['rank'] == 'Not in top 3000' else x['rank']
-        ))
+                    })
+            except Exception as e:
+                print(f"Error fetching data for {model_id}: {str(e)}")
+                filtered_models.append({
+                    'id': model_id,
+                    'global_rank': 'Not in top 10000',
+                    'downloads': 0,
+                    'likes': 0,
+                    'title': 'No Title'
+                })
+        
+        # 순위로 정렬
+        filtered_models.sort(key=lambda x: float('inf') if isinstance(x['global_rank'], str) else x['global_rank'])
         
         if not filtered_models:
-            return create_error_plot(), "<div>선택된 모델의 데이터를 찾을 수 없습니다.</div>", pd.DataFrame()
+            return create_error_plot(), "<div>모델 데이터를 찾을 수 없습니다.</div>", pd.DataFrame()
         
         progress(0.3, desc="Creating visualization...")
         
@@ -391,62 +388,72 @@ def get_models_data(progress=gr.Progress()):
         
         # 데이터 준비
         ids = [model['id'] for model in filtered_models]
-        ranks = [model['rank'] for model in filtered_models]
+        ranks = [model['global_rank'] for model in filtered_models]
         likes = [model['likes'] for model in filtered_models]
         downloads = [model['downloads'] for model in filtered_models]
         
-        # Y축 값을 반전 (숫자 순위만)
-        y_values = [3001 - r if isinstance(r, int) else 0 for r in ranks]
-        
-        # 막대 그래프 생성
-        fig.add_trace(go.Bar(
-            x=ids,
-            y=y_values,
-            text=[f"Rank: {r}<br>Likes: {l:,}<br>Downloads: {d:,}" 
-                  for r, l, d in zip(ranks, likes, downloads)],
-            textposition='auto',
-            marker_color='rgb(158,202,225)',
-            opacity=0.8
-        ))
+        # 순위권 내 모델만 필터링
+        valid_indices = [i for i, rank in enumerate(ranks) if isinstance(rank, (int, float))]
         
-        fig.update_layout(
-            title={
-                'text': 'Hugging Face Models Global Download Rankings (Top 3000)',
-                'y':0.95,
-                'x':0.5,
-                'xanchor': 'center',
-                'yanchor': 'top'
-            },
-            xaxis_title='Model ID',
-            yaxis_title='Global Rank',
-            yaxis=dict(
-                ticktext=[str(i) for i in range(1, 3001, 150)],
-                tickvals=[3001 - i for i in range(1, 3001, 150)],
-                range=[0, 3000]
-            ),
-            height=800,
-            showlegend=False,
-            template='plotly_white',
-            xaxis_tickangle=-45
-        )
+        if valid_indices:  # 순위권 내 모델이 있는 경우만 그래프 생성
+            valid_ids = [ids[i] for i in valid_indices]
+            valid_ranks = [ranks[i] for i in valid_indices]
+            valid_likes = [likes[i] for i in valid_indices]
+            valid_downloads = [downloads[i] for i in valid_indices]
+            
+            # Y축 값을 반전
+            y_values = [10001 - r if isinstance(r, (int, float)) else 0 for r in valid_ranks]
+            
+            # 막대 그래프 생성
+            fig.add_trace(go.Bar(
+                x=valid_ids,
+                y=y_values,
+                text=[f"Global Rank: {r}<br>Likes: {format(l, ',')}<br>Downloads: {format(d, ',')}" 
+                      for r, l, d in zip(valid_ranks, valid_likes, valid_downloads)],
+                textposition='auto',
+                marker_color='rgb(158,202,225)',
+                opacity=0.8
+            ))
+            
+            fig.update_layout(
+                title={
+                    'text': 'Hugging Face Models Global Rankings (by Likes)',
+                    'y':0.95,
+                    'x':0.5,
+                    'xanchor': 'center',
+                    'yanchor': 'top'
+                },
+                xaxis_title='Model ID',
+                yaxis_title='Global Rank',
+                yaxis=dict(
+                    ticktext=[str(i) for i in range(1, 10001, 500)],
+                    tickvals=[10001 - i for i in range(1, 10001, 500)],
+                    range=[0, 10000]
+                ),
+                height=800,
+                showlegend=False,
+                template='plotly_white',
+                xaxis_tickangle=-45
+            )
         
         progress(0.6, desc="Creating model cards...")
         
         # HTML 카드 생성
         html_content = """
         <div style='padding: 20px; background: #f5f5f5;'>
-            <h2 style='color: #2c3e50;'>Models 글로벌 인기 순위 (Top 3000)</h2>
+            <h2 style='color: #2c3e50;'>Models Global Rankings (by Likes)</h2>
             <div style='display: grid; grid-template-columns: repeat(auto-fill, minmax(300px, 1fr)); gap: 20px;'>
         """
         
-        # 순위권 내 모델 카드 생성
         for model in filtered_models:
             model_id = model['id']
-            rank = model['rank']
-            likes = model.get('likes', 0)
-            downloads = model.get('downloads', 0)
+            global_rank = model['global_rank']
+            likes = model['likes']
+            downloads = model['downloads']
             title = model.get('title', 'No Title')
             
+            rank_display = f"Global Rank #{global_rank}" if isinstance(global_rank, (int, float)) else global_rank
+            
             html_content += f"""
             <div style='
                 background: white;
@@ -455,10 +462,10 @@ def get_models_data(progress=gr.Progress()):
                 box-shadow: 0 2px 4px rgba(0,0,0,0.1);
                 transition: transform 0.2s;
             '>
-                <h3 style='color: #34495e;'>Rank #{rank} - {model_id}</h3>
+                <h3 style='color: #34495e;'>{rank_display} - {model_id}</h3>
                 <p style='color: #2c3e50;'>{title}</p>
-                <p style='color: #7f8c8d;'>👍 Likes: {likes:,}</p>
-                <p style='color: #7f8c8d;'>⬇️ Downloads: {downloads:,}</p>
+                <p style='color: #7f8c8d;'>👍 Likes: {format(likes, ',')}</p>
+                <p style='color: #7f8c8d;'>⬇️ Downloads: {format(downloads, ',')}</p>
                 <a href='{target_models[model_id]}' 
                    target='_blank' 
                    style='
@@ -478,17 +485,14 @@ def get_models_data(progress=gr.Progress()):
         html_content += "</div></div>"
         
         # 데이터프레임 생성
-        df_data = []
-        # 모든 모델 정보를 데이터프레임에 추가
-        for model in filtered_models:
-            df_data.append({
-                'Global Rank': model['rank'],
-                'Model ID': model['id'],
-                'Title': model.get('title', 'No Title'),
-                'Likes': f"{model.get('likes', 0):,}",
-                'Downloads': f"{model.get('downloads', 0):,}",
-                'URL': target_models[model['id']]
-            })
+        df_data = [{
+            'Global Rank': model['global_rank'],
+            'Model ID': model['id'],
+            'Title': model.get('title', 'No Title'),
+            'Likes': format(model['likes'], ','),
+            'Downloads': format(model['downloads'], ','),
+            'URL': target_models[model['id']]
+        } for model in filtered_models]
         
         df = pd.DataFrame(df_data)