[app.py] 1.1 PR

app.py

@@ -1,503 +1,90 @@
 import discord
-import os  
-import threading
+from discord import app_commands
 import gradio as gr
-import requests
-import json
-import random
-import time
-import re
-from discord import Embed, Color
-from discord.ext import commands
-# aa
-from gradio_client import Client
-from PIL import Image
-#from ratelimiter import RateLimiter
-
-import asyncio
-import concurrent.futures
-import multiprocessing
-
-import shutil # for doing image movement magic
-
-#import tempfile
-#import glob
-
-import uuid
-import glob
+import os
+import threading
+from falcon import try_falcon
+from falcon import continue_falcon
+from deepfloydif import deepfloydif_stage_1
+from deepfloydif import deepfloydif_stage_2_react_check
+
+# HF GUILD SETTINGS
+MY_GUILD_ID = 1077674588122648679 if os.getenv("TEST_ENV", False) else 879548962464493619
+MY_GUILD = discord.Object(id=MY_GUILD_ID)
+DISCORD_TOKEN = os.environ.get("DISCORD_TOKEN", None)
 
-#todo
-# experiment with animeGANv2
-#✅ tasks for concurrent coroutines (now jobs)
-# ratelimits
 
-# enlarge each of 4 images?
-# Error: [Errno 104] Connection reset by peer?
+class MyClient(discord.Client):
+    """This structure allows slash commands to work instantly."""
 
-# clean up old threads
-# safety for on_reaction_add?
-# could use one channel, use threads to organize it. Otherwise may be too split and harder to keep track of
-# lock generation after ~120s, can change
-# restructure using slash commands? generate -> deepfloydif -> prompt -> thread -> combined -> upscale -> thread
+    def __init__(self, *, intents: discord.Intents):
+        super().__init__(intents=intents)
+        self.tree = app_commands.CommandTree(self)
 
-HF_TOKEN = os.getenv('HF_TOKEN')
-DISCORD_TOKEN = os.environ.get("DISCORD_TOKEN", None)
+    async def setup_hook(self):
+        # This copies the global commands over to our guild
+        self.tree.copy_global_to(guild=MY_GUILD)
+        await self.tree.sync(guild=MY_GUILD)
 
-df = Client("huggingface-projects/IF", HF_TOKEN)
-#jojogan = Client("akhaliq/JoJoGAN", HF_TOKEN)
-falconclient = Client("HuggingFaceH4/falcon-chat", HF_TOKEN)
 
-intents = discord.Intents.default()
-intents.message_content = True
+client = MyClient(intents=discord.Intents.all())
 
-bot = commands.Bot(command_prefix='!', intents=intents)
 
-#---------------------------------------------------------------------------------------------------------------------------------------------
-@bot.event
+@client.event
 async def on_ready():
