testing

app.py

@@ -1,130 +1,112 @@
+import discord
 import os
 import threading
+from discord.ext import commands
+import json
 
-import discord
-import matplotlib.pyplot as plt
-from io import BytesIO
 import gradio_client
 import gradio as gr
 from gradio_client import Client
-import json
-import time
-from discord import app_commands
-from discord.ext import commands
-
-
 
-# HF GUILD SETTINGS
-MY_GUILD_ID = 879548962464493619
-MY_GUILD = discord.Object(id=MY_GUILD_ID)
 DISCORD_TOKEN = os.environ.get("DISCORD_TOKEN", None)
+intents = discord.Intents.all() 
+bot = commands.Bot(command_prefix='!', intents=intents)
 
 
-class Bot(commands.Bot):
-    """This structure allows slash commands to work instantly."""
-
-    def __init__(self):
-        super().__init__(command_prefix="/", intents=discord.Intents.all())
-
-    async def setup_hook(self):
-        await self.tree.sync(guild=discord.Object(MY_GUILD_ID))
-        print(f"Synced slash commands for {self.user}.")
 
+""""""
+XP_PER_MESSAGE = 10
+""""""
 
-client = Bot()
 
+@bot.event
+async def on_ready():
+    print(f'Logged in as {bot.user.name}')
 
 
-XP_PER_MESSAGE = 10
-xp_data = {}
+try:
+    with open('xp_data.json', 'r') as f:
+        xp_data = json.load(f)
+except FileNotFoundError:
+    xp_data = {}
 
-
-@client.event
-async def on_ready():
-    print(f"Logged in as {client.user} (ID: {client.user.id})")
-    print("------")
+    
+def save_xp_data():
+    with open('xp_data.json', 'w') as f:
+        json.dump(xp_data, f)
 
 
-@client.event
+@bot.event
 async def on_message(message):
     try:
-        global xp_data
-        
-        if message.author.bot:
-            return
-
-        if message.author.id not in xp_data:
-            xp_data[message.author.id] = 0
+        if message.author != bot.user:
+            """AWAIT LEVEL ALGORITM OR SOMETHING (MULTIPLE FILES?)"""
+            author_id = str(message.author.id) # dictionary pairs (ID -> TOTAL XP)
+            xp_data.setdefault(author_id, 0) # default if it doesn't already exist
             
-        old = xp_data[message.author.id]
-        new = old + XP_PER_MESSAGE
-        xp_data[message.author.id] = new
-        level = calculate_level(new)
-        
-        print(f"{message.author} xp: {xp_data[message.author.id]}")
-        print(f"{message.author} level: {level}")
-        print(f"xp_data: {xp_data}")
-
+            xp_data[author_id] += XP_PER_MESSAGE
+            save_xp_data()
+            
+            await bot.process_commands(message)
 
     except Exception as e:
         print(f"Error: {e}")
 
-
+        
+# Calculate the level based on XP
 def calculate_level(xp):
-    return int(xp ** (1.0 / 3.0)) # 100k messages = lvl 100, good for super long term plan
+    return int(xp ** (1.0 / 3.0))
 
 
-@client.command()
+@bot.command()
 async def level(ctx):
-    global xp_data
-    print(ctx.author.id)
-    print(ctx.author.mention)
-    if ctx.author.id == 811235357663297546: 
-        if ctx.author.id in xp_data:
-            print(f"{ctx.author} is in xp_data")
-            xp = xp_data[ctx.author.id]
-            level = calculate_level(xp)
-
-            await ctx.send(f'You are at level {level} with {xp} total XP.')
-            # progress bar with ascii? could be nice, easy
-        else:
-            await ctx.send('You have not earned any XP yet.')
-
-
-
-
-
+    author_id = str(ctx.author.id)
+    if author_id in xp_data:
+        xp = xp_data[author_id]
+        level = calculate_level(xp)
+        await ctx.send(f'You are at level {level} with {xp} XP.')
+    else:
+        await ctx.send('You have not earned any XP yet.')
 
 
-@client.hybrid_command(name="levelbot", with_app_command=True, description="check level")
-@app_commands.guilds(MY_GUILD)
-async def levelbot(ctx):
-    try:
-        await ctx.send(f'test')
-    except Exception as e:
-        print(f"Error: {e}")
+@bot.command()
+async def top_users(ctx, limit: int = 10):
+    """Get the top users with the highest message counts."""
+    message_counts = {}
+    channel = discord.utils.get(ctx.guild.text_channels, name="general")  # Replace with your channel name
+    
+    async for message in channel.history(limit=None):
+        if not message.author.bot:
+            message_counts[message.author] = message_counts.get(message.author, 0) + 1
+    
+    sorted_users = sorted(message_counts.items(), key=lambda x: x[1], reverse=True)
+    top_list = "\n".join([f"{member.name}: {count}" for member, count in sorted_users[:limit]])
+    await ctx.send(f"Top {limit} users by message count:\n{top_list}")
 
 
 
+    """
+    for member in ctx.guild.members:
+        #if not member.bot:
+        message_counts[member] = sum(1 for _ in await ctx.history(user=member).flatten())
+    
+    sorted_users = sorted(message_counts.items(), key=lambda x: x[1], reverse=True)
+    top_list = "\n".join([f"{member.name}: {count}" for member, count in sorted_users[:limit]])
+    await ctx.send(f"Top {limit} users by message count:\n{top_list}")    
+    """
 
 
 
-
-            
+    
 
 
+        
+""""""
+DISCORD_TOKEN = os.environ.get("DISCORD_TOKEN", None)
 def run_bot():
-    client.run(DISCORD_TOKEN)
-
-
+    bot.run(DISCORD_TOKEN)
 threading.Thread(target=run_bot).start()
-"""This allows us to run the Discord bot in a Python thread"""
-with gr.Blocks() as demo:
-    gr.Markdown("""
-    # Huggingbots Server
-    This space hosts the huggingbots discord bot.
-    Currently supported models are Falcon and DeepfloydIF
-    """)
-demo.queue(concurrency_count=100)
-demo.queue(max_size=100)
-demo.launch()
+def greet(name):
+    return "Hello " + name + "!"
+demo = gr.Interface(fn=greet, inputs="text", outputs="text")
+demo.launch()