test (self restart adjust)

app.py

@@ -6,40 +6,34 @@ import discord
 import aiohttp
 import pandas as pd
 import gradio as gr
-from datetime import datetime, timedelta
+import logging
 from discord.ext import commands
-from apscheduler.schedulers.asyncio import AsyncIOScheduler
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+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)
-
-# Set up an async scheduler for periodic tasks (like a bot restart)
-scheduler = AsyncIOScheduler()
-
-def restart_bot():
-    print("Restarting bot...")
-    os.execv(sys.executable, ['python'] + sys.argv)
-
-@scheduler.scheduled_job('interval', minutes=60)
-def periodic_restart():
-    print("Scheduled restart triggered...")
-    restart_bot()
+bot = commands.Bot(command_prefix="!", intents=intents)
 
 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')
+    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}")
+            logger.error(f"Error converting Discord ID {discord_id}: {e}")
             return
 
         if not member:
@@ -48,7 +42,7 @@ async def process_row(row, guild, role):
         if role not in member.roles:
             try:
                 await member.add_roles(role)
-                print(f"Role added to member: {member}")
+                logger.info(f"Role added to member: {member}")
                 lunar = bot.get_user(811235357663297546)
                 if lunar:
                     await lunar.send(f"Verified role given to {member}!")
@@ -56,7 +50,7 @@ async def process_row(row, guild, role):
                     f"Verification successful! [{member} <---> {row['discord_user_name']}]"
                 )
             except Exception as e:
-                print(f"Error processing member {member}: {e}")
+                logger.error(f"Error processing member {member}: {e}")
 
 async def give_verified_roles():
     """
@@ -68,48 +62,57 @@ async def give_verified_roles():
                 try:
                     async with session.get(
                         "https://docs.google.com/spreadsheets/d/1C8aLqgCqLYcMiIFf-P_Aosaa03C_WLIB_UyqvjSdWg8/export?format=csv&gid=0",
-                        timeout=10
+                        timeout=10,
                     ) as response:
                         if response.status != 200:
-                            print(f"Failed to fetch CSV: HTTP {response.status}")
+                            logger.error(f"Failed to fetch CSV: HTTP {response.status}")
                             await asyncio.sleep(30)
                             continue
                         csv_data = await response.text()
-                        global_df = pd.read_csv(io.StringIO(csv_data))
+                        # 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:
-                    print("CSV fetch timed out.")
+                    logger.error("CSV fetch timed out.")
                     await asyncio.sleep(30)
                     continue
                 except Exception as e:
-                    print(f"Error fetching CSV: {e}")
+                    logger.error(f"Error fetching CSV: {e}")
                     await asyncio.sleep(30)
                     continue
 
             guild = bot.get_guild(879548962464493619)
             if not guild:
-                print("Guild not found.")
+                logger.error("Guild not found.")
                 await asyncio.sleep(30)
                 continue
             role = guild.get_role(900063512829755413)
             if not role:
-                print("Role not found.")
+                logger.error("Role not found.")
                 await asyncio.sleep(30)
                 continue
 
-            await guild.chunk()  # Cache all guild members
+            # 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)
         except Exception as e:
-            print(f"Error in give_verified_roles loop: {e}")
+            logger.error(f"Error in give_verified_roles loop: {e}")
         await asyncio.sleep(30)  # Adjust the sleep interval as needed
 
 @bot.event
 async def on_ready():
-    print(f"We have logged in as {bot.user}")
-    scheduler.start()
+    logger.info(f"We have logged in as {bot.user}")
     # Start the background role verification loop
     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)
 
 def greet(name):
     return "Hello " + name + "!"
@@ -118,9 +121,8 @@ def greet(name):
 demo = gr.Interface(fn=greet, inputs="text", outputs="text")
 
 async def main():
-    # Launch Gradio in a separate thread (non-blocking) without using the unsupported 'block' parameter
+    # Launch Gradio in a separate thread to avoid blocking
     gradio_thread = asyncio.to_thread(demo.launch, share=False)
-    # Run both the Discord bot and Gradio concurrently
     await asyncio.gather(
         bot.start(DISCORD_TOKEN),
         gradio_thread
@@ -130,4 +132,4 @@ if __name__ == "__main__":
     try:
         asyncio.run(main())
     except KeyboardInterrupt:
-        print("Shutting down...")
+        logger.info("Shutting down...")