Added database, notes and filters

Added database, notes and filters, thanks to @rojserbest

README.md

@@ -24,7 +24,6 @@ Just Another Telegram Bot Written In Python Using Pyrogram.
 
 * Group Management
 * Music Downloading 
-* Artificial Intelligence ChatBot
 * Web Scraping 
 * Get Pictures/Wallpapers  
 * Dictionary

requirements.txt

@@ -12,3 +12,5 @@ youtube_dl
 search_engine_parser
 cryptography
 googletrans==4.0.0-rc1
+motor
+dnspython

sample_config.py

@@ -15,5 +15,7 @@ fernet_encryption_key = "iKMq0WZMnJKjMQxZWKtv-cplMuF_LoyshXj0XbTGGWM="
 
 captcha_delay_in_seconds = 300
 
+mongo_db_uri = "mongodb+srv://username:password@cluster0.ksiis.mongodb.net/YourDataBaseName?retryWrites=true&w=majority"
+
 # Leave This As It Is
 ARQ_API_BASE_URL = "https://thearq.tech"

wbb/__init__.py

@@ -1,10 +1,11 @@
 from config import (
-        bot_token, api_id, api_hash, OWNER_ID,
-        sudo_users_id as SUDO_USER_ID, log_group_id as LOG_GROUP_ID,
-        fernet_encryption_key as FERNET_ENCRYPTION_KEY,
-        captcha_delay_in_seconds as WELCOME_DELAY_KICK_SEC,
-        ARQ_API_BASE_URL as ARQ_API)
+    bot_token, api_id, api_hash, OWNER_ID,
+    sudo_users_id as SUDO_USER_ID, log_group_id as LOG_GROUP_ID,
+    fernet_encryption_key as FERNET_ENCRYPTION_KEY, mongo_db_uri as mdb_uri,
+    captcha_delay_in_seconds as WELCOME_DELAY_KICK_SEC,
+    ARQ_API_BASE_URL as ARQ_API)
 from pyrogram import Client
+from motor.motor_asyncio import AsyncIOMotorClient as MongoClient
 from Python_ARQ import ARQ
 import time
 import logging
@@ -40,6 +41,7 @@ SUDOERS.append(OWNER_ID)
 MOD_LOAD = []
 MOD_NOLOAD = []
 bot_start_time = time.time()
-
+mongo_client = MongoClient(mdb_uri)
+db = mongo_client.wbb
 app = Client("wbb", bot_token=bot_token, api_id=api_id, api_hash=api_hash)
 arq = ARQ(ARQ_API)

wbb/modules/admin.py

@@ -3,10 +3,14 @@ from pyrogram.types import ChatPermissions
 from wbb import OWNER_ID, SUDOERS, app
 from wbb.utils.botinfo import BOT_ID
 from wbb.utils.errors import capture_err
