feat: enhanced filters and welcome message formatting with advanced buttons and placeholders

QueenNoxi/modules/cust_filters.py

@@ -16,6 +16,7 @@ from QueenNoxi.modules.helper_funcs.chat_status import user_admin, connection_st
 from QueenNoxi.modules.helper_funcs.misc import build_keyboard, revert_buttons
 from QueenNoxi.modules.helper_funcs.msg_types import get_filter_type, Types
 from QueenNoxi.modules.helper_funcs.string_handling import button_markdown_parser, split_quotes
+from QueenNoxi.modules.helper_funcs.formatters import format_message
 from QueenNoxi.modules.sql import cust_filters_sql as sql
 
 # Handler group for filters
@@ -44,11 +45,12 @@ async def add_filter(client: Client, message: Message):
             return
         keyword = extracted[0].lower()
 
-    text, file_type, file_id = await get_filter_type(message)
-    
-    # Extract buttons from text if any
-    _, buttons = button_markdown_parser(text) if text else (None, [])
+    text, file_type, file_id, buttons = await get_filter_type(message)
     
+    if not file_type:
+        await message.reply_text("You didn't specify what to reply with!")
+        return
+
     sql.new_add_filter(chat_id, keyword, text, file_type, file_id, buttons)
     await message.reply_text(f"Saved filter '{keyword}'!")
 
@@ -100,18 +102,23 @@ async def reply_filter(client: Client, message: Message):
             buttons = sql.get_buttons(chat_id, keyword)
             keyboard = InlineKeyboardMarkup(build_keyboard(buttons)) if buttons else None
             
+            res, flags = await format_message(filt.reply_text, message.from_user, message.chat)
+
             if filt.file_type in (Types.TEXT, Types.BUTTON_TEXT):
                 await message.reply_text(
-                    filt.reply_text,
+                    res,
                     reply_markup=keyboard,
-                    disable_web_page_preview=True
+                    reply_to_message_id=message.id,
+                    **flags
                 )
             else:
                 await client.send_cached_media(
                     chat_id,
                     filt.file_id,
-                    caption=filt.reply_text,
-                    reply_markup=keyboard
+                    caption=res,
+                    reply_markup=keyboard,
+                    reply_to_message_id=message.id,
+                    **flags
                 )
             break
 

QueenNoxi/modules/helper_funcs/formatters.py

@@ -0,0 +1,71 @@
+import re
+from typing import Optional, Dict, Tuple
+from pyrogram import enums
+from pyrogram.types import Message, User, Chat
+from QueenNoxi import BOT_USERNAME
+from QueenNoxi.modules.helper_funcs.string_handling import escape_markdown, escape_invalid_curly_brackets
+
+async def format_message(text: str, user: User, chat: Chat) -> Tuple[str, Dict]:
+    if not text:
+        return "", {}
+
+    first = escape_markdown(user.first_name)
+    last = escape_markdown(user.last_name or user.first_name)
+    fullname = escape_markdown(f"{user.first_name} {user.last_name}" if user.last_name else user.first_name)
+    username = f"@{user.username}" if user.username else user.mention
+    mention = user.mention
+    id = user.id
+    chatname = escape_markdown(chat.title if chat and chat.type != enums.ChatType.PRIVATE else user.first_name)
+    
+    rules_link = f"t.me/{BOT_USERNAME}?start={chat.id}" if chat and chat.type != enums.ChatType.PRIVATE else f"t.me/{BOT_USERNAME}"
+    rules = f"[Rules]({rules_link})"
+
+    VALID_PLACEHOLDERS = [
+        "first", "last", "fullname", "username", "mention", "id", "chatname", "rules"
+    ]
+    
+    text = escape_invalid_curly_brackets(text, VALID_PLACEHOLDERS)
+
+    try:
+        text = text.format(
+            first=first,
+            last=last,
+            fullname=fullname,
+            username=username,
+            mention=mention,
+            id=id,
+            chatname=chatname,
+            rules=rules
+        )
+    except Exception as e:
+        import logging
+        logging.error(f"Error formatting message: {e}")
+
+    # Flags extraction
+    flags = {
+        "disable_web_page_preview": False,
+        "disable_notification": False,
+        "protect_content": False,
+        "has_spoiler": False
+    }
+
+    if "{preview}" in text:
+        text = text.replace("{preview}", "")
+        flags["disable_web_page_preview"] = False # Logic might be inverted depending on default
+    else:
+        flags["disable_web_page_preview"] = True # Default to disable if not specified? 
+        # Actually user said "{preview} enables link previews", so default should be disabled.
+    
+    if "{nonotif}" in text:
+        text = text.replace("{nonotif}", "")
+        flags["disable_notification"] = True
+        
+    if "{protect}" in text:
+        text = text.replace("{protect}", "")
+        flags["protect_content"] = True
+        
+    if "{mediaspoiler}" in text:
+        text = text.replace("{mediaspoiler}", "")
+        flags["has_spoiler"] = True
+
+    return text.strip(), flags

