Update app.py

app.py

@@ -270,68 +270,223 @@ def make_calendar_heatmap(df, title, year):
     st.pyplot(fig)
 
 
-# Function to fetch follower data for a user
-@lru_cache(maxsize=100)
-def fetch_follower_data(username):
-    try:
-        # Generate fake data for demonstration purposes
-        # In a real implementation, this would make an API call to get actual follower data
-        import random
-        from dateutil.relativedelta import relativedelta
-        
-        # Generate 12 months of fake data
-        today = datetime.now()
-        data = []
-        followers = random.randint(10, 100)
-        
-        for i in range(12):
-            date = today - relativedelta(months=11-i)
-            followers += random.randint(0, 10)
-            data.append({
-                "date": date.strftime("%Y-%m-%d"),
-                "followers": followers
-            })
-        
-        return data
-    except Exception as e:
-        st.error(f"Error generating follower data: {str(e)}")
-        return []
+# Function to create a fancy contribution radar chart
+def create_contribution_radar(username, models_count, spaces_count, datasets_count, commits_count):
+    # Create radar chart for contribution metrics
+    categories = ['Models', 'Spaces', 'Datasets', 'Activity']
+    values = [models_count, spaces_count, datasets_count, commits_count]
+    
+    # Normalize values for better visualization
+    max_vals = [100, 100, 50, 500]  # Reasonable max values for each category
+    normalized = [min(v/m, 1.0) for v, m in zip(values, max_vals)]
+    
+    # Create radar chart
+    angles = np.linspace(0, 2*np.pi, len(categories), endpoint=False).tolist()
+    angles += angles[:1]  # Close the loop
+    
+    normalized += normalized[:1]  # Close the loop
+    
+    fig, ax = plt.subplots(figsize=(6, 6), subplot_kw={'polar': True})
+    
+    # Add background grid
+    ax.set_theta_offset(np.pi / 2)
+    ax.set_theta_direction(-1)
+    ax.set_thetagrids(np.degrees(angles[:-1]), categories)
+    
+    # Draw the chart
+    ax.fill(angles, normalized, color='#4CAF50', alpha=0.25)
+    ax.plot(angles, normalized, color='#4CAF50', linewidth=2)
+    
+    # Add value labels
+    for i, val in enumerate(values):
+        angle = angles[i]
+        x = normalized[i] * np.cos(angle)
+        y = normalized[i] * np.sin(angle)
+        ax.text(angle, normalized[i] + 0.05, str(val), 
+                ha='center', va='center', fontsize=10, 
+                fontweight='bold')
+    
+    ax.set_title(f"{username}'s Contribution Profile", fontsize=15, pad=20)
+    
+    return fig
 
 
-# Function to render follower chart
-def render_follower_chart(username):
-    follower_data = fetch_follower_data(username)
+# Function to create contribution distribution pie chart
+def create_contribution_pie(model_commits, dataset_commits, space_commits):
+    labels = ['Models', 'Datasets', 'Spaces']
+    sizes = [model_commits, dataset_commits, space_commits]
     
