update

pydvpl_bot.py

@@ -3,7 +3,6 @@ import time
 import json 
 import asyncio
 import psutil
-import socket
 import discord
 import requests
 from datetime import datetime
@@ -35,7 +34,7 @@ load_dotenv()
 # DEFINES ------------------------------------------------------ START
 
 
-BOT_VERSION = '1.3.1'
+BOT_VERSION = '1.3.2'
 
 AUTHORIZED_USER_ID = os.getenv('AUTHORIZED_ID')
 
@@ -98,9 +97,9 @@ async def list_feedback(ctx, folder_path, title):
                     inline=False
                 )
     if feedback_embed.fields:
-        await ctx.send(embed=feedback_embed)
+        await ctx.reply(embed=feedback_embed)
     else:
-        await ctx.send("No feedback found.")
+        await ctx.reply("No feedback found.")
     
 
 
@@ -109,15 +108,18 @@ async def list_feedback(ctx, folder_path, title):
 
 async def clean_directory(ctx, directory):
     try:
+
+        msg = await ctx.reply("Cleaning...")
+
         file_count = 0
         for filename in os.listdir(directory):
             file_path = os.path.join(directory, filename)
             if os.path.isfile(file_path):
                 os.remove(file_path)
                 file_count += 1
-        await ctx.send(f"All files cleaned successfully in {directory}. Total files cleaned: {file_count}.")
+        await msg.edit(content=f"All files cleaned successfully in {directory}. Total files cleaned: {file_count}.")
     except Exception as e:
-        await ctx.send(f"An error occurred while cleaning files: {e}")
+        await msg.edit(content=f"An error occurred while cleaning files: {e}")
     
 
 
@@ -218,7 +220,7 @@ async def on_command(ctx):
 @bot.event
 async def on_command_error(ctx, error):
     if isinstance(error, commands.CommandNotFound):
-        await ctx.send("Sorry, I couldn't find that command. Use `/help` or `>>help` to see the list of available commands.")
+        await ctx.reply("Sorry, I couldn't find that command. Use `/help` or `>>help` to see the list of available commands.")
         
     else:
         print(f'An error occurred: {error}')
@@ -326,9 +328,9 @@ async def help(ctx):
     # embed.set_footer(value="Use /help or >>help <command> for more details on a specific command.")
 
     # Send the embed as an ephemeral message
-    await ctx.send(embed=embed, ephemeral=True)
+    await ctx.reply(embed=embed, ephemeral=True)
 
-    await ctx.send(f"The command `help` was executed by - {ctx.author.mention}")
+    await ctx.reply(f"The command `help` was executed by - {ctx.author.mention}")
 
 
 # FUNCTION ------------------------------------------------------ SPLIT
@@ -339,30 +341,33 @@ async def compress(ctx , attachments: discord.Attachment):
     attachments = ctx.message.attachments
 
     if not attachments:
-        await ctx.send("No file attached.")
-        await ctx.send(f"The command `compress` was executed by - {ctx.author.mention}")
+        await ctx.reply("No file attached.")
+        await ctx.reply(f"The command `compress` was executed by - {ctx.author.mention}")
         
         return
 
     for attachment in attachments:
         file_path = os.path.join(COMPRESS_FOLDER, attachment.filename)
 
+        msg = await ctx.reply("Compressing...")
+
         # Check if the file is already in .dvpl format, if so, skip it
         if file_path.endswith(".dvpl"):
-            await ctx.send(f"File {attachment.filename} is already in .dvpl format. Skipping.")
+            await ctx.reply(f"File {attachment.filename} is already in .dvpl format. Skipping.")
 
             continue
 
         await attachment.save(file_path)
         compressed_file_path = await compress_file(file_path)
         if compressed_file_path:
-            await ctx.send(file=discord.File(compressed_file_path))
+            await msg.edit(content=f"File {attachment.filename} has succesfully compressed.")
+            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.send("Failed to `compress` the file.")
+            await ctx.reply("Failed to `compress` the file.")
 
-    await ctx.send(f"The command `compress` was executed by - {ctx.author.mention}")
+    await msg.edit(content=f"The command `compress` was executed by - {ctx.author.mention}")
     
 
 
