reorganize gradio demo / thread running discord bot (RuntimeError: cannot schedule new futures after shutdown)

app.py

@@ -66,7 +66,7 @@ async def on_ready():
     #data.to_csv(csv_file, index=False)
 
 
-async def update_google_sheet():
+def update_google_sheet():
     """save data from HF Space -> google sheets (makes 1 API call)"""
     print("test")
     name = "levelbot"
@@ -74,6 +74,13 @@ async def update_google_sheet():
     set_with_dataframe(worksheet, global_df)
     print({f"Google sheet {name} successfully updated!"})
 
+"""
+scheduler = BackgroundScheduler()
+scheduler.add_job(update_google_sheet, "interval", seconds=60)
+scheduler.start()
+
+"""
+
 
 def calculate_level(xp):
     return int(xp ** (1.0 / 3.0))
@@ -82,6 +89,43 @@ def calculate_level(xp):
 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:
+        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}")    
+
     
 async def add_exp(member_id):
     try:
@@ -174,7 +218,7 @@ async def add_exp(member_id):
                     print(f"Gave {member} {lvl1}")  # can log this better          
 
         if member_id == 811235357663297546:
-            await update_google_sheet()
+            update_google_sheet()
     except Exception as e:
         print(f"add_exp Error: {e}")   
 
@@ -191,16 +235,147 @@ async def on_message(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.id}")
+            await asyncio.sleep(1)
+            await add_exp(user.id)
+    except Exception as e:
+        print(f"on_reaction_add Error: {e}")
+
+
+@bot.command(name='update_leaderboard')
+async def update_leaderboard(ctx, num_results: int = 10): # needs rewrite
+    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```")
+
+
+@bot.command(name='xp_help')
+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)
+
+# 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 
 
 """"""
+def get_data():
+    first_3_columns = global_df.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:
-    gr.HTML("a")
-demo.queue().launch()  
+    column_values_unique = sorted(global_df.iloc[:, 3].unique())
+    dataframe2 = pd.DataFrame({'Levels': column_values_unique})
+    counts = {}
+    for value in global_df.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()       
+
 
 DISCORD_TOKEN = os.environ.get("DISCORD_TOKEN", None)
 def run_bot():
     bot.run(DISCORD_TOKEN)
 threading.Thread(target=run_bot).start()
 
-     
+