-    if not follower_data:
-        st.info(f"No follower data available for {username}")
-        return
+    # Filter out zero values
+    filtered_labels = [label for label, size in zip(labels, sizes) if size > 0]
+    filtered_sizes = [size for size in sizes if size > 0]
+    
+    if not filtered_sizes:
+        return None  # No data to show
+    
+    fig, ax = plt.subplots(figsize=(6, 6))
+    colors = ['#FF9800', '#2196F3', '#4CAF50']
+    filtered_colors = [color for color, size in zip(colors, sizes) if size > 0]
+    
+    # Create exploded pie chart
+    explode = [0.05] * len(filtered_sizes)  # Explode all slices slightly
+    
+    ax.pie(filtered_sizes, labels=filtered_labels, colors=filtered_colors,
+           autopct='%1.1f%%', startangle=90, shadow=True, explode=explode)
+    ax.axis('equal')  # Equal aspect ratio ensures that pie is drawn as a circle
+    
+    ax.set_title('Distribution of Contributions by Type', fontsize=15)
+    
+    return fig
+
+
+# Function to create monthly activity chart
+def create_monthly_activity(df, year):
+    if df.empty:
+        return None
+    
+    # Aggregate by month
+    df['date'] = pd.to_datetime(df['date'])
+    df['month'] = df['date'].dt.strftime('%b')
+    monthly_counts = df.groupby('month')['date'].count().reindex(
+        pd.date_range(start=f'{year}-01-01', end=f'{year}-12-31', freq='MS').strftime('%b')
+    ).fillna(0)
+    
+    # Create bar chart
+    fig, ax = plt.subplots(figsize=(12, 5))
+    months = monthly_counts.index
+    counts = monthly_counts.values
+    
+    bars = ax.bar(months, counts, color='#2196F3')
+    
+    # Highlight the month with most activity
+    if counts.max() > 0:
+        max_idx = counts.argmax()
+        bars[max_idx].set_color('#FF5722')
+    
+    # Add labels and styling
+    ax.set_title(f'Monthly Activity in {year}', fontsize=15)
+    ax.set_xlabel('Month', fontsize=12)
+    ax.set_ylabel('Number of Contributions', fontsize=12)
+    
+    # Add value labels on top of bars
+    for i, count in enumerate(counts):
+        if count > 0:
+            ax.text(i, count + 0.5, str(int(count)), ha='center', fontsize=10)
+    
+    # Add grid for better readability
+    ax.grid(axis='y', linestyle='--', alpha=0.7)
+    
+    plt.xticks(rotation=45)
+    plt.tight_layout()
+    
+    return fig
+
+
+# Function to render follower growth simulation
+def simulate_follower_data(username, spaces_count, models_count, total_commits):
+    # Simulate follower growth based on contribution metrics
+    # This is just a simulation for visual purposes
+    import numpy as np
+    from datetime import timedelta
+    
+    # Start with a base number of followers proportional to contribution metrics
+    base_followers = max(10, int((spaces_count * 2 + models_count * 3 + total_commits/10) / 6))
+    
+    # Generate timestamps for the past year
+    end_date = datetime.now()
+    start_date = end_date - timedelta(days=365)
+    dates = pd.date_range(start=start_date, end=end_date, freq='W')  # Weekly data points
+    
+    # Generate follower growth with some randomness
+    followers = []
+    current = base_followers / 2  # Start from half the base
+    
+    for i in range(len(dates)):
+        growth_factor = 1 + (np.random.random() * 0.1)  # Random growth between 0% and 10%
+        current = current * growth_factor
+        followers.append(int(current))
     
-    # Prepare data for chart
-    dates = [item["date"] for item in follower_data]
-    followers = [item["followers"] for item in follower_data]
+    # Ensure end value matches our base_followers estimate
+    followers[-1] = base_followers
     
     # Create the chart
     fig, ax = plt.subplots(figsize=(12, 5))
-    ax.plot(dates, followers, marker='o', linestyle='-', color='#60A5FA')
+    ax.plot(dates, followers, marker='o', linestyle='-', color='#9C27B0', markersize=5)
     
-    # Set plot styling
-    ax.set_title(f"Follower Evolution for {username}", fontsize=16)
+    # Add styling
+    ax.set_title(f"Estimated Follower Growth for {username}", fontsize=15)
     ax.set_xlabel("Date", fontsize=12)
     ax.set_ylabel("Followers", fontsize=12)
     
-    # Style improvements
+    # Add grid for better readability
     ax.grid(True, linestyle='--', alpha=0.7)
     
-    # Rotate date labels for better readability
+    # Format date axis
     plt.xticks(rotation=45)
-    
-    # Tight layout to ensure everything fits
     plt.tight_layout()
     