@@ -374,58 +379,86 @@ async def decompress(ctx, attachments: discord.Attachment):
     attachments = ctx.message.attachments
 
     if not attachments:
-        await ctx.send("No file attached.")
-        await ctx.send(f"The command `decompress` was executed by - {ctx.author.mention}")
+        await ctx.reply("No file attached.")
+        await ctx.reply(f"The command `decompress` was executed by - {ctx.author.mention}")
         
         return
 
     for attachment in attachments:
         file_path = os.path.join(DECOMPRESS_FOLDER, attachment.filename)
 
+        msg = await ctx.reply("Decompressing...")
+
         # Check if the file is not in .dvpl format, if so, skip it
         if not file_path.endswith(".dvpl"):
-            await ctx.send(f"File {attachment.filename} is not in .dvpl format. Skipping.")
+            await ctx.reply(f"File {attachment.filename} is not in .dvpl format. Skipping.")
             continue
 
         await attachment.save(file_path)
         decompressed_file_path = await decompress_file(file_path)
         if decompressed_file_path:
-            await ctx.send(file=discord.File(decompressed_file_path))
+            await msg.edit(content=f"File {attachment.filename} has succesfully decompressed.")
+            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.send("Failed to decompress the file.")
+            await ctx.reply("Failed to decompress the file.")
     
-    await ctx.send(f"The command `decompress` was executed by - {ctx.author.mention}")
+    await msg.edit(content=f"The command `decompress` was executed by - {ctx.author.mention}")
     
     
     
 # FUNCTION ------------------------------------------------------ SPLIT
-  
+
 
 @bot.hybrid_command(help="Pings to check bot's latency")
 async def ping(ctx):
-    latency = round(bot.latency * 1000)  # latency in milliseconds
-    await ctx.send(f"Pong! Bot latency is {latency}ms.")
 
-    await ctx.send(f"The command `ping` was executed by - {ctx.author.mention}")
+    msg = await ctx.reply("Pinging...")
     
+    # Calculate client latency
+    client_latency = (ctx.message.created_at - ctx.message.created_at).total_seconds() * 1000
+
+    # Calculate shared latency
+    shared_latency = round((bot.latency * 1000) - client_latency)
+
+    await msg.edit(content=f"Pong! Client latency is {client_latency:.2f}ms. - Shared latency is {shared_latency}ms.")
+
+    await ctx.reply(f"The command `ping` was executed by - {ctx.author.mention}")
+
 
 # FUNCTION ------------------------------------------------------ SPLIT
 
 
-@bot.hybrid_command(help="Pings custom nameservers")
-async def pinger(ctx, nameservers: str):
-    if not nameservers:
-        await ctx.send("Please provide at least one nameserver to ping.")
-        return
+@bot.command()
+async def pinger(ctx, address):
+    try:
 
