test adjust

app.py

@@ -45,31 +45,11 @@ intents = discord.Intents.all()
 bot = commands.Bot(command_prefix='!', intents=intents)
 
 GRADIO_APP_URL = "https://huggingface.co/spaces/discord-community/LevelBot"
-# Dictionary to store user IDs and their corresponding unique strings
-user_tokens = {}
 
 
-""""""
-XP_PER_MESSAGE = 10 # 100k messages = 1M exp = lvl 100
-""""""
-service_account = json.loads(os.environ.get('KEY'))
-file_path = 'service_account.json'
-with open(file_path, 'w') as json_file:
-    json.dump(service_account, json_file)
-gspread_bot = gspread.service_account(filename='service_account.json')
-worksheet = gspread_bot.open("levelbot").sheet1
-test_merge_worksheet = gspread_bot.open("test_merge").sheet1
 """"""
 bot_ids = [1136614989411655780, 1166392942387265536, 1158038249835610123, 1130774761031610388, 1155489509518098565, 1155169841276260546, 1152238037355474964, 1154395078735953930]
 """"""
-api = HfApi()
-""""""
-global_df = pd.DataFrame()
-print(type(global_df))
-community_global_df = pd.DataFrame() 
-community_global_df_with_id = pd.DataFrame()
-community_global_df_gradio = pd.DataFrame()
-test_merge = pd.read_csv("https://docs.google.com/spreadsheets/d/1C8aLqgCqLYcMiIFf-P_Aosaa03C_WLIB_UyqvjSdWg8/export?format=csv&gid=0")
 
 hf_token = os.environ.get("HF_TOKEN")
 
@@ -81,26 +61,28 @@ class DMButton(Button):
     async def callback(self, interaction: discord.Interaction):
         # await interaction.user.send(self.message) # this is for DMs, but users may have DMs disabled
         user_id = interaction.user.id
-        if int(user_id) in user_tokens:
-            del user_tokens[int(user_id)] # always delete all past tokens for a given user when creating new link
-        unique_string = generate_unique_string()
-        user_tokens[user_id] = unique_string
-        unique_link = f"<{GRADIO_APP_URL}?user_id={user_id}&token={unique_string}>"
+    
+        guild = interaction.guild
+        member = guild.get_member(user_id)
+        pending_role = guild.get_role(1380908157475360899) # pending verification role, this is to verify that the discord account actually clicked the button at least once
+
+        if member and pending_role:
+            await member.add_roles(pending_role)
+            print(f"Assigned 'Pending Verification' role to {member.name}") # should log this in #admin-logs properly
+
+        unique_link = f"<{GRADIO_APP_URL}?user_id={user_id}>" # don't need token
         message = f"Login link generated! To complete the verification process:\n- 1 Visit this link,\n- 2 click the '🤗Sign in with Hugging Face' button\n\n{unique_link}"
         await interaction.response.send_message(message, ephemeral=True)
 
 
