1.4.0 update now all embeds

feedback/issues/issues.json

@@ -0,0 +1,26 @@
+[
+    {
+        "author_id": 289085424348168194,
+        "author_name": "rifsxd",
+        "timestamp": "2024-04-06 00:42:03.796000+00:00",
+        "message": "test"
+    },
+    {
+        "author_id": 289085424348168194,
+        "author_name": "rifsxd",
+        "timestamp": "2024-04-06 00:43:53.579000+00:00",
+        "message": "test"
+    },
+    {
+        "author_id": 289085424348168194,
+        "author_name": "rifsxd",
+        "timestamp": "2024-04-06 00:44:45.699000+00:00",
+        "message": "test"
+    },
+    {
+        "author_id": 289085424348168194,
+        "author_name": "rifsxd",
+        "timestamp": "2024-04-06 00:45:50.606000+00:00",
+        "message": "test"
+    }
+]

pydvpl_bot.py

@@ -35,7 +35,7 @@ load_dotenv()
 # DEFINES ------------------------------------------------------ START
 
 
-BOT_VERSION = '1.3.4'
+BOT_VERSION = '1.4.0'
 
 AUTHORIZED_USER_ID = os.getenv('AUTHORIZED_ID')
 
@@ -45,6 +45,10 @@ LOG_CHANNEL_ID = os.getenv('CHANNEL_ID')
 
 AUTHORIZED_AI_ACCESS_ID = os.getenv('AUTHORIZED_AI_ID')
 
+MY_SERVER_ID = os.getenv('MY_SERVER_ID')
+
+FEEDBACK_CHANNEL_ID = os.getenv('FEEDBACK_CHANNEL_ID')
+
 UPDATE_INTERVAL = 60
 
 activity_start_time = 0
@@ -312,23 +316,21 @@ bot.remove_command("help")
 
 @bot.hybrid_command(help="Displays the list of available commands.")
 async def help(ctx):
-    embed = discord.Embed(title="Command List", description="Here's a list of available commands:", color=discord.Color.yellow())
+    # Create an embed to display the list of available commands
+    embed = discord.Embed(title="Command List", description="Here's a list of available commands:", color=discord.Color.blue())
 
-    # Add commands to the embed with descriptions
+    # Add fields for different categories of commands with their descriptions
     embed.add_field(name="PyDVPL Prefix:", value="`/` - Discord's slash command prefix.\n`>>` - PyDVPL default prefix.")
     embed.add_field(name="Dvpl Commands:", value="`compress` - Compresses files.\n`decompress` - Decompresses files.", inline=False)
-    embed.add_field(name="User Utility Commands:", value="`ping` - Checks the bot's latency.\n`invite` - Get the bot's invite link.\n`uptime` - Displays the bot's uptime.\n`clock` - Shows the current date and time.\n`chat` - Chat with ai llm models like 'phind', 'chatgpt' & 'blackboxai'.", inline=False)
-    embed.add_field(name="Premium User Commands:", value="`chat` - Chat with ai llm models like 'phind', 'chatgpt' & 'blackboxai'.\n`image` - Generate images with 'craiyon' ai.", inline=False)
+    embed.add_field(name="User Utility Commands:", value="`ping` - Checks the bot's latency.\n`invite` - Get the bot's invite link.\n`uptime` - Displays the bot's uptime.\n`clock` - Shows the current date and time.\n`chat` - Chat with AI LLM models like 'phind', 'chatgpt' & 'blackboxai'.", inline=False)
+    embed.add_field(name="Premium User Commands:", value="`chat` - Chat with AI LLM models like 'phind', 'chatgpt' & 'blackboxai'.\n`image` - Generate images with 'craiyon' AI.", inline=False)
     embed.add_field(name="Moderator Commands:", value="`kick` - Kick a member from the server.\n`ban` - Ban a member from the server.\n`timeout` - Timeout a member for a specified duration.\n`purge` - Bulk deletes set amount of messages in guilds.", inline=False)
-    embed.add_field(name="Admin Utility Commands:", value="`stats` - Displays bot statistics.\n`list` - Lists server members.\n`say` - Make the bot say something.\n`announce` - Announces a message to a channel.\n`activity` - Sets bot activity status.\n`online` - Sets bot status to online.\n`dnd` - Sets bot status to Do Not Disturb.\n`offline` - Sets bot status to offline.\n`clean` - Cleans up bot's messages.\n`update` - Update a Python package using pip.\n`ip` - Shows the ip address of the current server.", inline=False)
+    embed.add_field(name="Admin Utility Commands:", value="`stats` - Displays bot statistics.\n`list` - Lists server members.\n`say` - Make the bot say something.\n`announce` - Announces a message to a channel.\n`activity` - Sets bot activity status.\n`online` - Sets bot status to online.\n`dnd` - Sets bot status to Do Not Disturb.\n`offline` - Sets bot status to offline.\n`clean` - Cleans up bot's messages.\n`update` - Update a Python package using pip.\n`ip` - Shows the IP address of the current server.", inline=False)
     embed.add_field(name="Feedback Commands:", value="`feedback` - Sends feedback to bot developers. (usage: >>feedback issues/requests <message>)", inline=False)
     
-    # Customize based on your commands
-
-    # Set the footer
-    # embed.set_footer(value="Use /help or >>help <command> for more details on a specific command.")
-
-    # Send the embed as an ephemeral message
+    embed.set_footer(text=f"Requested by {ctx.author.display_name}", icon_url=ctx.author.display_avatar.url if ctx.author.display_avatar else discord.Embed.Empty)
+    embed.timestamp = ctx.message.created_at
+    # Send the embed as an ephemeral message, visible only to the command invoker
     await ctx.reply(embed=embed, ephemeral=True)
 
     #await ctx.reply(f"The command `help` was executed by - {ctx.author.mention}")
@@ -343,8 +345,6 @@ async def compress(ctx , attachments: discord.Attachment):
 
     if not attachments:
         await ctx.reply("No file attached.")
-        #await ctx.reply(f"The command `compress` was executed by - {ctx.author.mention}")
-        
         return
 
     for attachment in attachments:
@@ -354,26 +354,39 @@ async def compress(ctx , attachments: discord.Attachment):
 
         # Check if the file is already in .dvpl format, if so, skip it
         if file_path.endswith(".dvpl"):
-            await ctx.reply(f"File {attachment.filename} is already in .dvpl format. Skipping.")
-
+            embed = discord.Embed(
+                title="Compression Skipped",
+                description=f"File {attachment.filename} is already in .dvpl format.",
+                color=discord.Color.gold()
+            )
+            embed.set_footer(text=f"Requested by {ctx.author.display_name}", icon_url=ctx.author.display_avatar.url if ctx.author.display_avatar else discord.Embed.Empty)
+            embed.timestamp = ctx.message.created_at
+            await msg.edit(content=None, embed=embed)
             continue
 
         await attachment.save(file_path)
         compressed_file_path = await compress_file(file_path)
         if compressed_file_path:
-            await msg.edit(content=f"File {attachment.filename} has succesfully compressed.")
+            embed = discord.Embed(
+                title="Compression Successful",
+                description=f"File {attachment.filename} has been successfully compressed.",
+                color=discord.Color.green()
+            )
+            embed.set_footer(text=f"Requested by {ctx.author.display_name}", icon_url=ctx.author.display_avatar.url if ctx.author.display_avatar else discord.Embed.Empty)
+            embed.timestamp = ctx.message.created_at
+            await msg.edit(content=None, embed=embed)
             await ctx.reply(file=discord.File(compressed_file_path))
             os.remove(file_path)  # Delete the original file
             os.remove(compressed_file_path)  # Delete the compressed file
         else:
