Update app.py

app.py

@@ -5,39 +5,23 @@ from datetime import datetime, timedelta
 import time
 import os
 
-def get_contribution_count_graphql(username, github_token, days=30):
+def get_contribution_count(username, github_token, days=30):
     """
-    Get ACCURATE contribution count using GitHub GraphQL API with proper date range
+    Get accurate contribution count using GitHub GraphQL API
     """
     if not github_token:
-        return 0, "No token provided"
+        return 0
     
-    # Calculate exact date range
     end_date = datetime.now()
     start_date = end_date - timedelta(days=days)
     
-    # Format dates in ISO format with timezone
-    from_date = start_date.strftime('%Y-%m-%dT%H:%M:%SZ')
-    to_date = end_date.strftime('%Y-%m-%dT%H:%M:%SZ')
-    
-    # GraphQL query - get detailed contribution data
     query = """
     query($username: String!, $from: DateTime!, $to: DateTime!) {
       user(login: $username) {
         contributionsCollection(from: $from, to: $to) {
           contributionCalendar {
             totalContributions
-            weeks {
-              contributionDays {
-                contributionCount
-                date
-              }
-            }
           }
-          totalCommitContributions
-          totalIssueContributions
-          totalPullRequestContributions
-          totalPullRequestReviewContributions
         }
       }
     }
@@ -45,8 +29,8 @@ def get_contribution_count_graphql(username, github_token, days=30):
     
     variables = {
         "username": username,
-        "from": from_date,
-        "to": to_date
+        "from": start_date.isoformat(),
+        "to": end_date.isoformat()
     }
     
     headers = {
@@ -58,283 +42,132 @@ def get_contribution_count_graphql(username, github_token, days=30):
         response = requests.post(
             'https://api.github.com/graphql',
             json={'query': query, 'variables': variables},
-            headers=headers,
-            timeout=10
+            headers=headers
         )
         
         if response.status_code == 200:
             data = response.json()
-            
-            # Check for errors in response
-            if 'errors' in data:
-                return 0, f"GraphQL Error: {data['errors']}"
-            
             if 'data' in data and data['data'] and data['data']['user']:
-                contrib_collection = data['data']['user']['contributionsCollection']
-                
-                # Get the total contributions from the calendar
-                total = contrib_collection['contributionCalendar']['totalContributions']
-                
-                # Detailed breakdown (for debugging)
-                commits = contrib_collection.get('totalCommitContributions', 0)
-                issues = contrib_collection.get('totalIssueContributions', 0)
-                prs = contrib_collection.get('totalPullRequestContributions', 0)
-                reviews = contrib_collection.get('totalPullRequestReviewContributions', 0)
-                
-                debug_info = f"Total: {total} (Commits: {commits}, Issues: {issues}, PRs: {prs}, Reviews: {reviews})"
-                
-                return total, debug_info
-            else:
-                return 0, "User not found or no data"
-        else:
-            return 0, f"HTTP Error {response.status_code}: {response.text[:200]}"
-            
+                return data['data']['user']['contributionsCollection']['contributionCalendar']['totalContributions']
     except Exception as e:
-        return 0, f"Exception: {str(e)}"
-
-def is_uae_location(location):
-    """
-    Check if location string indicates UAE - case insensitive matching
-    """
-    if not location:
-        return False
-    
-    # Convert to lowercase and strip whitespace for comparison
-    location_lower = location.lower().strip()
-    
-    # Country-level keywords (highest priority)
-    country_keywords = [
-        'united arab emirates',
-        'uae',
-        'u.a.e',
-        'u.a.e.',
-        'emirates',
-    ]
-    
-    # City keywords (secondary check)
-    city_keywords = [
-        'dubai',
-        'abu dhabi',
-        'abudhabi',
-        'sharjah',
-        'ajman',
-        'ras al khaimah',
-        'ras al-khaimah',
-        'rak',
-        'fujairah',
-        'umm al quwain',
-        'umm al-quwain',
-        'al ain',
-        'dubayy',
-        'دبي',
-        'الإمارات'
-    ]
-    
-    # Check country keywords first (case insensitive)
-    for keyword in country_keywords:
-        if keyword.lower() in location_lower:
-            return True
-    
-    # Then check city keywords (case insensitive)
-    for keyword in city_keywords:
-        if keyword.lower() in location_lower:
-            return True
+        print(f"Error fetching contributions for {username}: {e}")
     
-    return False
+    return 0
 
-def fetch_github_users(github_token=None, max_users=200, min_followers=0, days=30):
+def fetch_github_users(github_token=None, max_users=200, min_followers=10, days=30):
     """
-    Fetch GitHub users from UAE with ACCURATE contribution counts
+    Fetch GitHub users from UAE directly using GitHub API
+    Sorted by contributions (primary) and followers (secondary)
     """
-    # Read token from environment variable if not provided
     if not github_token:
         github_token = os.getenv('GITHUB_TOKEN')
-    
-    if not github_token:
-        return pd.DataFrame(), "❌ GitHub token is REQUIRED. Please provide a token with 'read:user' scope."
 
     headers = {
         'Accept': 'application/vnd.github.v3+json',
-        'Authorization': f'token {github_token}'
     }
 
-    all_users = {}  # Use dict to avoid duplicates by login
+    if github_token:
+        headers['Authorization'] = f'token {github_token}'
+
+    all_users = []
+
+    # Search locations in UAE - KEEP THE ORIGINAL WORKING APPROACH
+    locations = [
+        'Dubai', 'Abu Dhabi', 'Sharjah', 'Ajman',
+        'United Arab Emirates', 'UAE',
+        'Ras Al Khaimah', 'Fujairah', 'Umm Al Quwain'
+    ]
+
     status_updates = []
-    total_api_calls = 0
-    contribution_errors = []
 
     try:
-        # Country-level searches
-        country_searches = [
-            'United+Arab+Emirates',
-            'UAE',
-            '"United Arab Emirates"',
-        ]
-        
-        status_updates.append(f"🔍 Phase 1: Country-level search (UAE)...")
-        status_updates.append(f"📅 Counting contributions from last {days} days")
-        
-        for search_term in country_searches:
-            if total_api_calls >= 150:
-                break
-            
-            # Multiple sort methods to get diverse users
-            sort_methods = [
-                ('followers', 'desc'),
-                ('repositories', 'desc'),
-                ('joined', 'desc'),
-            ]
-            
-            for sort_by, order in sort_methods:
-                if total_api_calls >= 150:
-                    break
-                
-                search_url = f'https://api.github.com/search/users?q=location:{search_term}+followers:>={min_followers}&sort={sort_by}&order={order}&per_page=100'
-                
-                response = requests.get(search_url, headers=headers)
-                total_api_calls += 1
-                
-                if response.status_code == 200:
-                    data = response.json()
-                    users = data.get('items', [])
-                    
-                    status_updates.append(f"  📍 Search '{search_term}' by {sort_by}: {len(users)} users")
-                    
-                    for user in users:
-                        if user['login'] not in all_users:
-                            if total_api_calls >= 150:
-                                break
-                            
-                            # Fetch detailed user info
-                            user_response = requests.get(user['url'], headers=headers)
-                            total_api_calls += 1
+        for location in locations:
+            status_updates.append(f"🔍 Searching users in {location}...")
+
+            # Search users by location and followers
+            search_url = f'https://api.github.com/search/users?q=location:{location}+followers:>={min_followers}&sort=followers&order=desc&per_page=100'
+
+            response = requests.get(search_url, headers=headers)
+
+            if response.status_code == 200:
+                data = response.json()
+                users = data.get('items', [])
+
+                for user in users:
+                    if not any(u['login'] == user['login'] for u in all_users):
+                        # Fetch detailed user info
+                        user_url = user['url']
+                        user_response = requests.get(user_url, headers=headers)
+
+                        if user_response.status_code == 200:
+                            user_data = user_response.json()
                             
-                            if user_response.status_code == 200:
-                                user_data = user_response.json()
-                                user_location = user_data.get('location', '')
-                                
-                                if is_uae_location(user_location):
-                                    # Get ACCURATE contribution count via GraphQL
-                                    contributions, debug_info = get_contribution_count_graphql(
-                                        user['login'], 
-                                        github_token, 
-                                        days
-                                    )
-                                    
-                                    if contributions == 0 and "Error" in debug_info:
-                                        contribution_errors.append(f"{user['login']}: {debug_info}")
-                                    
-                                    all_users[user['login']] = {
-                                        'login': user_data.get('login', ''),
-                                        'name': user_data.get('name') or user_data.get('login', ''),
-                                        'avatar': user_data.get('avatar_url', ''),
-                                        'followers': user_data.get('followers', 0),
-                                        'public_repos': user_data.get('public_repos', 0),
-                                        'contributions': contributions,
-                                        'location': user_data.get('location', ''),
-                                        'bio': user_data.get('bio', ''),
-                                        'company': user_data.get('company', ''),
-                                        'debug_info': debug_info
-                                    }
-                                    
-                                    if len(all_users) % 20 == 0:
-                                        status_updates.append(f"  ✅ Processed {len(all_users)} unique UAE users...")
-                                
-                                time.sleep(0.8)  # Rate limiting - be more conservative
-                    
-                    time.sleep(1.5)
-                    
-                elif response.status_code == 403:
-                    status_updates.append(f"⚠️ Rate limit hit after {total_api_calls} calls")
-                    break
-                elif response.status_code == 422:
-                    continue
-                else:
-                    status_updates.append(f"  ❌ Search error: {response.status_code}")
-        
-        # Phase 2: Major cities
-        if len(all_users) < max_users * 1.5 and total_api_calls < 130:
-            status_updates.append(f"🔍 Phase 2: Major city searches...")
-            
-            cities = ['Dubai', 'Abu+Dhabi', 'Sharjah']
-            
-            for city in cities:
-                if total_api_calls >= 150:
-                    break
-                
-                search_url = f'https://api.github.com/search/users?q=location:{city}+followers:>={min_followers}&sort=followers&order=desc&per_page=50'
-                response = requests.get(search_url, headers=headers)
-                total_api_calls += 1
-                
-                if response.status_code == 200:
-                    users = response.json().get('items', [])
-                    
-                    for user in users[:25]:
-                        if user['login'] not in all_users and total_api_calls < 150:
-                            user_response = requests.get(user['url'], headers=headers)
-                            total_api_calls += 1
+                            # Verify location contains UAE-related keywords (case insensitive)
+                            user_location = (user_data.get('location') or '').lower()
+                            # Keywords are already lowercase for comparison
+                            uae_keywords = ['dubai', 'abu dhabi', 'sharjah', 'ajman', 'uae', 'u.a.e', 
+                                           'united arab emirates', 'ras al khaimah', 'fujairah', 
+                                           'umm al quwain', 'emirates', 'abudhabi', 'rak']
                             
-                            if user_response.status_code == 200:
-                                user_data = user_response.json()
-                                if is_uae_location(user_data.get('location', '')):
-                                    contributions, debug_info = get_contribution_count_graphql(
-                                        user['login'], github_token, days
-                                    )
-                                    
-                                    all_users[user['login']] = {
-                                        'login': user_data.get('login', ''),
-                                        'name': user_data.get('name') or user_data.get('login', ''),
-                                        'avatar': user_data.get('avatar_url', ''),
-                                        'followers': user_data.get('followers', 0),
-                                        'public_repos': user_data.get('public_repos', 0),
-                                        'contributions': contributions,
-                                        'location': user_data.get('location', ''),
-                                        'bio': user_data.get('bio', ''),
-                                        'company': user_data.get('company', ''),
-                                        'debug_info': debug_info
-                                    }
-                                
-                                time.sleep(0.8)
-                    time.sleep(1.5)
-
-        # Convert and sort
-        users_list = list(all_users.values())
-        status_updates.append(f"📊 Found {len(users_list)} unique UAE developers")
-        
-        # Sort by contributions (primary), then followers (secondary)
-        users_list.sort(key=lambda x: (x['contributions'], x['followers']), reverse=True)
-        
-        # Take top N
-        top_users = users_list[:max_users]
-        
-        # Add rank
+                            # Check if any UAE keyword exists in the lowercased location
+                            if not any(keyword in user_location for keyword in uae_keywords):
+                                continue
+
+                            # Get accurate contribution count using GraphQL (FIX: Use GraphQL instead of Events API)
+                            contributions = get_contribution_count(user['login'], github_token, days)
+
+                            all_users.append({
+                                'login': user_data.get('login', ''),
+                                'name': user_data.get('name', user_data.get('login', '')),
+                                'avatar': user_data.get('avatar_url', ''),
+                                'followers': user_data.get('followers', 0),
+                                'public_repos': user_data.get('public_repos', 0),
+                                'contributions': contributions,
+                                'location': user_data.get('location', ''),
+                                'bio': user_data.get('bio', ''),
+                                'company': user_data.get('company', ''),
+                            })
+
+                            time.sleep(0.5)  # Rate limiting
+
+                        if len(all_users) >= max_users * 2:  # Fetch more to ensure we get top contributors
+                            break
+
+                status_updates.append(f"✅ Found {len(users)} users in {location}")
+                time.sleep(1)  # Rate limiting between searches
+
+            elif response.status_code == 403:
+                status_updates.append(f"⚠️ Rate limit reached. Please add a GitHub token.")
+                break
+            else:
+                status_updates.append(f"❌ Error searching {location}: {response.status_code}")
+
+            if len(all_users) >= max_users * 2:
+                break
+
+        # Sort by CONTRIBUTIONS FIRST (descending), then by followers (descending)
+        all_users.sort(key=lambda x: (x['contributions'], x['followers']), reverse=True)
+
+        # Take top contributors based on max_users
+        top_users = all_users[:max_users]
+
+        # Add rank based on contribution order
         for i, user in enumerate(top_users, 1):
             user['rank'] = i
-        
-        # Create DataFrame
+
+        # Convert to DataFrame
         df = pd.DataFrame(top_users)
-        
+
         if not df.empty:
             display_df = df[['rank', 'name', 'login', 'contributions', 'followers', 'public_repos', 'location']].copy()
             display_df.columns = ['Rank', 'Name', 'Username', 'Contributions', 'Followers', 'Public Repos', 'Location']
             display_df['GitHub Profile'] = df['login'].apply(lambda x: f"https://github.com/{x}")
-            
-            status_message = f"""✅ Successfully fetched top {len(df)} contributors (last {days} days)
-📊 Total unique users found: {len(all_users)}
-🔧 API calls made: {total_api_calls}
-📅 Date range: {datetime.now() - timedelta(days=days)} to {datetime.now()}
-
-Recent status:
-""" + "\n".join(status_updates[-6:])
-            
-            if contribution_errors:
-                status_message += f"\n\n⚠️ Contribution fetch errors: {len(contribution_errors)}"
-                status_message += f"\n(First 3: {', '.join(contribution_errors[:3])})"
-            
+
+            status_message = f"✅ Successfully fetched top {len(df)} contributors (last {days} days)\n" + "\n".join(status_updates[-5:])
             return display_df, status_message
         else:
             return pd.DataFrame(), "⚠️ No users found\n" + "\n".join(status_updates)
-    
+
     except Exception as e:
         return pd.DataFrame(), f"❌ Error: {str(e)}\n" + "\n".join(status_updates)
 
@@ -342,53 +175,49 @@ def search_users(df, search_term):
     """Filter users based on search term"""
     if df is None or df.empty:
         return df
+
     if not search_term:
         return df
-    
+
     search_term = search_term.lower()
     mask = (
         df['Name'].str.lower().str.contains(search_term, na=False) |
-        df['Username'].str.lower().str.contains(search_term, na=False) |
-        df['Location'].str.lower().str.contains(search_term, na=False)
+        df['Username'].str.lower().str.contains(search_term, na=False)
     )
     return df[mask]
 
 # Create Gradio interface
 with gr.Blocks(theme=gr.themes.Soft(), title="GitHub UAE Top Contributors") as app:
-    
+
     gr.Markdown("""
