import os import re import csv import json import time import random import asyncio import discord import logging import os.path import secrets import gspread import datetime import requests import threading 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 apscheduler.executors.pool import ThreadPoolExecutor from apscheduler.executors.asyncio import AsyncIOExecutor from apscheduler.schedulers.asyncio import AsyncIOScheduler from gspread_formatting.dataframe import format_with_dataframe from apscheduler.schedulers.background import BackgroundScheduler from gspread_dataframe import get_as_dataframe, set_with_dataframe from huggingface_hub import HfApi, list_liked_repos, list_metrics, list_models DISCORD_TOKEN = os.environ.get("DISCORD_TOKEN", None) 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") class DMButton(Button): def __init__(self, label, style): super().__init__(label=label, style=style) 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}>" 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 channel = bot.get_channel(900125909984624713) if channel: try: message = await channel.fetch_message(1271145797433557023) if message: button = DMButton(label="Verify Discord Account", style=discord.ButtonStyle.primary) view = View(timeout=None) view.add_item(button) await message.edit(view=view) print("message edited") except discord.NotFound: print(f"Message with ID 1271145797433557023 not found.") except discord.HTTPException as e: 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() give_verified_roles.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)""" try: print("Updating google sheets...") print("------------------------------------------------------------------------") name = "test_merge_worksheet" set_with_dataframe(test_merge_worksheet, global_df) 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("------------------------------------------------------------------------") except Exception as e: print(f"update_google_sheet 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("------------------------------------------------------------------------") @tasks.loop(minutes=1) async def give_verified_roles(): global global_df 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) lunar = bot.get_user(811235357663297546) 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}") 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=2, executor='default') scheduler.add_job(update_hub_stats, trigger='interval', minutes=1.5, max_instances=2, executor='default') #scheduler.add_job(give_verified_roles, trigger='interval', minutes=1, max_instances=1, executor='asyncio') 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'{username}' @tasks.loop(minutes=1) async def remove_huggingfolks(): try: # remove huggingfolks global community_global_df global community_global_df_with_id global community_global_df_gradio community_global_df = global_df.copy() guild = bot.get_guild(879548962464493619) role = discord.utils.get(guild.roles, id=897376942817419265) members_with_role = [member.id for member in guild.members if role in member.roles] # remove L formatting (doesn't affect main global_df) 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.iloc[:, 0] != str(member_id)] # make a copy while discord id column still exists -> use for rank in discord embeds community_global_df_with_id = community_global_df_with_id.copy() # reorder (switching from discord_user_name to hf_user_name) 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] # drop first column (discord id -> this is so we can display the important stuff in the leaderboard) 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') # add profile hyperlinks to gradio demo community_global_df_gradio = community_global_df.copy() # must be a COPY, otherwise it adds a new name for the same dataframe. 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.nlargest(top_num, 'total_exp') top_num_exp['D'] = ['πŸ₯‡','πŸ₯ˆ','πŸ₯‰'] + [''] * (top_num - 3) top_num_rows = top_num_exp.values.tolist() #print(top_30_rows) channel = bot.get_channel(1197143964994773023) message = await channel.fetch_message(1197148293164187678) # put into message / leaderboard 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}") @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) def run_bot(): bot.run(DISCORD_TOKEN) 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}") #------------------------------------------------------------------------------------------------------------------------------- # 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) user_id = query_params.get('user_id', [None])[0] print(f"user_id={user_id}") token = query_params.get('token', [None])[0] print(f"token={token}") print(f"||| token:{token}||| user_id:{user_id}||| profile:{profile}||| user_tokens:{user_tokens}") if user_id is None or token is None: return "# ❌ Invalid link. Generate a new link [here](https://discord.com/channels/879548962464493619/900125909984624713) !" if int(user_id) not in user_tokens or user_tokens[int(user_id)] != token: return "# ❌ Invalid or expired link. Generate a new link [here](https://discord.com/channels/879548962464493619/900125909984624713) !" if profile is None: return f"# ❌ Not logged in with Hugging Face yet." # check if hf_user_name in dataframe: if profile.username in global_df['hf_user_name'].values: return (f"# ❌ The HF account {profile.username} is already verified! To change discord accounts or HF accounts, contact @lunarflu or adam@huggingface.co") # check if discord_user_id in dataframe: altered_member_id = "L" + str(user_id) + "L" if altered_member_id in global_df['discord_user_id'].values: hf_user_name = global_df.loc[global_df['discord_user_id'] == altered_member_id, 'hf_user_name'].iloc[0] if pd.isnull(hf_user_name) or hf_user_name == 'n/a': # empty (no link created yet between discord_user_id and hf_user_name) so we can update verified_date = datetime.now().strftime("%m/%d/%Y, %H:%M:%S") global_df.loc[global_df['discord_user_id'] == altered_member_id, 'hf_user_name'] = profile.username global_df.loc[global_df['discord_user_id'] == altered_member_id, 'verified_date'] = verified_date org_link = "https://huggingface.co/organizations/discord-community/share/wPKRAHYbAlaEaCxUxcqVyaaaeZcYagDvqc" invite_message = "Click to join our community org on the HF Hub!" return (f"# βœ… Verification successful! [Discord ID {user_id} <---> {profile.username}] πŸ€—\n{invite_message}\n{org_link} ") print(f"# βœ… Verification successful! [Discord ID {user_id} <---> {profile.username}] πŸ€—") else: return (f"# ❌ The Discord account {user_id} is already verified! To change discord accounts or HF accounts, contact @lunarflu or adam@huggingface.co") print(f"# ❌ The Discord account {user_id} is already verified! To change discord accounts or HF accounts, contact @lunarflu or adam@huggingface.co") # Remove the token after successful verification del user_tokens[int(user_id)] 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 = """

πŸ€— Hugging Face Level Leaderboard

""" gr.HTML(TITLE) with gr.Tabs(elem_classes="tab-buttons") as tabs: 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("βœ… Discord Verification", elem_id="verify-tab", id=2): login_button = gr.LoginButton() m1 = gr.Markdown() demo.load(verify_button, inputs=None, outputs=m1) def check_login_status(): try: return login_button.get_session().get("oauth_info", None) except AttributeError: return None def check_login_wrapper(): session = check_login_status() if session is None: return "Not logged in." else: return f"Logged in as {session.get('username', 'Unknown')}" login_button.click(check_login_wrapper, inputs=None, outputs=m1) #------------------------------------------------------------------------------ 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: print(f"gradio demo Error: {e}") demo.queue().launch()