-    for nameserver in nameservers:
-        try:
-            response = await bot.loop.run_in_executor(None, lambda: socket.gethostbyname(nameserver))
-            await ctx.send(f"Ping to {nameserver} successful. IP Address: {response}")
-        except socket.gaierror:
-            await ctx.send(f"Unable to resolve {nameserver}.")
+        msg = await ctx.reply("Pinging...")
+
+        # Pinging the given address
+        process = subprocess.Popen(['ping', '-c', '4', address], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        stdout, stderr = process.communicate()
+
+        
+        # Extracting latency from the output
+        output = stdout.decode('utf-8')
+        lines = output.split('\n')
+        latency_line = lines[-2]  # assuming the second last line contains latency information
+        latency_values = latency_line.split('=')[-1].split('/')
+        min_latency = latency_values[0]
+        avg_latency = latency_values[1]
+        max_latency = latency_values[2]
+        mdev_latency = latency_values[3].split(' ')[0]  # remove 'ms' from the end
+
+        # Sending latency to the channel
+        await msg.edit(content=f'Latency for {address}: Min={min_latency} ms, Avg={avg_latency} ms, Max={max_latency} ms, StdDev={mdev_latency} ms')
+
+    except Exception as e:
+        await msg.edit(content=f'Error occurred: {e}')
+    
+    # Send the author information
+    await ctx.reply(f"The command `ping` was executed by - {ctx.author.mention}")
 
 
 
@@ -457,11 +490,11 @@ async def invite(ctx):
     # Send the invite link to the user's DM
     try:
         await ctx.author.send(f"Invite link for PyDVPL: {invite_link}")
-        await ctx.send(f"Sent the invite link to your DM. {ctx.author.mention}")
+        await ctx.reply(f"Sent the invite link to your DM. {ctx.author.mention}")
     except discord.Forbidden:
-        await ctx.send(f"Failed to send the invite link to your DM. {ctx.author.mention} Please make sure your DMs are open.")
+        await ctx.reply(f"Failed to send the invite link to your DM. {ctx.author.mention} Please make sure your DMs are open.")
     
-    await ctx.send(f"The command `invite` was executed by - {ctx.author.mention}")
+    await ctx.reply(f"The command `invite` was executed by - {ctx.author.mention}")
     
 
 
@@ -472,7 +505,7 @@ async def invite(ctx):
 @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"]:
-        await ctx.send("Invalid category. Please choose 'requests' or 'issues'.")
+        await ctx.reply("Invalid category. Please choose 'requests' or 'issues'.")
         return
 
     feedback_data = {
@@ -496,9 +529,9 @@ async def feedback(ctx, category: str, *, message: str):
     with open(file_path, "w") as f:
         json.dump(data, f, indent=4)
 
-    await ctx.send(f"Thank you for your {category.lower()}. It has been recorded.")
+    await ctx.reply(f"Thank you for your {category.lower()}. It has been recorded.")
 
-    await ctx.send(f"The command `feedback` was executed by - {ctx.author.mention}")
+    await ctx.reply(f"The command `feedback` was executed by - {ctx.author.mention}")
     
 
 
@@ -511,7 +544,7 @@ async def uptime(ctx):
 
     if activity_start_time == 0:
         bot_mention = ctx.me.mention
-        await ctx.send("{bot_mention}'s activity hasn't been set yet.")
+        await ctx.reply("{bot_mention}'s activity hasn't been set yet.")
         
         return
 
@@ -522,9 +555,9 @@ async def uptime(ctx):
 
     bot_mention = ctx.me.mention
     uptime_message = f"{bot_mention} has been playing for - {hours} hours, {minutes} minutes, {seconds} seconds."
-    await ctx.send(uptime_message)
+    await ctx.reply(uptime_message)
 
-    await ctx.send(f"The command `uptime` was executed by - {ctx.author.mention}")
+    await ctx.reply(f"The command `uptime` was executed by - {ctx.author.mention}")
 
 
 # FUNCTION ------------------------------------------------------ SPLIT
@@ -546,9 +579,9 @@ async def version(ctx):
     embed.add_field(name="Craiyon Lib Version:", value=f"``{craiyon.__version__}``", inline=False)
     
     # Send the embed message
-    await ctx.send(embed=embed) 
+    await ctx.reply(embed=embed) 
 
-    await ctx.send(f"The command `version` was executed by - {ctx.author.mention}")
+    await ctx.reply(f"The command `version` was executed by - {ctx.author.mention}")
 
 
 # FUNCTION ------------------------------------------------------ SPLIT
@@ -561,9 +594,9 @@ async def clock(ctx):
     # Format the date and time
     formatted_now = now.strftime("%Y-%m-%d %H:%M:%S")
 
-    await ctx.send(f"Current date and time: `{formatted_now}`")
+    await ctx.reply(f"Current date and time: `{formatted_now}`")
 
-    await ctx.send(f"The command `clock` was executed by - {ctx.author.mention}")
+    await ctx.reply(f"The command `clock` was executed by - {ctx.author.mention}")
 
 
 # FUNCTION ------------------------------------------------------ SPLIT
@@ -573,9 +606,11 @@ async def clock(ctx):
 async def chat(ctx, model, *, message):
 
     if str(ctx.author.id) not in AUTHORIZED_AI_ACCESS_ID:
-        await ctx.send("You are not authorized to use this command. Only `@rifsxd`'s server boosters & special permitted users can enjoy free `ChatGPT` access.")
+        await ctx.reply("You are not authorized to use this command. Only `@rifsxd`'s server boosters & special permitted users can enjoy free `ChatGPT` access.")
         
         return
+    
+    msg = await ctx.reply("Responding...")
 
     if model.lower() == "phind":
         bot = phind.PHIND()
@@ -584,13 +619,13 @@ async def chat(ctx, model, *, message):
     elif model.lower() == "blackboxai":
         bot = blackboxai.BLACKBOXAI()
     else:
-        await ctx.send("Invalid model. Please choose 'phind' or 'chatgpt' or 'blackboxai'.")
+        await ctx.reply("Invalid model. Please choose 'phind' or 'chatgpt' or 'blackboxai'.")
         return
 
     response = bot.chat(message)
-    await ctx.send(response)
+    await msg.edit(content=response)
 
-    await ctx.send(f"The command `chat` was executed by - {ctx.author.mention}")
+    await ctx.reply(f"The command `chat` was executed by - {ctx.author.mention}")
 
 
 # FUNCTION ------------------------------------------------------ SPLIT
@@ -600,11 +635,11 @@ async def chat(ctx, model, *, message):
 async def image(ctx, *, prompt: str):
     # Check if the user is authorized to use the command
     if str(ctx.author.id) not in AUTHORIZED_AI_ACCESS_ID:
-        await ctx.send("You are not authorized to use this command.")
+        await ctx.reply("You are not authorized to use this command.")
         return
 
     # Inform the user that the generation process has started
-    await ctx.send(f"Generating images for prompt: `{prompt}`. Please be patient...")
+    msg = await ctx.reply(f"Generating images for prompt: `{prompt}`. Please be patient...")
 
     try:
         generator = Craiyon()
@@ -620,15 +655,16 @@ 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)
 
     except Exception as e:
         # Print the specific exception message for debugging
         print(f"An error occurred while generating images: {e}")
-        await ctx.send("An error occurred while generating images. Please try again later.")
+        await ctx.reply("An error occurred while generating images. Please try again later.")
 
-    await ctx.send(f"The command `image` was executed by - {ctx.author.mention}")
+    await ctx.reply(f"The command `image` was executed by - {ctx.author.mention}")
 
 
 
@@ -642,7 +678,7 @@ async def image(ctx, *, prompt: str):
 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.send("You are not authorized to use this command.")
+        await ctx.reply("You are not authorized to use this command.")
         
         return
 
@@ -655,7 +691,7 @@ async def clean(ctx, clean_mode):
     elif clean_mode.lower() == 'requests':
         await clean_directory(ctx, REQUESTS_FOLDER)
     else:
-        await ctx.send("Invalid clean mode. Please choose 'received_to_compress', 'received_to_decompress', 'feedback_issues', or 'feedback_requests'.")
+        await ctx.reply("Invalid clean mode. Please choose 'received_to_compress', 'received_to_decompress', 'feedback_issues', or 'feedback_requests'.")
 
 
 # FUNCTION ------------------------------------------------------ SPLIT
@@ -665,11 +701,11 @@ async def clean(ctx, clean_mode):
 async def online(ctx):
     # Check if the author is authorized to use this command
     if str(ctx.author.id) != AUTHORIZED_USER_ID:
-        await ctx.send("You are not authorized to use this command.")
+        await ctx.reply("You are not authorized to use this command.")
         
         return
     await bot.change_presence(activity=discord.Game(name=playing_time_activity))
-    await ctx.send("Bot's presence set to online.")
+    await ctx.reply("Bot's presence set to online.")
     
 
 
@@ -680,11 +716,11 @@ async def online(ctx):
 async def dnd(ctx):
     # Check if the author is authorized to use this command
     if str(ctx.author.id) != AUTHORIZED_USER_ID:
-        await ctx.send("You are not authorized to use this command.")
+        await ctx.reply("You are not authorized to use this command.")
         
         return
     await bot.change_presence(status=discord.Status.dnd)
-    await ctx.send("Bot's presence set to Do Not Disturb.")
+    await ctx.reply("Bot's presence set to Do Not Disturb.")
     
 
 
@@ -695,11 +731,11 @@ async def dnd(ctx):
 async def offline(ctx):
     # Check if the author is authorized to use this command
     if str(ctx.author.id) != AUTHORIZED_USER_ID:
-        await ctx.send("You are not authorized to use this command.")
+        await ctx.reply("You are not authorized to use this command.")
         
         return
     await bot.change_presence(status=discord.Status.offline)
-    await ctx.send("Bot's presence set to offline.")
+    await ctx.reply("Bot's presence set to offline.")
     
 
 
@@ -710,7 +746,7 @@ async def offline(ctx):
 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.send("You are not authorized to use this command.")
+        await ctx.reply("You are not authorized to use this command.")
         
         return
 
@@ -721,17 +757,17 @@ async def activity(ctx, activity_type, *, activity_text=None):
     elif activity_type.lower() == 'playing':
         activity = discord.Activity(type=discord.ActivityType.playing, name=activity_text)
     else:
-        await ctx.send('Invalid activity type. Please choose either "listening", "playing" or "watching".')
+        await ctx.reply('Invalid activity type. Please choose either "listening", "playing" or "watching".')
         
         return
 
     if not activity_text:
-        await ctx.send('Please provide an activity text.')
+        await ctx.reply('Please provide an activity text.')
         
         return
 
     await bot.change_presence(activity=activity)
-    await ctx.send(f'Activity set to {activity_type} {activity_text}')
+    await ctx.reply(f'Activity set to {activity_type} {activity_text}')
     
 
 
@@ -742,72 +778,72 @@ async def activity(ctx, activity_type, *, activity_text=None):
 async def say(ctx, destination_type, *, id, message):
     # Check if the author is authorized to use this command
     if str(ctx.author.id) != AUTHORIZED_USER_ID:
-        await ctx.send("You are not authorized to use this command.")
+        await ctx.reply("You are not authorized to use this command.")
         return
 
     if destination_type.lower() == 'channel':
         try:
             channel_id = int(id)
         except ValueError:
-            await ctx.send("Channel ID must be a valid integer.")
+            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.send(f"Message `{message}` sent to channel `{channel.name}`.")
+            await ctx.reply(f"Message `{message}` sent to channel `{channel.name}`.")
         else:
-            await ctx.send("Channel not found.")
+            await ctx.reply("Channel not found.")
             
     elif destination_type.lower() == 'server':
         try:
             server_id = int(id)
         except ValueError:
-            await ctx.send("Server ID must be a valid integer.")
+            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.send(f"Message `{message}` sent to server `{server.name}` in `important-announcements` channel.")
+                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.send(f"Message `{message}` sent to server `{server.name}` in `announcements` channel.")
+                    await ctx.reply(f"Message `{message}` sent to server `{server.name}` in `announcements` channel.")
                 else:
                     public_updates_channel = server.public_updates_channel
                     if public_updates_channel:
                         await public_updates_channel.send(message)
-                        await ctx.send(f"Message `{message}` sent to server `{server.name}` in `public updates` channel.")
+                        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]  # Default to the first text channel
                         if  default_channel:
                             await default_channel.send(message)