-            await ctx.reply("Failed to `compress` the file.")
-
-    #await ctx.reply(f"The command `compress` was executed by - {ctx.author.mention}")
-    
-
-
-# FUNCTION ------------------------------------------------------ SPLIT
-
+            embed = discord.Embed(
+                title="Compression Failed",
+                description="Failed to compress the file.",
+                color=discord.Color.red()
+            )
+            embed.set_footer(text=f"Requested by {ctx.author.display_name}", icon_url=ctx.author.display_avatar.url if ctx.author.display_avatar else discord.Embed.Empty)
+            embed.timestamp = ctx.message.created_at
+            await msg.edit(content=None, embed=embed)
 
 @bot.hybrid_command(help="Decompresses attached files.")
 async def decompress(ctx, attachments: discord.Attachment):
@@ -381,8 +394,6 @@ async def decompress(ctx, attachments: discord.Attachment):
 
     if not attachments:
         await ctx.reply("No file attached.")
-        #await ctx.reply(f"The command `decompress` was executed by - {ctx.author.mention}")
-        
         return
 
     for attachment in attachments:
@@ -392,18 +403,39 @@ async def decompress(ctx, attachments: discord.Attachment):
 
         # Check if the file is not in .dvpl format, if so, skip it
         if not file_path.endswith(".dvpl"):
-            await ctx.reply(f"File {attachment.filename} is not in .dvpl format. Skipping.")
+            embed = discord.Embed(
+                title="Decompression Skipped",
+                description=f"File {attachment.filename} is not in .dvpl format.",
+                color=discord.Color.gold()
+            )
+            embed.set_footer(text=f"Requested by {ctx.author.display_name}", icon_url=ctx.author.display_avatar.url if ctx.author.display_avatar else discord.Embed.Empty)
+            embed.timestamp = ctx.message.created_at
+            await msg.edit(content=None, embed=embed)
             continue
 
         await attachment.save(file_path)
         decompressed_file_path = await decompress_file(file_path)
         if decompressed_file_path:
-            await msg.edit(content=f"File {attachment.filename} has succesfully decompressed.")
+            embed = discord.Embed(
+                title="Decompression Successful",
+                description=f"File {attachment.filename} has been successfully decompressed.",
+                color=discord.Color.green()
+            )
+            embed.set_footer(text=f"Requested by {ctx.author.display_name}", icon_url=ctx.author.display_avatar.url if ctx.author.display_avatar else discord.Embed.Empty)
+            embed.timestamp = ctx.message.created_at
+            await msg.edit(content=None, embed=embed)
             await ctx.reply(file=discord.File(decompressed_file_path))
             os.remove(file_path)  # Delete the original file
             os.remove(decompressed_file_path)  # Delete the decompressed file
         else:
-            await ctx.reply("Failed to decompress the file.")
+            embed = discord.Embed(
+                title="Decompression Failed",
+                description="Failed to decompress the file.",
+                color=discord.Color.red()
+            )
+            embed.set_footer(text=f"Requested by {ctx.author.display_name}", icon_url=ctx.author.display_avatar.url if ctx.author.display_avatar else discord.Embed.Empty)
+            embed.timestamp = ctx.message.created_at
+            await msg.edit(content=None, embed=embed)
     
     #await ctx.reply(f"The command `decompress` was executed by - {ctx.author.mention}")
     
@@ -414,15 +446,26 @@ async def decompress(ctx, attachments: discord.Attachment):
 
 @bot.hybrid_command(help="Pings to check bot's latency")
 async def ping(ctx):
+    start_time = time.monotonic()
     msg = await ctx.reply("Pinging...")
 
-    # Calculate client latency
-    client_latency = (msg.created_at - ctx.message.created_at).total_seconds() * 1000
+    # Measure WebSocket latency
+    ws_latency = bot.latency * 1000
+
+    # Calculate elapsed time since sending the message
+    end_time = time.monotonic()
+    elapsed_time = (end_time - start_time) * 1000
 
-    # Calculate shared latency
-    shared_latency = round(bot.latency * 1000)
+    # Create an embedded message
+    embed = discord.Embed(
+        title="Pong! 🏓",
+        description=f"WebSocket latency: `{ws_latency:.2f}ms`\nResponse time: `{elapsed_time:.2f}ms`",
+        color=discord.Color.blurple()
+    )
+    embed.set_footer(text=f"Requested by {ctx.author.display_name}", icon_url=ctx.author.display_avatar.url if ctx.author.display_avatar else discord.Embed.Empty)
+    embed.timestamp = ctx.message.created_at
 
-    await msg.edit(content=f"🏓 Pong! Client latency is `{client_latency:.2f}ms` - Shared latency is `{shared_latency}ms`.")
+    await msg.edit(content=None, embed=embed)
 
     #await ctx.reply(f"The command `ping` was executed by - {ctx.author.mention}")
 
@@ -430,7 +473,7 @@ async def ping(ctx):
 # FUNCTION ------------------------------------------------------ SPLIT
 
 
-@bot.command()
+@bot.hybrid_command()
 async def pinger(ctx, target):
     try:
         # Attempt to resolve the target to an IP address
@@ -451,15 +494,44 @@ async def pinger(ctx, target):
         # Calculate the round trip time (RTT)
         rtt = (time.time() - start_time) * 1000  # Convert to milliseconds
         
-        # Send a message indicating success with latency
-        await ctx.send(f'Ping to {target} successful! 🟢 Latency: {rtt:.2f}ms')
-        
         # Close the socket
         s.close()
+
+        # Create an embedded message
+        embed = discord.Embed(
+            title="Ping Result",
+            color=discord.Color.green()
+        )
+        embed.add_field(name="Target", value=target, inline=False)
+        embed.add_field(name="Status", value="Successful 🟢", inline=False)
+        embed.add_field(name="Latency", value=f"{rtt:.2f}ms", inline=False)
+
+        embed.set_footer(text=f"Requested by {ctx.author.display_name}", icon_url=ctx.author.display_avatar.url if ctx.author.display_avatar else discord.Embed.Empty)
+        embed.timestamp = ctx.message.created_at
+
+        # Send the embedded message
+        await ctx.send(embed=embed)
+
     except socket.gaierror:
-        await ctx.send(f'Error: Unable to resolve {target} to an IP address. 🔴')
+        # Create an embedded message for resolution error
+        embed = discord.Embed(
+            title="Ping Result",
+            description=f"Error: Unable to resolve {target} to an IP address. 🔴",
+            color=discord.Color.red()
+        )
+        embed.set_footer(text=f"Requested by {ctx.author.display_name}", icon_url=ctx.author.display_avatar.url if ctx.author.display_avatar else discord.Embed.Empty)
+        embed.timestamp = ctx.message.created_at
+        await ctx.send(embed=embed)
     except socket.error:
-        await ctx.send(f'Error: {target} is unreachable. 🔴')
+        # Create an embedded message for unreachable error
+        embed = discord.Embed(
+            title="Ping Result",
+            description=f"Error: {target} is unreachable. 🔴",
+            color=discord.Color.red()
+        )
+        embed.set_footer(text=f"Requested by {ctx.author.display_name}", icon_url=ctx.author.display_avatar.url if ctx.author.display_avatar else discord.Embed.Empty)
+        embed.timestamp = ctx.message.created_at
+        await ctx.send(embed=embed)
 
 
 
@@ -489,12 +561,51 @@ async def invite(ctx):
     client_id = bot.user.id
     invite_link = discord.utils.oauth_url(client_id, permissions=permissions, scopes=['bot'])
 
-    # Send the invite link to the user's DM
+    # Create an embedded message for the invite link
+    invite_embed = discord.Embed(
+        title="Invite Link",
+        description=f"Click the button below to invite PyDVPL to your server",
+        color=discord.Color.blue()
+    )
+
+    invite_embed.set_footer(text=f"Requested by {ctx.author.display_name}", icon_url=ctx.author.display_avatar.url if ctx.author.display_avatar else discord.Embed.Empty)
+    invite_embed.timestamp = ctx.message.created_at
+
+    # Create a button for the invite link
+    invite_button = discord.ui.Button(
+        style=discord.ButtonStyle.link,
+        label="Invite PyDVPL",
+        url=invite_link
+    )
+
+    # Create a View to hold the button
+    view = discord.ui.View()
+    view.add_item(invite_button)
+
+    # Send the embed with the button to the user's DM
     try:
