Update app.py

app.py

@@ -55,10 +55,58 @@ def get_contribution_count(username, github_token, days=30):
     
     return 0
 
-def fetch_github_users(github_token=None, max_users=200, min_followers=10, days=30):
+def is_uae_location(location):
     """
-    Fetch GitHub users from UAE directly using GitHub API
-    Sorted by contributions (primary) and followers (secondary)
+    Check if location string indicates UAE
+    """
+    if not location:
+        return False
+    
+    location = location.lower()
+    
+    # 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
+    for keyword in country_keywords:
+        if keyword in location:
+            return True
+    
+    # Then check city keywords
+    for keyword in city_keywords:
+        if keyword in location:
+            return True
+    
+    return False
+
+def fetch_github_users(github_token=None, max_users=200, min_followers=1, days=30):
+    """
+    Fetch GitHub users from UAE - Country-focused search
     """
     # Read token from environment variable if not provided
     if not github_token:
@@ -72,94 +120,182 @@ def fetch_github_users(github_token=None, max_users=200, min_followers=10, days=
         'Authorization': f'token {github_token}'
     }
 
-    all_users = []
-
-    # Search locations in UAE
-    locations = [
-        'Dubai', 'Abu Dhabi', 'Sharjah', 'Ajman',
-        'United Arab Emirates', 'UAE',
-        'Ras Al Khaimah', 'Fujairah', 'Umm Al Quwain'
-    ]
-
+    all_users = {}  # Use dict to avoid duplicates by login
     status_updates = []
+    total_api_calls = 0
 
     try:
-        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()
-
-                            # Get accurate contribution count using GraphQL
-                            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.")
-                break
-            else:
-                status_updates.append(f"❌ Error searching {location}: {response.status_code}")
-
-            if len(all_users) >= max_users * 2:
+        # PRIORITY 1: Country-level searches (most reliable)
+        country_searches = [
+            'United+Arab+Emirates',
+            'UAE',
+            'U.A.E',
+            '"United Arab Emirates"',
+            '"UAE"',
+            'Emirates',
+        ]
+        
+        status_updates.append("🔍 Phase 1: Searching by country (United Arab Emirates)...")
+        
+        for search_term in country_searches:
+            if total_api_calls >= 200:
                 break
-
+            
+            # Search with different sorting methods to catch different users
+            sort_methods = [
+                ('followers', 'desc'),  # Most followed
+                ('repositories', 'desc'),  # Most repos
+                ('joined', 'desc'),  # Recently joined
+            ]
+            
+            for sort_by, order in sort_methods:
+                if total_api_calls >= 200:
+                    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"  📍 Found {len(users)} users with search '{search_term}' sorted by {sort_by}")
+                    
+                    for user in users:
+                        if user['login'] not in all_users:
+                            if total_api_calls >= 200:
+                                break
+                                
+                            # Fetch detailed user info
+                            user_url = user['url']
+                            user_response = requests.get(user_url, headers=headers)
+                            total_api_calls += 1
+                            
+                            if user_response.status_code == 200:
+                                user_data = user_response.json()
+                                
+                                # Verify location is UAE-related
+                                user_location = user_data.get('location', '')
+                                
+                                if is_uae_location(user_location):
+                                    # Get accurate contribution count
+                                    contributions = get_contribution_count(user['login'], github_token, days)
+                                    
+                                    all_users[user['login']] = {
+                                        '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', ''),
+                                    }
+                                    
+                                    if len(all_users) % 10 == 0:
+                                        status_updates.append(f"  ✅ Collected {len(all_users)} unique UAE users so far...")
+                                
+                                time.sleep(0.5)  # Rate limiting
+                    
+                    time.sleep(1)  # Rate limiting between searches
+                    
+                elif response.status_code == 403:
+                    status_updates.append(f"⚠️ Rate limit reached after {total_api_calls} calls")
+                    break
+                elif response.status_code == 422:
+                    status_updates.append(f"  ⚠️ Search term '{search_term}' invalid, skipping...")
+                    continue
+                else:
+                    status_updates.append(f"  ❌ Error with search '{search_term}': {response.status_code}")
+        
+        # PRIORITY 2: City-level searches as supplementary (if we need more users)
+        if len(all_users) < max_users * 1.5 and total_api_calls < 180:
+            status_updates.append(f"🔍 Phase 2: Supplementary city-level search...")
+            
+            city_searches = [
+                'Dubai',
+                'Abu+Dhabi',
+                'Sharjah',
+                'Ajman',
+            ]
+            
+            for city in city_searches:
+                if total_api_calls >= 200 or len(all_users) >= max_users * 2:
+                    break
+                
+                search_url = f'https://api.github.com/search/users?q=location:{city}+followers:>={min_followers}&sort=followers&order=desc&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', [])
+                    
+                    for user in users[:30]:  # Limit to top 30 per city
+                        if user['login'] not in all_users and total_api_calls < 200:
+                            user_url = user['url']
+                            user_response = requests.get(user_url, headers=headers)
+                            total_api_calls += 1
+                            
+                            if user_response.status_code == 200:
+                                user_data = user_response.json()
+                                user_location = user_data.get('location', '')
+                                
+                                if is_uae_location(user_location):
+                                    contributions = get_contribution_count(user['login'], github_token, days)
+                                    
+                                    all_users[user['login']] = {
+                                        '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)
+                    
+                    time.sleep(1)
+
+        # Convert dict to list
+        users_list = list(all_users.values())
+        
+        status_updates.append(f"📊 Total unique UAE users found: {len(users_list)}")
+        
         # Sort by CONTRIBUTIONS FIRST (descending), then by followers (descending)
-        all_users.sort(key=lambda x: (x['contributions'], x['followers']), reverse=True)
-
+        users_list.sort(key=lambda x: (x['contributions'], x['followers']), reverse=True)
+        
         # Take top contributors based on max_users
-        top_users = all_users[:max_users]
-
+        top_users = users_list[:max_users]
+        
         # Add rank based on contribution order
         for i, user in enumerate(top_users, 1):
             user['rank'] = i
-
+        
         # 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)\n" + "\n".join(status_updates[-5:])
+            
+            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}
+🌍 Search strategy: Country-first (UAE/United Arab Emirates)
+""" + "\n".join(status_updates[-8:])
             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)
 
@@ -167,28 +303,29 @@ 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['Username'].str.lower().str.contains(search_term, na=False) |
+        df['Location'].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("""
-    # 🏆 Top 200 GitHub Contributors in UAE
-    ### Ranked by Accurate Contribution Counts
-
-    **IMPORTANT:** This app requires a GitHub Personal Access Token for accurate contribution counts.
-    The token needs the `read:user` scope for GraphQL API access.
+    # 🇦🇪 Top 200 GitHub Contributors in UAE
+    ### Country-Focused Search with Accurate Contribution Counts
+    
+    **Search Strategy:** Prioritizes "United Arab Emirates" and "UAE" country-level searches, 
+    supplemented by major city searches. This ensures comprehensive coverage.
     """)
-
+    
     with gr.Row():
         token_input = gr.Textbox(
             label="GitHub Personal Access Token (Required)",
@@ -197,46 +334,46 @@ with gr.Blocks(theme=gr.themes.Soft(), title="GitHub UAE Top Contributors") as a
             scale=3
         )
         max_users_input = gr.Slider(
-            label="Max Contributors",
+            label="Max Contributors to Display",
             minimum=10,
             maximum=500,
             value=200,
             step=10,
             scale=1
         )
-
+    
     with gr.Row():
         min_followers_input = gr.Slider(
-            label="Minimum Followers (for initial search)",
-            minimum=1,
-            maximum=100,
-            value=10,
+            label="Minimum Followers (0 = most comprehensive)",
+            minimum=0,
+            maximum=50,
+            value=0,
             step=1
         )
         days_input = gr.Slider(
-            label="Days to Count (30 days = last 30 days, not calendar month)",
+            label="Days to Count Contributions",
             minimum=7,
             maximum=90,
             value=30,
             step=1
         )
-
+    
     with gr.Row():
-        fetch_btn = gr.Button("🚀 Fetch Top Contributors from GitHub", variant="primary", size="lg")
-
-    status_msg = gr.Textbox(label="Status", interactive=False, lines=3)
-
+        fetch_btn = gr.Button("🚀 Fetch Top Contributors from UAE", variant="primary", size="lg")
+    
+    status_msg = gr.Textbox(label="Status & Progress", interactive=False, lines=6)
+    
     with gr.Row():
         search_box = gr.Textbox(
-            label="🔍 Search by Name or Username",
+            label="🔍 Search by Name, Username, or Location",
             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"],
@@ -244,57 +381,68 @@ with gr.Blocks(theme=gr.themes.Soft(), title="GitHub UAE Top Contributors") as a
         wrap=True,
         interactive=False
     )
-
+    
     gr.Markdown("""
     ---