+#from wbb.utils.dbfunctions import add_warn, get_warns, remove_warns
 
 __MODULE__ = "Admin"
 __HELP__ = '''/ban - Ban A User
 /unban - Unban A User
+/warn - Warn A User
+/rmwarns - Remove All Warning of A User
+/warns - Show Warning Of A User
 /kick - Kick A User
 /purge - Purge Messages
 /del - Delete Replied Message
@@ -80,8 +84,8 @@ async def purge(client, message):
                 message_ids.append(a_s_message_id)
                 if len(message_ids) == 100:
                     await client.delete_messages(chat_id=chat_id,
-                        message_ids=message_ids,
-                        revoke=True)
+                                                 message_ids=message_ids,
+                                                 revoke=True)
 
                     message_ids = []
             if len(message_ids) > 0:
@@ -262,8 +266,8 @@ async def promote(_, message):
                     can_change_info=True,
                     can_invite_users=True,
                     can_delete_messages=True,
-                    can_restrict_members=False, 
-                    can_pin_messages=True, 
+                    can_restrict_members=False,
+                    can_pin_messages=True,
                     can_promote_members=True)
                 await message.reply_text('Promoted!')
             else:
@@ -373,3 +377,87 @@ async def ban_deleted_accounts(_, message):
     except Exception as e:
         await message.reply_text(str(e))
         print(str(e))
+
+"""
+# Warn
+
+
+@app.on_message(filters.command("warn") & ~filters.edited)
+@capture_err
+async def warn_user(_, message):
+
+    from_user_id = message.from_user.id
+    chat_id = message.chat.id
+    permissions = await member_permissions(chat_id, from_user_id)
+    if "can_restrict_members" in permissions or from_user_id in SUDOERS:
+        if message.reply_to_message:
+            user_id = message.reply_to_message.from_user.id
+            mention = message.reply_to_message.from_user.mention
+            if user_id in SUDOERS:
+                await message.reply_text("You Wanna Warn The Elevated One?")
+            else:
+                if user_id in await list_members(chat_id):
+                    warns = await get_warns(chat_id, user_id)
+                    if warns >= 3:
+                        await message.chat.kick_member(user_id)
+                        await message.reply_text(f"Number of warns of {mention} exceeded, Banned!")
+                        await remove_warns(chat_id, user_id)
+                    else:
+                        await add_warn(chat_id, user_id)
+                        await message.reply_text(f"Warned {mention}!, {warns}/3 warnings now.")
+                else:
+                    await message.reply_text("This user isn't here.")
+        else:
+            await message.reply_text("Reply to someone's message to warn him.")
+
+
+
+# Rmwarns
+
+
+@app.on_message(filters.command("rmwarns") & ~filters.edited)
+@capture_err
+async def remove_warnings(_, message):
+    try:
+        from_user_id = message.from_user.id
+        user_id = message.reply_to_message.from_user.id
+        mention = message.reply_to_message.from_user.mention
+        chat_id = message.chat.id
+        permissions = await member_permissions(chat_id, from_user_id)
+        if "can_restrict_members" in permissions or from_user_id in SUDOERS:
+            if message.reply_to_message:
+                warns = await get_warns(chat_id, user_id)
+                if warns == 0:
+                    await message.reply_text(f"{mention} have no warnings.")
+                else:
+                    await remove_warns(chat_id, user_id)
+                    await message.reply_text(f"Removed warnings of {mention}.")
+            else:
+                await message.reply_text("Reply to someone's message to remove Warnings")
+        else:
+            await message.reply_text("You don't have enough permissions")
+    except Exception as e:
+        await message.reply_text(str(e))
+
+
+# Warns
+
+
+@app.on_message(filters.command("warns") & ~filters.edited)
+@capture_err
+async def check_warns(_, message):
+    try:
+        from_user_id = message.from_user.id
+        user_id = message.reply_to_message.from_user.id
+        mention_user = message.reply_to_message.from_user.mention
+        mention_from_user = message.from_user.mention
+        chat_id = message.chat.id
+        if message.reply_to_message:
+            warns = await get_warns(chat_id, user_id)
+            await message.reply_text(f"{mention_user} have {warns}/3 warnings.")
+            return
+        warns = await get_warns(chat_id, from_user_id)
+        await message.reply_text(f"{mention__from_user} have {warns}/3 warnings.")
+    except Exception as e:
+        await message.reply_text(str(e))
+"""

wbb/modules/advanced.py

@@ -1,76 +0,0 @@
-from wbb import app, LOG_GROUP_ID
-from wbb.utils.json_prettify import json_object_prettify
-from wbb.utils.errors import capture_err
-from pyrogram.errors.exceptions.bad_request_400 import ChannelInvalid, PeerIdInvalid
-from pyrogram import filters
-
-
-__MODULE__ = "Advanced"
-__HELP__ = """**NOTE** - Some of these commands are only supported in BOT_LOG_GROUP [OWNER]
-/get_chat [CHAT_ID] - Get Info of A Chat.
-/get_user [USER_ID] - Get Info of A User.
-/leave_chat [CHAT_ID] - Leave The Chat.
-/send_message [CHAT_ID] [TEXT] - Send A Message To A Chat."""
-
-
-@app.on_message(filters.command("get_chat") & ~filters.edited)
-@capture_err
-async def get_chat_data(_, message):
-    if len(message.command) != 2:
-        await message.reply_text("/get_chat [CHAT_ID]")
-        return
-    try:
-        chat_id = message.text.split(None, 1)[1]
-        chat_data = await app.get_chat(chat_id)
-        data = await json_object_prettify(chat_data)
-        await app.send_message(message.chat.id, data)
-    except (PeerIdInvalid, ChannelInvalid) as e:
-        await message.reply_text("PEER_ID_INVALID")
-        print(str(e))
-
-
-@app.on_message(filters.command("get_user") & ~filters.edited)
-@capture_err
-async def get_user_data(_, message):
-    if len(message.command) != 2:
-        await message.reply_text("/get_user [USER_ID]")
-        return
-    try:
-        user_id = message.text.split(None, 1)[1]
-        user_data = await app.get_users(user_id)
-        data = await json_object_prettify(user_data)
-        await app.send_message(message.chat.id, data)
-    except (PeerIdInvalid, ChannelInvalid) as e:
-        await message.reply_text("PEER_ID_INVALID")
-        print(str(e))
-
-
-@app.on_message(filters.command("leave_chat") & ~filters.edited & filters.chat(LOG_GROUP_ID))
-@capture_err
-async def leave_chat(_, message):
-    if len(message.command) != 2:
-        await message.reply_text("/leave_chat [CHAT_ID]")
-        return
-    try:
-        chat_id = message.text.split(None, 1)[1]
-        await app.leave_chat(chat_id)
-        await message.reply_text("Left The Chat!")
-    except Exception as e:
-        await message.reply_text(str(e))
-        print(str(e))
-
-
-@app.on_message(filters.command("send_message") & ~filters.edited & filters.chat(LOG_GROUP_ID))
-@capture_err
-async def send_message(_, message):
-    if len(message.command) < 3:
-        await message.reply_text("/send_message [CHAT_ID] [TEXT]")
-        return
-    try:
-        chat_id = message.text.split(None, 2)[1]
-        text = message.text.split(None, 2)[2]
-        await app.send_message(chat_id, text=text)
-        await message.reply_text("Message Sent!")
-    except Exception as e:
-        await message.reply_text(str(e))
-        print(str(e))

wbb/modules/chatbot.py

@@ -13,7 +13,7 @@ active_chats = []
 # Enabled | Disable Chatbot
 
 
-@app.on_message(filters.command("chatbot"))
+@app.on_message(filters.command("chatbot") & ~filters.edited)
 @capture_err
 async def chatbot_status(_, message):
     global active_chats
@@ -47,7 +47,8 @@ async def chatbot_status(_, message):
 
 
 
-@app.on_message(filters.text & filters.reply & ~filters.bot)
+@app.on_message(filters.text & filters.reply & ~filters.bot &
+        ~filters.via_bot & ~filters.forwarded, group=2)
 @capture_err
 async def chatbot_talk(_, message):
     if message.chat.id not in active_chats:
@@ -59,3 +60,4 @@ async def chatbot_talk(_, message):
     response = luna.response
     await app.send_chat_action(message.chat.id, "typing")
     await message.reply_text(response)
+

wbb/modules/f.py

@@ -1,54 +0,0 @@
-from pyrogram.types import InlineKeyboardButton, InlineKeyboardMarkup
-from wbb import app
-from pyrogram import filters
-from wbb.utils.errors import capture_err
-
-i = 0
-m = None
-pressers = []
-keyboard = InlineKeyboardMarkup(
-        [
-            [
-                InlineKeyboardButton("F", callback_data="ff"),
-                InlineKeyboardButton("Delete", callback_data="deletef")
-                ]
-            ]
-        )
-
-
-@app.on_message(filters.command("f"))
-@capture_err
-async def f(_, message):
-    global i, m, pressers
-    i = 0
-    pressers = []
-    try:
-        await m.delete()
-    except:
-        pass
-    m = await app.send_message(message.chat.id, text=f"Press F To Pay Respect.\nRespect = `{i}`", reply_markup=keyboard)
-
-
-@app.on_callback_query(filters.regex("ff"))
-async def end_callbacc(_, CallbackQuery):
-    global i, m, pressers
-    i += 1
-    user_id = CallbackQuery.from_user.id
-    if user_id in pressers:
-        await app.answer_callback_query(CallbackQuery.id,
-                "Didn't You Already Pressed 'F' like 0.0069 Seconds Ago?",
-                show_alert=True
-                )
-        return
-    pressers.append(user_id)
-    await m.edit(text=f"Press F To Pay Respect.\nRespect = `{i}`", reply_markup=keyboard)
-    await app.answer_callback_query(CallbackQuery.id, "Respect +", show_alert=True)
-
-
-@app.on_callback_query(filters.regex("deletef"))
-async def del_callbacc(_, CallbackQuery):
-    global i, m, pressers
-    pressers = []
-    i = 0
-    await app.send_message(CallbackQuery.message.chat.id, text=f"{CallbackQuery.from_user.id} Deleted F's")
-    await m.delete()

wbb/modules/filters.py

@@ -0,0 +1,96 @@
+from wbb import app, db
+from wbb.modules.admin import member_permissions
+from wbb.utils.dbfunctions import (
+        _get_filters, save_filter,
+        get_filters_names, get_filter,
+        delete_filter
+        )
+from pyrogram import filters
+from wbb.utils.errors import capture_err
+
+
+__MODULE__ = "Filters"
+__HELP__ = """/filters To Get All The Filters In The Chat.
+/filter [FILTER_NAME] To Save A Filter (Can be a sticker or text).
+/stop [FILTER_NAME] To Stop A Filter."""
+
+
+@app.on_message(filters.command("filter") & ~filters.edited & ~filters.private)
+@capture_err
+async def save_filters(_, message):
+    if len(message.command) < 2 or not message.reply_to_message:
+        await message.reply_text("Usage:\nReply to a text or sticker with /filter [FILTER_NAME] to save it.")
+
+    elif not message.reply_to_message.text and not message.reply_to_message.sticker:
+        await message.reply_text("__**You can only save text or stickers in filters.**__")
+
+    elif len(await member_permissions(message.chat.id, message.from_user.id)) < 1:
+        await message.reply_text("**You don't have enough permissions**")
+    else:
+        name = message.text.split(None, 1)[1].strip()
+        if not name:
+            await message.reply_text("**Usage**\n__/filter [FILTER_NAME]__")
+            return
+        _type = "text" if message.reply_to_message.text else "sticker"
+        _filter = {
+            "type": _type,
+            "data": message.reply_to_message.text.markdown if _type == "text" else message.reply_to_message.sticker.file_id
+        }
+        await save_filter(message.chat.id, name, _filter)
+        await message.reply_text(f"__**Saved filter {name}.**__")
+
+
+@app.on_message(filters.command("filters") & ~filters.edited & ~filters.private)
+@capture_err
+async def get_filterss(_, message):
+    _filters = await get_filters_names(message.chat.id)
+    if not _filters:
+        await message.reply_text("**No filters in this chat.**")
+    else:
+        msg = f"List of filters in {message.chat.title}\n"
+        for _filter in _filters:
+            msg += f"**-** `{_filter}`\n"
+        await message.reply_text(msg)
+
+
+@app.on_message(filters.command("stop") & ~filters.edited & ~filters.private)
+@capture_err
+async def del_filter(_, message):
+    if len(message.command) < 2:
+        await message.reply_text("**Usage**\n__/stop [FILTER_NAME]__")
+
+    elif len(await member_permissions(message.chat.id, message.from_user.id)) < 1:
+        await message.reply_text("**You don't have enough permissions**")
+
+    else:
+        name = message.text.split(None, 1)[1].strip()
+        if not name:
+            await message.reply_text("**Usage**\n__/stop [FILTER_NAME]__")
+            return
+        chat_id = message.chat.id
+        deleted = await delete_filter(chat_id, name)
+        if deleted:
+            await message.reply_text(f"**Deleted filter {name} successfully.**")
+        else:
+            await message.reply_text(f"**No such filter.**")
+
+
+@app.on_message(filters.text & ~filters.edited &
+                ~filters.private & ~filters.via_bot &
+                ~filters.forwarded, group=1)
+async def filters_re(_, message):
+    if message.text[0] != "/":
+        text = message.text.lower().strip().split(" ")
+        if text:
+            chat_id = message.chat.id
+            list_of_filters = await get_filters_names(chat_id)
+            for word in text:
+                if word in list_of_filters:
+                    _filter = await get_filter(chat_id, word)
+                    data_type = _filter['type']
+                    data = _filter['data']
+                    if data_type == "text":
+                        await message.reply_text(data)
+                    else:
+                        await message.reply_sticker(data)
+                    return

wbb/modules/github.py

@@ -3,7 +3,6 @@ from pyrogram import filters
 from wbb import app
 from wbb.utils.errors import capture_err
 
-
 __MODULE__ = 'Github'
 __HELP__ = "Get information about a GitHub user.\n /github [username]"
 

wbb/modules/greetings.py

@@ -13,10 +13,11 @@ import asyncio
 from datetime import datetime
 from pyrogram import filters
 from wbb import app, WELCOME_DELAY_KICK_SEC
-from wbb.utils.errors import capture_err
 from wbb.modules.admin import list_admins
 from pyrogram.types import Message, InlineKeyboardMarkup, InlineKeyboardButton, ChatPermissions, User
 from pyrogram.errors.exceptions.bad_request_400 import UserNotParticipant
+from wbb.utils.errors import capture_err
+
 
 @app.on_message(filters.new_chat_members)
 @capture_err
@@ -24,11 +25,11 @@ async def welcome(_, message: Message):
     """Mute new member and send message with button"""
     for member in message.new_chat_members:
         if member.is_bot:
-            continue # ignore bots
-            
+            continue  # ignore bots
+
         text = (f"Welcome, {(member.mention())}\n**Are you human?**\n"
-            "You will be removed from this chat if you are not verified "
-            f"in {WELCOME_DELAY_KICK_SEC} seconds")
+                "You will be removed from this chat if you are not verified "
+                f"in {WELCOME_DELAY_KICK_SEC} seconds")
         await message.chat.restrict_member(member.id, ChatPermissions())
         user = await app.get_users(member.id)
         name_length = len(str(user.first_name) + str(user.last_name))
@@ -42,19 +43,22 @@ async def welcome(_, message: Message):
                     [
                         InlineKeyboardButton(
                             "Press Here to Verify",
-                            callback_data="pressed_button {}".format(member.id) # According to the docs, the user can send arbitrary data in this field, yet, I'm not able to do so, so until there's a db to pass data, imma use it like this so it will be very easy to change it to use a db in the future
+                            # According to the docs, the user can send arbitrary data in this field, yet, I'm not able to do so, so until there's a db to pass data, imma use it like this so it will be very easy to change it to use a db in the future
+                            callback_data="pressed_button {}".format(member.id)
                         )
                     ]
                 ]
             ),
             quote=True
         )
-        #await message.reply_animation("CgACAgQAAx0CWIlO9AABATjjYBrlKqQID0SQ7Ey7bkVRKM5gNn8AAl8CAAIm39VRHDx6EoKU6W0eBA") 
+        # await message.reply_animation("CgACAgQAAx0CWIlO9AABATjjYBrlKqQID0SQ7Ey7bkVRKM5gNn8AAl8CAAIm39VRHDx6EoKU6W0eBA")
         # wtf is this? "file_id is unique for each individual bot and can't be transferred from one bot to another." source: https://core.telegram.org/bots/api#sending-files
-        #and here is the error I just received -- pyrogram.errors.exceptions.bad_request_400.MediaEmpty: [400 MEDIA_EMPTY]: The media you tried to send is invalid (caused by "messages.SendMedia")
-        asyncio.create_task(kick_restricted_after_delay(WELCOME_DELAY_KICK_SEC, button_message, member))
+        # and here is the error I just received -- pyrogram.errors.exceptions.bad_request_400.MediaEmpty: [400 MEDIA_EMPTY]: The media you tried to send is invalid (caused by "messages.SendMedia")
+        asyncio.create_task(kick_restricted_after_delay(
+            WELCOME_DELAY_KICK_SEC, button_message, member))
         await asyncio.sleep(0.5)
 
+
 @app.on_callback_query(filters.regex("pressed_button"))
 async def callback_query_welcome_button(client, callback_query):
     """After the new member presses the button, set his permissions to
@@ -75,6 +79,8 @@ async def callback_query_welcome_button(client, callback_query):
 # If anyone is interested, we should use threads and kill them when the user has verified himself.
 # Also, once there's a db, we should save this data and re-create the threads in case the bot crashed, tho pyrogram doesn't support history messages (obviously)
 # so in such a case we may lose data anyway
+
+
 async def kick_restricted_after_delay(delay, button_message: Message, user: User):
     """If the new member is still restricted after the delay, delete
     button message and join message and then kick him

wbb/modules/images.py

@@ -5,8 +5,6 @@ from random import randint
 from pyrogram import filters
 from wbb import app, arq
 from wbb.utils.errors import capture_err
-from wbb.utils.fetch import fetch
-
 
 __MODULE__ = "Images"
 __HELP__ = '''/cat  - Get Cute Cats Images