-        await ctx.author.send(f"Invite link for PyDVPL: {invite_link}")
-        await ctx.reply(f"Sent the invite link to your DM. {ctx.author.mention}")
+        await ctx.author.send(
+            embed=invite_embed,
+            view=view
+        )
+
+        invite_confirmation_embed = discord.Embed(
+            title="Invite Link Sent",
+            description=f"The invite link has been sent to your DM, {ctx.author.mention}.",
+            color=discord.Color.green()
+        )
+        invite_confirmation_embed.set_footer(text=f"Requested by {ctx.author.display_name}", icon_url=ctx.author.display_avatar.url if ctx.author.display_avatar else discord.Embed.Empty)
+        invite_confirmation_embed.timestamp = ctx.message.created_at
+        await ctx.reply(embed=invite_confirmation_embed)
     except discord.Forbidden:
-        await ctx.reply(f"Failed to send the invite link to your DM. {ctx.author.mention} Please make sure your DMs are open.")
+        invite_error_embed = discord.Embed(
+            title="Invite Link Sending Failed",
+            description=f"Failed to send the invite link to your DM, {ctx.author.mention}. Please make sure your DMs are open.",
+            color=discord.Color.red()
+        )
+        invite_error_embed.set_footer(text=f"Requested by {ctx.author.display_name}", icon_url=ctx.author.display_avatar.url if ctx.author.display_avatar else discord.Embed.Empty)
+        invite_error_embed.timestamp = ctx.message.created_at
+        await ctx.reply(embed=invite_error_embed)
     
     #await ctx.reply(f"The command `invite` was executed by - {ctx.author.mention}")
     
@@ -503,7 +614,6 @@ async def invite(ctx):
 # FUNCTION ------------------------------------------------------ SPLIT
 
 
-# Command: Feedback
 @bot.hybrid_command(help="Send feedback or report issues", usage="<requests/issues> <message>")
 async def feedback(ctx, category: str, *, message: str):
     if category.lower() not in ["requests", "issues"]:
@@ -534,19 +644,27 @@ async def feedback(ctx, category: str, *, message: str):
     await ctx.reply(f"Thank you for your {category.lower()}. It has been recorded.")
 
     # Create an Embed object for the feedback data
-    embed = discord.Embed(title=f"New {category.lower()} feedback", color=discord.Color.yellow())
-    embed.add_field(name="Author ID", value=feedback_data["author_id"], inline=False)
-    embed.add_field(name="Author Name", value=feedback_data["author_name"], inline=False)
-    embed.add_field(name="Timestamp", value=feedback_data["timestamp"], inline=False)
-    embed.add_field(name="Message", value=feedback_data["message"], inline=False)
-
-    # Send the embed to the specified channel
-    feedback_channel_id = 1225913942564540616
-    feedback_channel = ctx.guild.get_channel(feedback_channel_id)
-    if feedback_channel:
-        await feedback_channel.send(embed=embed)
+    embed = discord.Embed(
+        title=f"New {category.lower()} feedback",
+        description=f"**Author Name:** {feedback_data['author_name']}\n**Timestamp:** {feedback_data['timestamp']}\n**Message:** {feedback_data['message']}",
+        color=discord.Color.yellow()
+    )
+
+    embed.set_footer(text=f"Requested by {ctx.author.display_name}", icon_url=ctx.author.display_avatar.url if ctx.author.display_avatar else discord.Embed.Empty)
+    embed.timestamp = ctx.message.created_at
+
+    # Send the embed to the specified server's feedback channel
+    server_id = MY_SERVER_ID  # Replace with your server ID
+    feedback_channel_id = FEEDBACK_CHANNEL_ID  # Replace with your feedback channel ID
+    server = bot.get_guild(server_id)
+    if server:
+        feedback_channel = server.get_channel(feedback_channel_id)
+        if feedback_channel:
+            await feedback_channel.send(embed=embed)
+        else:
+            print("Feedback channel not found in the server.")
     else:
-        print("Feedback channel not found.")
+        print("Server not found.")
 
 
     #await ctx.reply(f"The command `feedback` was executed by - {ctx.author.mention}")
@@ -562,8 +680,7 @@ async def uptime(ctx):
 
     if activity_start_time == 0:
         bot_mention = ctx.me.mention
-        await ctx.reply("{bot_mention}'s activity hasn't been set yet.")
-        
+        await ctx.reply(f"{bot_mention}'s activity hasn't been set yet.")
         return
 
     current_time = time.time()
@@ -572,9 +689,21 @@ async def uptime(ctx):
     hours, minutes = divmod(minutes, 60)
 
     bot_mention = ctx.me.mention
-    uptime_message = f"{bot_mention} has been playing for - {hours} hours, {minutes} minutes, {seconds} seconds."
-    await ctx.reply(uptime_message)
 
+    # Create an embedded message for the uptime
+    embed = discord.Embed(
+        title="Bot Uptime",
+        description=f"{bot_mention} has been playing for:",
+        color=discord.Color.blue()
+    )
+    embed.add_field(name="Hours", value=hours)
+    embed.add_field(name="Minutes", value=minutes)
+    embed.add_field(name="Seconds", value=seconds)
+
+    embed.set_footer(text=f"Requested by {ctx.author.display_name}", icon_url=ctx.author.display_avatar.url if ctx.author.display_avatar else discord.Embed.Empty)
+    embed.timestamp = ctx.message.created_at
+
+    await ctx.reply(embed=embed)
     #await ctx.reply(f"The command `uptime` was executed by - {ctx.author.mention}")
 
 
@@ -595,6 +724,9 @@ async def version(ctx):
     embed.add_field(name="Discord PY Version:", value=f"``{discord.__version__}``", inline=False)
     embed.add_field(name="PyTGPT Lib Version:", value=f"``{pytgpt.__version__}``", inline=False)
     embed.add_field(name="Craiyon Lib Version:", value=f"``{craiyon.__version__}``", inline=False)
+
+    embed.set_footer(text=f"Requested by {ctx.author.display_name}", icon_url=ctx.author.display_avatar.url if ctx.author.display_avatar else discord.Embed.Empty)
+    embed.timestamp = ctx.message.created_at
     
     # Send the embed message
     await ctx.reply(embed=embed) 
@@ -612,7 +744,18 @@ async def clock(ctx):
     # Format the date and time
     formatted_now = now.strftime("%Y-%m-%d %H:%M:%S")
 
-    await ctx.reply(f"Current date and time: `{formatted_now}`")
+    # Create an embed message to display the current date and time
+    embed = discord.Embed(
+        title="Current Date and Time",
+        description=f"```\n{formatted_now}\n```",
+        color=discord.Color.blue()
+    )
+
+    embed.set_footer(text=f"Requested by {ctx.author.display_name}", icon_url=ctx.author.display_avatar.url if ctx.author.display_avatar else discord.Embed.Empty)
+    embed.timestamp = ctx.message.created_at
+
+    # Send the embed message
+    await ctx.reply(embed=embed)
 
     #await ctx.reply(f"The command `clock` was executed by - {ctx.author.mention}")
 
@@ -643,10 +786,28 @@ async def chat(ctx, model, *, message):
         half_length = len(response) // 2
         first_half = response[:half_length]
         second_half = response[half_length:]