-    **Ranking Criteria:**
-    - **Primary Sort:** Total contributions in selected time period (accurate count from GitHub)
-    - **Secondary Sort:** Followers count
-    - Uses GitHub's GraphQL API for accurate contribution counts
-    - Counts ALL contribution types (commits, PRs, issues, reviews, etc.)
-
-    **How to set up GitHub Token with correct permissions:**
-
-    1. Go to [GitHub Settings > Developer settings > Personal access tokens > Tokens (classic)](https://github.com/settings/tokens)
-    2. Click "Generate new token (classic)"
-    3. Give it a name like "UAE Contributors Tracker"
-    4. Select scopes: **read:user** (this is required for GraphQL API)
-    5. Generate and copy the token
-    6. Either:
-       - Paste it in the field above, OR
-       - Set environment variable: `export GITHUB_TOKEN="ghp_your_token_here"`
-
-    **Why the change?**
-    - The Events API only returns ~100 events and may miss many contributions
-    - GraphQL API gives accurate counts of ALL contribution types
-    - This matches what you see on your GitHub profile
+    **Improved Search Strategy:**
+    
+    ✅ **Phase 1: Country-Level Search (Primary)**
+    - Searches: "United Arab Emirates", "UAE", "U.A.E", "Emirates"
+    - Multiple sort orders: followers, repositories, recently joined
+    - Catches users regardless of city
+    
+    ✅ **Phase 2: City-Level Search (Supplementary)**  
+    - Searches: Dubai, Abu Dhabi, Sharjah, Ajman
+    - Only if needed to reach target count
+    
+    ✅ **Smart Location Verification**
+    - Validates location field contains UAE/Emirates/city keywords
+    - Filters out false positives
+    
+    ✅ **Comprehensive Coverage**
+    - Multiple search variations and sort methods
+    - Automatic deduplication
+    - Up to 200 API calls for thorough search
+    
+    **Ranking:**
+    - Primary: Contributions in last N days (accurate count from GitHub GraphQL)
+    - Secondary: Follower count
+    
+    **Token Setup:**
+    1. [Generate token](https://github.com/settings/tokens) with `read:user` scope
+    2. Paste above or set `GITHUB_TOKEN` environment variable
+    
+    **Tips:**
+    - Set "Minimum Followers" to 0 for most comprehensive results
+    - Increase "Max Contributors" to 300-500 for broader coverage
+    - Takes 2-5 minutes depending on settings
     """)
-
+    
     # 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],