app.py

import discord
import os
import threading
from discord.ext import commands
import json
import time
import matplotlib.pyplot as plt
from io import BytesIO
import gradio_client
import gradio as gr
from gradio_client import Client


DISCORD_TOKEN = os.environ.get("DISCORD_TOKEN", None)
MY_GUILD_ID = 879548962464493619

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}.")


bot = Bot()

XP_PER_MESSAGE = 10

xp_data = {}


def load_xp_data():
    try:
        with open('xp_data.json', 'r') as f:
            return json.load(f)
    except FileNotFoundError:
        return {}


def save_xp_data(xp_data):
    with open('xp_data.json', 'w') as f:
        json.dump(xp_data, f)


@bot.event
async def on_ready():
    print(f'Logged in as {bot.user.name}')


@bot.event
async def on_message(message):
    global xp_data
    
    if message.author.bot:
        return

    if message.author.id not in xp_data:
        xp_data[message.author.id] = 0
        
    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.mention} xp: {xp_data[message.author.id]}")
    print(f"{message.author.mention} level: {level}")
    save_xp_data(xp_data)
    



def calculate_level(xp):
    return int(xp ** (1.0 / 3.0)) # 100k messages = lvl 100, good for super long term plan


@bot.command()
async def level(ctx):
    try:
        global xp_data
        print(ctx.author.id)
        print(ctx.author.mention)
        if ctx.author.id == 811235357663297546: # lunarflu
            if ctx.author.id 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.')

    except Exception as e:
        print(f"Error: {e}")


@bot.command()
async def plot_xp(ctx):
    if ctx.author.id == 811235357663297546:
        author_id = str(ctx.author.id)
        if author_id in xp_data:
            timestamps, xp_values = zip(*xp_data[author_id])
            plt.plot(timestamps, xp_values)
            plt.xlabel('Timestamp')
            plt.ylabel('XP')
            plt.title('XP Over Time')
            
            image_stream = BytesIO()
            plt.savefig(image_stream, format='png')
            plt.close()
            
            image_stream.seek(0)
            await ctx.send(file=discord.File(fp=image_stream, filename='xp_graph.png'))
        else:
            await ctx.send('You have not earned any XP yet.')


@bot.command()
async def show_xp_data(ctx):
    if ctx.author.id == 811235357663297546:
        author_id = str(ctx.author.id)
        if author_id in xp_data:
            xp = xp_data[author_id]
            await ctx.send(f'Your XP data: {xp}')
        else:
            await ctx.send('You have not earned any XP yet.')


@bot.command()
async def load_xp(ctx):
    if ctx.author.id == 811235357663297546:
        try:
            xp_data.clear()  # Clear current XP data
            with open('xp_data.json', 'r') as f:
                loaded_data = json.load(f)
                xp_data.update(loaded_data)  # Update with loaded data
            await ctx.send('XP data has been loaded from the file.')
        except FileNotFoundError:
            await ctx.send('No XP data file found.')


    


        
""""""
def run_bot():
    client.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()