Create app.py

app.py

@@ -0,0 +1,245 @@
+import gradio as gr
+import requests
+import pandas as pd
+from datetime import datetime, timedelta
+import time
+import os
+
+def fetch_github_users(github_token=None, max_users=256, min_followers=34):
+    """
+    Fetch GitHub users from UAE directly using GitHub API
+    """
+    # Read token from environment variable if not provided
+    if not github_token:
+        github_token = os.getenv('GITHUB_TOKEN')
+
+    headers = {
+        'Accept': 'application/vnd.github.v3+json',
+    }
+
+    if github_token:
+        headers['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'
+    ]
+
+    status_updates = []
+
+    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()
+
+                            # Fetch user's contribution data (public repos and events)
+                            events_url = f"https://api.github.com/users/{user['login']}/events/public"
+                            events_response = requests.get(events_url, headers=headers)
+
+                            contributions = 0
+                            if events_response.status_code == 200:
+                                events = events_response.json()
+                                # Count push events as contributions
+                                contributions = len([e for e in events if e.get('type') == 'PushEvent'])
+
+                            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 + user_data.get('public_repos', 0),
+                                '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:
+                            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:
+                break
+
+        # Sort by followers and contributions
+        all_users.sort(key=lambda x: (x['followers'], x['contributions']), reverse=True)
+
+        # Add rank
+        for i, user in enumerate(all_users[:max_users], 1):
+            user['rank'] = i
+
+        # Convert to DataFrame
+        df = pd.DataFrame(all_users[:max_users])
+
+        if not df.empty:
+            display_df = df[['rank', 'name', 'login', 'followers', 'public_repos', 'contributions', 'location']].copy()
+            display_df.columns = ['Rank', 'Name', 'Username', 'Followers', 'Public Repos', 'Contributions', 'Location']
+            display_df['GitHub Profile'] = df['login'].apply(lambda x: f"https://github.com/{x}")
+
+            status_message = f"✅ Successfully fetched {len(df)} users\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)
+
+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)
+    )
+    return df[mask]
+
+# Create Gradio interface
+with gr.Blocks(theme=gr.themes.Soft(), title="GitHub UAE Users Fetcher") as app:
+
+    gr.Markdown("""
+    # 🏆 GitHub Users in UAE - Direct Fetcher
+    ### Fetch active GitHub users directly from GitHub API
+
+    **Note:** The app will automatically use `GITHUB_TOKEN` environment variable if set.
+    Without a token, you're limited to 60 requests/hour. With a token: 5000 requests/hour.
+    """)
+
+    with gr.Row():
+        token_input = gr.Textbox(
+            label="GitHub Personal Access Token (Optional - overrides env variable)",
+            placeholder="ghp_xxxxxxxxxxxx or leave empty to use GITHUB_TOKEN env var",
+            type="password",
+            scale=3
+        )
+        max_users_input = gr.Slider(
+            label="Max Users",
+            minimum=10,
+            maximum=500,
+            value=256,
+            step=1,
+            scale=1
+        )
+
+    with gr.Row():
+        min_followers_input = gr.Slider(
+            label="Minimum Followers",
+            minimum=1,
+            maximum=100,
+            value=34,
+            step=1
+        )
+
+    with gr.Row():
+        fetch_btn = gr.Button("🚀 Fetch Users 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 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", "Followers", "Public Repos", "Contributions", "Location", "GitHub Profile"],
+        datatype=["number", "str", "str", "number", "number", "number", "str", "str"],
+        wrap=True,
+        interactive=False
+    )
+
+    gr.Markdown("""
+    ---
+    **How to set up GitHub Token:**
+
+    **Option 1: Environment Variable (Recommended)**
+    ```bash
+    export GITHUB_TOKEN="ghp_your_token_here"
+    python app.py
+    ```
+
+    **Option 2: Manual Input**
+    1. Go to [GitHub Settings > Developer settings > Personal access tokens](https://github.com/settings/tokens)
+    2. Generate new token (classic)
+    3. No special scopes needed for public data
+    4. Copy and paste the token in the field above
+
+    **Data fetched directly from:** GitHub API
+    """)
+
+    # Event handlers
+    def fetch_and_display(token, max_users, min_followers):
+        df, msg = fetch_github_users(token if token else None, int(max_users), int(min_followers))
+        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],
+        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()