-    print('Logged on as', bot.user)
-    bot.log_channel = bot.get_channel(1100458786826747945) # 1100458786826747945 = bot-test, 1107006391547342910 = lunarbot server  
-#---------------------------------------------------------------------------------------------------------------------------------------------   
-async def safetychecks(ctx): 
-    failure_emoji = '<:disagree:1098628957521313892>' 
-    try:
-        if ctx.author.bot:
-            print(f"Error: The bot is not allowed to use its own commands.")
-            await ctx.message.add_reaction(failure_emoji)
-            return False
-    
-        #✅✅ check if the bot is offline 
-        offline_bot_role_id = 1103676632667017266
-        bot_member = ctx.guild.get_member(bot.user.id)
-        if any(role.id == offline_bot_role_id for role in bot_member.roles):
-            print(f"Error: {ctx.author} The bot is offline or under maintenance. (Remove the offline-bot role to bring it online)") 
-            thread = await ctx.message.create_thread(name=f'Offline Error')
-            await thread.send(f"Error: {ctx.author.mention} The bot is offline or under maintenance. (Remove the offline-bot role to bring it online)")
-            await ctx.message.add_reaction(failure_emoji)
-            return False
-    
-        '''
-        # review this, may be able to remove
-        #✅✅ check if the command is in the allowed channel(s)
-        bot_test = 1100458786826747945
-        deepfloydif_channel = 1119313215675973714
-        falcon_channel = 1119313248056004729
-        
-        channel_ids = [bot_test, deepfloydif_channel, jojo_channel, spidey_channel, sketch_channel, falcon_channel]
-        if ctx.channel.id not in channel_ids: 
-            print(f"{ctx.author}, commands are not permitted in {ctx.channel}")
-            thread = await ctx.message.create_thread(name=f'Channel Error')
-            await thread.send(f"Error: {ctx.author.mention} commands are not permitted in {ctx.channel}")
-            await ctx.message.add_reaction(failure_emoji)
-            return False  
-        '''          
-            
-        '''    
-        #✅✅ check if the user has the required role(s)   
-        guild_id = 879548962464493619
-        verified_role_id = 900063512829755413  # @verified = 900063512829755413,  HF = 897376942817419265, fellows = 963431900825919498
-        huggingfolks_role_id = 897376942817419265
-        fellows_role_id = 963431900825919498
-        contentcreator_role_id = 928589475968323636
-        betatester_role_id = 1113511652990668893
-        
-        allowed_role_ids = [huggingfolks_role_id, fellows_role_id, contentcreator_role_id, betatester_role_id]
-        guild = bot.get_guild(guild_id)
-        user_roles = ctx.author.roles
-        has_allowed_role = any(role.id in allowed_role_ids for role in user_roles)
-        if not has_allowed_role:
-            print(f"Error: {ctx.author} does not have any of the required roles to use that command.")
-            thread = await ctx.message.create_thread(name=f'Perms Error')
-            await thread.send(f"Error: {ctx.author.mention} does not have any of the required roles to use that command.")
-            await ctx.message.add_reaction(failure_emoji)
-            return False
-        '''   
-    
-        return True
+    print(f"Logged in as {client.user} (ID: {client.user.id})")
+    print("------")
 
-    # ping lunarflu if any safety check ever fails
-    except Exception as e:
-        print(f"Error: safetychecks failed somewhere, command will not continue, {e}")
-        await ctx.message.reply(f"❌ <@811235357663297546> SC failed somewhere ❌ {e}") # this will always ping, as long as the bot has access to the channel
-        await ctx.message.add_reaction(failure_emoji)
-#----------------------------------------------------------------------------------------------------------------------------------------------
-async def fullqueue(e, thread): # can improve this using jobs from gradio
-    error_message = str(e)
-    if "Error: Expecting value: line 1 column 1 (char 0)" in error_message:
-        await thread.send("Queue is full! Please try again.")
-    elif "Error: Queue is full! Please try again." in error_message:
-        await thread.send("Queue is full! Please try again.")
-    # raised when the space we depend on needs to build after some inactivity (~10h)
-    elif "local variable 'stage_1_results' referenced before assignment" in error_message:
-        await thread.send("Space is building! Please try again after a few minutes.")    
 
