test speed upgrade

app.py

@@ -1,45 +1,23 @@
 import os
 import io
-import re
-import csv
 import sys
-import json
-import time
-import random
 import asyncio
 import discord
-import logging
 import aiohttp
-import gspread
-import datetime
-import requests
-import threading
-import schedule
-import gradio_client
-
-import numpy as np
 import pandas as pd
 import gradio as gr
-import plotly.graph_objects as go
-
-from tabulate import tabulate
-from requests import HTTPError
-from gradio_client import Client
-from discord import Color, Embed
-from discord.ui import Button, View
-from discord.ext import commands, tasks
 from datetime import datetime, timedelta
-from urllib.parse import urlparse, parse_qs
+from discord.ext import commands
 from apscheduler.schedulers.asyncio import AsyncIOScheduler
-from gspread_formatting.dataframe import format_with_dataframe
-from gspread_dataframe import get_as_dataframe, set_with_dataframe
-from huggingface_hub import HfApi, list_liked_repos, list_models
 
+# Environment variable for Discord token
 DISCORD_TOKEN = os.environ.get("DISCORD_TOKEN", None)
 
+# Create Discord bot with all intents
 intents = discord.Intents.all() 
 bot = commands.Bot(command_prefix='!', intents=intents)
 
+# Setup an async scheduler for periodic tasks like a bot restart
 scheduler = AsyncIOScheduler()
 
 def restart_bot():
@@ -51,18 +29,41 @@ def periodic_restart():
     print("Scheduled restart triggered...")
     restart_bot()
 
-@bot.event
-async def on_ready():
-    """Import data from Google Sheets -> HF Space df"""
-    print(f"We have logged in as {bot.user}")
-    scheduler.start()
-    await give_verified_roles()
+async def process_row(row, guild, role):
+    """
+    Process a single CSV row to verify a member and add the role if needed.
+    """
+    hf_user_name = row['hf_user_name']
+    if pd.notna(hf_user_name) and hf_user_name.lower() != 'n/a':
+        discord_id = row['discord_user_id'].strip('L')
+        try:
+            member = guild.get_member(int(discord_id))
+        except Exception as e:
+            print(f"Error converting Discord ID {discord_id}: {e}")
+            return
+
+        if not member:
+            return
+        if role not in member.roles:
+            try:
+                await member.add_roles(role)
+                print(f"Role added to member: {member}")
+                lunar = bot.get_user(811235357663297546)
+                if lunar:
+                    await lunar.send(f"Verified role given to {member}!")
+                await member.send(
+                    f"Verification successful! [{member} <---> {row['discord_user_name']}]"
+                )
+            except Exception as e:
+                print(f"Error processing member {member}: {e}")
 
 async def give_verified_roles():
+    """
+    Periodically fetch CSV data from Google Sheets and verify roles for members.
+    """
     while True:
         try:
-            global_df = pd.DataFrame()
-
+            # Fetch the CSV from Google Sheets
             async with aiohttp.ClientSession() as session:
                 try:
                     async with session.get(
@@ -84,43 +85,50 @@ async def give_verified_roles():
                     await asyncio.sleep(30)
                     continue
 
+            # Get the guild and role objects
             guild = bot.get_guild(879548962464493619)
+            if not guild:
+                print("Guild not found.")
+                await asyncio.sleep(30)
+                continue
             role = guild.get_role(900063512829755413)
+            if not role:
+                print("Role not found.")
+                await asyncio.sleep(30)
+                continue
 
-            org_link = "https://huggingface.co/organizations/discord-community/share/wPKRAHYbAlaEaCxUxcqVyaaaeZcYagDvqc"
-            invite_message = "Click to join our community org on the HF Hub!"
-
-            await guild.chunk()
-
-            for index, row in global_df.iterrows():
-                hf_user_name = row['hf_user_name']
-                if pd.notna(hf_user_name) and hf_user_name.lower() != 'n/a':
-                    discord_id = row['discord_user_id'].strip('L')
-                    member = guild.get_member(int(discord_id))
-                    if not member:
-                        continue
-                    if role not in member.roles:
-                        await member.add_roles(role)
-                        #await asyncio.sleep(1)
-                        print(f"Role added to member: {member}")
-                        lunar = bot.get_user(811235357663297546)
-                        if lunar:
-                            await lunar.send(f"Verified role given to {member}!") 
-                        await member.send(
-                            f"Verification successful! [{member} <---> {row['discord_user_name']}] \n🤗 {org_link} {invite_message}"
-                        )
-                        #await asyncio.sleep(1)
+            await guild.chunk()  # Ensure all guild members are cached
 
+            # Process all rows concurrently
+            tasks = [process_row(row, guild, role) for _, row in global_df.iterrows()]
+            await asyncio.gather(*tasks)
         except Exception as e:
-            print(f"Error encountered: {e}")
-        await asyncio.sleep(10) # 30
+            print(f"Error in give_verified_roles loop: {e}")
+        # Adjust the sleep interval based on how often you expect updates
+        await asyncio.sleep(30)
 
-def run_bot():
-    bot.run(DISCORD_TOKEN)
-
-threading.Thread(target=run_bot).start()
+@bot.event
+async def on_ready():
+    print(f"We have logged in as {bot.user}")
+    scheduler.start()
+    # Start the background role verification loop
+    bot.loop.create_task(give_verified_roles())
 
+# A simple Gradio interface function
 def greet(name):
     return "Hello " + name + "!"
+
+# Create the Gradio interface
 demo = gr.Interface(fn=greet, inputs="text", outputs="text")
-demo.launch()
+
+async def main():
+    # Launch Gradio in non-blocking mode so it doesn't interfere with the bot's event loop
+    demo.launch(share=False, block=False)
+    # Start the Discord bot (this will run until the bot is stopped)
+    await bot.start(DISCORD_TOKEN)
+
+if __name__ == "__main__":
+    try:
+        asyncio.run(main())
+    except KeyboardInterrupt:
+        print("Shutting down...")