test fix ratelimits, timestampts for logs

app.py

@@ -10,23 +10,27 @@ import logging
 from discord.ext import commands
 
 # Set up logging
-logging.basicConfig(level=logging.INFO)
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+    datefmt="%Y-%m-%d %H:%M:%S"
+)
 logger = logging.getLogger(__name__)
 
-# Environment variable for Discord token
 DISCORD_TOKEN = os.environ.get("DISCORD_TOKEN", None)
 if not DISCORD_TOKEN:
     logger.error("DISCORD_TOKEN not set. Exiting.")
     sys.exit(1)
 
-# Create Discord bot with all intents
 intents = discord.Intents.all()
 bot = commands.Bot(command_prefix="!", intents=intents)
 
+# Cache guild/role globally
+GUILD_ID = 879548962464493619
+ROLE_ID = 900063512829755413
+LUNAR_ID = 811235357663297546
+
 async def process_row(row, guild, role):
-    """
-    Process a single CSV row: if the Discord member associated with the row hasn't received the role, add it.
-    """
     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")
@@ -43,19 +47,34 @@ async def process_row(row, guild, role):
             try:
                 await member.add_roles(role)
                 logger.info(f"Role added to member: {member}")
-                lunar = bot.get_user(811235357663297546)
+
+                # Send confirmation to Lunar (optional)
+                lunar = bot.get_user(LUNAR_ID)
                 if lunar:
-                    await lunar.send(f"Verified role given to {member}!")
-                await member.send(
-                    f"Verification successful! [{member} <---> {row['discord_user_name']}]"
-                )
+                    try:
+                        await lunar.send(f"Verified role given to {member}!")
+                    except discord.Forbidden:
+                        logger.warning("Could not DM Lunar.")
+
+                # DM the user (optional)
+                try:
+                    await member.send(
+                        f"Verification successful! [{member} <---> {row['discord_user_name']}]"
+                    )
+                except discord.Forbidden:
+                    logger.warning(f"Cannot DM {member} — DMs likely off.")
+
             except Exception as e:
                 logger.error(f"Error processing member {member}: {e}")
 
 async def give_verified_roles():
-    """
-    Periodically fetch CSV data from Google Sheets and verify roles for members.
-    """
+    guild = bot.get_guild(GUILD_ID)
+    role = guild.get_role(ROLE_ID)
+
+    if not guild or not role:
+        logger.error("Guild or role not found. Exiting loop.")
+        return
+
     while True:
         try:
             async with aiohttp.ClientSession() as session:
@@ -68,9 +87,10 @@ async def give_verified_roles():
                             logger.error(f"Failed to fetch CSV: HTTP {response.status}")
                             await asyncio.sleep(30)
                             continue
+
                         csv_data = await response.text()
-                        # Offload CSV parsing to avoid blocking the event loop.
                         global_df = await asyncio.to_thread(pd.read_csv, io.StringIO(csv_data))
+
                 except asyncio.TimeoutError:
                     logger.error("CSV fetch timed out.")
                     await asyncio.sleep(30)
@@ -80,48 +100,41 @@ async def give_verified_roles():
                     await asyncio.sleep(30)
                     continue
 
-            guild = bot.get_guild(879548962464493619)
-            if not guild:
-                logger.error("Guild not found.")
-                await asyncio.sleep(30)
-                continue
-            role = guild.get_role(900063512829755413)
-            if not role:
-                logger.error("Role not found.")
-                await asyncio.sleep(30)
-                continue
-
-            # Ensure all guild members are cached.
-            await guild.chunk()
-
-            tasks = [process_row(row, guild, role) for _, row in global_df.iterrows()]
-            await asyncio.gather(*tasks)
+            # Throttled loop to avoid hitting rate limits
+            for _, row in global_df.iterrows():
+                await process_row(row, guild, role)
+                await asyncio.sleep(1.5)  # Delay between role assignments
+
         except Exception as e:
             logger.error(f"Error in give_verified_roles loop: {e}")
-        await asyncio.sleep(30)  # Adjust the sleep interval as needed
+
+        await asyncio.sleep(30)
 
 @bot.event
 async def on_ready():
     logger.info(f"We have logged in as {bot.user}")
-    # Start the background role verification loop
+    guild = bot.get_guild(GUILD_ID)
+    if guild:
+        await guild.chunk()  # Cache members once on ready
+        logger.info("Guild member cache initialized.")
+    else:
+        logger.warning("Guild not found on startup.")
+
     bot.loop.create_task(give_verified_roles())
-    # Optionally, you can add a heartbeat task to log regular status messages.
     bot.loop.create_task(heartbeat())
 
 async def heartbeat():
-    """Simple heartbeat task to indicate the bot is still responsive."""
     while True:
         logger.info("Heartbeat: Bot is active.")
         await asyncio.sleep(60)
 
+# Gradio setup
 def greet(name):
     return "Hello " + name + "!"
 
-# Create the Gradio interface
 demo = gr.Interface(fn=greet, inputs="text", outputs="text")
 
 async def main():
-    # Launch Gradio in a separate thread to avoid blocking
     gradio_thread = asyncio.to_thread(demo.launch, share=False)
     await asyncio.gather(
         bot.start(DISCORD_TOKEN),