QueenNoxi/modules/helper_funcs/misc.py

@@ -101,19 +101,39 @@ async def send_to_list(client, send_to: list, message: str, parse_mode=None) ->
 def build_keyboard(buttons):
     keyb = []
     for btn in buttons:
+        color_prefix = ""
+        if btn.color:
+            if btn.color == "success":
+                color_prefix = "🟢 "
+            elif btn.color == "danger":
+                color_prefix = "🔴 "
+            elif btn.color == "primary":
+                color_prefix = "🔵 "
+            elif btn.color == "warning":
+                color_prefix = "🟡 "
+        
+        btn_text = f"{color_prefix}{btn.name}"
+        
+        if btn.url.startswith("#"):
+            note_name = btn.url[1:]
+            button = InlineKeyboardButton(btn_text, callback_data=f"note_{note_name}")
+        elif btn.url in ("btn_next", "btn_back", "btn_home"):
+            button = InlineKeyboardButton(btn_text, callback_data=f"paginate_{btn.url}")
+        else:
+            button = InlineKeyboardButton(btn_text, url=btn.url)
+
         if btn.same_line and keyb:
-            keyb[-1].append(InlineKeyboardButton(btn.name, url=btn.url))
+            keyb[-1].append(button)
         else:
-            keyb.append([InlineKeyboardButton(btn.name, url=btn.url)])
+            keyb.append([button])
     return keyb
 
 def revert_buttons(buttons):
     res = ""
     for btn in buttons:
-        if btn.same_line:
-            res += "\n[{}](buttonurl://{}:same)".format(btn.name, btn.url)
-        else:
-            res += "\n[{}](buttonurl://{})".format(btn.name, btn.url)
+        color_part = f"#{btn.color}" if btn.color else ""
+        same_line = ":same" if btn.same_line else ""
+        res += f"\n[{btn.name}](buttonurl{color_part}://{btn.url}{same_line})"
     return res
 
 def is_module_loaded(name):

QueenNoxi/modules/helper_funcs/msg_types.py

@@ -120,44 +120,55 @@ async def get_filter_type(msg: Message):
     text = None
     data_type = None
     content = None
+    buttons = []
 
     if not msg.reply_to_message and msg.text and len(msg.text.split()) >= 3:
-        text = msg.text.split(None, 2)[2]
-        data_type = Types.TEXT
+        raw_text = msg.text.split(None, 2)[2]
+        text, buttons = button_markdown_parser(raw_text, entities=msg.entities)
+        data_type = Types.BUTTON_TEXT if buttons else Types.TEXT
 
     elif msg.reply_to_message:
         reply = msg.reply_to_message
-        if reply.text:
-            text = reply.text
-            data_type = Types.TEXT
-        elif reply.sticker:
+        if reply.text or reply.caption:
+            msgtext = reply.text or reply.caption
+            entities = reply.entities or reply.caption_entities
+            text, buttons = button_markdown_parser(msgtext, entities=entities)
+            
+            # Auto-detect buttons from InlineKeyboardMarkup if no markdown buttons found
+            if not buttons and reply.reply_markup and reply.reply_markup.inline_keyboard:
+                from QueenNoxi.modules.helper_funcs.string_handling import Button
+                for row in reply.reply_markup.inline_keyboard:
+                    for btn in row:
+                        url = btn.url or (f"#{btn.callback_data}" if btn.callback_data else "")
+                        if url:
+                            same = True if row.index(btn) > 0 else False
+                            buttons.append(Button(btn.text, url, same_line=same))
+
+            data_type = Types.BUTTON_TEXT if buttons else Types.TEXT
+        
+        if reply.sticker:
             content = reply.sticker.file_id
             data_type = Types.STICKER
         elif reply.document:
             content = reply.document.file_id
-            text = reply.caption
             data_type = Types.DOCUMENT
         elif reply.photo:
             content = reply.photo.file_id
-            text = reply.caption
             data_type = Types.PHOTO
         elif reply.audio:
             content = reply.audio.file_id
-            text = reply.caption
             data_type = Types.AUDIO
         elif reply.voice:
             content = reply.voice.file_id