-    # 🇦🇪 GitHub UAE Top Contributors Leaderboard
-    ### Accurate Contribution Counting via GitHub GraphQL API
-    
-    **This tool ranks UAE-based developers by their actual contribution count from GitHub's official API.**
-    
-    ⚠️ **IMPORTANT:** You MUST provide a GitHub Personal Access Token with `read:user` scope for accurate contribution counts.
-    
-    **Confirmed to find:** YASSERRMD (Sharjah), zning1994 (Dubai), nkapila6 (Dubai), tschm (Abu Dhabi) and many more!
+    # 🏆 Top 200 GitHub Contributors in UAE (Last 30 Days)
+    ### Ranked by Contributions Using GitHub GraphQL API
+
+    **This version uses the WORKING search from v1 + ACCURATE GraphQL contribution counting**
     """)
-    
+
     with gr.Row():
         token_input = gr.Textbox(
-            label="GitHub Personal Access Token (REQUIRED - needs 'read:user' scope)",
-            placeholder="ghp_xxxxxxxxxxxx or set GITHUB_TOKEN environment variable",
+            label="GitHub Personal Access Token (REQUIRED for GraphQL)",
+            placeholder="ghp_xxxxxxxxxxxx or leave empty to use GITHUB_TOKEN env var",
             type="password",
             scale=3
         )
         max_users_input = gr.Slider(
-            label="Max Contributors to Display",
+            label="Max Contributors",
             minimum=10,
             maximum=500,
             value=200,
             step=10,
             scale=1
         )
-    
+
     with gr.Row():
         min_followers_input = gr.Slider(
-            label="Minimum Followers (0 = everyone)",
+            label="Minimum Followers (for initial search)",
             minimum=0,
-            maximum=50,
-            value=0,
+            maximum=100,
+            value=10,
             step=1
         )
         days_input = gr.Slider(
@@ -398,97 +227,89 @@ with gr.Blocks(theme=gr.themes.Soft(), title="GitHub UAE Top Contributors") as a
             value=30,
             step=1
         )
-    
+
     with gr.Row():
-        fetch_btn = gr.Button("🚀 Fetch Top Contributors", variant="primary", size="lg")
-    
-    status_msg = gr.Textbox(label="Status & Debug Info", interactive=False, lines=8)
-    
+        fetch_btn = gr.Button("🚀 Fetch Top Contributors from GitHub", variant="primary", size="lg")
+
+    status_msg = gr.Textbox(label="Status", interactive=False, lines=3)
+
     with gr.Row():
         search_box = gr.Textbox(
-            label="🔍 Search Results",
-            placeholder="Search by name, username, or location...",
+            label="🔍 Search by Name or Username",
+            placeholder="Type to search...",
             scale=4
         )
         clear_btn = gr.Button("Clear", scale=1)
-    
+
+    # Store the full dataframe
     full_data = gr.State(value=pd.DataFrame())
-    
+
+    # Display dataframe
     data_display = gr.Dataframe(
         headers=["Rank", "Name", "Username", "Contributions", "Followers", "Public Repos", "Location", "GitHub Profile"],
         datatype=["number", "str", "str", "number", "number", "number", "str", "str"],
         wrap=True,
         interactive=False
     )
-    
+
     gr.Markdown("""
     ---
