fix: admins can use the nsfw and non admins can't use the nsfw enable anddisable and add inline button for kang.py

DragMusic/plugins/management/kang.py

@@ -166,9 +166,12 @@ async def kang(client, message: Message):
             break
 
         await msg.edit(
-            f"Sticker Kanged To <a href='https://t.me/addstickers/{packname}'>Pack</a>\nEmoji: {sticker_emoji}",
+            f"Sticker Kanged To <a href='https://t.me/addstickers/{packname}'>Sticker Pack</a>\nEmoji: {sticker_emoji}",
             disable_web_page_preview=True,
-            parse_mode=ParseMode.HTML
+            parse_mode=ParseMode.HTML,
+            reply_markup=InlineKeyboardMarkup([
+                [InlineKeyboardButton("Sticker Pack", url=f"https://t.me/addstickers/{packname}")]
+            ])
         )
 
     except (PeerIdInvalid, UserIsBlocked):

DragMusic/plugins/plugins/nsfw.py

@@ -9,22 +9,22 @@ from pyrogram.types import Message
 from transformers import AutoModelForImageClassification, ViTImageProcessor
 from DragMusic import app
 from motor.motor_asyncio import AsyncIOMotorClient
-from pyrogram.errors import PeerIdInvalid, UserNotParticipant
 from config import MONGO_DB_URI
 
-# Initialize MongoDB client and select database & collection
+# MongoDB setup
 db_client = AsyncIOMotorClient(MONGO_DB_URI)
 db = db_client['AnonXDatabase']
 nsfw_chats_collection = db['nsfw_chats']
 
-# Logger setup
+# Logger configuration
 LOGGER_ID = -1002471976725
 LOGGER_TOPIC_ID = 6314
 
-# Load model and processor
+# Load the NSFW detection model
 model = AutoModelForImageClassification.from_pretrained("Falconsai/nsfw_image_detection")
 processor = ViTImageProcessor.from_pretrained("Falconsai/nsfw_image_detection")
 
+# Check if NSFW scanning is enabled for a group
 async def is_nsfw_enabled(chat_id: int) -> bool:
     chat = await nsfw_chats_collection.find_one({"chat_id": chat_id})
     return bool(chat)
@@ -35,18 +35,20 @@ async def enable_nsfw(chat_id: int):
 async def disable_nsfw(chat_id: int):
     await nsfw_chats_collection.delete_one({"chat_id": chat_id})
 
-# Helper to check if a user is admin or owner
-async def is_admin(client, chat_id, user_id):
+# Admin check function
+async def is_admin(client: Client, chat_id: int, user_id: int) -> bool:
     try:
         member = await client.get_chat_member(chat_id, user_id)
-        return member.status in ["administrator", "owner"]
-    except:
+        return member.status in ["administrator", "creator"]
+    except Exception as e:
+        print(f"[is_admin] Error: {e}")
         return False
 
+# Command to enable/disable NSFW scanning
 @app.on_message(filters.command("nsfw") & filters.group)
-async def toggle_nsfw_scan(client, message: Message):
+async def toggle_nsfw_scan(client: Client, message: Message):
     if len(message.command) != 2:
-        return await message.reply("Usage: /nsfw enable or /nsfw disable")
+        return await message.reply("Usage: `/nsfw enable` or `/nsfw disable`", parse_mode="markdown")
 
     if not await is_admin(client, message.chat.id, message.from_user.id):
         return await message.reply("Only group admins and the group owner can use this command.")
@@ -54,24 +56,27 @@ async def toggle_nsfw_scan(client, message: Message):
     arg = message.command[1].lower()
     if arg == "enable":
         await enable_nsfw(message.chat.id)
-        await message.reply("Enabled NSFW scanning for this group.")
+        await message.reply("✅ Enabled NSFW scanning for this group.")
     elif arg == "disable":
         await disable_nsfw(message.chat.id)
-        await message.reply("Disabled NSFW scanning for this group.")
+        await message.reply("❌ Disabled NSFW scanning for this group.")
     else:
-        await message.reply("Invalid argument. Use /nsfw enable or /nsfw disable.")
-        
+        await message.reply("Invalid argument. Use `/nsfw enable` or `/nsfw disable`.", parse_mode="markdown")
+
+# Command to manually scan a media reply
 @app.on_message(filters.command("scan") & filters.reply)
