|
import os |
|
os.system("wget https://raw.githubusercontent.com/Weyaxi/scrape-open-llm-leaderboard/main/openllm.py") |
|
from openllm import * |
|
import requests |
|
import pandas as pd |
|
from bs4 import BeautifulSoup |
|
from tqdm import tqdm |
|
from huggingface_hub import HfApi, CommitOperationAdd, create_commit |
|
import gradio as gr |
|
import datetime |
|
|
|
api = HfApi() |
|
|
|
|
|
HF_TOKEN = os.getenv('HF_TOKEN') |
|
|
|
|
|
headers_models = ["🔢 Serial Number", "👤 Author Name", "📥 Total Downloads", "👍 Total Likes", "🤖 Number of Models", |
|
"🏆 Best Model On Open LLM Leaderboard", "🥇 Best Rank On Open LLM Leaderboard", |
|
"📊 Average Downloads per Model", "📈 Average Likes per Model", "🚀 Most Downloaded Model", |
|
"📈 Most Download Count", "❤️ Most Liked Model", "👍 Most Like Count", "🔥 Trending Model", |
|
"👑 Best Rank at Trending Models", "🏷️ Type"] |
|
|
|
headers_datasets = ["🔢 Serial Number", "👤 Author Name", "📥 Total Downloads", "👍 Total Likes", "📊 Number of Datasets", |
|
"📊 Average Downloads per Dataset", "📈 Average Likes per Dataset", "🚀 Most Downloaded Dataset", |
|
"📈 Most Download Count", "❤️ Most Liked Dataset", "👍 Most Like Count", "🔥 Trending Dataset", |
|
"👑 Best Rank at Trending Datasets", "🏷️ Type"] |
|
|
|
headers_spaces = ["🔢 Serial Number", "👤 Author Name", "👍 Total Likes", "🚀 Number of Spaces", "📈 Average Likes per Space", |
|
"❤️ Most Liked Space", "👍 Most Like Count", "🔥 Trending Space", "👑 Best Rank at Trending Spaces", |
|
"🏷️ Type"] |
|
|
|
|
|
def apply_headers(df, headers): |
|
tmp = df.copy() |
|
tmp.columns = headers |
|
|
|
return tmp |
|
|
|
|
|
def get_time(): |
|
return datetime.datetime.now().strftime("%d-%m-%Y %H-%M") |
|
|
|
|
|
def upload_datasets(dfs): |
|
|
|
time = get_time() |
|
|
|
operations = [CommitOperationAdd(path_in_repo=f"{time}/models_df.csv", path_or_fileobj=(dfs[0].to_csv()).encode()), |
|
CommitOperationAdd(path_in_repo=f"{time}/datasets_df.csv", path_or_fileobj=(dfs[1].to_csv()).encode()), |
|
CommitOperationAdd(path_in_repo=f"{time}/spaces_df.csv", path_or_fileobj=(dfs[2].to_csv()).encode())] |
|
|
|
return (create_commit(repo_id="Weyaxi/huggingface-leaderboard-history", operations=operations, commit_message=f"Uploading history of {time}", repo_type="dataset", token=HF_TOKEN)) |
|
|
|
|
|
def get_most(df_for_most_function): |
|
download_sorted_df = df_for_most_function.sort_values(by=['downloads'], ascending=False) |
|
most_downloaded = download_sorted_df.iloc[0] |
|
|
|
like_sorted_df = df_for_most_function.sort_values(by=['likes'], ascending=False) |
|
most_liked = like_sorted_df.iloc[0] |
|
|
|
return {"Most Download": {"id": most_downloaded['id'], "downloads": most_downloaded['downloads'], |
|
"likes": most_downloaded['likes']}, |
|
"Most Likes": {"id": most_liked['id'], "downloads": most_liked['downloads'], "likes": most_liked['likes']}} |
|
|
|
|
|
def get_sum(df_for_sum_function): |
|
sum_downloads = sum(df_for_sum_function['downloads'].tolist()) |
|
sum_likes = sum(df_for_sum_function['likes'].tolist()) |
|
|
|
return {"Downloads": sum_downloads, "Likes": sum_likes} |
|
|
|
|
|
def get_openllm_leaderboard(): |
|
try: |
|
data = get_json_format_data() |
|
finished_models = get_datas(data) |
|
df = pd.DataFrame(finished_models) |
|
return df['Model'].tolist() |
|
except Exception as e: |
|
print(e) |
|
return [] |
|
|
|
|
|
def get_ranking(model_list, target_org): |
|
if not model_list: |
|
return "Error on Leaderboard" |
|
for index, model in enumerate(model_list): |
|
if model.split("/")[0].lower() == target_org.lower(): |
|
return [index + 1, model] |
|
return "Not Found" |
|
|
|
|
|
def get_models(which_one): |
|
if which_one == "models": |
|
data = api.list_models() |
|
elif which_one == "datasets": |
|
data = api.list_datasets() |
|
elif which_one == "spaces": |
|
data = api.list_spaces() |
|
|
|
all_list = [] |
|
for i in tqdm(data, desc=f"Scraping {which_one}", position=0, leave=True): |
|
i = i.__dict__ |
|
|
|
id = i["id"].split("/") |
|
if len(id) != 1: |
|
json_format_data = {"author": id[0], "id": "/".join(id), "downloads": i['downloads'], |
|
"likes": i['likes']} if which_one != "spaces" else {"author": id[0], "id": "/".join(id), |
|
"downloads": 0, "likes": i['likes']} |
|
|
|
all_list.append(json_format_data) |
|
return all_list |
|
|
|
|
|
|
|
def search(models_dict, author_name): |
|
return pd.DataFrame(models_dict.get(author_name, [])) |
|
|
|
|
|
def group_models_by_author(all_things): |
|
models_by_author = {} |
|
for model in all_things: |
|
author_name = model['author'] |
|
if author_name not in models_by_author: |
|
models_by_author[author_name] = [] |
|
models_by_author[author_name].append(model) |
|
return models_by_author |
|
|
|
|
|
def make_leaderboard(orgs, users, which_one, data): |
|
data_rows = [] |
|
open_llm_leaderboard = get_openllm_leaderboard() if which_one == "models" else None |
|
|
|
trend = get_trending_list(1, which_one) |
|
hepsi = [orgs, users] |
|
|
|
for index, orgs in enumerate(hepsi): |
|
org_or_user = "Organization" if index == 0 else "User" |
|
for org in tqdm(orgs, desc=f"Proccesing: ({which_one}) ({org_or_user})", position=0, leave=True): |
|
rank = get_ranking_trend(trend, org) |
|
|
|
df = search(data, org) |
|
|
|
if len(df) == 0: |
|
continue |
|
num_things = len(df) |
|
sum_info = get_sum(df) |
|
most_info = get_most(df) |
|
|
|
if which_one == "models": |
|
open_llm_leaderboard_get_org = get_ranking(open_llm_leaderboard, org) |
|
|
|
data_rows.append({ |
|
"Author Name": org, |
|
"Total Downloads": sum_info["Downloads"], |
|
"Total Likes": sum_info["Likes"], |
|
"Number of Models": num_things, |
|
"Best Model On Open LLM Leaderboard": open_llm_leaderboard_get_org[1] if open_llm_leaderboard_get_org != "Not Found" else open_llm_leaderboard_get_org, |
|
"Best Rank On Open LLM Leaderboard": open_llm_leaderboard_get_org[0] if open_llm_leaderboard_get_org != "Not Found" else open_llm_leaderboard_get_org, |
|
"Average Downloads per Model": int(sum_info["Downloads"] / num_things) if num_things != 0 else 0, |
|
"Average Likes per Model": int(sum_info["Likes"] / num_things) if num_things != 0 else 0, |
|
"Most Downloaded Model": most_info["Most Download"]["id"], |
|
"Most Download Count": most_info["Most Download"]["downloads"], |
|
"Most Liked Model": most_info["Most Likes"]["id"], |
|
"Most Like Count": most_info["Most Likes"]["likes"], |
|
"Trending Model": rank['id'], |
|
"Best Rank at Trending Models": rank['rank'], |
|
"Type": org_or_user |
|
}) |
|
elif which_one == "datasets": |
|
|
|
data_rows.append({ |
|
"Author Name": org, |
|
"Total Downloads": sum_info["Downloads"], |
|
"Total Likes": sum_info["Likes"], |
|
"Number of Datasets": num_things, |
|
"Average Downloads per Dataset": int(sum_info["Downloads"] / num_things) if num_things != 0 else 0, |
|
"Average Likes per Dataset": int(sum_info["Likes"] / num_things) if num_things != 0 else 0, |
|
"Most Downloaded Dataset": most_info["Most Download"]["id"], |
|
"Most Download Count": most_info["Most Download"]["downloads"], |
|
"Most Liked Dataset": most_info["Most Likes"]["id"], |
|
"Most Like Count": most_info["Most Likes"]["likes"], |
|
"Trending Dataset": rank['id'], |
|
"Best Rank at Trending Datasets": rank['rank'], |
|
"Type": org_or_user |
|
}) |
|
|
|
elif which_one == "spaces": |
|
|
|
data_rows.append({ |
|
"Author Name": org, |
|
"Total Likes": sum_info["Likes"], |
|
"Number of Spaces": num_things, |
|
"Average Likes per Space": int(sum_info["Likes"] / num_things) if num_things != 0 else 0, |
|
"Most Liked Space": most_info["Most Likes"]["id"], |
|
"Most Like Count": most_info["Most Likes"]["likes"], |
|
"Trending Space": rank['id'], |
|
"Best Rank at Trending Spaces": rank['rank'], |
|
"Type": org_or_user |
|
}) |
|
|
|
leaderboard = pd.DataFrame(data_rows) |
|
temp = ["Total Downloads"] if which_one != "spaces" else ["Total Likes"] |
|
|
|
leaderboard = leaderboard.sort_values(by=temp, ascending=False) |
|
leaderboard.insert(0, "Serial Number", range(1, len(leaderboard) + 1)) |
|
return leaderboard |
|
|
|
|
|
def clickable(x, which_one): |
|
if which_one == "models": |
|
if x != "Not Found": |
|
return f'<a target="_blank" href="https://huggingface.co/{x}" style="color: var(--link-text-color); text-decoration: underline;text-decoration-style: dotted;">{x}</a>' |
|
else: |
|
return "Not Found" |
|
else: |
|
if x != "Not Found": |
|
return f'<a target="_blank" href="https://huggingface.co/{which_one}/{x}" style="color: var(--link-text-color); text-decoration: underline;text-decoration-style: dotted;">{x}</a>' |
|
return "Not Found" |
|
|
|
|
|
def models_df_to_clickable(df, columns, which_one): |
|
for column in columns: |
|
if column == "Author Name": |
|
df[column] = df[column].apply(lambda x: clickable(x, "models")) |
|
else: |
|
df[column] = df[column].apply(lambda x: clickable(x, which_one)) |
|
return df |
|
|
|
|
|
def get_trending_list(pages, which_one): |
|
trending_list = [] |
|
for i in range(pages): |
|
json_data = requests.get(f"https://huggingface.co/{which_one}-json?p={i}").json() |
|
|
|
for thing in json_data[which_one]: |
|
id = thing["id"] |
|
likes = thing["likes"] |
|
|
|
if which_one != "spaces": |
|
downloads = thing["downloads"] |
|
|
|
trending_list.append({"id": id, "downloads": downloads, "likes": likes}) |
|
else: |
|
trending_list.append({"id": id, "likes": likes}) |
|
|
|
return trending_list |
|
|
|
|
|
def get_ranking_trend(json_data, org_name): |
|
names = [item['id'].split("/")[0] for item in json_data] |
|
models = [item['id'] for item in json_data] |
|
if org_name in names: |
|
temp = names.index(org_name) |
|
return {"id": models[temp], "rank": temp + 1} |
|
else: |
|
return {"id": "Not Found", "rank": "Not Found"} |
|
|
|
|
|
|
|
def fetch_data_from_url(url): |
|
response = requests.get(url) |
|
if response.status_code == 200: |
|
data = response.text.splitlines() |
|
return [line.rstrip("\n") for line in data] |
|
else: |
|
print(f"Failed to fetch data from URL: {url}") |
|
return [] |
|
|
|
user_names_url = "https://huggingface.co/datasets/Weyaxi/user-orgs-huggingface-leaderboard/raw/main/user_names.txt" |
|
org_names_url = "https://huggingface.co/datasets/Weyaxi/user-orgs-huggingface-leaderboard/raw/main/org_names.txt" |
|
|
|
user_names_in_list = fetch_data_from_url(user_names_url) |
|
org_names_in_list = fetch_data_from_url(org_names_url) |
|
|
|
datetime_now = str(datetime.datetime.now().strftime("%Y-%m-%d %H:%M")) |
|
INTRODUCTION_TEXT = f""" |
|
🎯 The Leaderboard aims to track users and organizations rankings and stats. This space is inspired by the [Open LLM Leaderboard](https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard). |
|
|
|
## Available Dataframes: |
|
|
|
- 🏛️ Models |
|
|
|
- 📊 Datasets |
|
|
|
- 🚀 Spaces |
|
|
|
## Backend |
|
|
|
🛠️ The leaderboard's backend mainly runs on the [Hugging Face Hub API](https://huggingface.co/docs/huggingface_hub/v0.5.1/en/package_reference/hf_api). |
|
|
|
📒 **Note:** In the model's dataframe, there are some columns related to the [Open LLM Leaderboard](https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard). This data is also retrieved through web scraping. |
|
|
|
📒 **Note:** In trending models/datasets/spaces, first 300 models/datasets/spaces is being retrieved from huggingface. |
|
|
|
## 🔍 Searching Organizations and Users |
|
|
|
You can search for organizations and users in the Search tab. In this tab, you can view an author's stats even if they are not at the top of the leaderboard. |
|
|
|
## Filtering Organizations and Users |
|
|
|
🧮 You can filter the dataset to show only Organizations or Users! |
|
|
|
✅ Use checkboxs for this! |
|
|
|
## Last Update |
|
|
|
⌛ This space is last updated in **{datetime_now}**. |
|
""" |
|
|
|
|
|
|
|
def get_avatar(user_name, user): |
|
try: |
|
url = f"https://huggingface.co/{user_name}" |
|
response = requests.get(url) |
|
soup = BeautifulSoup(response.text, "html.parser") |
|
if user: |
|
|
|
avatar = soup.find("img", {"class": "h-32 w-32 overflow-hidden rounded-full shadow-inner lg:h-48 lg:w-48"})['src'] |
|
full = soup.find("span", {"class": "mr-3 leading-6"}).text |
|
return [avatar, full] |
|
|
|
else: |
|
|
|
avatar = soup.find("img", {"class": "mb-2 mr-4 h-12 w-12 flex-none overflow-hidden rounded-lg sm:mb-0 sm:h-20 sm:w-20"})['src'] |
|
full = soup.find("h1", {"class": "mb-2 mr-3 text-2xl font-bold md:mb-0"}).text |
|
return [avatar, full] |
|
except Exception as e: |
|
print(e) |
|
return "Error" |
|
|
|
|
|
def update_table(orgs, users, how_much=400, return_all=False): |
|
dataFrame = models_df |
|
|
|
if not orgs and users: |
|
filtered_df = dataFrame[(dataFrame['Type'] != 'Organization') | (dataFrame['Type'] == 'User')] |
|
|
|
elif orgs and not users: |
|
filtered_df = dataFrame[(dataFrame['Type'] == 'Organization') | (dataFrame['Type'] != 'User')] |
|
|
|
elif orgs and users: |
|
filtered_df = dataFrame[(dataFrame['Type'] == 'Organization') | (dataFrame['Type'] == 'User')] |
|
|
|
else: |
|
return apply_headers(dataFrame.head(0), headers_models) |
|
|
|
if return_all: |
|
return apply_headers(filtered_df, headers_models) |
|
else: |
|
return apply_headers(filtered_df, headers_models).head(how_much) |
|
|
|
|
|
def update_table_datasets(orgs, users, how_much=250, return_all=False): |
|
dataFrame = dataset_df |
|
|
|
if not orgs and users: |
|
filtered_df = dataFrame[(dataFrame['Type'] != 'Organization') | (dataFrame['Type'] == 'User')] |
|
|
|
elif orgs and not users: |
|
filtered_df = dataFrame[(dataFrame['Type'] == 'Organization') | (dataFrame['Type'] != 'User')] |
|
|
|
elif orgs and users: |
|
filtered_df = dataFrame[(dataFrame['Type'] == 'Organization') | (dataFrame['Type'] == 'User')] |
|
|
|
else: |
|
return apply_headers(dataFrame, headers_datasets).head(0) |
|
|
|
if return_all: |
|
return apply_headers(filtered_df, headers_datasets) |
|
else: |
|
return apply_headers(filtered_df, headers_datasets).head(how_much) |
|
|
|
|
|
def update_table_spaces(orgs, users, how_much=200, return_all=False): |
|
dataFrame = spaces_df |
|
|
|
if not orgs and users: |
|
filtered_df = dataFrame[(dataFrame['Type'] != 'Organization') | (dataFrame['Type'] == 'User')] |
|
|
|
elif orgs and not users: |
|
filtered_df = dataFrame[(dataFrame['Type'] == 'Organization') | (dataFrame['Type'] != 'User')] |
|
|
|
elif orgs and users: |
|
filtered_df = dataFrame[(dataFrame['Type'] == 'Organization') | (dataFrame['Type'] == 'User')] |
|
|
|
else: |
|
return apply_headers(dataFrame, headers_spaces).head(0) |
|
|
|
if return_all: |
|
return apply_headers(filtered_df, headers_spaces) |
|
else: |
|
return apply_headers(filtered_df, headers_spaces).head(how_much) |
|
|
|
|
|
|
|
def search_df(author): |
|
sonuc_models, sonuc_datasets, sonuc_spaces =[], [], [] |
|
org_or_user = "User" if author in user_names_in_list else "Org" |
|
|
|
a = get_avatar(author, True if org_or_user=="User" else False) |
|
|
|
if a == "Error": |
|
return "Error happened, maybe author name is not valid." |
|
|
|
|
|
df = models_df |
|
for index, item in enumerate(df['Author Name'].tolist()): |
|
if f'"https://huggingface.co/{author}"' in item: |
|
sonuc_models = df.iloc[index] |
|
break |
|
|
|
|
|
df = dataset_df |
|
for index, item in enumerate(df['Author Name'].tolist()): |
|
if f'"https://huggingface.co/{author}"' in item: |
|
sonuc_datasets = df.iloc[index] |
|
break |
|
|
|
|
|
df = spaces_df |
|
for index, item in enumerate(df['Author Name'].tolist()): |
|
if f'"https://huggingface.co/{author}"' in item: |
|
sonuc_spaces = df.iloc[index] |
|
break |
|
|
|
|
|
|
|
author_name = sonuc_models['Author Name'] if len(sonuc_models) > 0 else "Not Found" |
|
global_rank = sonuc_models['Serial Number'] if len(sonuc_models) > 0 else "Not Found" |
|
|
|
if len(sonuc_models) > 0: |
|
if org_or_user == "User": |
|
user_rank = filtered_model_users.index(f'<a target="_blank" href="https://huggingface.co/{author}" style="color: var(--link-text-color); text-decoration: underline;text-decoration-style: dotted;">{author}</a>') |
|
else: |
|
user_rank = filtered_model_orgs.index(f'<a target="_blank" href="https://huggingface.co/{author}" style="color: var(--link-text-color); text-decoration: underline;text-decoration-style: dotted;">{author}</a>') |
|
else: |
|
user_rank = "Not Found" |
|
|
|
global_datasets = sonuc_datasets['Serial Number'] if len(sonuc_datasets) > 0 else "Not Found" |
|
|
|
if len(sonuc_datasets) > 0: |
|
if org_or_user == "User": |
|
user_datasets = filtered_datasets_users.index(f'<a target="_blank" href="https://huggingface.co/{author}" style="color: var(--link-text-color); text-decoration: underline;text-decoration-style: dotted;">{author}</a>') |
|
else: |
|
user_datasets = filtered_datasets_orgs.index(f'<a target="_blank" href="https://huggingface.co/{author}" style="color: var(--link-text-color); text-decoration: underline;text-decoration-style: dotted;">{author}</a>') |
|
else: |
|
user_datasets = "Not Found" |
|
|
|
|
|
global_spaces = sonuc_spaces['Serial Number'] if len(sonuc_spaces) > 0 else "Not Found" |
|
|
|
if len(sonuc_spaces) > 0: |
|
if org_or_user == "User": |
|
user_spaces = filtered_spaces_users.index(f'<a target="_blank" href="https://huggingface.co/{author}" style="color: var(--link-text-color); text-decoration: underline;text-decoration-style: dotted;">{author}</a>') |
|
else: |
|
user_spaces = filtered_spaces_orgs.index(f'<a target="_blank" href="https://huggingface.co/{author}" style="color: var(--link-text-color); text-decoration: underline;text-decoration-style: dotted;">{author}</a>') |
|
else: |
|
user_spaces = "Not Found" |
|
|
|
total_model_downloads = sonuc_models['Total Downloads'] if len(sonuc_models) > 0 else "Not Found" |
|
total_model_likes = sonuc_models['Total Likes'] if len(sonuc_models) > 0 else "Not Found" |
|
model_count = sonuc_models['Number of Models'] if len(sonuc_models) > 0 else "Not Found" |
|
total_dataset_downloads = sonuc_datasets['Total Downloads'] if len(sonuc_datasets) > 0 else "Not Found" |
|
total_dataset_likes = sonuc_datasets['Total Likes'] if len(sonuc_datasets) > 0 else "Not Found" |
|
dataset_count = sonuc_datasets['Number of Datasets'] if len(sonuc_datasets) > 0 else "Not Found" |
|
total_space_likes = sonuc_spaces['Total Likes'] if len(sonuc_spaces) > 0 else "Not Found" |
|
space_count = sonuc_spaces['Number of Spaces'] if len(sonuc_spaces) > 0 else "Not Found" |
|
|
|
|
|
|
|
|
|
markdown_text = f''' |
|
<img style="float: right;" src="{a[0]}"> |
|
<h1>{author_name} ({a[1]})<h1> |
|
|
|
## 🏆 Ranks |
|
- Global: {global_rank} |
|
- Models in authors category: {user_rank} |
|
- Datasets (global): {global_datasets} |
|
- Datasets in authors category: {user_datasets} |
|
- Spaces (global): {global_spaces} |
|
- Spaces in authors category: {user_spaces} |
|
|
|
## 🤖 Models |
|
- Total downloads: {total_model_downloads} |
|
- Total Likes: {total_model_likes} |
|
- Model count: {model_count} |
|
|
|
## 📊 Datasets |
|
- Total downloads: {total_dataset_downloads} |
|
- Total Likes: {total_dataset_likes} |
|
- Dataset count: {dataset_count} |
|
|
|
## 🚀 Spaces |
|
- Total Likes: {total_space_likes} |
|
- Spaces count: {space_count} |
|
''' |
|
|
|
return markdown_text |
|
|
|
|
|
with gr.Blocks() as demo: |
|
gr.Markdown("""<h1 align="center" id="space-title">🤗 Huggingface Leaderboard</h1>""") |
|
gr.Markdown(INTRODUCTION_TEXT, elem_classes="markdown-text") |
|
|
|
all_models = get_models("models") |
|
all_datasets = get_models("datasets") |
|
all_spaces = get_models("spaces") |
|
|
|
with gr.Column(min_width=320): |
|
with gr.Box(): |
|
orgs = gr.Checkbox(value=True, label="Show Organizations", interactive=True) |
|
users = gr.Checkbox(value=True, label="Show users", interactive=True) |
|
|
|
with gr.TabItem("🏛️ Models", id=1): |
|
columns_to_convert = ["Author Name", "Best Model On Open LLM Leaderboard", "Most Downloaded Model", |
|
"Most Liked Model", "Trending Model"] |
|
models_df = make_leaderboard(org_names_in_list, user_names_in_list, "models", group_models_by_author(all_models)) |
|
models_df = models_df_to_clickable(models_df, columns_to_convert, "models") |
|
|
|
gr_models = gr.Dataframe(apply_headers(models_df, headers_models).head(400), headers=headers_models, interactive=True, |
|
datatype=["str", "markdown", "str", "str", "str", "markdown", "str", "str", "str", |
|
"markdown", "str", "markdown", "str", "markdown", "str", "str"]) |
|
|
|
with gr.TabItem("📊 Datasets", id=2): |
|
columns_to_convert = ["Author Name", "Most Downloaded Dataset", "Most Liked Dataset", "Trending Dataset"] |
|
dataset_df = make_leaderboard(org_names_in_list, user_names_in_list, "datasets", group_models_by_author(all_datasets)) |
|
dataset_df = models_df_to_clickable(dataset_df, columns_to_convert, "datasets") |
|
|
|
gr_datasets = gr.Dataframe(apply_headers(dataset_df, headers_datasets).head(250), headers=headers_datasets, interactive=False, |
|
datatype=["str", "markdown", "str", "str", "str", "str", "str", "markdown", "str", |
|
"markdown", "str", "markdown", "str", "str"]) |
|
|
|
with gr.TabItem("🚀 Spaces", id=3): |
|
columns_to_convert = ["Author Name", "Most Liked Space", "Trending Space"] |
|
|
|
spaces_df = make_leaderboard(org_names_in_list, user_names_in_list, "spaces", group_models_by_author(all_spaces)) |
|
spaces_df = models_df_to_clickable(spaces_df, columns_to_convert, "spaces") |
|
|
|
gr_spaces = gr.Dataframe(apply_headers(spaces_df, headers_spaces).head(200), headers=headers_spaces, interactive=False, |
|
datatype=["str", "markdown", "str", "str", "str", "markdown", "str", "markdown", "str", |
|
"str"]) |
|
|
|
|
|
with gr.TabItem("🔍 Search", id=4): |
|
with gr.Column(min_width=320): |
|
search_bar = gr.Textbox( |
|
placeholder=" 🔍 Search for your author and press ENTER", |
|
show_label=False) |
|
run_btn = gr.Button("Show stats for author") |
|
yazi = gr.Markdown() |
|
run_btn.click(fn=search_df, inputs=search_bar, outputs=yazi) |
|
search_bar.submit(fn=search_df, inputs=search_bar, outputs=yazi) |
|
|
|
|
|
commit = upload_datasets([models_df, dataset_df, spaces_df]) |
|
print(commit) |
|
|
|
orgs.change(fn=update_table, inputs=[orgs, users], outputs=gr_models) |
|
|
|
orgs.change(fn=update_table_datasets, inputs=[orgs, users], outputs=gr_datasets) |
|
|
|
orgs.change(fn=update_table_spaces, inputs=[orgs, users], outputs=gr_spaces) |
|
|
|
users.change(fn=update_table, inputs=[orgs, users], outputs=gr_models) |
|
|
|
users.change(fn=update_table_datasets, inputs=[orgs, users], outputs=gr_datasets) |
|
|
|
users.change(fn=update_table_spaces, inputs=[orgs, users], outputs=gr_spaces) |
|
|
|
|
|
filtered_model_users = update_table(orgs=False, users=True, return_all=True)['👤 Author Name'].tolist() |
|
filtered_model_orgs = update_table(orgs=True, users=False, return_all=True)['👤 Author Name'].tolist() |
|
|
|
filtered_datasets_users = update_table_datasets(orgs=False, users=True, return_all=True)['👤 Author Name'].tolist() |
|
filtered_datasets_orgs = update_table_datasets(orgs=True, users=False, return_all=True)['👤 Author Name'].tolist() |
|
|
|
filtered_spaces_users = update_table_spaces(orgs=False, users=True, return_all=True)['👤 Author Name'].tolist() |
|
filtered_spaces_orgs = update_table_spaces(orgs=True, users=False, return_all=True)['👤 Author Name'].tolist() |
|
|
|
demo.launch(debug=True) |
|
|
|
|