-#----------------------------------------------------------------------------------------------------------------------------------------------  
-# deepfloydif stage 1 generation ✅
-def inference(prompt):
-    negative_prompt = ''
-    seed = random.randint(0, 1000)
-    #seed = 1
-    number_of_images = 4
-    guidance_scale = 7
-    custom_timesteps_1 = 'smart50'
-    number_of_inference_steps = 50
-    
-    stage_1_results, stage_1_param_path, stage_1_result_path = df.predict(
-        prompt, negative_prompt, seed, number_of_images, guidance_scale, custom_timesteps_1, number_of_inference_steps, api_name='/generate64')
-    
-    return [stage_1_results, stage_1_param_path, stage_1_result_path]
-#---------------------------------------------------------------------------------------------------------------------------------------------- 
-# deepfloydif stage 2 upscaling ✅
-def inference2(index, stage_1_result_path):
-    selected_index_for_stage_2 = index
-    seed_2 = 0
-    guidance_scale_2 = 4
-    custom_timesteps_2 = 'smart50'
-    number_of_inference_steps_2 = 50
-    result_path = df.predict(stage_1_result_path, selected_index_for_stage_2, seed_2, 
-                             guidance_scale_2, custom_timesteps_2, number_of_inference_steps_2, api_name='/upscale256')
-    
-    return result_path    
-#----------------------------------------------------------------------------------------------------------------------------------------------  
-# ✅
-async def react1234(reaction_emojis, combined_image_dfif):
-    for emoji in reaction_emojis:
-        await combined_image_dfif.add_reaction(emoji)  
-#----------------------------------------------------------------------------------------------------------------------------------------------  
-# Stage 1 ✅
-@bot.command()
-async def deepfloydif(ctx, *, prompt: str):
-    thread = None
+@client.tree.command()
+@app_commands.describe(prompt="Enter some text to chat with the bot! Like this: /falcon Hello, how are you?")
+async def falcon(interaction: discord.Interaction, prompt: str):
+    """Command that begins a new conversation with Falcon"""
     try:
-        try:
-            if await safetychecks(ctx): #✅
-                if ctx.channel.id == 1119313215675973714:
-                    await ctx.message.add_reaction('<a:loading:1114111677990981692>') 
-                    dfif_command_message_id = ctx.message.id # we will use this in some magic later on
-                    thread = await ctx.message.create_thread(name=f'DeepfloydIF | {prompt}', auto_archive_duration=60) # could also just use prompt, no deepfloydif
-                    # create thread -> send new message inside thread + combined_image -> add reactions -> dfif2
-        
-                    #current_time = int(time.time())
-                    #random.seed(current_time)
-        
-                    negative_prompt = ''
-                    seed = random.randint(0, 1000)
-                    #seed = 1
-                    number_of_images = 4
-                    guidance_scale = 7
-                    custom_timesteps_1 = 'smart50'
-                    number_of_inference_steps = 50
-                    api_name = '/generate64'
-                    await thread.send(f'{ctx.author.mention}Generating images in thread, can take ~1 minute...')
-            
-        except Exception as e:
-            print(f"Error: {e}")
-            if thread is None:
-                thread = await ctx.message.create_thread(name=f'DFIF1 Error')  
-            await thread.send(f"{ctx.author.mention} Error before stage 1 generation, {e}. If error code: 50035, upscale can still work.")
-            await fullqueue(e, thread)  
-            await ctx.message.remove_reaction('<a:loading:1114111677990981692>', bot.user)
-            await ctx.message.add_reaction('<:disagree:1098628957521313892>')
-            await thread.edit(archived=True)            
-        #generation✅-------------------------------------------------------
-        try:
-            #stage_1_results, stage_1_param_path, stage_1_result_path = df.predict(
-            #    prompt, negative_prompt, seed, number_of_images, guidance_scale, custom_timesteps_1, number_of_inference_steps, api_name='/generate64')
-
-            # run blocking function in executor
-            #await thread.send(f'✅running blocking function in executor')  
-            loop = asyncio.get_running_loop()
-            result = await loop.run_in_executor(None, inference, prompt)
-            #await thread.send(f'{ctx.author.mention}after executor')
-            #await thread.send(f'✅run_in_executor ran successfully')            
-            stage_1_results = result[0]
-            stage_1_result_path = result[2]
-            
-            partialpath = stage_1_result_path[5:] #magic for later
-            
-        except Exception as e:
-            print(f"Error: {e}")
-            if thread is None:
-                thread = await ctx.message.create_thread(name=f'Generation Error')
-            await thread.send(f"{ctx.author.mention} Error during stage 1 generation, {e}")
-            await fullqueue(e, thread)  
-            await ctx.message.remove_reaction('<a:loading:1114111677990981692>', bot.user)
-            await ctx.message.add_reaction('<:disagree:1098628957521313892>')
-            await thread.edit(archived=True)            
-        #posting images✅----------------------------------------------------------------    
-        try:
-            #await thread.send(f'✅combining images...') 
-            #old, see: https://huggingface.co/spaces/DeepFloyd/IF/commit/fb79844b1d0b013a28ac435a36f804d8030fba50
-            #png_files = [f for f in os.listdir(stage_1_results) if f.endswith('.png')] 
-            png_files = list(glob.glob(f"{stage_1_results}/**/*.png"))
-
-            if png_files:
-                first_png = png_files[0]
-                second_png = png_files[1]
-                third_png = png_files[2]
-                fourth_png = png_files[3]
-    
-                first_png_path = os.path.join(stage_1_results, first_png)
-                second_png_path = os.path.join(stage_1_results, second_png)
-                third_png_path = os.path.join(stage_1_results, third_png)
-                fourth_png_path = os.path.join(stage_1_results, fourth_png)
-    
-                img1 = Image.open(first_png_path)
-                img2 = Image.open(second_png_path)
-                img3 = Image.open(third_png_path)
-                img4 = Image.open(fourth_png_path)
-    
-                combined_image = Image.new('RGB', (img1.width * 2, img1.height * 2))
-    
-                combined_image.paste(img1, (0, 0))
-                combined_image.paste(img2, (img1.width, 0))
-                combined_image.paste(img3, (0, img1.height))
-                combined_image.paste(img4, (img1.width, img1.height))
-    
-                combined_image_path = os.path.join(stage_1_results, f'{partialpath}{dfif_command_message_id}.png')
-                combined_image.save(combined_image_path)   
-
-            with open(combined_image_path, 'rb') as f:
-                combined_image_dfif = await thread.send(f'{ctx.author.mention}React with the image number you want to upscale!', file=discord.File(
-                    f, f'{partialpath}{dfif_command_message_id}.png')) # named something like: tmpgtv4qjix1111269940599738479.png 
-
-            #await thread.send(f'✅reacting with 1234...') 
-            emoji_list = ['↖️', '↗️', '↙️', '↘️']
-            await react1234(emoji_list, combined_image_dfif)
-
-            await ctx.message.remove_reaction('<a:loading:1114111677990981692>', bot.user)
-            await ctx.message.add_reaction('<:agree:1098629085955113011>')
-            ''' individual images
-            if png_files:
-                for i, png_file in enumerate(png_files):
-                    png_file_path = os.path.join(stage_1_results, png_file)
-                    img = Image.open(png_file_path)
-                    image_path = os.path.join(stage_1_results, f'{i+1}{partialpath}.png')
-                    img.save(image_path)
-                    with open(image_path, 'rb') as f:
-                        await thread.send(f'{ctx.author.mention}Image {i+1}', file=discord.File(f, f'{i+1}{partialpath}.png'))
-                    await asyncio.sleep(1)             
-            
-            '''
-            
-        except Exception as e:
-            print(f"Error: {e}")
-            if thread is None:
-                thread = await ctx.message.create_thread(name=f'Posting Error')
-            await thread.send(f"{ctx.author.mention} Encountered error while posting combined image in thread, {e}")
-            await fullqueue(e, thread)  
-            await ctx.message.remove_reaction('<a:loading:1114111677990981692>', bot.user)
-            await ctx.message.add_reaction('<:disagree:1098628957521313892>')
-            await thread.edit(archived=True)            
-    #deepfloydif try/except
+        await try_falcon(interaction, prompt)
     except Exception as e:
         print(f"Error: {e}")
