Spaces:
Running
on
CPU Upgrade
Running
on
CPU Upgrade
import discord | |
import os | |
import threading | |
from discord.ext import commands | |
import json | |
import datetime | |
import requests | |
import os.path | |
import random | |
import gspread | |
import re | |
import asyncio | |
import csv | |
from tabulate import tabulate | |
import logging | |
import time | |
import pandas as pd | |
from gspread_dataframe import get_as_dataframe, set_with_dataframe | |
from gspread_formatting.dataframe import format_with_dataframe | |
import gradio_client | |
import gradio as gr | |
from gradio_client import Client | |
from huggingface_hub import HfApi, list_models, list_liked_repos, list_metrics | |
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() | |
"""""" | |
async def on_ready(): | |
print(f'Logged in as {bot.user.name}') | |
print(f"XP_PER_MESSAGE: {XP_PER_MESSAGE}") | |
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(): | |
try: | |
await asyncio.sleep(1) | |
column_values_3 = worksheet2.col_values(3) | |
column_values_8 = worksheet2.col_values(8) | |
for i, user in enumerate(column_values_3): | |
if user in processed_users: | |
continue | |
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.update(values=[[likes, models, datasets, spaces, discussions, papers, upvotes]], | |
range_name=f'G{i+1}:M{i+1}') | |
processed_users.add(user) | |
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}") | |
def blocking_io(member_id): | |
try: | |
time.sleep(1) | |
worksheet = gspread_bot.open("levelbot").sheet1 | |
guild = bot.get_guild(879548962464493619) | |
member = guild.get_member(member_id) | |
print(f" {member}") | |
print(f"2") | |
cell = worksheet.find(str(member.id)) | |
length = len(worksheet.col_values(1)) | |
print(f"3") | |
if cell is None: | |
print(f"creating new record for {member}") | |
# if not, create new record | |
string_member_id = str(member.id) | |
xp = 10 | |
current_level = calculate_level(xp) | |
member_name = member.name | |
worksheet.update(values=[[string_member_id, member_name, xp, current_level]], range_name=f'A{length+1}:D{length+1}') | |
# initial role assignment | |
if current_level == 1: | |
if lvl1 not in member.roles: | |
return(1) | |
else: | |
print(f"4") | |
if cell: | |
# if so, update that row... | |
xp = worksheet.cell(cell.row, cell.col+2).value | |
xp = int(xp) + XP_PER_MESSAGE | |
current_level = calculate_level(xp) | |
print(f"updating record for {member}: {xp} xp") | |
# write with added xp | |
worksheet.update(values=[[xp, current_level]], range_name=f'C{cell.row}:D{cell.row}') | |
# level up | |
print(f"current_level: {current_level}") | |
if current_level >= 2 and current_level <=30: | |
# pass current_level as int? | |
return(current_level) | |
except Exception as e: | |
print(f"blocking_io Error: {e}") | |
async def add_exp(member_id): | |
try: | |
await asyncio.sleep(1) | |
loop = asyncio.get_running_loop() | |
result = await loop.run_in_executor(None, blocking_io, member_id) | |
guild = bot.get_guild(879548962464493619) | |
member = guild.get_member(member_id) | |
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) | |
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, | |
} | |
if result == 1: | |
await member.add_roles(lvl1) | |
print(f"Gave {member} {lvl1}") | |
print(f"result: {result}") | |
if result >= 2: | |
current_level = result | |
current_role = lvls[current_level] | |
if current_role not in member.roles: | |
await member.add_roles(current_role) | |
print(f"Giving {member} {current_role}") | |
await member.remove_roles(lvls[current_level-1]) | |
print(f"Removed {lvls[current_level-1]} from {member}") | |
#print(f"{member} Level up! {current_level-1} -> {current_level}!") | |
if current_role in member.roles: | |
await member.send(f"Level up! {current_level-1} -> {current_level}!") | |
except Exception as e: | |
print(f"add_exp Error: {e}") | |
async def on_message(message): | |
try: | |
if message.author.id not in bot_ids: | |
if "!help_xp" not in message.content: | |
print(f"adding exp from message {message.author}") | |
await asyncio.sleep(1) | |
await add_exp(message.author.id) | |
#await periodic_api_test() # run this ~1 per day otherwise will lead to issues | |
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.id}") | |
await asyncio.sleep(1) | |
await add_exp(user.id) | |
except Exception as e: | |
print(f"on_reaction_add Error: {e}") | |
async def update_leaderboard(ctx, num_results: int = 10): | |
if ctx.author.id == 811235357663297546: | |
await asyncio.sleep(1) | |
worksheet = gspread_bot.open("levelbot").sheet1 | |
names_list = worksheet.col_values(2)[1:] | |
levels_list = worksheet.col_values(4)[1:] | |
exp_list = worksheet.col_values(3)[1:] | |
channel = bot.get_channel(1197143964994773023) | |
message = await channel.fetch_message(1197148293164187678) | |
# for 3 lists | |
combined_list = [list(sublist) for sublist in zip(names_list, levels_list, exp_list)] | |
combined_list = [[name, int(level), int(exp)] for name, level, exp in combined_list] | |
combined_list = sorted(combined_list, key=lambda x: x[1], reverse=True) | |
print(combined_list) | |
top_results = combined_list[:num_results] | |
#print(top_results) | |
""" | |
# get position, then find that value in updated_names_list | |
levels_list = list(map(int, levels_list)) | |
data_pairs = list(zip(names_list, levels_list)) | |
sorted_data_pairs = sorted(data_pairs, key=lambda x: x[1], reverse=True) | |
top_data_pairs = sorted_data_pairs[:num_results] | |
""" | |
# remove huggingfolks | |
guild = ctx.guild | |
role = discord.utils.get(guild.roles, id=897376942817419265) | |
if role is None: | |
await ctx.send("Role not found.") | |
return | |
members_with_role = [member.name for member in guild.members if role in member.roles] | |
top_results = [r for r in top_results if r[0] not in members_with_role] | |
for name, level, xp in top_results: | |
print(f"Name: {name}, Level: {level}, Exp: {xp}") | |
def xp_required_to_next_level(current_level, current_xp): | |
level_floor_xp = calculate_xp(current_level) | |
level_ceiling_xp = calculate_xp(current_level+1) | |
xp_to_level_up = level_ceiling_xp - current_xp | |
return (xp_to_level_up) | |
# put into message / leaderboard | |
new_leaderboard_data = [(name, level, str(xp_required_to_next_level(int(level), int(xp)))) for name, level, xp in top_results] | |
new_table = tabulate(new_leaderboard_data, headers=["Name", "Level", "XP to level up"], tablefmt="plain") | |
await message.edit(content=f"Updated Leaderboard:\n```\n{new_table}\n```") | |
async def xp_help(ctx): | |
help_message = "How to earn Discord / Hub exp: Post messages, react, Like, discuss, create repos and papers" | |
await ctx.author.send(help_message) | |
async def write_csv(ctx): | |
if ctx.author.id == 811235357663297546: | |
worksheet = gspread_bot.open("levelbot").sheet1 | |
values = worksheet.get_all_values() | |
target_id = '811235357663297546' | |
variable_xp = 0 | |
csv_file_path = 'test.csv' | |
with open(csv_file_path, 'w', newline='') as csv_file: | |
csv_writer = csv.writer(csv_file) | |
csv_writer.writerows(values) | |
# modifying csv data | |
with open(csv_file_path, 'r') as csv_file: | |
csv_reader = csv.reader(csv_file) | |
rows = list(csv_reader) | |
for row in rows: | |
print(row) | |
if target_id in row: | |
index_of_target = row.index(target_id) | |
# 2 to right | |
cell_to_increment_index = index_of_target + 2 | |
# +10 | |
try: | |
row[cell_to_increment_index] = str(int(row[cell_to_increment_index]) + variable_xp) | |
print(row[cell_to_increment_index]) | |
except (IndexError, ValueError): | |
print(f"Error: Unable to increment cell at index {cell_to_increment_index}") | |
break | |
# write modified data and send in discord | |
with open(csv_file_path, 'w', newline='') as csv_file: | |
csv_writer = csv.writer(csv_file) | |
csv_writer.writerows(rows) | |
csv_data_str = '\n'.join(','.join(row) for row in rows) | |
csv_file = discord.File(csv_file_path) | |
await ctx.channel.send(content="csv", file=csv_file) | |
#target_user = await bot.fetch_user(int(target_id)) | |
#await target_user.send(content="csv", file=csv_file) | |
async def read_csv(ctx): | |
if ctx.author.id == 811235357663297546: | |
async for message in ctx.channel.history(limit=10): | |
if message.attachments: | |
attachment = message.attachments[0] | |
if attachment.filename.endswith('.csv'): | |
csv_content = await attachment.read() | |
csv_data = [] | |
csv_lines = csv_content.decode('utf-8').splitlines() | |
csv_reader = csv.reader(csv_lines) | |
for row in csv_reader: | |
csv_data.append(row) | |
print(csv_data) | |
await ctx.send("discord -> read -> updated HF Hub") | |
# react to the given message, helps with explainability | |
await message.add_reaction('β ') | |
break | |
async def dataframe_test(ctx): | |
if ctx.author.id == 811235357663297546: | |
""" | |
URL = "https://docs.google.com/spreadsheets/d/1YJEwP7kZChI3Z2GKv4zFEfwwyQrO3zwXclv0QMrkOqA/edit#gid=0" | |
csv_url = URL.replace('/edit#gid=', '/export?format=csv&gid=') | |
data = pd.read_csv(csv_url) | |
print(data) | |
""" | |
worksheet = gspread_bot.open("levelbot").sheet1 | |
test_worksheet = gspread_bot.open("test").sheet1 | |
df = get_as_dataframe(worksheet, dtype={βaβ: np.int64}) | |
set_with_dataframe(test_worksheet, df) | |
def get_data(): | |
first_3_columns = data.iloc[:, 1:4] # Skip the first column and select the next three columns | |
first_3_columns.to_csv('first_3_columns.csv', index=False) | |
return first_3_columns | |
# embeds with user pfps? | |
# name, pfp, time in server.... | |
# discord_level column | |
# pick 10 highest | |
# update | |
# weekly do different count | |
# count number of messages per user for every channel (total messages) | |
# fix sheet if necessary | |
# might need cell location data to pull both level and username at same time | |
# 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(): | |
data = pd.read_csv(csv_url) | |
first_3_columns = data.iloc[:, 1:4] | |
first_3_columns.to_csv('first_3_columns.csv', index=False) | |
return first_3_columns | |
# csv | |
# read into pandas dataframe1 | |
# read levels column and create pandas dataframe2 with first column containing levels from 2-max found in dataframe1 | |
# create second column in dataframe2 for number of each level found in dataframe1 levels column | |
demo = gr.Blocks() | |
with demo: | |
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 dataframe1.iloc[:, 3]: | |
counts[value] = counts.get(value, 0) + 1 | |
dataframe2['Members'] = dataframe2['Levels'].map(counts) | |
print("Dataframe 1:") | |
print(dataframe1) | |
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.TabItem("π Members of the Week", elem_id="week-table", id=1): | |
#with gr.TabItem("π Hub-only leaderboard", elem_id="hub-table", id=2): | |
demo.queue().launch() |