-def generate_unique_string(length=6):
-    return secrets.token_hex(length // 2)
 
     
 @bot.event
 async def on_ready():
     try:
-        global global_df
-        await asyncio.sleep(1.1)
+
         print(f'Logged in as {bot.user.name}')
-        print(f"XP_PER_MESSAGE: {XP_PER_MESSAGE}")
+
 
         guild = bot.get_guild(879548962464493619)
         await guild.chunk() # get all users into bot cache
@@ -121,541 +103,23 @@ async def on_ready():
                 print(f"Failed to fetch message with ID 1271145797433557023: {e}")        
    
     
-        """import data from google sheets -> HF Space df (doesn't make API call this way, as it's read-only)""" 
-        global_df = test_merge
-        print(f"csv successfully retrieved: \n {global_df}")
-
-
-        # updates both leaderboards
-        remove_huggingfolks.start()
-
-        print("------------------------------------------------------------------------")
-    except Exception as e:
-        print(f"on_ready Error: {e}")
-
-
-def update_google_sheet():
-    """save data from HF Space -> google sheets (makes 1 API call)"""
-    start_time = time.time()
-    timeout = 300
-    try:
-        print("Updating google sheets...")
-        print("------------------------------------------------------------------------")
-        name = "test_merge_worksheet"
-        set_with_dataframe(test_merge_worksheet, global_df)
-        update_hf_dataset(global_df)  # starting to migrate away from google sheets and towards HF datasets
-        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-        print("------------------------------------------------------------------------")
-        print(f"Google sheet {name} {test_merge_worksheet} successfully updated at {timestamp}! \n{global_df}")
-        print("------------------------------------------------------------------------")
-        if time.time() - start_time > timeout:
-            print(f"Job exceeded timeout of {timeout} seconds.")
-    except Exception as e:
-        print(f"update_google_sheet Error: {e}")
-
-
-# starting to migrate away from google sheets and towards HF datasets
-def update_hf_dataset(df, repo_id="lunarflu/levelbot-data", filename="levelbot-data.csv"):
-    try:
-        hf_token = os.environ.get("HF_TOKEN")
-        api = HfApi(token=hf_token)
-
-        with tempfile.NamedTemporaryFile(mode='w', suffix=".csv", delete=False) as tmp:
-            df.to_csv(tmp.name, index=False)
-            api.upload_file(
-                path_or_fileobj=tmp.name,
-                path_in_repo=filename,
-                repo_id=repo_id,
-                repo_type="dataset",
-                token=hf_token,
-                commit_message="Update leaderboard CSV"
-            )
-        print(f"✅ Hugging Face dataset `{repo_id}/{filename}` updated successfully.")
-    except Exception as e:
-        print(f"❌ update_hf_dataset Error: {e}")
-
-
-#@tasks.loop(minutes=1) tasks.loop leads to heartbeat blocked issues (merging calculations too much with normal discord bot functions)
-def update_hub_stats():
-    try:
-        global global_df
-        print("Updating hub stats...")
-        print("------------------------------------------------------------------------")
-
-        for index, row in global_df.iterrows():
-            user = row['hf_user_name']
-            if pd.notna(user):
-                #print(f"user: {user}")
-                url = f"https://huggingface.co/api/users/{user}/overview"
-                #print(f"url: {url}")
-                response = requests.get(url)
-                #print(f"response: {response}")
-                if response.status_code == 200:
-                    data = response.json()
-                    #print(f"data: {data}")
-                    likes = data["numLikes"]
-                    models = data["numModels"]
-                    datasets = data["numDatasets"]
-                    spaces = data["numSpaces"]
-                    discussions = data["numDiscussions"]
-                    papers = data["numPapers"]
-                    upvotes = data["numUpvotes"]
-
-                    # recalculate level as well (no longer only depends on discord activity)
-                    try:
-                        global_df.loc[index, 'likes'] = likes
-                        global_df.loc[index, 'models'] = models
-                        global_df.loc[index, 'datasets'] = datasets
-                        global_df.loc[index, 'spaces'] = spaces
-                        global_df.loc[index, 'discussions'] = discussions
-                        global_df.loc[index, 'papers'] = papers
-                        global_df.loc[index, 'upvotes'] = upvotes    
-
-                        total_hub_activity = likes + models + datasets + spaces + discussions + papers + upvotes
-                        total_hub_exp = total_hub_activity * 20 #2x better than discord
-                        total_hub_exp_string = "L" + str(total_hub_exp) + "L"
-
-                        # hub exp
-                        global_df.loc[index, 'hub_exp'] = total_hub_exp_string
-                        
-                        # total exp (discord + hub)
-                        discord_exp = row['discord_exp']
-                        discord_exp_int = discord_exp.strip('L')
-                        total_exp = int(discord_exp_int) + int(total_hub_exp)
-                        total_exp_string = "L" + str(total_exp) + "L"
-                        global_df.loc[index, 'total_exp'] = total_exp_string
-
-                        # level
-                        level = calculate_level(total_exp)
-                        global_df.loc[index, 'discord_level'] = level
-                        
-                    except Exception as e:
-                        print(f"{e} error updating the dataframe")      
-
-
-    except Exception as e:
-        print(f"Failed to parse data for user {user}. {e}")
-    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-    print("------------------------------------------------------------------------")
-    print(f"Hub stats successfully updated at {timestamp}! \n{global_df}")
-    print("------------------------------------------------------------------------")
-
-                 
-thread_pool_executor = ThreadPoolExecutor(max_workers=2)
-asyncio_executor = AsyncIOExecutor()
-scheduler = BackgroundScheduler(executors={
-    'default': thread_pool_executor
-})
-scheduler.add_job(update_google_sheet, trigger='interval', minutes=1, max_instances=5, executor='default')
-scheduler.add_job(update_hub_stats, trigger='interval', minutes=1.5, max_instances=5, executor='default')
-scheduler.start()
-#asyncio.get_event_loop().run_forever()
-
-
-def calculate_level(xp):
-    return int(xp ** (1.0 / 3.0))
-
-
-def calculate_xp(level):
-    return (int(level ** 3))
-
-    
-async def add_exp(member_id):
-    try:
-        """Uses member_id to create new record or update old one [member_id_column] ... [member_exp_column]"""
-        await asyncio.sleep(0.1)
-        global global_df
-        
-        guild = bot.get_guild(879548962464493619)
-        member = guild.get_member(member_id) # bot.get_user == User, guild.get_member == Member (not the same thing!)
-
-        lvl1 = guild.get_role(1171861537699397733)
-        lvl2 = guild.get_role(1171861595115245699)
-        lvl3 = guild.get_role(1171861626715115591)
-        lvl4 = guild.get_role(1171861657975259206)
-        lvl5 = guild.get_role(1171861686580412497)
-        lvl6 = guild.get_role(1171861900301172736)
-        lvl7 = guild.get_role(1171861936258941018)
-        lvl8 = guild.get_role(1171861968597024868)
-        lvl9 = guild.get_role(1171862009982242836)
-        lvl10 = guild.get_role(1164188093713223721)
-        
-        lvl11 = guild.get_role(1171524944354607104)
-        lvl12 = guild.get_role(1171524990257082458)
-        lvl13 = guild.get_role(1171525021928263791)
-        lvl14 = guild.get_role(1171525062201966724)
-        lvl15 = guild.get_role(1171525098465918996)
-        lvl16 = guild.get_role(1176826165546201099)
-        lvl17 = guild.get_role(1176826221301092392)
-        lvl18 = guild.get_role(1176826260643659776)
-        lvl19 = guild.get_role(1176826288816791693)
-        lvl20 = guild.get_role(1176826319447801896)
-
-        lvl21 = guild.get_role(1195030831174008902)
-        lvl22 = guild.get_role(1195030883351150592)
-        lvl23 = guild.get_role(1196055555006009445)
-        lvl24 = guild.get_role(1196055640917938216)
-        lvl25 = guild.get_role(1196055712506318869)
-        lvl26 = guild.get_role(1196055775924195378)
-        lvl27 = guild.get_role(1196055837018435664)
-        lvl28 = guild.get_role(1196055908267081849)
-        lvl29 = guild.get_role(1196055970804150352)
-        lvl30 = guild.get_role(1196056027720847380)
-
-        lvl31 = guild.get_role(1206542603261186078)
-        lvl32 = guild.get_role(1206542673549205514)
-        lvl33 = guild.get_role(1206542690939048007)
-        lvl34 = guild.get_role(1206542707862806568)
-        lvl35 = guild.get_role(1206542723633512468)
-        lvl36 = guild.get_role(1206542738728681485)
-        lvl37 = guild.get_role(1206542754625101866)
-        lvl38 = guild.get_role(1206542771314364416)
-        lvl39 = guild.get_role(1206542785973321758)
-        lvl40 = guild.get_role(1206542802155208725)     
-
-        lvl41 = guild.get_role(1206568953221218354)
-        lvl42 = guild.get_role(1206568979393413150)
-        lvl43 = guild.get_role(1206568997374394368)
-        lvl44 = guild.get_role(1206569014747463681)
-        lvl45 = guild.get_role(1206569031650385921)
-        lvl46 = guild.get_role(1206569047207182356)
-        lvl47 = guild.get_role(1206569062851805254)
-        lvl48 = guild.get_role(1206569077112315984)
-        lvl49 = guild.get_role(1206569091826057306)
-        lvl50 = guild.get_role(1206569107118493757)        
-        
-        lvls = {
-            1: lvl1, 2: lvl2, 3: lvl3, 4: lvl4, 5: lvl5, 6: lvl6, 7: lvl7, 8: lvl8, 9: lvl9, 10: lvl10,
-            11: lvl11, 12: lvl12, 13: lvl13, 14: lvl14, 15: lvl15, 16: lvl16, 17: lvl17, 18: lvl18, 19: lvl19, 20: lvl20,
-            21: lvl21, 22: lvl22, 23: lvl23, 24: lvl24, 25: lvl25, 26: lvl26, 27: lvl27, 28: lvl28, 29: lvl29, 30: lvl30,
-            31: lvl31, 32: lvl32, 33: lvl33, 34: lvl34, 35: lvl35, 36: lvl36, 37: lvl37, 38: lvl38, 39: lvl39, 40: lvl40,
-            41: lvl41, 42: lvl42, 43: lvl43, 44: lvl44, 45: lvl45, 46: lvl46, 47: lvl47, 48: lvl48, 49: lvl49, 50: lvl50,
-        }              
-
-        member_found = False    
-
-        print(f"Searching for member_id {member_id} in dataframe...")
-        # discord_user_id column
-        # iterate over items of first column (discord_user_id)
-        for index, cell_value in global_df.iloc[:, 0].items():
-            # tldr; set_as_dataframe forces scientific notation which corrupts discord_user_id data.
-            # set_as_dataframe is still highly efficient (1 API call), so we format numerical data as strings,
-            # which results in efficient google sheet updating + data integrity
-            cell_value = str(cell_value)
-            if cell_value.startswith("L") and cell_value.endswith("L"):
-                cell_value_clipped = cell_value[1:-1]
-                if cell_value_clipped == str(member_id): # str(member_id) needed, it is int by default
-                    print("test4")
-                    # if found, update that row...
-                    member_found = True
-                    print(f"Record for {member} found at row {index + 1}, column 1")
-            
-                    # increment the old experience value (better not to replace outright)
-                    old_xp = global_df.loc[index, 'discord_exp']
-
-                    # remove L (write, so we replace)
-                    old_xp = str(old_xp)
-                    if old_xp.startswith("L") and old_xp.endswith("L"):  
-                        old_xp = old_xp[1:-1]                      
-                        
-                    # str -> int temporarily for adding
-                    new_xp = int(old_xp) + XP_PER_MESSAGE
-                    
-                    total_exp = global_df.loc[index, 'total_exp']
-                    hub_xp = global_df.loc[index, 'hub_exp']
-                    
-                    total_exp = str(total_exp)
-                    hub_xp = str(hub_xp)
-                    
-                    if total_exp.startswith("L") and total_exp.endswith("L"):  
-                        total_exp = total_exp[1:-1]
-                    if hub_xp.startswith("L") and hub_xp.endswith("L"):  
-                        hub_xp = hub_xp[1:-1]   
-
-                    # set old level; use this for more accurate logging and jumping multiple levels at once (for example, verifying)
-                    old_total_xp = int(total_exp)
-                    #old_level = calculate_level(old_total_xp)                    
-
-                    # check if hub exp not empty
-                    if hub_xp.strip():  
-                        total_exp = int(new_xp) + int(hub_xp)
-                    else:
-                        total_exp = int(new_xp)
-                    
-                    # total v
-                    current_level = calculate_level(total_exp) 
-
-                    # convert back to string + google sheet proofing
-                    new_xp = str(new_xp)
-                    if not new_xp.startswith("L") and not new_xp.endswith("L"): 
-                        new_xp = "L" + str(new_xp) + "L"
-                    global_df.loc[index, 'discord_exp'] = new_xp # do not change column name
-
-                    # after
-                    total_exp = str(total_exp)
-                    if not total_exp.startswith("L") and not total_exp.endswith("L"): 
-                        total_exp = "L" + str(total_exp) + "L" 
-                    
-                    # add back to dataframe in memory after checking redundantly; 
-                    if total_exp.startswith("L") and total_exp.endswith("L"): 
-                        print("test5")
-                        global_df.loc[index, 'total_exp'] = total_exp # do not change column name 
-                        print(f"Record for {member} updated from {old_total_xp} to {global_df.loc[index, 'total_exp']} (+{XP_PER_MESSAGE}) ")
-                  
-                        # level up
-                        verified_role = guild.get_role(900063512829755413)
-                        
-                        print(f"Current_level for {member}: {current_level}")
-                        if current_level >= 2 and current_level <=50:
-                            print("test6")
-                            current_role = lvls[current_level]
-                            if current_role not in member.roles: # if we need to level up / update role
-                                print("test7")
-                                # finding leaderboard rank + excluding huggingfolks (still need exclusion)
-                                try:
-                                    print("Calculating rank...")
-                                    copy_df = global_df.copy()
-                                    copy_df['discord_user_id'] = copy_df['discord_user_id'].str.strip('L').astype(str)
-                                    copy_df['total_exp'] = copy_df['total_exp'].str.strip('L').astype(int)
-                                    row = copy_df[copy_df['discord_user_id'] == str(member_id)]
-                                    target_exp = row['total_exp'].values[0]
-                                    rank = (copy_df['total_exp'] > target_exp).sum() + 1
-                                    print(f"The rank for {member} based on total_exp is: {rank}")
-                                except Exception as e:
-                                    print(f"Discord ID {member} {member_id} not found in the DataFrame. {e}") 
-                                    rank = "🤗"
-        
-                                # if level 3 -> then send embed, remove some exp
-                                if current_level >= 3: # could change to 4 maybe
-                                    if verified_role not in member.roles:     
-
-                                        # L12345L -> `12345` -> 12345
-                                        total_exp = total_exp[1:-1]
-                                        total_exp = int(total_exp)
-                                        
-                                        if total_exp % 30 == 0: # staggers messages so we don't send one every time exp is earned
-                                            # claim exp (-30 for level 3, but +100 as bonus exp. This scales infinitely until the member verifies,
-                                            # so they can continue earning exp, it just won't translate to levels and the leaderboard.
-                                            # This way they can claim at any time and get a big boost in levels!
-                                            claim_exp = total_exp + 70
-                                                                 
-                                            # send embed 
-                                            embed = Embed(color=Color.red())
-                                            embed.set_author(name=f"{member}", icon_url=member.avatar.url if member.avatar else bot.user.avatar.url)
-                                            embed.title = f"⚠️Your account is not Verified! Unable to level up `🚀` -> `{current_level}` ❌"
-                                            msg = f'🤗 Hey {member}! You can continue leveling up in the Hugging Face Discord server by Verifying your account, and claim `{claim_exp}` bonus exp points!'
-                                            embed.description = f"{msg}"
-                                            verification_link = "https://discord.com/channels/879548962464493619/900125909984624713"
-                                            embed.add_field(name="Verify Here:", value=verification_link, inline=True)
-                                            u_1 = "👑 Earn exp for activity on Discord and HF and climb the ⁠leaderboard !"
-                                            u_2 = "🌎 Feature your content in weekly news and increase its visibility!"
-                                            u_3 = "🚀 Early access to Beta features!"
-                                            u_4 = "🛡️ Secure your progress, and restore if needed!"
-                                            embed.add_field(name="You can Unlock:", value=f"{u_1}\n{u_2}\n{u_3}\n{u_4}", inline=True)
-                                            embed.set_image(url='https://cdn.discordapp.com/attachments/1150399343912833024/1205537451242688573/download_1.png?ex=65d8bb3e&is=65c6463e&hm=042fe7dd3521887db0bd48eeb846de1cc7c75194f9e95215c23512ff61ea3475&')
-                                            
-                                            lunar = bot.get_user(811235357663297546)
-                                            await member.send(embed=embed)  
-                                            await lunar.send(embed=embed)  
-                                            print("Sent verification cap embed to {member}")
-                                            print("------------------------------------------------------------------------")
-                                            return
-                                    
-                                # increment the old level value (better to replace outright)
-                                # only increment level column if you are lvl2 or 3+ with verified role (this may make some members not appear)
-                                global_df.loc[index, 'discord_level'] = current_level # do not change column name  
-
-                                # remove all level roles then add new role
-                                current_level_roles = [role for level, role in lvls.items() if role in member.roles]
-                                if current_level_roles:
-                                    print(f"current_level_roles for {member}: {current_level_roles}")
-                                    for removable_role in current_level_roles:
-                                        await member.remove_roles(removable_role)
-                                        print(f"Removed {removable_role} from {member}")
-                                        removable_role_name = removable_role.name
-                                else:
-                                    removable_role_name = "🚀"
-                                await member.add_roles(current_role)
-                                print(f"Level Up! Gave {member} {current_role}")
- 
-                                if current_level == 2: # special embed with opt-out instructions for discord newcomers
-                                    embed = Embed(color=Color.blue())
-                                    embed.set_author(name=f"{member}", icon_url=member.avatar.url if member.avatar else bot.user.avatar.url)
-                                    embed.title = f"Level Up! `{removable_role_name}` -> `{current_level}`"
-                                    msg = f'🤗 Congrats {member}! You just leveled up in the Hugging Face Discord server. To opt out of these notifications, you can right click -> "Block" me!'
-                                    embed.description = f"{msg}."
-                                    embed.add_field(name="Leaderboard Ranking:", value=f"👑 **{rank}**\n\nhttps://discord.com/channels/879548962464493619/1197143964994773023", inline=True)
-                                    msg3 = "- Posting\n- Reacting / being reacted to\n- Being active on the Hugging Face Hub (verify to link your Hub + Discord accounts!)"
-                                    embed.add_field(name="How to Level Up:", value=msg3, inline=True)
-                                    verification_link = "https://discord.com/channels/879548962464493619/900125909984624713"
-                                    embed.add_field(name="Verify Here:", value=verification_link, inline=True)
-                                    lunar = bot.get_user(811235357663297546)
-                                    await member.send(embed=embed)
-                                    await lunar.send(embed=embed)  
-                                    print(f"Sent levelup embed to {member}")
-                                    return
-                                
-                                if current_role in member.roles:
-                                    # send embed
-                                    embed = Embed(color=Color.blue())
-                                    embed.set_author(name=f"{member}", icon_url=member.avatar.url if member.avatar else bot.user.avatar.url)
-                                    embed.title = f"Level Up! `{removable_role_name}` -> `{current_level}`"
-                                    msg = f'🤗 Congrats {member}! You just leveled up in the Hugging Face Discord server'
-                                    embed.description = f"{msg}."
-                                    embed.add_field(name="Leaderboard Ranking:", value=f"👑 **{rank}**\n\nhttps://discord.com/channels/879548962464493619/1197143964994773023", inline=True)
-                                    msg3 = "- Posting\n- Reacting / being reacted to\n- Being active on the Hugging Face Hub (verify to link your Hub + Discord accounts!)"
-                                    embed.add_field(name="How to Level Up:", value=msg3, inline=True)
-                                    verification_link = "https://discord.com/channels/879548962464493619/900125909984624713"
-                                    embed.add_field(name="Verify Here:", value=verification_link, inline=True)
-        
-                                    lunar = bot.get_user(811235357663297546)
-                                    await member.send(embed=embed)
-                                    await lunar.send(embed=embed)  
-                                    print(f"Sent levelup embed to {member}")                                    
-                    print("------------------------------------------------------------------------")
-        if not member_found: # this only checks if discord_user_id (with L) is present in discord_user_id column, 
-            # if not, create new record
-            print(f"Creating new record for {member}")            
-            
-            xp = 10 # define somewhere else?
-            current_level = calculate_level(xp)
-            xp = str(xp)
-            if not xp.startswith("L") and not xp.endswith("L"): 
-                xp = "L" + str(xp) + "L"            
-            member_id = str(member_id)
-            if not member_id.startswith("L") and not member_id.endswith("L"): 
-                member_id = "L" + str(member_id) + "L"
-            member_name = str(member.name)
-            hf_user_name = "n/a"
-            hub_exp = "L0L"
-            total_exp = xp
-            verified_date = "n/a"
-
-            # need to initialize these when creating new record
-            likes = 0
-            models = 0
-            datasets = 0
-            spaces = 0
-            discussions = 0
-            papers =  0
-            upvotes = 0
-            
-            row_data = [member_id, member_name, xp, current_level, hf_user_name, hub_exp, total_exp, verified_date, likes, models, datasets, spaces, discussions, papers, upvotes]
-            global_df.loc[len(global_df.index)] = row_data  
-
-            print("------------------------------------------------------------------------")
-    except Exception as e:
-        print(f"add_exp Error: {e}")   
-
-
-@bot.event
-async def on_message(message):
-    org_link = "https://huggingface.co/organizations/discord-community/share/wPKRAHYbAlaEaCxUxcqVyaaaeZcYagDvqc"
-    invite_message = "Click to join our community org on the HF Hub!"
-    try:
-        if message.author.id not in bot_ids: # could change to if author does not have bot role (roleid)
-            print(f"adding exp from message {message.author}")
-            await asyncio.sleep(0.1)
-            await add_exp(message.author.id)
-            
-            # add check for verification
-            if message.content.find("!help") != -1:
-                await message.channel.send(
-                    "To verify your 🤗 account, generate a login link in the verification channel! "
-                )                    
-        await bot.process_commands(message)
-    except Exception as e:
-        print(f"on_message Error: {e}")
 
-        
-@bot.event
-async def on_reaction_add(reaction, user):
-    try:
-        if user.id not in bot_ids:
-            print(f"adding exp from react {user}")
-            await asyncio.sleep(0.1) 
-            if not isinstance(reaction.message.channel, discord.DMChannel) and reaction.message.author.id != user.id: # can't earn exp from reacting in bot DMs, which is harder to track, and can't earn while self-reacting, which is abuseable
-                await add_exp(reaction.message.author.id)
-            await asyncio.sleep(0.1)
-            
-    except Exception as e:
-        print(f"on_reaction_add Error: {e}")
-
-
-def format_hyperlink(username):
-    return f'<a target="_blank" href="https://huggingface.co/{username}" style="color: var(--link-text-color);">{username}</a>'
-
-
-
-@tasks.loop(minutes=10)
-async def remove_huggingfolks():
-    try:
-        guild = bot.get_guild(879548962464493619)
-        role = discord.utils.get(guild.roles, id=897376942817419265)
-        await guild.chunk()
-        members_with_role = [member.id for member in guild.members if role in member.roles]
 
-        top_num_rows = await asyncio.to_thread(_remove_huggingfolks_sync, members_with_role)
 
-        channel = bot.get_channel(1197143964994773023)
-        message = await channel.fetch_message(1197148293164187678)
 
-        new_table = tabulate(top_num_rows, headers=["Name", "Level", "Experience", "Rank"], tablefmt="plain")
-        await message.edit(content=f"Updated Leaderboard:\n```\n{new_table}\n```")
-        print("Updated discord leaderboard!")
         print("------------------------------------------------------------------------")
     except Exception as e:
-        print(f"remove_huggingfolks Error: {e}")
-
-
-def _remove_huggingfolks_sync(members_with_role):
-    global community_global_df
-    global community_global_df_with_id
-    global community_global_df_gradio
-
-
-    community_global_df = global_df.copy()
+        print(f"on_ready Error: {e}")
 
-    community_global_df['discord_user_id'] = community_global_df['discord_user_id'].str.strip('L').astype(str)
 
-    for member_id in members_with_role:
-        community_global_df = community_global_df[community_global_df['discord_user_id'] != str(member_id)]
 
-    community_global_df_with_id = community_global_df.copy()
 
-    reorder = ['discord_user_id', 'hf_user_name', 'discord_exp', 'discord_level', 'discord_user_name', 'hub_exp', 'total_exp', 'verified_date']
-    community_global_df = community_global_df[reorder]
 
-    community_global_df.drop(community_global_df.columns[0], axis=1, inplace=True)
-    community_global_df.drop(community_global_df.columns[1], axis=1, inplace=True)
-    community_global_df.drop(community_global_df.columns[2], axis=1, inplace=True)
-    community_global_df.drop(community_global_df.columns[2], axis=1, inplace=True)
-    community_global_df.drop(community_global_df.columns[3], axis=1, inplace=True)
-    
-    # drop rows (records) where hf_user_name does not exist (we display only verified users)
-    community_global_df = community_global_df.dropna(subset=['hf_user_name'])
-    community_global_df['total_exp'] = community_global_df['total_exp'].str.strip('L').astype(int)
-    community_global_df['total_exp'] = pd.to_numeric(community_global_df['total_exp'], errors='coerce').fillna(0).astype(int)
-    community_global_df = community_global_df.nlargest(len(community_global_df), 'total_exp')  
 
-    community_global_df_gradio = community_global_df.copy()
-    community_global_df_gradio['hf_user_name'] = community_global_df_gradio['hf_user_name'].apply(format_hyperlink)
 
-    top_num = 30
-    top_num_exp = community_global_df.head(top_num).copy()
-    top_num_exp['Rank'] = ['🥇', '🥈', '🥉'] + [''] * (top_num - 3)
-    top_num_rows = top_num_exp.values.tolist()
-    return top_num_rows
 
 
 
-@bot.command(name='xp_help')
-async def xp_help(ctx):
-    try:
-        help_message = "How to earn Discord / Hub exp: Post messages, react, Like, discuss, create repos and papers"
-        await ctx.author.send(help_message)
-    except Exception as e:
-        print(f"xp_help Error: {e}")
   
 
 DISCORD_TOKEN = os.environ.get("DISCORD_TOKEN", None)
@@ -664,201 +128,11 @@ def run_bot():
 threading.Thread(target=run_bot).start()
 
 
-def get_data():
-    try:
-        return community_global_df_gradio   
-    except Exception as e:
-        print(f"get_data Error: {e}")
-
-
-def get_data2():
-    try:
-        display_data = {
-            '🤗 Hub (+30 exp)': ['Creating Repos', 'Papers', 'Likes/Upvotes', 'Discussions'],
-            'Discord (+10 exp)': ['Posting messages', 'Reacting', '', '']
-        }
-        display_df = pd.DataFrame(display_data) 
-        return display_df
-    except Exception as e:
-        print(f"get_data2 Error: {e}")    
-
-
-@bot.event
-async def on_member_join(member):
-    try:
-        # Check if the member already has a record
-        global global_df
-        member_id = f"L{member.id}L"  # Ensure consistent formatting with the database
-        if member_id not in global_df['discord_user_id'].values:
-            # Create a new row for the user
-            print(f"Creating new record for {member}")
-            xp = 0  # Start with zero XP
-            current_level = calculate_level(xp)
-            xp = f"L{xp}L"
-            member_name = member.name
-            hf_user_name = "n/a"
-            hub_exp = "L0L"
-            total_exp = xp
-            verified_date = "n/a"
-
-            # Initialize additional columns for the new row
-            likes = 0
-            models = 0
-            datasets = 0
-            spaces = 0
-            discussions = 0
-            papers = 0
-            upvotes = 0
-
-            row_data = [
-                member_id, member_name, xp, current_level, hf_user_name, hub_exp,
-                total_exp, verified_date, likes, models, datasets, spaces, discussions,
-                papers, upvotes
-            ]
-            global_df.loc[len(global_df.index)] = row_data  # Add the new row
-
-            print(f"Added new user {member.name} with ID {member.id} to the database.")
-        else:
-            print(f"User {member.name} with ID {member.id} already exists in the database.")
-    except Exception as e:
-        print(f"Error adding new member {member}: {e}")
-
 
 #-------------------------------------------------------------------------------------------------------------------------------
-# year->get all dates
-def get_dates_in_year(year):
-    start_date = datetime(year, 1, 1)
-    end_date = datetime(year + 1, 1, 1)
-    delta = end_date - start_date
-    return [start_date + timedelta(days=i) for i in range(delta.days)]
-
-# HF API->get activity
-def get_user_likes(username):
-    url = f"https://huggingface.co/api/users/{username}/likes"
-    response = requests.get(url)
-    if response.status_code == 200:
-        return response.json()
-    else:
-        print(f"Failed to fetch data: {response.status_code}")
-        return []
-
-# data->get dates
-def parse_activity_dates(activity_data):
-    activity_dates = []
-    for item in activity_data:
-        timestamp = item.get('createdAt')
-        if timestamp:
-            date = datetime.fromisoformat(timestamp[:-1]).date()
-            activity_dates.append(date)
-    return activity_dates
-
-def create_plot(username, year):
-    dates_in_year = get_dates_in_year(year)
-    dates_in_year = [d.date() for d in dates_in_year]
-
-    activity_data = get_user_likes(username)
-    activity_dates = parse_activity_dates(activity_data)
-
-    activity_count = {date: 0 for date in dates_in_year}
-    for date in activity_dates:
-        if date in activity_count:
-            activity_count[date] += 1
-
-    total_activities = sum(activity_count.values())
-
-    # activity->color
-    def get_color(activity_count):
-        if activity_count == 0:
-            return 'white'
-        elif activity_count < 5:
-            return 'lightgreen'
-        elif activity_count < 10:
-            return 'green'
-        else:
-            return 'darkgreen'
-
-    # data->Plotly
-    num_weeks = len(dates_in_year) // 7 + (1 if len(dates_in_year) % 7 != 0 else 0)
-
-    z = [[None for _ in range(num_weeks)] for _ in range(7)]
-    hover_texts = [["" for _ in range(num_weeks)] for _ in range(7)]
-
-    for idx, date in enumerate(dates_in_year):
-        week = idx // 7
-        day = idx % 7
-        z[day][week] = activity_count[date]
-        hover_texts[day][week] = f"{date}: {activity_count[date]} activities"
-
-    # month labels
-    month_labels = ["JAN", "FEB", "MAR", "APR", "MAY", "JUN", "JUL", "AUG", "SEP", "OCT", "NOV", "DEC"]
-    month_positions = [0]  # JAN
-
-    for month in range(2, 13):
-        first_day_of_month = datetime(year, month, 1).date()
-        month_position = (first_day_of_month - datetime(year, 1, 1).date()).days // 7
-        month_positions.append(month_position)
-
-    # heatmap
-    fig = go.Figure(data=go.Heatmap(
-        z=z,
-        x=list(range(num_weeks)),
-        y=list(range(7)),
-        hoverinfo='text',
-        text=hover_texts,
-        showscale=False,
-        colorscale=[
-            [0, 'white'],
-            [0.25, 'lightgreen'],
-            [0.5, 'green'],
-            [1, 'darkgreen']
-        ],
-        zmin=0,
-        zmax=20
-    ))
-
-    # lock the plot size and ensure cells are square
-    cell_size = 20
-    fig.update_layout(
-        title=f'{username} Activity in {year} | Total Contributions: {total_activities}',
-        xaxis_nticks=52,
-        yaxis_nticks=7,
-        xaxis_title=' ',
-        yaxis_title=' ',
-        yaxis=dict(
-            tickmode='array',
-            tickvals=list(range(7)),
-            ticktext=['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday'],
-            scaleanchor="x",  # This ensures that the cells are square
-            scaleratio=1
-        ),
-        xaxis=dict(
-            tickmode='array',
-            tickvals=month_positions,
-            ticktext=month_labels,
-            scaleanchor="y",
-            scaleratio=1,
-            fixedrange=True,  # disable zoom and pan
-        ),
-        autosize=False,
-        width=num_weeks * cell_size,
-        height=14 * cell_size,  # halve height of each cell
-        margin=dict(
-            l=20,
-            r=20,
-            b=20,
-            t=50,
-            pad=2
-        )
-    )
-
-    fig.update_layout(
-        xaxis=dict(fixedrange=True),  # disable zoom and pan
-        yaxis=dict(fixedrange=True)   # disable zoom and pan
-    )
-
-    return fig
-#-------------------------------------------------------------------------------------------------------------------------------
     
+
+"""
 def verify_button(profile: gr.OAuthProfile | None, request: gr.Request) -> str:
     url_str = str(request.url)
     query_params = parse_qs(urlparse(url_str).query)
@@ -903,21 +177,47 @@ def verify_button(profile: gr.OAuthProfile | None, request: gr.Request) -> str:
 
     # Remove the token after successful verification
     del user_tokens[int(user_id)]
+"""
+
+
+
+def verify_button(profile: gr.OAuthProfile | None, request: gr.Request) -> str:
+    query_params = parse_qs(urlparse(str(request.url)).query)
+    user_id = query_params.get('user_id', [None])[0]
+
+    if not user_id:
+        return "# ❌ Missing Discord user ID."
+
+    if profile is None:
+        return "# ❌ You're not logged in with Hugging Face."
+
+    async def upgrade_role():
+        guild = bot.get_guild(879548962464493619)
+        member = guild.get_member(int(user_id))
+        pending_role = guild.get_role(1380908157475360899) # pending
+        verified_role = guild.get_role(900063512829755413) # verified
+
+        if not member:
+            print(f"❌ Could not find Discord user {user_id}")
+            return
+
+        if pending_role in member.roles:
+            await member.remove_roles(pending_role)
+            await member.add_roles(verified_role)
+            print(f"✅ {member.name} verified and upgraded to verified role.")
+        else:
+            print(f"⚠️ {member.name} did not have the pending role. Ignoring.")
+
+    asyncio.create_task(upgrade_role())
+    return f"# ✅ Verification successful! Welcome, {profile.username} 🎉"
+
+
+
 
 
 demo = gr.Blocks()
 with demo:
     try:
-        dataframe1 = pd.read_csv("https://docs.google.com/spreadsheets/d/1C8aLqgCqLYcMiIFf-P_Aosaa03C_WLIB_UyqvjSdWg8/export?format=csv&gid=0") # required for timing
-        print(dataframe1)
-
-        level_counts = dataframe1['discord_level'].value_counts().sort_index()
-        dataframe2 = pd.DataFrame({
-            'Levels': level_counts.index,
-            'Members': level_counts.values
-        })
-        print(dataframe2)
-    
         TITLE = """<h1 align="center" id="space-title">🤗 Hugging Face Level Leaderboard</h1>"""
         gr.HTML(TITLE)
         with gr.Tabs(elem_classes="tab-buttons") as tabs:
@@ -942,42 +242,6 @@ with demo:
             
                 login_button.click(check_login_wrapper, inputs=None, outputs=m1)    
             #------------------------------------------------------------------------------
-            with gr.TabItem("🏅 Level leaderboard", elem_id="level-table", id=0):
-                #gr.Markdown("# 📈 Experience Leaderboard")
-                with gr.Row():
-                    with gr.Column():
-                        gr.DataFrame(get_data, every=5, height=500, datatype=["markdown"], interactive=False, col_count=(3, "fixed"), column_widths=["100px","100px","100px"])
-    
-                    with gr.Column():
-                        gr.BarPlot(
-                            value=dataframe2,
-                            x="Levels",
-                            y="Members",
-                            title="Level Distribution",
-                            height=450,
-                            width=450,
-                            interactive=False
-                        )        
-                with gr.Row():
-                    gr.Markdown("# 📈 How to earn Experience!")
-                with gr.Row():
-                    gr.DataFrame(get_data2, every=5, interactive=False)            
-            #------------------------------------------------------------------------------                    
-            with gr.TabItem("📈 Activity Heatmap", elem_id="activity-heatmap", id=1):
-                with gr.Row():
-                    username_input = gr.Textbox(label="Enter Username")
-                with gr.Row():
-                    year_buttons = [gr.Button(str(year)) for year in range(2021, 2025)]
-                with gr.Row():
-                    plot = gr.Plot(label="Activity Heatmap")
-            
-                # buttons for updating the plot
-                for button in year_buttons:
-                    button.click(
-                        fn=create_plot,
-                        inputs=[username_input, gr.State(int(button.value))],
-                        outputs=plot
-                    )            
          
             #with gr.TabItem("📈 Hub-only leaderboard", elem_id="hub-table", id=2):
     except Exception as e: