[dfif2] >>> upscaling non-blockable, dfif2 >>> added safetychecks, safetychecks >>> added debugging messages

app.py

@@ -21,10 +21,15 @@ import multiprocessing
 import shutil # for doing image movement magic
 
 #todo
-# 4 -> combined image
+# add safetychecks to all parts, test thoroughly
+# add discord channels, configure for fellows
+# add debugging messages, same as in deepfloydif, to the_painter
+# experiment with animeGANv2
+
+#✅ 4 -> combined image
 # loading emoji? animated emojis?
 # make success / fail emojis more consistent across both painter + dfif
-# tasks for concurrent coroutines
+#✅ tasks for concurrent coroutines
 # ratelimits
 
 # enlarge each of 4 images?
@@ -67,27 +72,39 @@ async def safetychecks(ctx):
         if any(role.id == offline_bot_role_id for role in bot_member.roles):
             print(f"Error: The bot is offline or under maintenance. (Remove the offline-bot role to bring it online)")         
             return False
+        else:
+            await ctx.channel.send(f"✅{bot} is online")            
     
         #✅✅ check if the command is in the allowed channel(s)
         channel_id = 1100458786826747945
-        if ctx.channel.id != 1100458786826747945: # #bot-test = 1100458786826747945
-            print(f"Error: This is not a permitted channel for that command. (bot-test is the correct channel)")
-            return False
+        if ctx.channel.id != channel_id: # #bot-test = 1100458786826747945
+            print(f"If using a command, commands are not permitted in {ctx.channel}")
+            thread = ctx.channel
+            if thread.parent_id != channel_id: # threads have different channel_ids than their parents
+                print(f"Error: {thread} is not a permitted thread for upscaling.")
+                return False
+            else:
+                await ctx.channel.send(f"✅{thread} is a valid thread for upscaling")
+        else:
+            await ctx.channel.send(f"✅{ctx.channel} is a valid channel for commands")            
             
         #✅✅ check if the user has the required role(s)   
         guild_id = 879548962464493619
-        required_role_id = 897376942817419265  # @verified = 900063512829755413,  HF = 897376942817419265
+        required_role_id = 900063512829755413  # @verified = 900063512829755413,  HF = 897376942817419265
         guild = bot.get_guild(guild_id)
         required_role = guild.get_role(required_role_id)
         if required_role not in ctx.author.roles:
             print(f"Error: The user does not have the required role to use that command. ({required_role} is the correct role)")        
             return False
+        else:
+            await ctx.channel.send(f"✅{ctx.author} has the required role {required_role}")
     
         return True
 
+    # ping lunarflu if any safety check ever fails
     except Exception as e:
         print(f"Error: safetychecks failed somewhere, command will not continue.")
-        await ctx.message.reply(f"<@811235357663297546> SC failed somewhere") # this will always ping, as long as the bot has access to the channel
+        await ctx.message.reply(f"❌ <@811235357663297546> SC failed somewhere ❌") # this will always ping, as long as the bot has access to the channel
 #---------------------------------------------------------------------------------------------------------------------------------------------- 
 # jojo ✅
 @bot.command()
@@ -190,26 +207,39 @@ async def sketch(ctx):
         await thread.send(f"{ctx.author.mention}Error: {e}")
         await ctx.message.add_reaction('❌') 
 #----------------------------------------------------------------------------------------------------------------------------------------------
-# deepfloydif stage 1 generation ❌
+# 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]
+    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):
+    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 ❌
+# Stage 1 ✅
 @bot.command()
 async def deepfloydif(ctx, *, prompt: str):
     try:
@@ -232,21 +262,23 @@ async def deepfloydif(ctx, *, prompt: str):
                 number_of_inference_steps = 50
                 api_name = '/generate64'
     
-                await thread.send(f'{ctx.author.mention}Generating images in thread, can take ~1 minute...')
+                await thread.send(f'✅{ctx.author.mention}Generating images in thread, can take ~1 minute...')
             
         except Exception as e:
             print(f"Error: {e}")
             await ctx.reply('stage 1 error -> pre generation')
             await ctx.message.add_reaction('❌')
             
-        #generation❌-------------------------------------------------------
+        #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'✅run_in_executor ran successfully')            
             stage_1_results = result[0]
             stage_1_result_path = result[2]
             