-    ## How It Works:
-    
-    **Data Source:** GitHub GraphQL API (v4) - same data shown on user profiles
-    
-    **Contribution Types Counted:**
-    - Commits to any branch
-    - Pull requests opened
-    - Issues opened  
-    - Pull request reviews
-    - Repository creation and more
-    
-    **Search Strategy:**
-    1. **Country search:** "United Arab Emirates", "UAE" (primary)
-    2. **City search:** Dubai, Abu Dhabi, Sharjah (supplementary)
-    3. **Location verification:** Confirms UAE location in profile
-    4. **Multiple sort orders:** Followers, repos, recently joined
-    
-    **Ranking:** Primary by contributions (last N days), secondary by followers
-    
-    ---
-    
-    ## Setup GitHub Token:
-    
-    1. Go to: https://github.com/settings/tokens
-    2. Click "Generate new token (classic)"
-    3. Name it: "UAE Contributors Tracker"
-    4. **Check the `read:user` scope** (REQUIRED for GraphQL API)
-    5. Generate and copy the token
-    6. Paste above OR set environment variable: `export GITHUB_TOKEN="ghp_..."`
-    
-    ---
-    
-    **Processing Time:** 2-5 minutes depending on settings
-    
-    **Note:** If you see 0 contributions for highly active users, there may be a GraphQL API error (check status output).
+    **What Changed from Original:**
+    - ✅ Kept the WORKING search approach (searches Dubai, Abu Dhabi, Sharjah, UAE, etc.)
+    - ✅ Fixed contribution counting: Now uses GitHub GraphQL API for ACCURATE counts
+    - ✅ GraphQL returns the EXACT number from user's contribution graph (not estimated from events)
+    
+    **Original Problem:**
+    - Events API only returns ~100 events and misses many contributions
+    - GraphQL API returns the actual total contributions for the date range
+    
+    **Ranking:**
+    - Primary: Contributions in last N days (accurate from GraphQL)
+    - Secondary: Followers count
+    
+    **Token Setup (REQUIRED):**
+    1. Go to [GitHub Settings > Tokens](https://github.com/settings/tokens)
+    2. Generate new token (classic)
+    3. Select scope: `read:user` (REQUIRED for GraphQL)
+    4. Copy and paste above OR set `GITHUB_TOKEN` env var
+    
+    **Why Token is Required:**
+    - REST API works without token but with rate limits
+    - GraphQL API REQUIRES authentication
+    - Without token: can search users but contributions will be 0
     """)
-    
+
+    # Event handlers
     def fetch_and_display(token, max_users, min_followers, days):
         df, msg = fetch_github_users(token if token else None, int(max_users), int(min_followers), int(days))
         return df, df, msg
-    
+
     def filter_data(df, search):
         if df is None or df.empty:
             return df
         return search_users(df, search)
-    
+
     def clear_search(df):
         return "", df
-    
+
     fetch_btn.click(
         fn=fetch_and_display,
         inputs=[token_input, max_users_input, min_followers_input, days_input],
         outputs=[full_data, data_display, status_msg]
     )
-    
+
     search_box.change(
         fn=filter_data,
         inputs=[full_data, search_box],
         outputs=data_display
     )
-    
+
     clear_btn.click(
         fn=clear_search,
         inputs=[full_data],
         outputs=[search_box, data_display]
     )
 
+# Launch the app
 if __name__ == "__main__":
     app.launch()