-        await msg.edit(content=f"{first_half}-")
-        await ctx.send(f"-{second_half}")
+        embed = discord.Embed(
+            title="Response",
+            color=discord.Color.green()
+        )
+        embed.add_field(name="First Half", value=f"{first_half}-")
+        embed.add_field(name="Second Half", value=f"-{second_half}")
+
+        embed.set_footer(text=f"Requested by {ctx.author.display_name}", icon_url=ctx.author.display_avatar.url if ctx.author.display_avatar else discord.Embed.Empty)
+        embed.timestamp = ctx.message.created_at
+
+        await msg.edit(content=None, embed=embed)
     else:
-        await msg.edit(content=response)
+        embed = discord.Embed(
+            title="Response",
+            description=response,
+            color=discord.Color.green()
+        )
+
+        embed.set_footer(text=f"Requested by {ctx.author.display_name}", icon_url=ctx.author.display_avatar.url if ctx.author.display_avatar else discord.Embed.Empty)
+        embed.timestamp = ctx.message.created_at
+
+        await msg.edit(content=None, embed=embed)
 
 
     #await ctx.reply(f"The command `chat` was executed by - {ctx.author.mention}")
@@ -679,9 +840,19 @@ async def image(ctx, *, prompt: str):
             image_file = discord.File(img_bytes, filename=f"result{index}.webp")
             images.append(image_file)
 
-        await msg.edit(content=f"Sucessfully generated {prompt} images.")
-        # Send images to the user
-        await ctx.reply(files=images)
+        embed = discord.Embed(
+            title="Generated Images",
+            description=f"Sucessfully generated images for prompt: `{prompt}`.",
+            color=discord.Color.green()
+        )
+        # Add a field for each generated image
+        for index, image in enumerate(images):
+            embed.add_field(name=f"Image {index+1}", value=f"[Click here to view]({image.url})")
+
+        embed.set_footer(text=f"Requested by {ctx.author.display_name}", icon_url=ctx.author.display_avatar.url if ctx.author.display_avatar else discord.Embed.Empty)
+        embed.timestamp = ctx.message.created_at
+
+        await msg.edit(content=None, embed=embed)
 
     except Exception as e:
         # Print the specific exception message for debugging
@@ -703,19 +874,33 @@ async def clean(ctx, clean_mode):
     # Check if the author is authorized to use this command
     if str(ctx.author.id) != AUTHORIZED_USER_ID:
         await ctx.reply("You are not authorized to use this command.")
-        
         return
 
+    embed = discord.Embed(title="File Cleaning Command", color=0x00ff00)  # Green color for the embed
+
     if clean_mode.lower() == 'compress':
         await clean_directory(ctx, COMPRESS_FOLDER)
+        embed.add_field(name="Action", value="Compress Folder Cleaning", inline=False)
     elif clean_mode.lower() == 'decompress':
         await clean_directory(ctx, DECOMPRESS_FOLDER)
+        embed.add_field(name="Action", value="Decompress Folder Cleaning", inline=False)
     elif clean_mode.lower() == 'issues':
         await clean_directory(ctx, ISSUES_FOLDER)
+        embed.add_field(name="Action", value="Issues Folder Cleaning", inline=False)
     elif clean_mode.lower() == 'requests':
         await clean_directory(ctx, REQUESTS_FOLDER)
+        embed.add_field(name="Action", value="Requests Folder Cleaning", inline=False)
     else:
-        await ctx.reply("Invalid clean mode. Please choose 'received_to_compress', 'received_to_decompress', 'feedback_issues', or 'feedback_requests'.")
+        embed.add_field(name="Error", value="Invalid clean mode. Please choose 'compress', 'decompress', 'issues', or 'requests'.", inline=False)
+        embed.set_footer(text=f"Requested by {ctx.author.display_name}", icon_url=ctx.author.display_avatar.url if ctx.author.display_avatar else discord.Embed.Empty)
+        embed.timestamp = ctx.message.created_at
+        await ctx.reply(embed=embed)
+        return
+
+    embed.add_field(name="Status", value="Cleaning completed successfully.", inline=False)
+    embed.set_footer(text=f"Requested by {ctx.author.display_name}", icon_url=ctx.author.display_avatar.url if ctx.author.display_avatar else discord.Embed.Empty)
+    embed.timestamp = ctx.message.created_at
+    await ctx.reply(embed=embed)
 
 
 # FUNCTION ------------------------------------------------------ SPLIT
@@ -726,10 +911,23 @@ async def online(ctx):
     # Check if the author is authorized to use this command
     if str(ctx.author.id) != AUTHORIZED_USER_ID:
         await ctx.reply("You are not authorized to use this command.")
-        
         return
+    
+    # Your playing_time_activity variable should be defined somewhere
+    playing_time_activity = "Your default activity here"
+
+    # Change the bot's presence
     await bot.change_presence(activity=discord.Game(name=playing_time_activity))
-    await ctx.reply("Bot's presence set to online.")
+
+    # Prepare an embed for response
+    embed = discord.Embed(title="Bot Presence Update", color=0x00ff00)  # Green color for the embed
+    embed.add_field(name="Status", value="Bot's presence set to online with activity: " + playing_time_activity, inline=False)
+
+    embed.set_footer(text=f"Requested by {ctx.author.display_name}", icon_url=ctx.author.display_avatar.url if ctx.author.display_avatar else discord.Embed.Empty)
+    embed.timestamp = ctx.message.created_at
+    
+    # Send the embed as a reply
+    await ctx.reply(embed=embed)
     
 
 
@@ -741,10 +939,20 @@ async def dnd(ctx):
     # Check if the author is authorized to use this command
     if str(ctx.author.id) != AUTHORIZED_USER_ID:
         await ctx.reply("You are not authorized to use this command.")
-        
         return
+    
+    # Change the bot's presence to Do Not Disturb
     await bot.change_presence(status=discord.Status.dnd)
-    await ctx.reply("Bot's presence set to Do Not Disturb.")
+
+    # Prepare an embed for response
+    embed = discord.Embed(title="Bot Presence Update", color=0xff0000)  # Red color for the embed
+    embed.add_field(name="Status", value="Bot's presence set to Do Not Disturb", inline=False)
+    
+    embed.set_footer(text=f"Requested by {ctx.author.display_name}", icon_url=ctx.author.display_avatar.url if ctx.author.display_avatar else discord.Embed.Empty)
+    embed.timestamp = ctx.message.created_at
+
+    # Send the embed as a reply
+    await ctx.reply(embed=embed)
     
 
 
@@ -756,10 +964,20 @@ async def offline(ctx):
     # Check if the author is authorized to use this command
     if str(ctx.author.id) != AUTHORIZED_USER_ID:
         await ctx.reply("You are not authorized to use this command.")
-        
         return
+    
+    # Change the bot's presence to offline
     await bot.change_presence(status=discord.Status.offline)
-    await ctx.reply("Bot's presence set to offline.")
+
+    # Prepare an embed for response
+    embed = discord.Embed(title="Bot Presence Update", color=0x000000)  # Black color for the embed
+    embed.add_field(name="Status", value="Bot's presence set to offline", inline=False)
+
+    embed.set_footer(text=f"Requested by {ctx.author.display_name}", icon_url=ctx.author.display_avatar.url if ctx.author.display_avatar else discord.Embed.Empty)
+    embed.timestamp = ctx.message.created_at
+
+    # Send the embed as a reply
+    await ctx.reply(embed=embed)
     
 
 
@@ -771,27 +989,47 @@ async def activity(ctx, activity_type, *, activity_text=None):
     # Check if the author is authorized to use this command
     if str(ctx.author.id) != AUTHORIZED_USER_ID:
         await ctx.reply("You are not authorized to use this command.")
-        
         return
 