@@ -254,10 +286,11 @@ async def deepfloydif(ctx, *, prompt: str):
             
         except Exception as e:
             print(f"Error: {e}")
-            await ctx.reply('stage 1 error -> during generation')
+            await ctx.reply('❌stage 1 error -> during generation')
             await ctx.message.add_reaction('❌')            
-        #posting images----------------------------------------------------------------    
+        #posting images✅----------------------------------------------------------------    
         try:
+            await thread.send(f'✅combining images...') 
             png_files = [f for f in os.listdir(stage_1_results) if f.endswith('.png')]
 
             if png_files:
@@ -290,6 +323,7 @@ async def deepfloydif(ctx, *, prompt: str):
                 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 = ['1️⃣', '2️⃣', '3️⃣', '4️⃣']
             await react1234(emoji_list, combined_image_dfif)
             
@@ -308,47 +342,45 @@ async def deepfloydif(ctx, *, prompt: str):
             
         except Exception as e:
             print(f"Error: {e}")
-            await ctx.reply('stage 1 error -> posting images in thread')
+            await ctx.reply('❌stage 1 error -> posting images in thread')
             await ctx.message.add_reaction('❌')
             
     #deepfloydif try/except
     except Exception as e:
         print(f"Error: {e}")
-        await ctx.reply('An error occurred in stage 1 for deepfloydif')
+        await ctx.reply('❌An error occurred in stage 1 for deepfloydif')
         await ctx.message.add_reaction('❌')
 
 #----------------------------------------------------------------------------------------------------------------------------
-# Stage 2 ❌
-async def dfif2(index: int, stage_1_result_path, thread, dfif_command_message_id): # add safetychecks
+# Stage 2 ✅
+async def dfif2(ctx, index: int, stage_1_result_path, thread, dfif_command_message_id): # add safetychecks
     try:
-        await thread.send(f"inside dfif2, upscaling")  
-        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')
-
-        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'))
-
-        # using custom emoji that looks nicer
-        emoji_guild = thread.guild  
-        confirm_emoji_id = 1098629085955113011
-        confirm_emoji = discord.utils.get(emoji_guild.emojis, id=confirm_emoji_id)
-        
-        # assuming dfif2 is always inside a thread, we can always exit the thread to find the channel with the original command,
-        # which allows us to react confirm on that message.
-        parent_channel = thread.parent
-        dfif_command_message = await parent_channel.fetch_message(dfif_command_message_id)
-
-        # reacting to original !deepfloydif command + using a custom emoji to do it
-        await dfif_command_message.add_reaction(confirm_emoji)
-        await thread.send(f"upscale posted")             
-            #await ctx.reply('Here is the result of the second stage', file=discord.File(f, 'result.png'))
-            #await ctx.message.add_reaction('✅') need to fix this
+        if await safetychecks(ctx):
+            await thread.send(f"✅inside dfif2, upscaling")  
+            
+            # run blocking function in executor
+            loop = asyncio.get_running_loop()
+            result_path = await loop.run_in_executor(None, inference2, index)
+    
+            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'))
+    
+            # using custom emoji that looks nicer
+            emoji_guild = thread.guild  
+            confirm_emoji_id = 1098629085955113011
+            confirm_emoji = discord.utils.get(emoji_guild.emojis, id=confirm_emoji_id)
+            
+            # assuming dfif2 is always inside a thread, we can always exit the thread to find the channel with the original command,
+            # which allows us to react confirm on that message.
+            parent_channel = thread.parent
+            dfif_command_message = await parent_channel.fetch_message(dfif_command_message_id)
+    
+            # reacting to original !deepfloydif command + using a custom emoji to do it
+            await dfif_command_message.add_reaction(confirm_emoji)
+            await thread.send(f"✅upscale posted")             
+                #await ctx.reply('Here is the result of the second stage', file=discord.File(f, 'result.png'))
+                #await ctx.message.add_reaction('✅') need to fix this
 
         '''
         try:
@@ -366,6 +398,7 @@ async def dfif2(index: int, stage_1_result_path, thread, dfif_command_message_id
 @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 ❌
         thread = reaction.message.channel
         threadparentid = thread.parent.id
@@ -403,8 +436,9 @@ async def on_reaction_add(reaction, user):    # ctx = await bot.get_context(reac
                         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)
+                        await dfif2(ctx, index, stage_1_result_path, thread, dfif_command_message_id)
         
         '''