-        if thread is None:
-            thread = await ctx.message.create_thread(name=f'deepfloydif Error')
-        await thread.send(f"{ctx.author.mention} Overall error with deepfloydif, {e}")
-        await fullqueue(e, thread)  
-        await ctx.message.remove_reaction('<a:loading:1114111677990981692>', bot.user)
-        await ctx.message.add_reaction('<:disagree:1098628957521313892>')
-        await thread.edit(archived=True)
-#----------------------------------------------------------------------------------------------------------------------------
-# Stage 2 ✅
-async def dfif2(index: int, stage_1_result_path, thread, dfif_command_message_id): # add safetychecks
-    try:
-        parent_channel = thread.parent
-        dfif_command_message = await parent_channel.fetch_message(dfif_command_message_id)
-        await dfif_command_message.remove_reaction('<:agree:1098629085955113011>', bot.user)
-        await dfif_command_message.add_reaction('<a:loading:1114111677990981692>')
-            
-        number = index + 1
-        if number == 1:
-            position = "top left"
-        elif number == 2:
-            position = "top right"
-        elif number == 3:
-            position = "bottom left"
-        elif number == 4:
-            position = "bottom right" 
-        await thread.send(f"Upscaling the {position} image...")  
-        
-        # run blocking function in executor
-        loop = asyncio.get_running_loop()
-        result_path = await loop.run_in_executor(None, inference2, index, stage_1_result_path)
 
-        #await thread.send(f"✅upscale done")          
-        with open(result_path, 'rb') as f:
-            await thread.send(f'Here is the upscaled image! :) ', file=discord.File(f, 'result.png'))
-            
-        await dfif_command_message.remove_reaction('<a:loading:1114111677990981692>', bot.user)
-        await dfif_command_message.add_reaction('<:agree:1098629085955113011>')
-        await thread.edit(archived=True)
 
+@client.event
+async def on_message(message):
+    """Checks channel and continues Falcon conversation if it's the right Discord Thread"""
+    try:
+        await continue_falcon(message)
     except Exception as e:
         print(f"Error: {e}")
-        parent_channel = thread.parent
-        dfif_command_message = await parent_channel.fetch_message(dfif_command_message_id)
-        await dfif_command_message.remove_reaction('<a:loading:1114111677990981692>', bot.user)
-        await dfif_command_message.add_reaction('<:disagree:1098628957521313892>')  
-        await thread.send(f"Error during stage 2 upscaling, {e}") 
-        await fullqueue(e, thread) 
-        await thread.edit(archived=True)
-#----------------------------------------------------------------------------------------------------------------------------
-# react detector for stage 2 ✅
-@bot.event
-async def on_reaction_add(reaction, user):    # ctx = await bot.get_context(reaction.message)? could try later, might simplify
-    try:
-        #ctx = await bot.get_context(reaction.message)
-        # safety checks first ✅
-
-
-        if not user.bot: 
-            thread = reaction.message.channel
-            threadparentid = thread.parent.id
-            if threadparentid == 1119313215675973714: # testing-the-bot, should be whatever the deepfloydif channel is
-                # 811235357663297546 =  lunarflu
-                if reaction.message.attachments:
-                    if user.id == reaction.message.mentions[0].id:  #  if user.id == reaction.message.mentions[0].id:           
-                        # magic begins
-                        #await reaction.message.channel.send("✅reaction detected")
-                        attachment = reaction.message.attachments[0]
-                        image_name = attachment.filename # named something like: tmpgtv4qjix1111269940599738479.png
-                        # remove .png first
-                        partialpathmessageid = image_name[:-4] # should be tmpgtv4qjix1111269940599738479 
-                        # extract partialpath, messageid
-                        partialpath = partialpathmessageid[:11] # tmpgtv4qjix
-                        messageid = partialpathmessageid[11:] # 1111269940599738479
-                        # add /tmp/ to partialpath, save as new variable
-                        fullpath = "/tmp/" + partialpath # should be /tmp/tmpgtv4qjix
-                        #await reaction.message.channel.send(f"✅fullpath extracted, {fullpath}")        
-                        emoji = reaction.emoji
-                        
-                        if emoji == "↖️":
-                            index = 0
-                        elif emoji == "↗️":
-                            index = 1
-                        elif emoji == "↙️":
-                            index = 2
-                        elif emoji == "↘️":
-                            index = 3 
-                            
-                        #await reaction.message.channel.send(f"✅index extracted, {index}")         
-                        index = index
-                        stage_1_result_path = fullpath
-                        thread = reaction.message.channel
-                        dfif_command_message_id = messageid
-                        ctx = await bot.get_context(reaction.message)
-                        #await reaction.message.channel.send(f"✅calling dfif2")  
-                        await dfif2(index, stage_1_result_path, thread, dfif_command_message_id)
 