+    # Check if a valid activity type is provided
+    valid_activity_types = ['listening', 'watching', 'playing']
+    if activity_type.lower() not in valid_activity_types:
+        embed = discord.Embed(title="Invalid Activity Type", color=0xff0000)  # Red color for the embed
+        embed.add_field(name="Error", value='Invalid activity type. Please choose either "listening", "playing" or "watching".', inline=False)
+        embed.set_footer(text=f"Requested by {ctx.author.display_name}", icon_url=ctx.author.display_avatar.url if ctx.author.display_avatar else discord.Embed.Empty)
+        embed.timestamp = ctx.message.created_at
+        await ctx.reply(embed=embed)
+        return
+
+    # Check if activity text is provided
+    if not activity_text:
+        embed = discord.Embed(title="Activity Text Missing", color=0xff0000)  # Red color for the embed
+        embed.add_field(name="Error", value='Please provide an activity text.', inline=False)
+        embed.set_footer(text=f"Requested by {ctx.author.display_name}", icon_url=ctx.author.display_avatar.url if ctx.author.display_avatar else discord.Embed.Empty)
+        embed.timestamp = ctx.message.created_at
+        await ctx.reply(embed=embed)
+        return
+
+    # Determine the activity based on the provided type
     if activity_type.lower() == 'listening':
         activity = discord.Activity(type=discord.ActivityType.listening, name=activity_text)
     elif activity_type.lower() == 'watching':
         activity = discord.Activity(type=discord.ActivityType.watching, name=activity_text)
     elif activity_type.lower() == 'playing':
         activity = discord.Activity(type=discord.ActivityType.playing, name=activity_text)
-    else:
-        await ctx.reply('Invalid activity type. Please choose either "listening", "playing" or "watching".')
-        
-        return
-
-    if not activity_text:
-        await ctx.reply('Please provide an activity text.')
-        
-        return
 
+    # Change the bot's presence
     await bot.change_presence(activity=activity)
-    await ctx.reply(f'Activity set to {activity_type} {activity_text}')
+
+    # Prepare an embed for response
+    embed = discord.Embed(title="Bot Activity Update", color=0x00ff00)  # Green color for the embed
+    embed.add_field(name="Status", value=f'Activity set to {activity_type.capitalize()} {activity_text}', inline=False)
+
+    embed.set_footer(text=f"Requested by {ctx.author.display_name}", icon_url=ctx.author.display_avatar.url if ctx.author.display_avatar else discord.Embed.Empty)
+    embed.timestamp = ctx.message.created_at
+
+    # Send the embed as a reply
+    await ctx.reply(embed=embed)
     
 
 
@@ -805,69 +1043,75 @@ async def say(ctx, destination_type, *, id, message):
         await ctx.reply("You are not authorized to use this command.")
         return
 
+    # Define function to send reply and return
+    async def send_reply(reply):
+        embed = discord.Embed(title="Message Sent", color=0x00ff00)  # Green color for the embed
+        embed.add_field(name="Status", value=reply, inline=False)
+        embed.set_footer(text=f"Requested by {ctx.author.display_name}", icon_url=ctx.author.display_avatar.url if ctx.author.display_avatar else discord.Embed.Empty)
+        embed.timestamp = ctx.message.created_at
+        await ctx.reply(embed=embed)
+
+    # Check destination type and send message accordingly
     if destination_type.lower() == 'channel':
         try:
             channel_id = int(id)
+            channel = bot.get_channel(channel_id)
+            if channel:
+                await channel.send(message)
+                await send_reply(f"Message `{message}` sent to channel `{channel.name}`.")
+            else:
+                await send_reply("Channel not found.")
         except ValueError:
-            await ctx.reply("Channel ID must be a valid integer.")
-            return
-        channel = bot.get_channel(channel_id)
-        if channel:
-            await channel.send(message)
-            await ctx.reply(f"Message `{message}` sent to channel `{channel.name}`.")
-        else:
-            await ctx.reply("Channel not found.")
-            
+            await send_reply("Channel ID must be a valid integer.")
+
     elif destination_type.lower() == 'server':
         try:
             server_id = int(id)
-        except ValueError:
-            await ctx.reply("Server ID must be a valid integer.")
-            return
-        server = bot.get_guild(server_id)
-        if server:
-            announcement_channel = discord.utils.get(server.channels, name="important-announcements")
-            if announcement_channel:
-                await announcement_channel.send(message)
-                await ctx.reply(f"Message `{message}` sent to server `{server.name}` in `important-announcements` channel.")
-            else:
-                announcements_channel = discord.utils.get(server.channels, name="announcements")
-                if announcements_channel:
-                    await announcements_channel.send(message)
-                    await ctx.reply(f"Message `{message}` sent to server `{server.name}` in `announcements` channel.")
+            server = bot.get_guild(server_id)
+            if server:
+                announcement_channel = discord.utils.get(server.channels, name="important-announcements")
+                if announcement_channel:
+                    await announcement_channel.send(message)
+                    await send_reply(f"Message `{message}` sent to server `{server.name}` in `important-announcements` channel.")
                 else:
-                    public_updates_channel = server.public_updates_channel
-                    if public_updates_channel:
-                        await public_updates_channel.send(message)
-                        await ctx.reply(f"Message `{message}` sent to server `{server.name}` in `public updates` channel.")
+                    announcements_channel = discord.utils.get(server.channels, name="announcements")
+                    if announcements_channel:
+                        await announcements_channel.send(message)
+                        await send_reply(f"Message `{message}` sent to server `{server.name}` in `announcements` channel.")
                     else:
-                        default_channel = server.system_channel or server.text_channels[0]  # Default to the first text channel
-                        if  default_channel:
-                            await default_channel.send(message)
-                            await ctx.reply(f"Message `{message}` sent to server `{server.name}` in the default channel.")
+                        public_updates_channel = server.public_updates_channel
+                        if public_updates_channel:
+                            await public_updates_channel.send(message)
+                            await send_reply(f"Message `{message}` sent to server `{server.name}` in `public updates` channel.")
                         else:
-                            await ctx.reply("No announcement channels found in the server. Also, no default `public updates` neither `default` channels found.")
-        else:
-            await ctx.reply("Server not found.")
-            
+                            default_channel = server.system_channel or server.text_channels[0]  # Default to the first text channel
+                            if default_channel:
+                                await default_channel.send(message)
+                                await send_reply(f"Message `{message}` sent to server `{server.name}` in the default channel.")
+                            else:
+                                await send_reply("No announcement channels found in the server. Also, no default `public updates` neither `default` channels found.")
+            else:
+                await send_reply("Server not found.")
+        except ValueError:
+            await send_reply("Server ID must be a valid integer.")
+
     elif destination_type.lower() == 'user':
         try:
             user_id = int(id)
+            user = bot.get_user(user_id)
+            if user:
+                try:
+                    await user.send(message)
+                    await send_reply(f"Message `{message}` sent to user '{user.display_name}'.")
+                except discord.Forbidden:
+                    await send_reply(f"Couldn't send message to `{user.display_name}`. Their DMs are closed.")
+            else:
+                await send_reply("User not found.")
         except ValueError:
-            await ctx.reply("User ID must be a valid integer.")
-            return
-        user = bot.get_user(user_id)
-        if user:
-            try:
-                await user.send(message)
-                await ctx.reply(f"Message `{message}` sent to user '{user.display_name}'.")
-            except discord.Forbidden:
-                await ctx.reply(f"Couldn't send message to `{user.display_name}`. Their DMs are closed.")
-        else:
-            await ctx.reply("User not found.")
-            
+            await send_reply("User ID must be a valid integer.")
+
     else:
-        await ctx.reply("Invalid destination type. Use either 'channel', 'server', or 'user'.")
+        await send_reply("Invalid destination type. Use either 'channel', 'server', or 'user'.")
         
 
 
@@ -879,32 +1123,42 @@ async def announce(ctx, *, message):
     # Check if the author is authorized to use this command
     if str(ctx.author.id) != AUTHORIZED_USER_ID:
         await ctx.reply("You are not authorized to use this command.")
-        
         return
 