-            text = reply.caption
             data_type = Types.VOICE
         elif reply.video:
             content = reply.video.file_id
-            text = reply.caption
             data_type = Types.VIDEO
         elif reply.video_note:
             content = reply.video_note.file_id
             data_type = Types.VIDEO_NOTE
 
-    return text, data_type, content
+    return text, data_type, content, buttons
 
 
 ##

QueenNoxi/modules/helper_funcs/string_handling.py

@@ -1,6 +1,6 @@
 import re
 import time
-from typing import List
+from typing import List, Tuple
 import bleach
 import markdown2
 from pyrogram import enums
@@ -15,7 +15,7 @@ MATCH_MD = re.compile(
 )
 
 LINK_REGEX = re.compile(r"(?<!\\)\[.+?\]\((.*?)\)")
-BTN_URL_REGEX = re.compile(r"(\[([^\[]+?)\]\(buttonurl:(?:/{0,2})(.+?)(:same)?\))")
+BTN_URL_REGEX = re.compile(r"(\[([^\[]+?)\]\(buttonurl(?:#([^:]+))?://(/{0,2})(.+?)(:same)?\))")
 
 def _selective_escape(to_parse: str) -> str:
     offset = 0
@@ -55,7 +55,14 @@ def markdown_parser(txt: str, entities: List[MessageEntity] = None, offset: int
     res += _selective_escape(txt[prev:])
     return res
 
-def button_markdown_parser(txt: str, entities: List[MessageEntity] = None, offset: int = 0) -> (str, List):
+class Button:
+    def __init__(self, name, url, same_line=False, color=None):
+        self.name = name
+        self.url = url
+        self.same_line = same_line
+        self.color = color
+
+def button_markdown_parser(txt: str, entities: List[MessageEntity] = None, offset: int = 0) -> Tuple[str, List[Button]]:
     markdown_note = markdown_parser(txt, entities, offset)
     prev = 0
     note_data = ""
@@ -68,7 +75,16 @@ def button_markdown_parser(txt: str, entities: List[MessageEntity] = None, offse
             to_check -= 1
 
         if n_escapes % 2 == 0:
-            buttons.append((match.group(2), match.group(3), bool(match.group(4))))
+            # match.group(2) -> name
+            # match.group(3) -> color
+            # match.group(5) -> url/back/next/home
+            # match.group(6) -> :same
+            buttons.append(Button(
+                match.group(2),
+                match.group(5),
+                bool(match.group(6)),
+                match.group(3)
+            ))
             note_data += markdown_note[prev : match.start(1)]
             prev = match.end(1)
         else:

QueenNoxi/modules/notes.py

@@ -12,6 +12,7 @@ from pyrogram.errors import RPCError
 
 import QueenNoxi.modules.sql.notes_sql as sql
 from QueenNoxi import DRAGONS, pbot, BOT_ID, SUPPORT_CHAT
+from QueenNoxi import DRAGONS, pbot, BOT_ID, SUPPORT_CHAT, LOGGER
 from QueenNoxi.modules.disable import DisableAbleCommandHandler
 from QueenNoxi.modules.helper_funcs.chat_status import connection_status, user_admin
 from QueenNoxi.modules.helper_funcs.misc import build_keyboard, revert_buttons
@@ -20,6 +21,7 @@ from QueenNoxi.modules.helper_funcs.string_handling import (
     escape_invalid_curly_brackets,
     escape_markdown
 )
+from QueenNoxi.modules.helper_funcs.formatters import format_message
 
 # Do not async
 @connection_status
@@ -42,34 +44,8 @@ async def get(client: Client, message: Message, notename: str, show_none=True, n
                 sql.rm_note(chat_id, notename)
                 return
         
-        VALID_NOTE_FORMATTERS = [
-            "first",
-            "last",
-            "fullname",
-            "username",
-            "id",
-            "chatname",
-            "mention",
-        ]
-        valid_format = escape_invalid_curly_brackets(note.value, VALID_NOTE_FORMATTERS)
-        if valid_format:
-            text = valid_format.format(
-                first=escape_markdown(message.from_user.first_name),
-                last=escape_markdown(message.from_user.last_name or message.from_user.first_name),
-                fullname=escape_markdown(
-                    " ".join(
-                        [message.from_user.first_name, message.from_user.last_name]
-                        if message.from_user.last_name
-                        else [message.from_user.first_name]
-                    )
-                ),
-                username="@" + message.from_user.username if message.from_user.username else message.from_user.mention,
-                mention=message.from_user.mention,
-                chatname=escape_markdown(message.chat.title if message.chat.type != enums.ChatType.PRIVATE else message.from_user.first_name),
-                id=message.from_user.id,
-            )
-        else:
-            text = ""
+        res, flags = await format_message(note.value, message.from_user, message.chat)
+        text = res
 
         buttons = sql.get_buttons(chat_id, notename)
         keyb = []
@@ -90,21 +66,22 @@ async def get(client: Client, message: Message, notename: str, show_none=True, n
                     reply_to_message_id=reply_id,
                     parse_mode=parse_mode,
                     reply_markup=keyboard,
+                    **flags
                 )
             elif note.msgtype == Types.STICKER:
-                await client.send_sticker(chat_id, note.file, reply_to_message_id=reply_id, reply_markup=keyboard)
+                await client.send_sticker(chat_id, note.file, reply_to_message_id=reply_id, reply_markup=keyboard, **flags)
             elif note.msgtype == Types.DOCUMENT:
-                await client.send_document(chat_id, note.file, caption=text, reply_to_message_id=reply_id, parse_mode=parse_mode, reply_markup=keyboard)
+                await client.send_document(chat_id, note.file, caption=text, reply_to_message_id=reply_id, parse_mode=parse_mode, reply_markup=keyboard, **flags)
             elif note.msgtype == Types.PHOTO:
-                await client.send_photo(chat_id, note.file, caption=text, reply_to_message_id=reply_id, parse_mode=parse_mode, reply_markup=keyboard)
+                await client.send_photo(chat_id, note.file, caption=text, reply_to_message_id=reply_id, parse_mode=parse_mode, reply_markup=keyboard, **flags)
             elif note.msgtype == Types.AUDIO:
-                await client.send_audio(chat_id, note.file, caption=text, reply_to_message_id=reply_id, parse_mode=parse_mode, reply_markup=keyboard)
+                await client.send_audio(chat_id, note.file, caption=text, reply_to_message_id=reply_id, parse_mode=parse_mode, reply_markup=keyboard, **flags)
             elif note.msgtype == Types.VOICE:
-                await client.send_voice(chat_id, note.file, caption=text, reply_to_message_id=reply_id, parse_mode=parse_mode, reply_markup=keyboard)
+                await client.send_voice(chat_id, note.file, caption=text, reply_to_message_id=reply_id, parse_mode=parse_mode, reply_markup=keyboard, **flags)
             elif note.msgtype == Types.VIDEO:
-                await client.send_video(chat_id, note.file, caption=text, reply_to_message_id=reply_id, parse_mode=parse_mode, reply_markup=keyboard)
+                await client.send_video(chat_id, note.file, caption=text, reply_to_message_id=reply_id, parse_mode=parse_mode, reply_markup=keyboard, **flags)
             elif note.msgtype == Types.VIDEO_NOTE:
-                await client.send_video_note(chat_id, note.file, reply_to_message_id=reply_id, reply_markup=keyboard)
+                await client.send_video_note(chat_id, note.file, reply_to_message_id=reply_id, reply_markup=keyboard, **flags)
 
         except RPCError as e:
             await message.reply_text(f"This note could not be sent. Error: {e.MESSAGE}")
@@ -207,6 +184,23 @@ async def clearall_btn(client: Client, query):
         else:
             await query.answer("Only the owner of the chat can do this.", show_alert=True)
 
+@pbot.on_callback_query(filters.regex(r"^note_.*"))
+async def note_callback(client: Client, query):
+    notename = query.data.split("_", 1)[1]
+    await get(client, query.message, notename, show_none=False)
+    await query.answer()
+
+@pbot.on_callback_query(filters.regex(r"^paginate_.*"))
+async def paginate_callback(client: Client, query):
+    action = query.data.split("_", 1)[1]
+    # Simple pagination placeholder logic
+    if action == "btn_next":
+        await query.answer("Next Page (Sample logic)", show_alert=True)
+    elif action == "btn_back":
+        await query.answer("Back Page (Sample logic)", show_alert=True)
+    elif action == "btn_home":
+        await query.answer("Home Page (Sample logic)", show_alert=True)
+
 
 @DisableAbleCommandHandler(["notes", "saved"])
 @connection_status

QueenNoxi/modules/welcome.py

@@ -40,6 +40,7 @@ from QueenNoxi.modules.helper_funcs.string_handling import (
     escape_invalid_curly_brackets,
     markdown_parser,
 )
+from QueenNoxi.modules.helper_funcs.formatters import format_message
 from QueenNoxi.modules.log_channel import loggable
 from QueenNoxi.modules.sql.global_bans_sql import is_user_gbanned
 
@@ -77,7 +78,7 @@ async def send(message: Message, text: str, keyboard: InlineKeyboardMarkup, back
         )
     except RPCError as excp:
         LOGGER.error(f"Error sending welcome: {excp}")
-        return await message.reply_text(backup_message)
+        return await message.reply_text(backup_message, reply_to_message_id=reply_to)
 
 @pbot.on_message(filters.new_chat_members & filters.group)
 @loggable
@@ -118,39 +119,29 @@ async def new_member(client: Client, message: Message):
             keyb = build_keyboard(buttons)
             keyboard = InlineKeyboardMarkup(keyb)
 
-            first_name = new_mem.first_name or "User"
-            last_name = new_mem.last_name or ""
-            fullname = f"{first_name} {last_name}".strip()
-            count = await chat.get_member_count()
-            mention = new_mem.mention
-            username = f"@{new_mem.username}" if new_mem.username else mention
-
             if cust_welcome:
                 if cust_welcome == sql.DEFAULT_WELCOME:
-                    cust_welcome = random.choice(sql.DEFAULT_WELCOME_MESSAGES).format(first=first_name)
-
-                res = cust_welcome.format(
-                    first=first_name,
-                    last=last_name or first_name,
-                    fullname=fullname,
-                    username=username,
-                    mention=mention,
-                    count=count,
-                    chatname=chat.title,
-                    id=new_mem.id
-                )
+                    cust_welcome = random.choice(sql.DEFAULT_WELCOME_MESSAGES)
+                
+                res, flags = await format_message(cust_welcome, new_mem, chat)
             else:
-                res = random.choice(sql.DEFAULT_WELCOME_MESSAGES).format(first=first_name)
+                res, flags = await format_message(random.choice(sql.DEFAULT_WELCOME_MESSAGES), new_mem, chat)
 
             if welc_type == Types.TEXT or welc_type == Types.BUTTON_TEXT:
-                sent = await send(message, res, keyboard, "Welcome!")
+                sent = await message.reply_text(
+                    res,
+                    reply_markup=keyboard,
+                    reply_to_message_id=message.id if not sql.clean_service(chat.id) else None,
+                    **flags
+                )
             else:
                 # Handle media welcomes
                 sent = await client.send_cached_media(
                     chat.id,
                     cust_content,
                     caption=res,
-                    reply_markup=keyboard
+                    reply_markup=keyboard,
+                    **flags
                 )
 
             # Clean previous welcome

README.md

@@ -8,7 +8,7 @@ pinned: false
 ---
 
 <h1 align="center">
-  <b>👸 QueenNoxi 👸</b>
+  <b>👸 Queen Noxi 👸</b>
 </h1>
 
 <p align="center">
@@ -29,31 +29,20 @@ pinned: false
 
 - 🛡️ **Advanced Protection**: Anti-Flood, Anti-Spam, and GBans.
 - 🎬 **Unique Animations**: Robust Tenor-only animation system with local caching (reliable even when API limits hit).
+- 🔨 **Animated Admin Commands**: Styled `/aban`, `/amute`, and `/aunmute` with premium visual effects.
 - 🧠 **AI Integration**: Built-in Chatbot and ChatGPT features.
-- 🎵 **Music Integration**: Manage your group's music with ease.
 - ⚙️ **Highly Customizable**: Easy to configure via environment variables.
 
 ## 🚀 Deployment
 
 ### Heroku / HuggingFace
-Click the button below to deploy your own instance:
-
 [![Deploy](https://www.herokucdn.com/deploy/button.svg)](https://heroku.com/deploy?template=https://github.com/AlexaInc/queen-noxi)
 
 ### Manual Setup
-1. Clone the repo:
-   ```bash
-   git clone https://github.com/AlexaInc/queen-noxi.git
-   ```
-2. Install requirements:
-   ```bash
-   pip install -r requirements.txt
-   ```
-3. Configure your `.env` following `SETUP_GUIDE.md`.
-4. Run the bot:
-   ```bash
-   python3 -m QueenNoxi
-   ```
+1. Clone: `git clone https://github.com/AlexaInc/queen-noxi.git`
+2. Install: `pip install -r requirements.txt`
+3. Configure `.env` from `SETUP_GUIDE.md`.
+4. Run: `python3 -m QueenNoxi`
 
 ## 📜 Credits
 - **Author**: [Alexainc](https://github.com/AlexaInc)