app.py

import gradio as gr
from huggingface_hub import list_spaces
from cachetools import TTLCache, cached
from toolz import groupby, valmap

# from diskcache import Cache
# import platform

# is_macos = platform.system() == "Darwin"

# if is_macos:
#     cache = Cache("cache")

#     def cached_decorator(func):
#         return cache.memoize(typed=True, expire=1)(func)

# else:
#     ttl_cache = TTLCache(maxsize=100, ttl=60 * 10)
#     cached_decorator = cached(cache=ttl_cache)


# @cached_decorator
@cached(cache=TTLCache(maxsize=100, ttl=60 * 30))
def get_spaces():
    return list(list_spaces(full=True))


get_spaces()  # to warm up the cache


def create_space_to_like_dict():
    spaces = get_spaces()
    return {space.id: space.likes for space in spaces}


def create_org_to_like_dict():
    spaces = get_spaces()
    grouped = groupby(lambda x: x.author, spaces)
    return valmap(lambda x: sum(s.likes for s in x), grouped)


def relative_rank(my_dict, target_key, filter_zero=False):
    if filter_zero:
        my_dict = {k: v for k, v in my_dict.items() if v != 0}

    if target_key not in my_dict:
        raise gr.Error(f"'{target_key}' not found please check the ID and try again.")

    sorted_items = sorted(my_dict.items(), key=lambda item: item[1], reverse=True)

    position = [key for key, _ in sorted_items].index(target_key)
    num_lower = len(sorted_items) - position - 1

    num_higher = position
    return {
        "rank": (num_higher + 1) / len(my_dict) * 100,
        "num_higher": num_higher,
        "num_lower": num_lower,
        "value": my_dict[target_key],
    }


@cached(cache=TTLCache(maxsize=100, ttl=60 * 30))
def relative_rank_for_space(space_id, filter_zero=False):
    space_to_like_dict = create_space_to_like_dict()
    return relative_rank(space_to_like_dict, space_id, filter_zero=filter_zero)


@cached(cache=TTLCache(maxsize=100, ttl=60 * 30))
def relative_rank_for_org(org_id, filter_zero=False):
    org_to_like_dict = create_org_to_like_dict()
    return relative_rank(org_to_like_dict, org_id, filter_zero=filter_zero)


@cached(cache=TTLCache(maxsize=100, ttl=60 * 30))
def rank_space(space_id):
    return relative_rank_for_space(space_id)


def rank_space_and_org(space_or_org_id, filter_zero):
    filter_zero = filter_zero == "yes"
    split = space_or_org_id.split("/")
    if len(split) == 2:
        space_rank = relative_rank_for_space(space_or_org_id, filter_zero=filter_zero)
        return f"""Space [{space_or_org_id}](https://huggingface.co/spaces/{space_or_org_id}) is ranked {space_rank['rank']:.2f}%
        You have {space_rank['value']:,} likes for this Space.
        You have {space_rank['num_higher']:,} Spaces above and {space_rank['num_lower']:,} Spaces below in the raking of Space likes"""
    if len(split) == 1:
        org_rank = relative_rank_for_org(space_or_org_id, filter_zero=filter_zero)
        return f"""Organization or user [{space_or_org_id}](https://huggingface.co/{space_or_org_id}) is ranked {org_rank['rank']:.2f}%
        You have {org_rank['value']:,} likes for this org/user. 
        You have {org_rank['num_higher']:,} orgs/users above and {org_rank['num_lower']:,} orgs/users below in the raking of Space likes"""


def get_top_n_orgs_and_users(top_n=100):
    orgs_to_likes = create_org_to_like_dict()
    sorted_items = sorted(orgs_to_likes.items(), key=lambda item: item[1], reverse=True)
    sorted_items = sorted_items[:top_n]
    return sorted_items


def plot_top_n_orgs_and_users(top_n=100):
    top_n = get_top_n_orgs_and_users(top_n)
    return "".join(
        f"\n{i+1}. [{org}](https://huggingface.co/{org}) with {likes:,} likes"
        for i, (org, likes) in enumerate(top_n)
    )


def get_top_n_spaces(top_n=100):
    orgs_to_likes = create_space_to_like_dict()
    sorted_items = sorted(orgs_to_likes.items(), key=lambda item: item[1], reverse=True)
    sorted_items = sorted_items[:top_n]
    return sorted_items


def plot_top_n_spaces(top_n=100):
    top_n = get_top_n_spaces(top_n)
    return "".join(
        f"\n{i+1}. [{space}](https://huggingface.co/spaces/{space}) with {likes:,} likes"
        for i, (space, likes) in enumerate(top_n)
    )


with gr.Blocks() as demo:
    gr.HTML("<h1 style='text-align: center;'> &#127942; HuggyRanker &#127942; </h1>")
    gr.HTML(
        """<p style='text-align: center;'>Rank a single Space or all of the Spaces created by an organization or user by likes</p>"""
    )
    gr.HTML(
        """<p style="text-align: center;"><i>Remember likes aren't everything!</i></p>"""
    )
    gr.Markdown(
        """## Rank Specific Spaces or Orgs
    Provide this app with a Space ID or a Username/Organization name to rank by likes."""
    )
    with gr.Row():
        space_id = gr.Textbox(
            "librarian-bots", max_lines=1, label="Space or user/organization ID"
        )
        filter_zero = gr.Radio(
            choices=["no", "yes"],
            label="Filter out spaces with 0 likes in the ranking?",
            value="yes",
        )
    run_btn = gr.Button("Show ranking for this Space org org/user!", label="Rank Space")
    gr.Markdown("### Ranking for org/user or space")
    result = gr.Markdown()
    run_btn.click(rank_space_and_org, inputs=[space_id, filter_zero], outputs=result)
    gr.Markdown("## Leaderboard of Top 100 Spaces and Orgs/Users by Likes")
    with gr.Row():
        with gr.Accordion("Show rankings for Orgs and Users", open=False):
            gr.Markdown("""## 🥇 Top 100 Orgs and Users by Likes 🥇""")
            ranking_board = gr.Markdown(plot_top_n_orgs_and_users())
        with gr.Accordion("Show rankings for Spaces", open=False):
            gr.Markdown("""## 🏅 Top 100 Spaces by Likes 🏅""")
            ranking_board = gr.Markdown(plot_top_n_spaces())

demo.queue(concurrency_count=4).launch()