+    # Prepare an embed for the announcement message
     embed = discord.Embed(title="Announcement!", description=message, color=discord.Color.yellow())
 
+
+    # Iterate through all servers the bot is in and send the announcement
     for server in bot.guilds:
         # First, check for an "important-announcements" channel
         announcement_channel = discord.utils.get(server.channels, name="important-announcements")
         if announcement_channel:
+            embed.set_footer(text=f"Requested by {ctx.author.display_name}", icon_url=ctx.author.display_avatar.url if ctx.author.display_avatar else discord.Embed.Empty)
+            embed.timestamp = ctx.message.created_at
             await announcement_channel.send(embed=embed)
             await ctx.reply(f"Message `{message}` sent to server `{server.name}` in `important-announcements` channel.")
         else:
             # If no "important-announcements" channel, check for "announcements" channel
             announcements_channel = discord.utils.get(server.channels, name="announcements")
             if announcements_channel:
+                embed.set_footer(text=f"Requested by {ctx.author.display_name}", icon_url=ctx.author.display_avatar.url if ctx.author.display_avatar else discord.Embed.Empty)
+                embed.timestamp = ctx.message.created_at
                 await announcements_channel.send(embed=embed)
                 await ctx.reply(f"Message `{message}` sent to server `{server.name}` in `announcements` channel.")
             else:
                 # If neither channel exists, send to the default channel or public updates channel
                 public_updates_channel = server.public_updates_channel
                 if public_updates_channel:
+                    embed.set_footer(text=f"Requested by {ctx.author.display_name}", icon_url=ctx.author.display_avatar.url if ctx.author.display_avatar else discord.Embed.Empty)
+                    embed.timestamp = ctx.message.created_at
                     await public_updates_channel.send(embed=embed)
                     await ctx.reply(f"Message `{message}` sent to server `{server.name}` in `public updates` channel.")
                 else:
                     default_channel = server.system_channel or server.text_channels[0]
-                    if  default_channel:
+                    if default_channel:
+                        embed.set_footer(text=f"Requested by {ctx.author.display_name}", icon_url=ctx.author.display_avatar.url if ctx.author.display_avatar else discord.Embed.Empty)
+                        embed.timestamp = ctx.message.created_at
                         await default_channel.send(embed=embed)
                         await ctx.reply(f"Message `{message}` sent to server `{server.name}` in `defaults` channel.")
                     else:
@@ -922,11 +1176,12 @@ async def stats(ctx):
     # Check if the author is authorized to use this command
     if str(ctx.author.id) != AUTHORIZED_USER_ID:
         await ctx.reply("You are not authorized to use this command.")
-        
         return
     
-    msg = await ctx.reply("Monitoring...")
+    # Send a message to indicate that statistics are being fetched
+    msg = await ctx.reply("Fetching statistics...")
 
+    # Get bot's statistics
     guild_count = len(bot.guilds)
     member_count = len(set(bot.get_all_members()))
 
@@ -943,17 +1198,20 @@ async def stats(ctx):
     # Get memory usage
     memory_usage = psutil.virtual_memory().percent
 
-    bot_mention = ctx.me.mention
-    stats_message = (
-        f"**{bot_mention}'s Statistics & Vitals -**\n\n"
-        f"Servers: `{guild_count}`\n"
-        f"Members: `{member_count}`\n"
-        f"Uptime: `{uptime_days} days`, `{uptime_hours} hours`, `{uptime_minutes} minutes`, `{uptime_seconds} seconds`\n"
-        f"Latency: `{latency}ms`\n"
-        f"CPU Usage: `{cpu_usage}%`\n"
-        f"Memory Usage: `{memory_usage}%`"
-    )
-    await msg.edit(content=stats_message)
+    # Prepare an embed for the statistics
+    embed = discord.Embed(title="Bot Statistics & Vitals", color=discord.Color.blue())
+    embed.add_field(name="Servers", value=f"`{guild_count}`", inline=True)
+    embed.add_field(name="Members", value=f"`{member_count}`", inline=True)
+    embed.add_field(name="Uptime", value=f"`{uptime_days} days`, `{uptime_hours} hours`, `{uptime_minutes} minutes`, `{uptime_seconds} seconds`", inline=False)
+    embed.add_field(name="Latency", value=f"`{latency}ms`", inline=True)
+    embed.add_field(name="CPU Usage", value=f"`{cpu_usage}%`", inline=True)
+    embed.add_field(name="Memory Usage", value=f"`{memory_usage}%`", inline=True)
+
+    embed.set_footer(text=f"Requested by {ctx.author.display_name}", icon_url=ctx.author.display_avatar.url if ctx.author.display_avatar else discord.Embed.Empty)
+    embed.timestamp = ctx.message.created_at
+
+    # Edit the initial message with the statistics embed
+    await msg.edit(content=None, embed=embed)
     
 
 # FUNCTION ------------------------------------------------------ SPLIT
@@ -964,17 +1222,35 @@ async def list(ctx, list_type):
     # Check if the author is authorized to use this command
     if str(ctx.author.id) != AUTHORIZED_USER_ID:
         await ctx.reply("You are not authorized to use this command.")
-        
         return
-    
+
+    # Function to list issues or requests
+    async def list_feedback(ctx, folder, title):
+        files = os.listdir(folder)
+        if not files:
+            await ctx.reply("No items found.")
+            return
+
+        feedback_list = "\n".join(files)
+        embed = discord.Embed(title=title, description=f"```{feedback_list}```", color=discord.Color.blue())
+        embed.set_footer(text=f"Requested by {ctx.author.display_name}", icon_url=ctx.author.display_avatar.url if ctx.author.display_avatar else discord.Embed.Empty)
+        embed.timestamp = ctx.message.created_at
+        await ctx.reply(embed=embed)
+
+    # Execute based on the provided list type
     if list_type.lower() == 'servers':
         servers_info = "\n".join([f"{server.name} - ID: {server.id}" for server in bot.guilds])
-        await ctx.reply(f"List of servers the bot is on:\n```{servers_info}```")
+        embed = discord.Embed(title="Servers List", description=f"```{servers_info}```", color=discord.Color.green())
+        embed.set_footer(text=f"Requested by {ctx.author.display_name}", icon_url=ctx.author.display_avatar.url if ctx.author.display_avatar else discord.Embed.Empty)
+        embed.timestamp = ctx.message.created_at
+        await ctx.reply(embed=embed)
         
     elif list_type.lower() == 'issues':
         await list_feedback(ctx, ISSUES_FOLDER, "List of issues:")
+        
     elif list_type.lower() == 'requests':
         await list_feedback(ctx, REQUESTS_FOLDER, "List of requests:")
+        
     else:
         await ctx.reply("Invalid list type. Please choose 'servers', 'issues', or 'requests'.")
 
@@ -990,37 +1266,66 @@ async def update(ctx, pkg_name):
         return
 
     try:
