Update app.py

app.py

@@ -40,16 +40,24 @@ def cached_list_items(username, kind):
 @lru_cache(maxsize=1)
 def get_trending_accounts(limit=100):
     try:
+        trending_data = {"spaces": [], "models": []}
+        
         # Get spaces for stats calculation
         spaces_response = requests.get("https://huggingface.co/api/spaces", 
                                       params={"limit": 10000}, 
                                       timeout=30)
         
+        # Get models for stats calculation
+        models_response = requests.get("https://huggingface.co/api/models", 
+                                      params={"limit": 10000}, 
+                                      timeout=30)
+        
+        # Process spaces data
         if spaces_response.status_code == 200:
             spaces = spaces_response.json()
             
             # Count spaces by owner
-            owner_counts = {}
+            owner_counts_spaces = {}
             for space in spaces:
                 if '/' in space.get('id', ''):
                     owner, _ = space.get('id', '').split('/', 1)
@@ -57,36 +65,61 @@ def get_trending_accounts(limit=100):
                     owner = space.get('owner', '')
                 
                 if owner != 'None':
-                    owner_counts[owner] = owner_counts.get(owner, 0) + 1
-            
-            # Get top owners by count
-            top_owners = sorted(owner_counts.items(), key=lambda x: x[1], reverse=True)[:limit]
-            
-            # Extract just the owner names for dropdown
-            trending_authors = [owner for owner, count in top_owners]
+                    owner_counts_spaces[owner] = owner_counts_spaces.get(owner, 0) + 1
             
-            return trending_authors, top_owners
-        else:
-            # Fallback to API method if HTTP request fails
-            trending_models = list(api.list_models(sort="trending", limit=limit))
-            trending_datasets = list(api.list_datasets(sort="trending", limit=limit))
-            trending_spaces = list(api.list_spaces(sort="trending", limit=limit))
+            # Get top owners by count for spaces
+            top_owners_spaces = sorted(owner_counts_spaces.items(), key=lambda x: x[1], reverse=True)[:limit]
+            trending_data["spaces"] = top_owners_spaces
+        
+        # Process models data
+        if models_response.status_code == 200:
+            models = models_response.json()
             
-            # Extract unique authors
-            authors = set()
-            for item in trending_models + trending_datasets + trending_spaces:
-                if hasattr(item, "author"):
-                    authors.add(item.author)
-                elif hasattr(item, "id") and "/" in item.id:
-                    authors.add(item.id.split("/")[0])
+            # Count models by owner
+            owner_counts_models = {}
+            for model in models:
+                if '/' in model.get('id', ''):
+                    owner, _ = model.get('id', '').split('/', 1)
+                else:
+                    owner = model.get('owner', '')
+                
+                if owner != 'None':
+                    owner_counts_models[owner] = owner_counts_models.get(owner, 0) + 1
             
-            # Return sorted list of unique authors and empty stats
-            author_list = sorted(list(authors))[:limit]
-            return author_list, [(author, 0) for author in author_list[:30]]
+            # Get top owners by count for models
+            top_owners_models = sorted(owner_counts_models.items(), key=lambda x: x[1], reverse=True)[:limit]
+            trending_data["models"] = top_owners_models
+        
+        # Combine rankings for overall trending (weighted average)
+        combined_scores = {}
+        
+        # Add scores from spaces
+        for owner, count in trending_data["spaces"]:
+            if owner not in combined_scores:
+                combined_scores[owner] = {"spaces": 0, "models": 0, "total": 0}
+            combined_scores[owner]["spaces"] = count
+        
+        # Add scores from models
+        for owner, count in trending_data["models"]:
+            if owner not in combined_scores:
+                combined_scores[owner] = {"spaces": 0, "models": 0, "total": 0}
+            combined_scores[owner]["models"] = count
+        
+        # Calculate total score (spaces + models)
+        for owner in combined_scores:
+            combined_scores[owner]["total"] = combined_scores[owner]["spaces"] + combined_scores[owner]["models"]
+        
+        # Sort by total score
+        sorted_combined = sorted(combined_scores.items(), key=lambda x: x[1]["total"], reverse=True)[:limit]
+        
+        # Extract just the owner names for dropdown
+        trending_authors = [owner for owner, _ in sorted_combined]
+        
+        return trending_authors, trending_data["spaces"], trending_data["models"]
     except Exception as e:
         st.error(f"Error fetching trending accounts: {str(e)}")
         fallback_authors = ["ritvik77", "facebook", "google", "stabilityai", "Salesforce", "tiiuae", "bigscience"]
-        return fallback_authors, [(author, 0) for author in fallback_authors]
+        return fallback_authors, [(author, 0) for author in fallback_authors], [(author, 0) for author in fallback_authors]
 
 
 # Rate limiting
@@ -252,11 +285,20 @@ with st.sidebar:
         ranking_data.index = ranking_data.index + 1  # Start index from 1 for ranking
         
         # Style the table
+        # Add a score column based on spaces count
+        ranking_data["Score"] = ranking_data["Spaces Count"].apply(lambda x: x * 10)  # Multiply by 10 for a score metric
+        
         st.dataframe(
             ranking_data,
             column_config={
                 "Contributor": st.column_config.TextColumn("Contributor"),
-                "Spaces Count": st.column_config.NumberColumn("Spaces Count (based on top 500 spaces)", format="%d")
+                "Spaces Count": st.column_config.NumberColumn("Spaces Count (based on top 500 spaces)", format="%d"),
+                "Score": st.column_config.ProgressColumn(
+                    "Score (within TOP 500 SPACES)",
+                    min_value=0,
+                    max_value=ranking_data["Score"].max() * 1.1,  # Add 10% to max for visual scale
+                    format="%d pts"
+                )
             },
             use_container_width=True,
             hide_index=False
@@ -319,6 +361,18 @@ if username:
         if username in trending_accounts[:30]:
             rank = trending_accounts.index(username) + 1
             st.success(f"🏆 {username} is ranked #{rank} in the top trending contributors!")
+            
+            # Find user in spaces ranking
+            for i, (owner, count) in enumerate(top_owners_spaces):
+                if owner == username:
+                    st.info(f"🚀 Spaces Ranking: #{i+1} with {count} spaces")
+                    break
+            
+            # Find user in models ranking
+            for i, (owner, count) in enumerate(top_owners_models):
+                if owner == username:
+                    st.info(f"🧠 Models Ranking: #{i+1} with {count} models")
+                    break
         
         # Create a dictionary to store commits by type
         commits_by_type = {}