-    # Display the chart
-    st.pyplot(fig)
+    return fig
+
+
+# Function to create ranking position visualization
+def create_ranking_chart(username, overall_rank, spaces_rank, models_rank):
+    if not (overall_rank or spaces_rank or models_rank):
+        return None
+    
+    # Create a horizontal bar chart for rankings
+    fig, ax = plt.subplots(figsize=(10, 4))
+    
+    categories = []
+    positions = []
+    colors = []
+    
+    if overall_rank:
+        categories.append('Overall')
+        positions.append(101 - overall_rank)  # Invert rank for visualization (higher is better)
+        colors.append('#673AB7')
+    
+    if spaces_rank:
+        categories.append('Spaces')
+        positions.append(101 - spaces_rank)
+        colors.append('#2196F3')
+    
+    if models_rank:
+        categories.append('Models')
+        positions.append(101 - models_rank)
+        colors.append('#FF9800')
+    
+    # Create horizontal bars
+    bars = ax.barh(categories, positions, color=colors, alpha=0.7)
+    
+    # Add rank values as text
+    for i, bar in enumerate(bars):
+        rank_val = 0
+        if categories[i] == 'Overall': rank_val = overall_rank
+        elif categories[i] == 'Spaces': rank_val = spaces_rank
+        elif categories[i] == 'Models': rank_val = models_rank
+        
+        ax.text(bar.get_width() + 1, bar.get_y() + bar.get_height()/2, 
+                f'Rank #{rank_val}', va='center', fontsize=10, fontweight='bold')
+    
+    # Set chart properties
+    ax.set_xlim(0, 100)
+    ax.set_title(f"Ranking Positions for {username} (Top 100)", fontsize=15)
+    ax.set_xlabel("Percentile (higher is better)", fontsize=12)
+    
+    # Add a vertical line at 90th percentile to highlight top 10
+    ax.axvline(x=90, color='red', linestyle='--', alpha=0.5)
+    ax.text(91, 0.5, 'Top 10', color='red', fontsize=10, rotation=90, va='center')
+    
+    # Invert x-axis to show ranking position more intuitively
+    ax.invert_xaxis()
+    
+    plt.tight_layout()
+    return fig
 
 
+# Import additional libraries for advanced visualizations
+import numpy as np
+
 # Fetch trending accounts with a loading spinner (do this once at the beginning)
 with st.spinner("Loading trending accounts..."):
     trending_accounts, top_owners_spaces, top_owners_models = get_trending_accounts(limit=100)
@@ -494,26 +649,35 @@ with st.sidebar:
 
 # Main Content
 st.title("🤗 Hugging Face Contributions")
+
 if username:
     with st.spinner(f"Fetching commit data for {username}..."):
-        # Display contributor rank if in top 30
+        # Initialize variables for tracking
+        overall_rank = None
+        spaces_rank = None
+        models_rank = None
+        spaces_count = 0
+        models_count = 0
+        datasets_count = 0
+        
+        # Display contributor rank if in top 100
         if username in trending_accounts[:100]:
-            rank = trending_accounts.index(username) + 1
-            st.success(f"🏆 {username} is ranked #{rank} in the top trending contributors!")
+            overall_rank = trending_accounts.index(username) + 1
+            st.success(f"🏆 {username} is ranked #{overall_rank} in the top trending contributors!")
             
             # Find user in spaces ranking
-            spaces_rank = None
             for i, (owner, count) in enumerate(top_owners_spaces):
                 if owner == username:
                     spaces_rank = i+1
+                    spaces_count = count
                     st.info(f"🚀 Spaces Ranking: #{spaces_rank} with {count} spaces")
                     break
             
             # Find user in models ranking
-            models_rank = None
             for i, (owner, count) in enumerate(top_owners_models):
                 if owner == username:
                     models_rank = i+1
+                    models_count = count
                     st.info(f"🧠 Models Ranking: #{models_rank} with {count} models")
                     break
                     
@@ -526,6 +690,11 @@ if username:
                 
             if combined_info:
                 st.success(f"Combined Rankings (Top 100): {', '.join(combined_info)}")
+                
+            # Add ranking visualization
+            rank_chart = create_ranking_chart(username, overall_rank, spaces_rank, models_rank)
+            if rank_chart:
+                st.pyplot(rank_chart)
         
         # Create a dictionary to store commits by type
         commits_by_type = {}
@@ -548,6 +717,23 @@ if username:
         for kind in types_to_fetch:
             try:
                 items = cached_list_items(username, kind)
+                
+                # Update counts for radar chart
+                if kind == "model":
+                    models_count = len(items)
+                elif kind == "dataset":
+
+
+items = cached_list_items(username, kind)
+                
+                # Update counts for radar chart
+                if kind == "model":
+                    models_count = len(items)
+                elif kind == "dataset":
+                    datasets_count = len(items)
+                elif kind == "space":
+                    spaces_count = len(items)
+                    
                 repo_ids = [item.id for item in items]
                 
                 st.info(f"Found {len(repo_ids)} {kind}s for {username}")
@@ -594,14 +780,8 @@ if username:
         # Profile information
         profile_col1, profile_col2 = st.columns([1, 3])
         with profile_col1:
-            # Try to get avatar
-            try:
-                avatar_url = f"https://huggingface.co/avatars/{username}"
-                st.image(avatar_url, width=150)
-            except:
-                st.info("No profile image available")
-        
-        with profile_col2:
+            # Skip avatar image display since it's causing problems
+            st.info(f"Profile: {username}")
             st.metric("Total Commits", total_commits)
             
             # Show contributor rank if in top owners
@@ -611,6 +791,11 @@ if username:
                     break
             
             st.markdown(f"[View Profile on Hugging Face](https://huggingface.co/{username})")
