Spaces:

discord-community
/

LevelBot

Running on CPU Upgrade

LevelBot / app.py

Style the first few rows of cells (gold silver bronze, first 2nd 3rd etc)

fbbc411 4 months ago

41.6 kB

	import asyncio
	import csv
	import datetime
	import json
	import logging
	import os
	import os.path
	import random
	import re
	import threading
	import time

	import discord
	import gradio as gr
	import gradio_client
	import gspread
	import numpy as np
	import pandas as pd
	import requests

	from requests import HTTPError
	from apscheduler.executors.pool import ThreadPoolExecutor
	from apscheduler.schedulers.background import BackgroundScheduler
	from discord import Color, Embed
	from discord.ext import commands, tasks
	from gradio_client import Client
	from gspread_dataframe import get_as_dataframe, set_with_dataframe
	from gspread_formatting.dataframe import format_with_dataframe
	from huggingface_hub import HfApi, list_liked_repos, list_metrics, list_models
	from tabulate import tabulate
	from datetime import datetime


	DISCORD_TOKEN = os.environ.get("DISCORD_TOKEN", None)
	intents = discord.Intents.all()
	bot = commands.Bot(command_prefix='!', intents=intents)


	""""""
	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")


	@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}")

	"""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)"""
	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")

	else:
	print(f"Failed to retrieve data for user {user}. Status code: {response.status_code}")


	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("------------------------------------------------------------------------")

	executor = ThreadPoolExecutor(max_workers=2)
	scheduler = BackgroundScheduler(executors={'default': executor})
	scheduler.add_job(update_google_sheet, trigger='interval', minutes=1, max_instances=2)
	scheduler.add_job(update_hub_stats, trigger='interval', minutes=1.5, max_instances=2)
	scheduler.start()


	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):
	global global_df
	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, message me '!auth <TOKEN>' using your API token found here: https://huggingface.co/settings/token"
	)
	if message.content.startswith('!auth'):
	await asyncio.sleep(3)
	lunar = bot.get_user(811235357663297546)
	token = message.content.split()[-1].strip()
	try:
	user = HfApi().whoami(token)
	except HTTPError as e:
	await message.channel.send(f"Error occured when trying to authenticate. Likely invalid API Token. {e}")
	token = "abc" # reset right after we use to be safe

	if user['type'] == 'org':
	await message.channel.send(
	"Authentication failed because you tried to authenticate with an organization's API token. Please authenticate with your User API token instead."
	)
	return

	try:
	server = bot.get_guild(879548962464493619)
	#role = discord.utils.get(server.roles, name="verified")
	role = server.get_role(900063512829755413)
	member = server.get_member(message.author.id)
	verified_date = datetime.now().strftime("%m/%d/%Y, %H:%M:%S")
	likes = 0
	models = 0
	datasets = 0
	spaces = 0
	discussions = 0
	papers = 0
	upvotes = 0
	# important!-----------------------------------------------------------------------------
	# In order to add verification to a discord account, some important checks must ALL pass:
	# 1. Discord account should not already have verified role.
	# 2. hf_user_name should not already exist in the dataframe.
	# -----> If it does, it means we are trying to link 1 HF account to multiple discord accounts. 1->many is disallowed.

	# check if the member has the verified role (prevent duplicate entries in google sheet)
	# if users want to change discord / HF accounts, we can deal with that manually
	if role in member.roles:
	await message.channel.send(f"{member} already has has the '{role}' role and is already verified! To change discord accounts or HF accounts, contact <@811235357663297546> or adam@huggingface.co")
	return

	# check if hf_user_name in dataframe:
	if user['name'] in global_df['hf_user_name'].values:
	await message.channel.send(f"The HF account {user['name']} is already verified! To change discord accounts or HF accounts, contact <@811235357663297546> or adam@huggingface.co")
	return

	# check if discord_user_id in dataframe:
	altered_member_id = "L" + str(member.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
	global_df.loc[global_df['discord_user_id'] == altered_member_id, 'hf_user_name'] = user['name']
	global_df.loc[global_df['discord_user_id'] == altered_member_id, 'verified_date'] = verified_date
	await member.add_roles(role)
	if role in member.roles:
	print(f"Updated hf_user_name for id {member.id} \| discord_user_name {member} \| hf_user_name {user['name']}")
	await message.channel.send(f"Verification successful! [{member} <---> {user['name']}] 🤗")
	await lunar.send(f"Verification successful! [{member} <---> {user['name']}] 🤗")
	print(f"Verification successful! [{member} <---> {user['name']}] 🤗")
	return
	else:
	await message.channel.send(f"The Discord account {member} is already verified! To change discord accounts or HF accounts, contact <@811235357663297546> or adam@huggingface.co")
	await lunar.send(f"The Discord account {member} is already verified! To change discord accounts or HF accounts, contact <@811235357663297546> or adam@huggingface.co")
	print(f"The Discord account {member} is already verified! To change discord accounts or HF accounts, contact <@811235357663297546> or adam@huggingface.co")
	return
	except Exception as e:
	print(f"verification Error: {e}")

	# -----------------------------------------------------------------------------------------
	# If creating new record (edge case)
	xp = 10
	discord_exp = "L10L"
	hub_exp = "L0L"
	total_exp = "L10L"
	current_level = calculate_level(xp)

	row_data = [altered_member_id,
	member.name,
	discord_exp,
	current_level,
	user['name'],
	"L0L",
	hub_exp,
	total_exp,
	verified_date,
	likes,
	models,
	datasets,
	spaces,
	discussions,
	papers,
	upvotes]

	global_df.loc[len(global_df.index)] = row_data
	await member.add_roles(role)
	if role in member.roles:
	print(f"New record created for {member}")
	print("------------------------------------------------------------------------")
	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): # can't earn exp from reacting in bot DMs, which is harder to track
	await add_exp(user.id)
	await asyncio.sleep(0.1)
	if reaction.message.author.id != user.id: # can't earn while self-reacting, which is abuseable
	await add_exp(reaction.message.author.id)
	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=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_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}")


	@bot.command()
	async def count_users_with_role(ctx, role_id):
	role = discord.utils.get(ctx.guild.roles, id=int(role_id))
	count = sum(1 for member in ctx.guild.members if role in member.roles)
	await ctx.send(f"Number of users with the role '{role.name}': {count}")


	DISCORD_TOKEN = os.environ.get("DISCORD_TOKEN", None)
	def run_bot():
	bot.run(DISCORD_TOKEN)
	threading.Thread(target=run_bot).start()


	def highlight_rows(dataframe):
	# Define a function that applies styling based on the row index
	def apply_row_styles(row):
	# Check the row index and apply styles accordingly
	if row.name == 0: # first row
	return ['background-color: rgba(255, 232, 170, 0.5)'] * len(row)
	elif row.name == 1: # second row
	return ['background-color: rgba(217, 217, 217, 0.5)'] * len(row)
	elif row.name == 2: # third row
	return ['background-color: rgba(232, 167, 106, 0.5)'] * len(row)
	else:
	return [''] * len(row) # Apply no style for other rows

	# Apply the styling function to each row
	styled = dataframe.style.apply(apply_row_styles, axis=1)
	return styled


	def get_data():
	try:
	return highlight_rows(community_global_df)
	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}")


	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:
	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("📈 Members of the Week", elem_id="week-table", id=1):

	#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()