-    except Exception as e:
-        print(f"Error: {e} (known error, does not cause issues, fix later)")
-#---------------------------------------------------------------------------------------------------------------------------- 
-chathistory = None
-falcon_users = []
-#falcon_threads = []
-falcon_dictionary = {}
-falcon_userid_threadid_dictionary = {}
 
-@bot.command()
-async def falcon(ctx, *, prompt: str):
-    # todo: need to be careful with these, rework into something simpler
+@client.tree.command()
+@app_commands.describe(prompt="Enter a prompt to generate an image! Can generate realistic text, too!")
+async def deepfloydif(interaction: discord.Interaction, prompt: str):
+    """DeepfloydIF stage 1 generation"""
     try:
-        global falcon_users
-        #global falcon_threads # deprecated
-        global falcon_dictionary
-        global falcon_userid_threadid_dictionary
-
-        # dict[generation, authorid]
-        # dict[threadid, authorid]
+        await deepfloydif_stage_1(interaction, prompt, client)
+    except Exception as e:
+        print(f"Error: {e}")
 
-        if not ctx.author.bot:
-            if ctx.channel.id == 1119313248056004729: # initial thread creation inside #falcon
-                #if ctx.author.id not in falcon_users: # deprecated
-                if ctx.author.id not in falcon_userid_threadid_dictionary:
-                    await ctx.message.add_reaction('<a:loading:1114111677990981692>')
-                    thread = await ctx.message.create_thread(name=f'{ctx.author}')
-                    #falcon_users = [ctx.author.id] + falcon_users # deprecated
-                    #falcon_threads = [thread.id] + falcon_threads # deprecated
-                    await thread.send(f"[DISCLAIMER: HuggingBot is a **highly experimental** beta feature; The Falcon model and system prompt can be found here: https://huggingface.co/spaces/HuggingFaceH4/falcon-chat]")
-                    
-                    # initial generation here
-                    chathistory = falconclient.predict( 
-                            fn_index=5
-                    ) # []
-                    instructions = "The following is a conversation between a highly knowledgeable and intelligent AI assistant, called Falcon, and a human user, called User. In the following interactions, User and Falcon will converse in natural language, and Falcon will answer User's questions. Falcon was built to be respectful, polite and inclusive. Falcon was built by the Technology Innovation Institute in Abu Dhabi. Falcon will never decline to answer a question, and always attempts to give an answer that User would be satisfied with. It knows a lot, and always tells the truth. The conversation begins."
-                    job = falconclient.submit(prompt, chathistory, instructions, 0.8, 0.9, fn_index=1)  # This is not blocking, similar to run_in_executor (but better)
-                    while job.done() == False: 
-                        status = job.status() # could be spammy, let's test anyways
-                        #print(status)
-                    else:
-                        file_paths = job.outputs()
-                        full_generation = file_paths[-1] # tmp12345678.json
-                    with open(full_generation, 'r') as file:
-                        data = json.load(file)
-                        output_text = data[-1][-1] # we output this as the bot
 
-                    falcon_dictionary[ctx.author.id] = full_generation # 1234567890: tmp12345678.json
-                    falcon_userid_threadid_dictionary[ctx.author.id] = thread.id
+@client.event
+async def on_reaction_add(reaction, user):
+    """Checks for a reaction in order to call dfif2"""
+    try:
+        await deepfloydif_stage_2_react_check(reaction, user)
+    except Exception as e:
+        print(f"Error: {e} (known error, does not cause issues, low priority)")
 
