revert

app.py

@@ -1,148 +1,126 @@
 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 logging
-from discord.ext import commands
-
-# Set up logging
-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__)
+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 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
 
 DISCORD_TOKEN = os.environ.get("DISCORD_TOKEN", None)
-if not DISCORD_TOKEN:
-    logger.error("DISCORD_TOKEN not set. Exiting.")
-    sys.exit(1)
-
-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):
-    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:
-            logger.error(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)
-                logger.info(f"Role added to member: {member}")
-
-                # Send confirmation to Lunar (optional)
-                lunar = bot.get_user(LUNAR_ID)
-                if lunar:
-                    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}")
+intents = discord.Intents.all() 
+bot = commands.Bot(command_prefix='!', intents=intents)
 
-async def give_verified_roles():
-    guild = bot.get_guild(GUILD_ID)
-    role = guild.get_role(ROLE_ID)
+scheduler = AsyncIOScheduler()
+
+def restart_bot():
+    print("Restarting bot...")
+    os.execv(sys.executable, ['python'] + sys.argv)
 
-    if not guild or not role:
-        logger.error("Guild or role not found. Exiting loop.")
-        return
+@scheduler.scheduled_job('interval', minutes=60)
+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 give_verified_roles():
     while True:
         try:
+            global_df = pd.DataFrame()
+
             async with aiohttp.ClientSession() as session:
                 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:
-                            logger.error(f"Failed to fetch CSV: HTTP {response.status}")
+                            print(f"Failed to fetch CSV: HTTP {response.status}")
                             await asyncio.sleep(30)
                             continue
-
                         csv_data = await response.text()
-                        global_df = await asyncio.to_thread(pd.read_csv, io.StringIO(csv_data))
-
+                        global_df = pd.read_csv(io.StringIO(csv_data))
                 except asyncio.TimeoutError:
-                    logger.error("CSV fetch timed out.")
+                    print("CSV fetch timed out.")
                     await asyncio.sleep(30)
                     continue
                 except Exception as e:
-                    logger.error(f"Error fetching CSV: {e}")
+                    print(f"Error fetching CSV: {e}")
                     await asyncio.sleep(30)
                     continue
 
-            # 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
+            guild = bot.get_guild(879548962464493619)
+            role = guild.get_role(900063512829755413)
+
+            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)
 
         except Exception as e:
-            logger.error(f"Error in give_verified_roles loop: {e}")
+            print(f"Error encountered: {e}")
+        await asyncio.sleep(10) # 30
 
-        await asyncio.sleep(30)
+def run_bot():
+    bot.run(DISCORD_TOKEN)
 
-@bot.event
-async def on_ready():
-    logger.info(f"We have logged in as {bot.user}")
-    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())
-    bot.loop.create_task(heartbeat())
-
-async def heartbeat():
-    while True:
-        logger.info("Heartbeat: Bot is active.")
-        await asyncio.sleep(60)
+threading.Thread(target=run_bot).start()
 
-# Gradio setup
 def greet(name):
     return "Hello " + name + "!"
-
 demo = gr.Interface(fn=greet, inputs="text", outputs="text")
-
-async def main():
-    gradio_thread = asyncio.to_thread(demo.launch, share=False)
-    await asyncio.gather(
-        bot.start(DISCORD_TOKEN),
-        gradio_thread
-    )
-
-if __name__ == "__main__":
-    try:
-        asyncio.run(main())
-    except KeyboardInterrupt:
-        logger.info("Shutting down...")
+demo.launch()