-                            await ctx.send(f"Message `{message}` sent to server `{server.name}` in the default channel.")
+                            await ctx.reply(f"Message `{message}` sent to server `{server.name}` in the default channel.")
                         else:
-                            await ctx.send("No announcement channels found in the server. Also, no default `public updates` neither `default` channels found.")
+                            await ctx.reply("No announcement channels found in the server. Also, no default `public updates` neither `default` channels found.")
         else:
-            await ctx.send("Server not found.")
+            await ctx.reply("Server not found.")
             
     elif destination_type.lower() == 'user':
         try:
             user_id = int(id)
         except ValueError:
-            await ctx.send("User ID must be a valid integer.")
+            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.send(f"Message `{message}` sent to user '{user.display_name}'.")
+                await ctx.reply(f"Message `{message}` sent to user '{user.display_name}'.")
             except discord.Forbidden:
-                await ctx.send(f"Couldn't send message to `{user.display_name}`. Their DMs are closed.")
+                await ctx.reply(f"Couldn't send message to `{user.display_name}`. Their DMs are closed.")
         else:
-            await ctx.send("User not found.")
+            await ctx.reply("User not found.")
             
     else:
-        await ctx.send("Invalid destination type. Use either 'channel', 'server', or 'user'.")
+        await ctx.reply("Invalid destination type. Use either 'channel', 'server', or 'user'.")
         
 
 