+        
+        with profile_col2:
+            # Display contribution radar chart
+            radar_fig = create_contribution_radar(username, models_count, spaces_count, datasets_count, total_commits)
+            st.pyplot(radar_fig)
 
         # Create DataFrame for all commits
         all_commits = []
@@ -620,13 +805,78 @@ if username:
         if not all_df.empty:
             all_df = all_df.drop_duplicates()  # Remove any duplicate dates
 
+        # Monthly activity chart
+        st.subheader(f"Monthly Activity Pattern ({selected_year})")
+        monthly_fig = create_monthly_activity(all_df, selected_year)
+        if monthly_fig:
+            st.pyplot(monthly_fig)
+        else:
+            st.info(f"No activity data available for {username} in {selected_year}")
+
+        # Calendar heatmap for all commits
+        st.subheader(f"Contribution Calendar ({selected_year})")
         make_calendar_heatmap(all_df, "All Commits", selected_year)
         
-        # Add followers chart section
-        st.subheader(f"👥 Follower Evolution for {username}")
-        render_follower_chart(username)
+        # Contribution distribution pie chart
+        st.subheader("Contribution Distribution by Type")
+        model_commits = commit_counts_by_type.get("model", 0)
+        dataset_commits = commit_counts_by_type.get("dataset", 0)
+        space_commits = commit_counts_by_type.get("space", 0)
+        
+        pie_chart = create_contribution_pie(model_commits, dataset_commits, space_commits)
+        if pie_chart:
+            st.pyplot(pie_chart)
+        else:
+            st.info("No contribution data available to show distribution")
+        
+        # Follower growth simulation
+        st.subheader(f"Follower Growth Simulation")
+        st.caption("Based on contribution metrics - for visualization purposes only")
+        follower_chart = simulate_follower_data(username, spaces_count, models_count, total_commits)
+        st.pyplot(follower_chart)
+        
+        # Add analysis message
+        if total_commits > 0:
+            st.subheader("📊 Analytics Summary")
+            
+            # Contribution pattern analysis
+            monthly_df = pd.DataFrame(all_commits, columns=["date"])
+            monthly_df['date'] = pd.to_datetime(monthly_df['date'])
+            monthly_df['month'] = monthly_df['date'].dt.month
+            
+            if not monthly_df.empty:
+                most_active_month = monthly_df['month'].value_counts().idxmax()
+                month_name = datetime(2020, most_active_month, 1).strftime('%B')
+                
+                st.markdown(f"""
+                ### Activity Analysis for {username}
+                
+                - **Total Activity**: {total_commits} contributions in {selected_year}
+                - **Most Active Month**: {month_name} with {monthly_df['month'].value_counts().max()} contributions
+                - **Repository Breakdown**: {models_count} Models, {spaces_count} Spaces, {datasets_count} Datasets
+                """)
+                
+                # Add ranking context if available
+                if overall_rank:
+                    percentile = 100 - overall_rank
+                    st.markdown(f"""
+                    ### Ranking Analysis
+                    
+                    - **Overall Ranking**: #{overall_rank} (Top {percentile}% of contributors)
+                    """)
+                    
+                    if spaces_rank and spaces_rank <= 10:
+                        st.markdown(f"- 🌟 **Elite Spaces Contributor**: Top 10 ({spaces_rank}) in Spaces contributions")
+                    elif spaces_rank and spaces_rank <= 30:
+                        st.markdown(f"- ✨ **Outstanding Spaces Contributor**: Top 30 ({spaces_rank}) in Spaces contributions")
+                    
+                    if models_rank and models_rank <= 10:
+                        st.markdown(f"- 🌟 **Elite Models Contributor**: Top 10 ({models_rank}) in Models contributions")
+                    elif models_rank and models_rank <= 30:
+                        st.markdown(f"- ✨ **Outstanding Models Contributor**: Top 30 ({models_rank}) in Models contributions")
         
         # Metrics and heatmaps for each selected type
+        st.subheader("Detailed Category Analysis")
         cols = st.columns(len(types_to_fetch)) if types_to_fetch else st.columns(1)
         
         for i, (kind, emoji, label) in enumerate([
@@ -652,4 +902,4 @@ if username:
                         st.metric(f"Commits in {selected_year}", 0)
                         make_calendar_heatmap(pd.DataFrame(), f"{label} Commits", selected_year)
 else:
-    st.info("Please select an account from the sidebar to view contributions.")
+    st.info("Please select an account from the sidebar to view contributions.")