-async def scan_command(_, message: Message):
+async def scan_command(_: Client, message: Message):
     if not message.reply_to_message:
         return await message.reply("Reply to an image, video, or sticker to scan.")
     await scan_media(message.reply_to_message, message)
 
+# Auto-scan media when enabled
 @app.on_message(filters.group & (filters.photo | filters.video | filters.sticker))
 async def auto_nsfw_scan(client: Client, message: Message):
     if await is_nsfw_enabled(message.chat.id):
         await scan_media(message, message)
 
+# Main media scanner
 async def scan_media(media_msg: Message, reply_msg: Message):
     media = media_msg.photo or media_msg.video or media_msg.sticker
     path = None
@@ -94,10 +99,13 @@ async def scan_media(media_msg: Message, reply_msg: Message):
         else:
             return await reply_msg.reply("Unable to download media.")
 
+        # Convert to image if needed
         if path.endswith((".webm", ".mp4", ".webp")):
             image_path = path + ".png"
-            subprocess.run(["ffmpeg", "-i", path, "-frames:v", "1", image_path, "-y"],
-                           stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+            subprocess.run(
+                ["ffmpeg", "-i", path, "-frames:v", "1", image_path, "-y"],
+                stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL
+            )
             if not os.path.exists(image_path) or os.path.getsize(image_path) == 0:
                 return await reply_msg.reply("Failed to extract image frame.")
             img = Image.open(image_path).convert("RGB")
@@ -113,33 +121,33 @@ async def scan_media(media_msg: Message, reply_msg: Message):
             confidence = round(probs[0][1].item() * 100, 2)
             label = "NSFW" if confidence > 50 else "SFW"
 
+        # Handle results
         if label == "NSFW":
             try:
                 await media_msg.delete()
             except Exception as e:
                 print(f"[NSFW] Failed to delete message: {e}")
 
-            if confidence > 50:
-                await reply_msg.reply(f"NSFW Detected ({confidence}%) — Message deleted.")
-                log_text = (
-                    f"NSFW Content Detected\n"
-                    f"Chat: {reply_msg.chat.title} ({reply_msg.chat.id})\n"
-                    f"User: {media_msg.from_user.mention if media_msg.from_user else 'Unknown'}\n"
-                    f"Confidence: {confidence}%"
+            await reply_msg.reply(f"🚫 NSFW Detected ({confidence}%) — Message deleted.")
+            log_text = (
+                f"🚨 NSFW Content Detected\n"
+                f"Chat: {reply_msg.chat.title} (`{reply_msg.chat.id}`)\n"
+                f"User: {media_msg.from_user.mention if media_msg.from_user else 'Unknown'}\n"
+                f"Confidence: {confidence}%"
+            )
+            try:
+                await app.send_message(
+                    chat_id=LOGGER_ID,
+                    text=log_text,
+                    message_thread_id=LOGGER_TOPIC_ID
                 )
-                try:
-                    await app.send_message(
-                        chat_id=LOGGER_ID,
-                        text=log_text,
-                        message_thread_id=LOGGER_TOPIC_ID
-                    )
-                except Exception as log_err:
-                    print(f"[NSFW Logger Error] {log_err}")
-        elif confidence > 50:
-            await reply_msg.reply(f"Scan Result: {label} ({confidence}%)")
+            except Exception as log_err:
+                print(f"[NSFW Logger Error] {log_err}")
+        else:
+            await reply_msg.reply(f"✅ Scan Result: {label} ({confidence}%)")
 
     except UnidentifiedImageError:
-        print(f"[NSFW Detection Error] cannot identify image file '{path or image_path}'")
+        print(f"[NSFW Detection Error] Cannot identify image file '{path or image_path}'")
         await reply_msg.reply("Failed to read image for scanning.")
     except Exception as e:
         print(f"[NSFW Detection Error] {e}")
@@ -148,4 +156,4 @@ async def scan_media(media_msg: Message, reply_msg: Message):
         if path and os.path.exists(path):
             os.remove(path)
         if image_path and os.path.exists(image_path):
-            os.remove(image_path) 
+            os.remove(image_path)