Spaces:
Running
on
CPU Upgrade
Running
on
CPU Upgrade
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 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) | |
#logger = logging.getLogger(__name__) | |
#logging.basicConfig(level=logging.DEBUG) | |
"""""" | |
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 | |
worksheet2 = gspread_bot.open("hf_discord_verified_users_test").sheet1 | |
"""""" | |
bot_ids = [1136614989411655780, 1166392942387265536, 1158038249835610123, 1130774761031610388, 1155489509518098565, 1155169841276260546, 1152238037355474964, 1154395078735953930] | |
"""""" | |
api = HfApi() | |
"""""" | |
#csv_file = 'data.csv' | |
global_df = pd.DataFrame() | |
worksheet2_df = pd.DataFrame() | |
print(type(global_df)) | |
community_global_df = pd.DataFrame() | |
community_global_df_with_id = pd.DataFrame() | |
data = pd.read_csv("https://docs.google.com/spreadsheets/d/1hQSsIg1Y9WdBF_CdNM1L1rUUREoxKqRTe3_ILo-WK8w/export?format=csv&gid=0") | |
data2 = pd.read_csv("https://docs.google.com/spreadsheets/d/1T_twNONDSZ8zw7aDcYhw92DlawqPktti1xFw9ssJ13Y/export?format=csv&gid=0") | |
async def on_ready(): | |
try: | |
global global_df | |
global worksheet2_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)""" | |
data['discord_user_id'] = data['discord_user_id'].astype(str) | |
global_df = data | |
print(f"csv successfully retrieved: \n {global_df}") | |
worksheet2_df = data2.copy() | |
worksheet2_df['discord_user_id'] = worksheet2_df['discord_user_id'].astype(str) | |
worksheet2_df['id_recover_test'] = worksheet2_df['id_recover_test'].astype(str) | |
print(worksheet2_df.dtypes) | |
# updates both leaderboards | |
#await remove_huggingfolks() # to initialize | |
#print(community_global_df_with_id) | |
remove_huggingfolks.start() | |
#await periodic_api_test() | |
print(f"------------------------------------------------------------------------") | |
except Exception as e: | |
print(f"on_ready Error: {e}") | |
def update_google_sheet(): | |
"""save data from HF Space -> google sheets (makes 2 API calls)""" | |
try: | |
print("Updating google sheets...") | |
print(f"------------------------------------------------------------------------") | |
name = "levelbot" | |
#worksheet = gspread_bot.open(name).sheet1 | |
global_df['discord_user_id'] = global_df['discord_user_id'].astype(str) | |
global_df['discord_exp'] = global_df['discord_exp'].astype(str) | |
# could just do this / format | |
set_with_dataframe(worksheet, global_df) | |
timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S") | |
print(f"------------------------------------------------------------------------") | |
print(f"Google sheet {name} successfully updated at {timestamp}! \n{global_df}") | |
print(f"------------------------------------------------------------------------") | |
except Exception as e: | |
print(f"update_google_sheet Error: {e}") | |
executor = ThreadPoolExecutor(max_workers=2) | |
scheduler = BackgroundScheduler(executors={'default': executor}) | |
scheduler.add_job(update_google_sheet, trigger='interval', minutes=1, max_instances=2) | |
scheduler.start() | |
def calculate_level(xp): | |
return int(xp ** (1.0 / 3.0)) | |
def calculate_xp(level): | |
return (int(level ** 3)) | |
processed_users = set() | |
async def periodic_api_test(): # needs rewrite, can do same thing and interact with csv -> push to google sheets | |
try: | |
# this should be gspread type function (do not mix with discord at all | |
global worksheet2_df | |
# get | |
for index, user in enumerate(worksheet2_df['hf_user_name']): | |
if user in processed_users: | |
continue | |
await asyncio.sleep(0.5) | |
url = f"https://huggingface.co/api/users/{user}/overview" | |
response = requests.get(url) | |
if response.status_code == 200: | |
data = response.json() | |
likes = data["numLikes"] | |
models = data["numModels"] | |
datasets = data["numDatasets"] | |
spaces = data["numSpaces"] | |
discussions = data["numDiscussions"] | |
papers = data["numPapers"] | |
upvotes = data["numUpvotes"] | |
worksheet2_df.loc[index:index, 'likes':'upvotes'] = [[likes, models, datasets, spaces, discussions, papers, upvotes]] | |
pd.set_option('display.max_rows', 30) | |
print(worksheet2_df) | |
processed_users.add(user) | |
print(processed_users) | |
else: | |
print(f"Failed to retrieve data for user {user}. Status code: {response.status_code}") | |
except Exception as e: | |
print(f"periodic_api_test Error: {e}") | |
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, | |
} | |
# xp = int64 | |
# member_name = string | |
# discord_user_id = string | |
member_found = False | |
print("test1") | |
# discord_user_id column | |
# iterate over items of first column (discord_user_id) | |
for index, cell_value in global_df.iloc[:, 0].items(): | |
# print("test2") | |
# remove L (read, so no need to replace) | |
# 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 | |
if cell_value.startswith("L") and cell_value.endswith("L"): | |
# print("test3") | |
cell_value_clipped = cell_value[1:-1] | |
# cell_value_clipped = 1234567890 | |
#print(f"cell_value_clipped: {cell_value_clipped}, type: {type(cell_value_clipped)}") | |
#print(f"member_id: {member_id}, type: {type(member_id)}") | |
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 = f"L" + str(new_xp) + f"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 = f"L" + str(total_exp) + f"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: | |
# cell_value = L1234567890L | |
# make copy | |
# remove L | |
# do calculations | |
print("test8") | |
copy_df = global_df.copy() | |
print("test9") | |
copy_df['discord_user_id'] = copy_df['discord_user_id'].str.strip('L').astype(str) | |
print("test10") | |
copy_df['total_exp'] = copy_df['total_exp'].str.strip('L').astype(int) | |
print("test11") | |
row = copy_df[copy_df['discord_user_id'] == str(member_id)] | |
print("test12") | |
print(f"Row found for {member_id}!") | |
target_exp = row['total_exp'].values[0] | |
print("test13") | |
rank = (copy_df['total_exp'] > target_exp).sum() + 1 | |
print(f"The rank for discord_id {member_id} based on total_exp is: {rank}") | |
except Exception as e: | |
print(f"Discord ID {member_id} not found in the DataFrame.") | |
rank = "π€" | |
# temporary fix: remove ~100 exp when not verified, send embed on "levelup" prompting to verify | |
# 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 `{old_level}` -> `{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 = f"π Earn exp for activity on Discord and HF and climb the β leaderboard !" | |
u_2 = f"π Feature your content in weekly news and increase its visibility!" | |
u_3 = f"π Early access to Beta features!" | |
u_4 = f"π‘οΈ 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(f"Sent verification cap embed to {member}") | |
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 | |
await member.remove_roles(lvls[old_level]) | |
print(f"Removed {lvls[old_level]} from {member}") | |
await member.add_roles(current_role) | |
print(f"Level Up! Gave {member} {current_role}") | |
#print(f"{member} Level up! {old_level} -> {current_level}!") | |
if current_role in member.roles: # needs update; reference exp reward for verification | |
#await member.send(f"Level up! {old_level} -> {current_level}!") | |
#if member_id == 811235357663297546: | |
# 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! `{old_level}` -> `{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) | |
# can use ^ to track changes in leaderboard ranking and display in levelup message when climbing | |
# (green red arrow thingies) | |
# could also pull ranks above and below yourself (if they exist, i.e.) | |
# 1 nateraw | |
# 2 [you are here] | |
# 3 osanseviero | |
# also, ahead by how much exp, how many levels maybe | |
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}") | |
#You can verify your account to earn 100 points! To verify, do A. | |
print(f"------------------------------------------------------------------------") | |
if not member_found: | |
print("test7") | |
# 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 = f"L" + str(xp) + f"L" | |
member_id = str(member_id) | |
if not member_id.startswith("L") and not member_id.endswith("L"): | |
member_id = f"L" + str(member_id) + f"L" | |
member_name = str(member.name) | |
row_data = [member_id, member_name, xp, current_level] | |
global_df.loc[len(global_df.index)] = row_data | |
print(f"------------------------------------------------------------------------") | |
except Exception as e: | |
print(f"add_exp Error: {e}") | |
async def on_message(message): | |
try: | |
if message.author.id not in bot_ids: # could change to if author does not have bot role (roleid) | |
if "!help_xp" not in message.content: | |
print(f"adding exp from message {message.author}") | |
await asyncio.sleep(0.1) | |
await add_exp(message.author.id) | |
await bot.process_commands(message) | |
except Exception as e: | |
print(f"on_message Error: {e}") | |
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) | |
await add_exp(user.id) | |
await asyncio.sleep(0.1) | |
await add_exp(reaction.message.author.id) | |
except Exception as e: | |
print(f"on_reaction_add Error: {e}") | |
async def remove_huggingfolks(): | |
try: | |
# remove huggingfolks | |
global community_global_df | |
global community_global_df_with_id | |
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() | |
# 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['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') | |
top_30_exp = community_global_df.nlargest(30, 'total_exp') | |
top_30_exp['D'] = ['π₯','π₯','π₯','','','','','','','','','','','','','','','','','','','','','','','','','','',''] | |
top_30_rows = top_30_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_30_rows, headers=["Name", "Experience", "Level", "Rank"], tablefmt="plain") | |
await message.edit(content=f"Updated Leaderboard:\n```\n{new_table}\n```") | |
print(f"Updated discord leaderboard!") | |
print(f"------------------------------------------------------------------------") | |
except Exception as e: | |
print(f"remove_huggingfolks Error: {e}") | |
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}") | |
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}") | |
# embeds with user pfps? | |
# name, pfp, time in server.... | |
# weekly do different count | |
# count number of messages per user for every channel (total messages) | |
# fix sheet if necessary | |
# add emojis for some color | |
# check if members are still in the server | |
"""""" | |
DISCORD_TOKEN = os.environ.get("DISCORD_TOKEN", None) | |
def run_bot(): | |
bot.run(DISCORD_TOKEN) | |
threading.Thread(target=run_bot).start() | |
URL = "https://docs.google.com/spreadsheets/d/1hQSsIg1Y9WdBF_CdNM1L1rUUREoxKqRTe3_ILo-WK8w/edit#gid=0" | |
csv_url = URL.replace('/edit#gid=', '/export?format=csv&gid=') | |
def get_data(): | |
try: | |
return 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(csv_url) | |
column_values_unique = sorted(dataframe1.iloc[:, 3].unique()) | |
dataframe2 = pd.DataFrame({'Levels': column_values_unique}) | |
counts = {} | |
for value in data.iloc[:, 3]: | |
counts[value] = counts.get(value, 0) + 1 | |
dataframe2['Members'] = dataframe2['Levels'].map(counts) | |
print("\nDataframe 2:") | |
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, 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() |