-                    print(output_text)
-                    await thread.send(f"{output_text}")     
-                    await ctx.message.remove_reaction('<a:loading:1114111677990981692>', bot.user)
-                #elif ctx.author.id in falcon_users: # deprecated
-                elif ctx.author.id in falcon_userid_threadid_dictionary:
-                    # get the threadid, grab the last message in that thread, link to that message
-                    thread_id = falcon_userid_threadid_dictionary[ctx.author.id]
-                    thread_link = f"https://discord.com/channels/879548962464493619/1119313248056004729/{thread_id}"
-                    await ctx.reply(f"{ctx.author.mention}, you already have an existing conversation here {thread_link}! Use !falconclear in the #falcon channel to start a new one.")
-            #------------------------------------
-            # post all other generations here
-            #if ctx.channel.id in falcon_threads: # deprecated
-            if ctx.channel.id in falcon_userid_threadid_dictionary.values():
-                if ctx.channel.id == falcon_userid_threadid_dictionary[ctx.author.id]:
-                    await ctx.message.add_reaction('<a:loading:1114111677990981692>')
-                    chathistory = falcon_dictionary[ctx.author.id]
 
-                    instructions = "The following is a conversation between a highly knowledgeable and intelligent AI assistant, called Falcon, and a human user, called User. In the following interactions, User and Falcon will converse in natural language, and Falcon will answer User's questions. Falcon was built to be respectful, polite and inclusive. Falcon was built by the Technology Innovation Institute in Abu Dhabi. Falcon will never decline to answer a question, and always attempts to give an answer that User would be satisfied with. It knows a lot, and always tells the truth. The conversation begins."
-                    job = falconclient.submit(prompt, chathistory, instructions, 0.8, 0.9, fn_index=1)  # This is not blocking, similar to run_in_executor (but better)
-                    while job.done() == False: 
-                        status = job.status() # could be spammy, let's test anyways
-                        #print(status)
-                    else:
-                        file_paths = job.outputs()
-                        full_generation = file_paths[-1] # tmp12345678.json
-                    with open(full_generation, 'r') as file:
-                        data = json.load(file)
-                        output_text = data[-1][-1] # we output this as the bot
-                    falcon_dictionary[ctx.author.id] = full_generation 
-                    print(output_text)
-                    await ctx.reply(f"{output_text}")                
-                    await ctx.message.remove_reaction('<a:loading:1114111677990981692>', bot.user)
-            
-    except Exception as e:
-        print(f"Error: {e}")
-        await ctx.reply(f"{e} cc <@811235357663297546> (falconprivate error)")           
-        await ctx.message.remove_reaction('<a:loading:1114111677990981692>', bot.user)        
-        await ctx.message.add_reaction('<:disagree:1098628957521313892>')
-#----------------------------------------------------------------------------------------------------------------------------
-@bot.command()
-async def falconclear(ctx):
-    if not ctx.author.bot:
-        if ctx.channel.id == 1119313248056004729:
-            if ctx.author.id in falcon_userid_threadid_dictionary:
-                if ctx.author.id in falcon_dictionary:
-                    del falcon_userid_threadid_dictionary[ctx.author.id]
-                    del falcon_dictionary[ctx.author.id]
-                    await ctx.reply(f"{ctx.author.mention}'s conversation has been cleared. Feel free to start a new one!")
-#---------------------------------------------------------------------------------------------------------------------------- 
-# hackerllama magic to run the bot in a Hugging Face Space
 def run_bot():
-    bot.run(DISCORD_TOKEN)
+    client.run(DISCORD_TOKEN)
 
-threading.Thread(target=run_bot).start()
-
-def greet(name):
-    return "Hello " + name + "!"
 
-demo = gr.Interface(fn=greet, inputs="text", outputs="text")
-#demo.queue(concurrency_count=10)
+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=20)
-demo.launch()
-#---------------------------------------------------------------------------------------------------------------------------- 
+demo.launch()