wbb/modules/misc.py

@@ -6,11 +6,10 @@ from googletrans import Translator
 from cryptography.fernet import Fernet
 from wbb import app, FERNET_ENCRYPTION_KEY
 from wbb.utils import random_line
-from wbb.utils.errors import capture_err
 from wbb.utils.json_prettify import json_prettify
 from wbb.utils.fetch import fetch
 from wbb.utils.nekobin import neko
-
+from wbb.utils.errors import capture_err
 
 __MODULE__ = "Misc"
 __HELP__ = '''/commit - Generate Funny Commit Messages
@@ -27,13 +26,11 @@ __HELP__ = '''/commit - Generate Funny Commit Messages
 
 
 @app.on_message(filters.command("commit") & ~filters.edited)
-@capture_err
 async def commit(_, message):
     await message.reply_text((await random_line('wbb/utils/commit.txt')))
 
 
 @app.on_message(filters.command("RTFM", "#"))
-@capture_err
 async def rtfm(_, message):
     await message.delete()
     if not message.reply_to_message:
@@ -43,7 +40,6 @@ async def rtfm(_, message):
 
 
 @app.on_message(filters.command("runs") & ~filters.edited)
-@capture_err
 async def runs(_, message):
     await message.reply_text((await random_line('wbb/utils/runs.txt')))
 