@@ -818,7 +854,7 @@ async def say(ctx, destination_type, *, id, message):
 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.send("You are not authorized to use this command.")
+        await ctx.reply("You are not authorized to use this command.")
         
         return
 
@@ -829,26 +865,26 @@ async def announce(ctx, *, message):
         announcement_channel = discord.utils.get(server.channels, name="important-announcements")
         if announcement_channel:
             await announcement_channel.send(embed=embed)
-            await ctx.send(f"Message `{message}` sent to server `{server.name}` in `important-announcements` channel.")
+            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:
                 await announcements_channel.send(embed=embed)
-                await ctx.send(f"Message `{message}` sent to server `{server.name}` in `announcements` channel.")
+                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:
                     await public_updates_channel.send(embed=embed)
-                    await ctx.send(f"Message `{message}` sent to server `{server.name}` in `public updates` channel.")
+                    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:
                         await default_channel.send(embed=embed)
-                        await ctx.send(f"Message `{message}` sent to server `{server.name}` in `defaults` channel.")
+                        await ctx.reply(f"Message `{message}` sent to server `{server.name}` in `defaults` channel.")
                     else:
-                        await ctx.send(f"No suitable announcement channel found in server `{server.name}`.")
+                        await ctx.reply(f"No suitable announcement channel found in server `{server.name}`.")
 
     # Delete the original command message
     