-
-        msg = await ctx.reply("Updating package `{pkg_name}`...")
+        # Send a message to indicate that the package update process has started
+        msg = await ctx.reply(f"Updating package `{pkg_name}`...")
 
         # Run pip install command to upgrade the package
         process = subprocess.Popen(['pip', 'install', pkg_name, '--upgrade'], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
         output, error = process.communicate()
 
+        # Check if any errors occurred during the update process
         if error:
-            await msg.edit(content=f"Failed to update package `{pkg_name}`. Error: {error.decode('utf-8')}")
+            # If there was an error, update the message with the error information
+            embed = discord.Embed(title="Package Update Failed", description=f"Failed to update package `{pkg_name}`.\nError: {error.decode('utf-8')}", color=discord.Color.red())
+            embed.set_footer(text=f"Requested by {ctx.author.display_name}", icon_url=ctx.author.display_avatar.url if ctx.author.display_avatar else discord.Embed.Empty)
+            embed.timestamp = ctx.message.created_at
+            await msg.edit(embed=embed)
         else:
-            await msg.edit(content=f"Package `{pkg_name}` successfully updated.")
+            # If the update was successful, update the message to indicate success
+            embed = discord.Embed(title="Package Update Successful", description=f"Package `{pkg_name}` successfully updated.", color=discord.Color.green())
+            embed.set_footer(text=f"Requested by {ctx.author.display_name}", icon_url=ctx.author.display_avatar.url if ctx.author.display_avatar else discord.Embed.Empty)
+            embed.timestamp = ctx.message.created_at
+            await msg.edit(embed=embed)
     except Exception as e:
-        await msg.edit(content=f"An error occurred while updating package `{pkg_name}`: {e}")
+        # If an exception occurs during the update process, update the message with the exception information
+        embed = discord.Embed(title="An Error Occurred", description=f"An error occurred while updating package `{pkg_name}`: {e}", color=discord.Color.red())
+        await msg.edit(embed=embed)
 
 
 # FUNCTION ------------------------------------------------------ SPLIT
 
 
-@bot.hybrid_command(help="Shows the ip address of the current server.")
+@bot.hybrid_command(help="Shows the IP address of the current server.")
 async def ip(ctx):
     # Check if the author is authorized to use this command
     if str(ctx.author.id) != AUTHORIZED_USER_ID:
         await ctx.reply("You are not authorized to use this command.")
-        
         return
 
-    response = requests.get('https://api.ipify.org')
-    if response.status_code == 200:
-        await ctx.reply(f'Your IP address is: `{response.text}`')
-    else:
-        await ctx.reply('Failed to fetch IP address.')
+    try:
+        # Send a message to indicate that the IP address is being fetched
+        msg = await ctx.reply("Fetching IP address...")
+
+        # Fetch the IP address using the ipify API
+        response = requests.get('https://api.ipify.org')
+        if response.status_code == 200:
+            # If the request was successful, send the IP address as a reply
+            embed = discord.Embed(title="IP Address", description=f"Your IP address is: `{response.text}`", color=discord.Color.green())
+            embed.set_footer(text=f"Requested by {ctx.author.display_name}", icon_url=ctx.author.display_avatar.url if ctx.author.display_avatar else discord.Embed.Empty)
+            embed.timestamp = ctx.message.created_at
+            await msg.edit(embed=embed)
+        else:
+            # If the request failed, update the message to indicate failure
+            embed = discord.Embed(title="Failed to Fetch IP Address", description="Failed to fetch IP address.", color=discord.Color.red())
+            embed.set_footer(text=f"Requested by {ctx.author.display_name}", icon_url=ctx.author.display_avatar.url if ctx.author.display_avatar else discord.Embed.Empty)
+            embed.timestamp = ctx.message.created_at
+            await msg.edit(embed=embed)
+    except Exception as e:
+        # If an exception occurs during the process, update the message with the exception information
+        embed = discord.Embed(title="An Error Occurred", description=f"An error occurred while fetching IP address: {e}", color=discord.Color.red())
+        embed.set_footer(text=f"Requested by {ctx.author.display_name}", icon_url=ctx.author.display_avatar.url if ctx.author.display_avatar else discord.Embed.Empty)
+        embed.timestamp = ctx.message.created_at
+        await msg.edit(embed=embed)
 
 
 # UTILITY ADMIN_CMD ------------------------------------------------------ END
@@ -1034,26 +1339,32 @@ async def ip(ctx):
 
 @bot.hybrid_command(help="Kick a member from the server.")
 async def kick(ctx, member: discord.Member, *, reason=None):
+    # Check if the command invoker has the necessary permissions to kick members
     if ctx.author.guild_permissions.kick_members or ctx.author == ctx.guild.owner:
-    
+        # Check if the invoker has a higher role than the member to be kicked
         if ctx.author.top_role.position > member.top_role.position:
-
-            # Attempt to send a DM to the kicked member
             try:
+                # Attempt to send a direct message to the kicked member
                 dm_message = f"You have been kicked from the server `{ctx.guild.name}`"
                 if reason:
                     dm_message += f" for the following reason: `{reason}`"
                 await member.send(dm_message)
             except discord.Forbidden:
+                # If unable to send a DM to the kicked member, inform the invoker
                 await ctx.reply(f"Failed to send a direct message to {member}.")
             
             # Kick the member from the server
             await member.kick(reason=reason)
-            await ctx.reply(f"{member} has been kicked from the server.")
+            # Send an embedded message confirming the member has been kicked
+            embed = discord.Embed(title="Member Kicked", description=f"{member} has been kicked from the server.", color=discord.Color.green())
+            embed.set_footer(text=f"Requested by {ctx.author.display_name}", icon_url=ctx.author.display_avatar.url if ctx.author.display_avatar else discord.Embed.Empty)
+            embed.timestamp = ctx.message.created_at
+            await ctx.reply(embed=embed)
         else:
+            # If the invoker does not have a higher role than the member, inform them
             await ctx.reply("You do not have permission to kick this member.")
-
     else:
+        # If the invoker does not have the necessary permissions, inform them
         await ctx.reply("You do not have permission to use this command.")
 
 
@@ -1062,67 +1373,72 @@ async def kick(ctx, member: discord.Member, *, reason=None):
 
 @bot.hybrid_command(help="Ban a member from the server.")
 async def ban(ctx, member: discord.Member, *, reason=None):
+    # Check if the command invoker has the necessary permissions to ban members
     if ctx.author.guild_permissions.ban_members or ctx.author == ctx.guild.owner:
-    
+        # Check if the invoker has a higher role than the member to be banned
         if ctx.author.top_role.position > member.top_role.position:
-
-            # Attempt to send a DM to the banned member
             try:
+                # Attempt to send a direct message to the banned member
                 dm_message = f"You have been banned from the server `{ctx.guild.name}`"
                 if reason:
                     dm_message += f" for the following reason: `{reason}`"
                 await member.send(dm_message)
             except discord.Forbidden:
+                # If unable to send a DM to the banned member, inform the invoker
                 await ctx.reply(f"Failed to send a direct message to {member}.")
             
             # Ban the member from the server
             await member.ban(reason=reason)
-            await ctx.reply(f"{member} has been banned from the server.")
+            # Send an embedded message confirming the member has been banned
+            embed = discord.Embed(title="Member Banned", description=f"{member} has been banned from the server.", color=discord.Color.green())
+            embed.set_footer(text=f"Requested by {ctx.author.display_name}", icon_url=ctx.author.display_avatar.url if ctx.author.display_avatar else discord.Embed.Empty)
+            embed.timestamp = ctx.message.created_at
+            await ctx.reply(embed=embed)
         else:
+            # If the invoker does not have a higher role than the member, inform them
             await ctx.reply("You do not have permission to ban this member.")
-
     else:
+        # If the invoker does not have the necessary permissions, inform them
         await ctx.reply("You do not have permission to use this command.")
 
 
 
-
 # FUNCTION ------------------------------------------------------ SPLIT
 
 
 
 @bot.hybrid_command(help="Timeout a member for a specified duration.")
 async def timeout(ctx, member: discord.Member, duration: int, *, reason=None):
-
-    # Check if the author is owner of the guild to use this command
+    # Check if the author is authorized to use this command
     if ctx.author.guild_permissions.manage_roles or ctx.author == ctx.guild.owner:
-    
+        # Check if the invoker has a higher role than the member to be timed out
         if ctx.author.top_role.position > member.top_role.position:
-        
             try:
-                # Duration in seconds
+                # Timeout duration in seconds
                 timeout_duration = duration
                 
                 # Timeout the member by removing all roles
                 await member.edit(roles=[], reason=reason)
-
-                await ctx.reply(f"`{member}` has been timed out for `{duration} seconds`. Reason: `{reason}`")
                 
-                # Construct the message to be sent as a DM
-                dm_message_init = f"You have been timed out in the server `{ctx.guild.name}` for `{duration} seconds`"
-                if reason:
-                    dm_message_init += f" for the following reason: `{reason}`"
+                # Inform about the timeout
+                embed = discord.Embed(title="Member Timed Out", description=f"`{member}` has been timed out for `{duration} seconds`.\nReason: `{reason}`", color=discord.Color.green())
+                embed.set_footer(text=f"Requested by {ctx.author.display_name}", icon_url=ctx.author.display_avatar.url if ctx.author.display_avatar else discord.Embed.Empty)
+                embed.timestamp = ctx.message.created_at
+                await ctx.reply(embed=embed)
                 
                 # Send a DM to the timed-out member
-                try:
-                    await member.send(dm_message_init)
-                except discord.Forbidden:
-                    # If unable to send DM, log the error and continue
-                    await ctx.reply(f"Failed to send DM to `{member}` for timeout.")
+                dm_message = f"You have been timed out in the server `{ctx.guild.name}` for `{duration} seconds`"
+                if reason:
+                    dm_message += f" for the following reason: `{reason}`"
+                await member.send(dm_message)
                 
             except Exception as e:
-                await ctx.reply(f"An error occurred: {e}")
-                return  # Stop execution if there's an error
+                # If an error occurs during the timeout process, inform the invoker
+                embed = discord.Embed(title="Error", description=f"An error occurred while timing out `{member}`: {e}", color=discord.Color.red())
+                embed.set_footer(text=f"Requested by {ctx.author.display_name}", icon_url=ctx.author.display_avatar.url if ctx.author.display_avatar else discord.Embed.Empty)
+                embed.timestamp = ctx.message.created_at
+                await ctx.reply(embed=embed)
+                return
                 
             # Wait for the duration of the timeout
             await asyncio.sleep(timeout_duration)
@@ -1131,23 +1447,27 @@ async def timeout(ctx, member: discord.Member, duration: int, *, reason=None):
             try:
                 await member.edit(roles=member.roles, reason=reason)
             except Exception as e:
+                # If an error occurs while restoring roles, inform the invoker
                 print(f"An error occurred while restoring roles to `{member}`: {e}")
-                return  # Stop execution if there's an error
+                return
                 
-            dm_message_exit = f"Your previous timeout in the server `{ctx.guild.name}` for `{duration} seconds`"
+            # Inform the member that their timeout has expired
+            dm_message = f"Your timeout in the server `{ctx.guild.name}` for `{duration} seconds`"
             if reason:
-                dm_message_exit += f" for the following reason: `{reason}` has been expired!"
-            
+                dm_message += f" for the following reason: `{reason}` has expired."
             try:
-                await member.send(dm_message_exit)
+                await member.send(dm_message)
             except discord.Forbidden:
-                # If unable to send DM, log the error and continue
-                await ctx.reply(f"Failed to send DM to `{member}` to notify timeout expiration.")
-
+                # If unable to send a DM, inform the invoker
+                embed = discord.Embed(title="Error", description=f"Failed to send DM to `{member}` to notify timeout expiration.", color=discord.Color.red())
+                embed.set_footer(text=f"Requested by {ctx.author.display_name}", icon_url=ctx.author.display_avatar.url if ctx.author.display_avatar else discord.Embed.Empty)
+                embed.timestamp = ctx.message.created_at
+                await ctx.reply(embed=embed)
         else:
+            # If the invoker does not have a higher role than the member, inform them
             await ctx.reply("You do not have permission to timeout this member.")
-    
     else:
+        # If the invoker does not have the necessary permissions, inform them
         await ctx.reply("You do not have permission to use this command.")
 
 
@@ -1156,37 +1476,53 @@ async def timeout(ctx, member: discord.Member, duration: int, *, reason=None):
 
 @bot.hybrid_command(help="Bulk deletes set amount of messages in guilds.")
 async def purge(ctx, amount: int):
-
+    # Check if the command is invoked in a direct message channel
     if isinstance(ctx.channel, discord.DMChannel):
-                msg = await ctx.reply(f"Purging `{amount}` messages...")
-                await msg.edit(content="Purging is not supported in direct messages.")
-                return
+        # Inform that purging is not supported in direct messages
+        embed = discord.Embed(title="Purge Error", description="Purging is not supported in direct messages.", color=discord.Color.red())
+        await ctx.reply(embed=embed)
+        return
 
-    # Check if the author is owner of the guild to use this command
+    # Check if the invoker has the necessary permissions to manage roles or is the guild owner
     if ctx.author.guild_permissions.manage_roles or ctx.author == ctx.guild.owner:
-        
         try:
-
+            # Send a message to indicate that purging is in progress
             msg = await ctx.reply(f"Purging `{amount}` messages...")
 
             try:
                 # Use the before parameter to only purge messages before the command is invoked
                 await ctx.channel.purge(limit=amount, before=ctx.message)
-                await msg.edit(content=f"`{amount}` messages purged successfully.")
+                # Update the message to indicate successful purging
+                embed = discord.Embed(title="Purge Successful", description=f"`{amount}` messages purged successfully.", color=discord.Color.green())
+                embed.set_footer(text=f"Requested by {ctx.author.display_name}", icon_url=ctx.author.display_avatar.url if ctx.author.display_avatar else discord.Embed.Empty)
+                embed.timestamp = ctx.message.created_at
+                await msg.edit(content="", embed=embed)  # Edit the message to remove content and set the new embed
             except discord.Forbidden:
-                await msg.edit(content="I don't have permission to delete messages in this channel.")
+                # If the bot doesn't have permission to delete messages, inform the invoker
+                embed = discord.Embed(title="Purge Error", description="I don't have permission to delete messages in this channel.", color=discord.Color.red())
+                embed.set_footer(text=f"Requested by {ctx.author.display_name}", icon_url=ctx.author.display_avatar.url if ctx.author.display_avatar else discord.Embed.Empty)
+                embed.timestamp = ctx.message.created_at
+                await msg.edit(content="", embed=embed)  # Edit the message to remove content and set the new embed
             except discord.HTTPException:
-                await msg.edit(content="Failed to purge messages due to an error.")
-
+                # If an error occurs during purging, inform the invoker
+                embed = discord.Embed(title="Purge Error", description="Failed to purge messages due to an error.", color=discord.Color.red())
+                embed.set_footer(text=f"Requested by {ctx.author.display_name}", icon_url=ctx.author.display_avatar.url if ctx.author.display_avatar else discord.Embed.Empty)
+                embed.timestamp = ctx.message.created_at
+                await msg.edit(content="", embed=embed)  # Edit the message to remove content and set the new embed
         
         except Exception as e:
-            await ctx.reply(f"An error occurred: {e}")
-            return  # Stop execution if there's an error
-            
-    
+            # If an error occurs during the process, inform the invoker
+            embed = discord.Embed(title="Error", description=f"An error occurred: {e}", color=discord.Color.red())
+            embed.set_footer(text=f"Requested by {ctx.author.display_name}", icon_url=ctx.author.display_avatar.url if ctx.author.display_avatar else discord.Embed.Empty)
+            embed.timestamp = ctx.message.created_at
+            await msg.edit(content="", embed=embed)
+            return
     else:
-        await ctx.reply("You do not have permission to use this command.")
-
+        # If the invoker doesn't have the necessary permissions, inform them
+        embed = discord.Embed(title="Permission Denied", description="You do not have permission to use this command.", color=discord.Color.red())
+        embed.set_footer(text=f"Requested by {ctx.author.display_name}", icon_url=ctx.author.display_avatar.url if ctx.author.display_avatar else discord.Embed.Empty)
+        embed.timestamp = ctx.message.created_at
+        await msg.edit(content="", embed=embed)
 
 # UTILITY MODERATOR_CMD ------------------------------------------------------ END