@@ -232,7 +228,6 @@ async def json_fetch(_, message):
     
 
 @app.on_message(filters.command('bun'))
-@capture_err
 async def bunn(_, message):
     if message.reply_to_message:
         await message.reply_to_message.reply_sticker('CAACAgUAAx0CWIlO9AABARyRYBhyjKXFATVhu7AGQwip3TzSFiMAAuMBAAJ7usBUIu2xBtXTmuweBA')

wbb/modules/music.py

@@ -11,7 +11,6 @@ from wbb import app, SUDOERS, arq
 from wbb.utils.fetch import fetch
 from wbb.utils.errors import capture_err
 
-
 __MODULE__ = "Music"
 __HELP__ = """/ytmusic [link] To Download Music From Various Websites Including Youtube.
 /saavn [query] To Download Music From Saavn.
@@ -85,7 +84,7 @@ async def download_song(url):
 # Jiosaavn Music
 
 
-@app.on_message(filters.command("saavn"))
+@app.on_message(filters.command("saavn") & ~filters.edited)
 @capture_err
 async def jssong(_, message):
     if len(message.command) < 2:
@@ -115,9 +114,9 @@ async def jssong(_, message):
 # Deezer Music
 
 
-@app.on_message(filters.command("deezer"))
+@app.on_message(filters.command("deezer") & ~filters.edited)
 @capture_err
-async def jssong(_, message):
+async def deezsong(_, message):
     if len(message.command) < 2:
         await message.reply_text("/deezer requires an argument.")
         return

wbb/modules/notes.py

@@ -0,0 +1,97 @@
+from wbb import app
+from wbb.utils.dbfunctions import (
+        _get_notes, save_note,
+        get_note_names, get_note,
+        delete_note
+        )
+from wbb.utils.errors import capture_err
+from wbb.modules.admin import member_permissions
+from pyrogram import filters
+
+
+__MODULE__ = "Notes"
+__HELP__ = """/notes To Get All The Notes In The Chat.
+/save [NOTE_NAME] To Save A Note (Can be a sticker or text).
+/get [NOTE_NAME] To Get A Note.
+/delete [NOTE_NAME] To Delete A Note."""
+
+
+@app.on_message(filters.command("save") & ~filters.edited & ~filters.private)
+@capture_err
+async def save_notee(_, message):
+    if len(message.command) < 2 or not message.reply_to_message:
+        await message.reply_text("Usage:\nReply to a text or sticker with /save [NOTE_NAME] to save it.")
+    
+    elif not message.reply_to_message.text and not message.reply_to_message.sticker:
+        await message.reply_text("__**You can only save text or stickers in notes.**__")
+    
+    elif len(await member_permissions(message.chat.id, message.from_user.id)) < 1:
+        await message.reply_text("**You don't have enough permissions**")
+    else:
+        name = message.text.split(None, 1)[1].strip()
+        if not name:
+            await message.reply_text("**Usage**\n__/save [NOTE_NAME]__")
+            return
+        _type = "text" if message.reply_to_message.text else "sticker"
+        note = {
+            "type": _type,
+            "data": message.reply_to_message.text.markdown if _type == "text" else message.reply_to_message.sticker.file_id
+        }
+        await save_note(message.chat.id, name, note)
+        await message.reply_text(f"__**Saved note {name}.**__")
+
+
+@app.on_message(filters.command("notes") & ~filters.edited & ~filters.private)
+@capture_err
+async def get_notes(_, message):
+    _notes = await get_note_names(message.chat.id)
+
+    if not _notes:
+        await message.reply_text("**No notes in this chat.**")
+    else:
+        msg = f"List of notes in {message.chat.title}\n"
+        for note in _notes:
+            msg += f"**-** `{note}`\n"
+        await message.reply_text(msg)
+
+
+@app.on_message(filters.command("get") & ~filters.edited & ~filters.private)
+@capture_err
+async def get_one_note(_, message):
+    if len(message.command) < 2:
+        await message.reply_text("**Usage**\n__/get [NOTE_NAME]__")
+    else:
+        name = message.text.split(None, 1)[1].strip()
+        if not name:
+            await message.reply_text("**Usage**\n__/get [NOTE_NAME]__")
+            return
+        _note = await get_note(message.chat.id, name)
+        if not _note:
+            await message.reply_text(f"**No such note.**")
+        else:
+            if _note["type"] == "text":
+                await message.reply_text(_note["data"])
+            else:
+                await message.reply_sticker(_note["data"])
+
+
+@app.on_message(filters.command("delete") & ~filters.edited & ~filters.private)
+@capture_err
+async def del_note(_, message):
+    if len(message.command) < 2:
+        await message.reply_text("**Usage**\n__/delete [NOTE_NAME]__")
+    
+    elif len(await member_permissions(message.chat.id, message.from_user.id)) < 1:
+        await message.reply_text("**You don't have enough permissions**")
+    
+    else:
+        name = message.text.split(None, 1)[1].strip()
+        if not name:
+            await message.reply_text("**Usage**\n__/delete [NOTE_NAME]__")
+            return
+        chat_id = message.chat.id
+        deleted = await delete_note(chat_id, name)
+        if deleted:
+            await message.reply_text(f"**Deleted note {name} successfully.**")
+        else:
+            await message.reply_text(f"**No such note.**")

wbb/modules/paste.py

@@ -1,8 +1,8 @@
 import os
 from pyrogram import filters
 from wbb.utils import nekobin
-from wbb.utils.errors import capture_err
 from wbb import app
+from wbb.utils.errors import capture_err
 
 __MODULE__ = "Paste"
 __HELP__ = "/paste - To Paste Replied Text Or Document To Neokobin"

wbb/modules/reddit.py

@@ -1,7 +1,6 @@
 from pyrogram import filters
 from wbb import app, arq
 from wbb.utils.errors import capture_err
-from wbb.utils.fetch import fetch
 
 __MODULE__ = "Reddit"
 __HELP__ = "/reddit [query] - results something from reddit"

wbb/modules/repo.py

@@ -1,26 +0,0 @@
-from pyrogram import filters
-from wbb import app
-from wbb.utils.errors import capture_err
-from wbb.utils.fetch import fetch
-
-__MODULE__ = "Repo"
-__HELP__ = "/repo - To Get My Github Repository Link " \
-           "And Support Group Link"
-
-
-@app.on_message(filters.command("repo") & ~filters.edited)
-@capture_err
-async def repo(_, message):
-    users = await fetch("https://api.github.com/repos/thehamkercat/williambutcherbot/contributors")
-    list_of_users = ""
-    count = 1    
-    for user in users:
-        list_of_users += f"**{count}.** [{user['login']}]({user['html_url']})\n"
-        count += 1
-
-    text = f"""[Github](https://github.com/thehamkercat/WilliamButcherBot) | [Group](t.me/PatheticProgrammers)
-```----------------
-| Contributors |
-----------------```
-{list_of_users}"""
-    await app.send_message(message.chat.id, text=text, disable_web_page_preview=True)

wbb/modules/rice.py

@@ -95,3 +95,4 @@ async def callback_query_ignore_rice(_, callback_query):
         await callback_query.answer("Only admin or OP could ignore it")
         return
     await callback_query.message.delete()
+

wbb/modules/search.py

@@ -2,7 +2,7 @@ from search_engine_parser import GoogleSearch
 from pyrogram import filters
 from wbb import app, arq
 from wbb.utils.errors import capture_err
-from wbb.utils.fetch import fetch
+
 
 __MODULE__ = "Search"
 __HELP__ = '''/ud - Search For Something In Urban Dictionary

wbb/modules/sudoers.py

@@ -4,8 +4,9 @@ from pyrogram import filters, types
 import speedtest
 import psutil
 from wbb.utils import nekobin, formatter
-from wbb.utils.errors import capture_err
 from wbb import app, SUDOERS, bot_start_time
+from wbb.utils.errors import capture_err
+
 
 __MODULE__ = "Sudoers"
 __HELP__ = '''/log - To Get Logs From Last Run.
@@ -44,7 +45,7 @@ logs_create = filters.create(logs_callback)
 
 @app.on_callback_query(logs_create)
 async def paste_log_neko(client, query):
-    if query.from_user.id == OWNER_ID or SUDO_USER_ID:
+    if query.from_user.id in SUDOERS:
         j = open("error.log", "r")
         data = await nekobin.neko(j.read())
         keyb = types.InlineKeyboardMarkup(

wbb/utils/botinfo.py

@@ -1,4 +1,3 @@
-from wbb import LOG_GROUP_ID
 BOT_ID = 0
 BOT_NAME = ""
 BOT_USERNAME = ""

wbb/utils/dbfunctions.py

@@ -0,0 +1,119 @@
+from wbb import db
+from typing import Dict, List, Union
+
+
+notesdb = db.notes
+filtersdb = db.filters
+warnsdb = db.warns
+
+
+""" Notes functions """
+
+
+async def _get_notes(chat_id: int) -> Dict[str, int]:
+    _notes = await notesdb.find_one({"chat_id": chat_id})
+    _notes = {} if not _notes else _notes["notes"]
+    return _notes
+
+
+async def save_note(chat_id: int, name: str, note: dict):
+    name = name.lower()
+    name = name.strip()
+    _notes = await _get_notes(chat_id)
+    _notes[name] = note
+
+    await notesdb.update_one(
+        {"chat_id": chat_id},
+        {
+            "$set": {
+                "notes": _notes
+            }
+        },
+        upsert=True
+    )
+
+
+async def get_note_names(
+    chat_id: int) -> List[str]: return [note for note in await _get_notes(chat_id)]
+
+
+async def get_note(chat_id: int, name: str) -> Union[bool, dict]:
+    name = name.lower()
+    name = name.strip()
+    _notes = await _get_notes(chat_id)
+    return _notes[name] if name in _notes else False
+
+
+async def delete_note(chat_id: int, name: str) -> bool:
+    notesd = await _get_notes(chat_id)
+    name = name.lower()
+    name = name.strip()
+    if name in notesd:
+        del notesd[name]
+        await notesdb.update_one(
+            {"chat_id": chat_id},
+            {
+                "$set": {
+                    "notes": notesd
+                }
+            },
+            upsert=True
+        )
+        return True
+    return False
+
+
+""" Filters funcions """
+
+
+async def _get_filters(chat_id: int) -> Dict[str, int]:
+    _filters = await filtersdb.find_one({"chat_id": chat_id})
+    _filters = {} if not _filters else _filters["filters"]
+    return _filters
+
+
+async def save_filter(chat_id: int, name: str, _filter: dict):
+    name = name.lower()
+    name = name.strip()
+    _filters = await _get_filters(chat_id)
+    _filters[name] = _filter
+
+    await filtersdb.update_one(
+        {"chat_id": chat_id},
+        {
+            "$set": {
+                "filters": _filters
+            }
+        },
+        upsert=True
+    )
+
+
+async def get_filters_names(
+    chat_id: int) -> List[str]: return [_filter for _filter in await _get_filters(chat_id)]
+
+
+async def get_filter(chat_id: int, name: str) -> Union[bool, dict]:
+    name = name.lower()
+    name = name.strip()
+    _filters = await _get_filters(chat_id)
+    return _filters[name] if name in _filters else False
+
+
+async def delete_filter(chat_id: int, name: str) -> bool:
+    filtersd = await _get_filters(chat_id)
+    name = name.lower()
+    name = name.strip()
+    if name in filtersd:
+        del filtersd[name]
+        await filtersdb.update_one(
+            {"chat_id": chat_id},
+            {
+                "$set": {
+                    "filters": filtersd
+                }
+            },
+            upsert=True
+        )
+        return True
+    return False