@@ -861,9 +897,11 @@ async def announce(ctx, *, message):
 async def stats(ctx):
     # Check if the author is authorized to use this command
     if str(ctx.author.id) != AUTHORIZED_USER_ID:
-        await ctx.send("You are not authorized to use this command.")
+        await ctx.reply("You are not authorized to use this command.")
         
         return
+    
+    msg = await ctx.reply("Monitoring...")
 
     guild_count = len(bot.guilds)
     member_count = len(set(bot.get_all_members()))
@@ -891,7 +929,7 @@ async def stats(ctx):
         f"CPU Usage: {cpu_usage}%\n"
         f"Memory Usage: {memory_usage}%"
     )
-    await ctx.send(stats_message)
+    await msg.edit(content=stats_message)
     
 
 # FUNCTION ------------------------------------------------------ SPLIT
@@ -901,20 +939,20 @@ async def stats(ctx):
 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.send("You are not authorized to use this command.")
+        await ctx.reply("You are not authorized to use this command.")
         
         return
     
     if list_type.lower() == 'servers':
         servers_info = "\n".join([f"{server.name} - ID: {server.id}" for server in bot.guilds])
-        await ctx.send(f"List of servers the bot is on:\n```{servers_info}```")
+        await ctx.reply(f"List of servers the bot is on:\n```{servers_info}```")
         
     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.send("Invalid list type. Please choose 'servers', 'issues', or 'requests'.")
+        await ctx.reply("Invalid list type. Please choose 'servers', 'issues', or 'requests'.")
 
 
 # FUNCTION ------------------------------------------------------ SPLIT
@@ -924,23 +962,23 @@ async def list(ctx, list_type):
 async def update(ctx, pkg_name):
     # Check if the author is authorized to use this command
     if str(ctx.author.id) != AUTHORIZED_USER_ID:
-        await ctx.send("You are not authorized to use this command.")
+        await ctx.reply("You are not authorized to use this command.")
         return
 
     try:
 
-        await ctx.send(f"Updating package `{pkg_name}`...")
+        msg = await ctx.reply("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()
 
         if error:
-            await ctx.send(f"Failed to update package `{pkg_name}`. Error: {error.decode('utf-8')}")
+            await msg.edit(content=f"Failed to update package `{pkg_name}`. Error: {error.decode('utf-8')}")
         else:
-            await ctx.send(f"Package `{pkg_name}` successfully updated.")
+            await msg.edit(content=f"Package `{pkg_name}` successfully updated.")
     except Exception as e:
-        await ctx.send(f"An error occurred while updating package `{pkg_name}`: {e}")
+        await msg.edit(content=f"An error occurred while updating package `{pkg_name}`: {e}")
 
 
 # FUNCTION ------------------------------------------------------ SPLIT
@@ -950,15 +988,15 @@ async def update(ctx, pkg_name):
 async def ip(ctx):
     # Check if the author is authorized to use this command
     if str(ctx.author.id) != AUTHORIZED_USER_ID:
-        await ctx.send("You are not authorized to use this command.")
+        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.send(f'Your IP address is: `{response.text}`')
+        await ctx.reply(f'Your IP address is: `{response.text}`')
     else:
-        await ctx.send('Failed to fetch IP address.')
+        await ctx.reply('Failed to fetch IP address.')
 
 
 # UTILITY ADMIN_CMD ------------------------------------------------------ END
@@ -983,16 +1021,16 @@ async def kick(ctx, member: discord.Member, *, reason=None):
                     dm_message += f" for the following reason: `{reason}`"
                 await member.send(dm_message)
             except discord.Forbidden:
-                await ctx.send(f"Failed to send a direct message to {member}.")
+                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.send(f"{member} has been kicked from the server.")
+            await ctx.reply(f"{member} has been kicked from the server.")
         else:
-            await ctx.send("You do not have permission to kick this member.")
+            await ctx.reply("You do not have permission to kick this member.")
 
     else:
-        await ctx.send("You do not have permission to use this command.")
+        await ctx.reply("You do not have permission to use this command.")
 
 
 # FUNCTION ------------------------------------------------------ SPLIT
@@ -1011,16 +1049,16 @@ async def ban(ctx, member: discord.Member, *, reason=None):
                     dm_message += f" for the following reason: `{reason}`"
                 await member.send(dm_message)
             except discord.Forbidden:
-                await ctx.send(f"Failed to send a direct message to {member}.")
+                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.send(f"{member} has been banned from the server.")
+            await ctx.reply(f"{member} has been banned from the server.")
         else:
-            await ctx.send("You do not have permission to ban this member.")
+            await ctx.reply("You do not have permission to ban this member.")
 
     else:
-        await ctx.send("You do not have permission to use this command.")
+        await ctx.reply("You do not have permission to use this command.")
 
 
 
@@ -1044,7 +1082,7 @@ async def timeout(ctx, member: discord.Member, duration: int, *, reason=None):
                 # Timeout the member by removing all roles
                 await member.edit(roles=[], reason=reason)
 
-                await ctx.send(f"`{member}` has been timed out for `{duration} seconds`. 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`"
@@ -1056,10 +1094,10 @@ async def timeout(ctx, member: discord.Member, duration: int, *, reason=None):
                     await member.send(dm_message_init)
                 except discord.Forbidden:
                     # If unable to send DM, log the error and continue
-                    await ctx.send(f"Failed to send DM to `{member}` for timeout.")
+                    await ctx.reply(f"Failed to send DM to `{member}` for timeout.")
                 
             except Exception as e:
-                await ctx.send(f"An error occurred: {e}")
+                await ctx.reply(f"An error occurred: {e}")
                 return  # Stop execution if there's an error
                 
             # Wait for the duration of the timeout
@@ -1080,13 +1118,13 @@ async def timeout(ctx, member: discord.Member, duration: int, *, reason=None):
                 await member.send(dm_message_exit)
             except discord.Forbidden:
                 # If unable to send DM, log the error and continue
-                await ctx.send(f"Failed to send DM to `{member}` to notify timeout expiration.")
+                await ctx.reply(f"Failed to send DM to `{member}` to notify timeout expiration.")
 
         else:
-            await ctx.send("You do not have permission to timeout this member.")
+            await ctx.reply("You do not have permission to timeout this member.")
     
     else:
-        await ctx.send("You do not have permission to use this command.")
+        await ctx.reply("You do not have permission to use this command.")
 
 
 # UTILITY MODERATOR_CMD ------------------------------------------------------ END