pixlib 1.0__py3-none-any.whl

pixlib/Pix/database/fitersdb.py

@@ -0,0 +1,76 @@
+import codecs
+import pickle
+from typing import Dict, List, Union
+from pixlib.Pix.database import db_x
+
+filtersdb = db_x["filters"]
+
+def obj_to_str(obj):
+    if not obj:
+        return False
+    string = codecs.encode(pickle.dumps(obj), "base64").decode()
+    return string
+
+
+def str_to_obj(string: str):
+    obj = pickle.loads(codecs.decode(string.encode(), "base64"))
+    return obj
+
+async def get_filters_count() -> dict:
+    chats_count = 0
+    filters_count = 0
+    async for chat in filtersdb.find({"chat_id": {"$lt": 0}}):
+        filters_name = await get_filters_names(chat["chat_id"])
+        filters_count += len(filters_name)
+        chats_count += 1
+    return {
+        "chats_count": chats_count,
+        "filters_count": filters_count,
+    }
+
+
+async def _get_filters(chat_id: int) -> Dict[str, int]:
+    _filters = await filtersdb.find_one({"chat_id": chat_id})
+    if not _filters:
+        return {}
+    return _filters["filters"]
+
+
+async def get_filters_names(chat_id: int) -> List[str]:
+    _filters = []
+    for _filter in await _get_filters(chat_id):
+        _filters.append(_filter)
+    return _filters
+
+
+async def get_filter(chat_id: int, name: str) -> Union[bool, dict]:
+    name = name.lower().strip()
+    _filters = await _get_filters(chat_id)
+    if name in _filters:
+        return _filters[name]
+    return False
+
+
+async def save_filter(chat_id: int, name: str, _filter: dict):
+    name = name.lower().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 delete_filter(chat_id: int, name: str) -> bool:
+    filtersd = await _get_filters(chat_id)
+    name = name.lower().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

pixlib/Pix/database/gbandb.py

@@ -0,0 +1,23 @@
+from pixlib.Pix.database import db_x
+
+gbun = db_x["GBAN"]
+
+
+async def gban_user(user, reason="#GBanned"):
+    await gbun.insert_one({"user": user, "reason": reason})
+
+
+async def ungban_user(user):
+    await gbun.delete_one({"user": user})
+
+
+async def gban_list():
+    return [lo async for lo in gbun.find({})]
+
+
+async def gban_info(user):
+    kk = await gbun.find_one({"user": user})
+    if not kk:
+        return False
+    else:
+        return kk["reason"]

pixlib/Pix/database/global.py

@@ -0,0 +1,42 @@
+from pixlib.Pix.database import db_x
+
+db = db_x
+collection = db['globals']
+
+class Globals:
+    def __init__(self, variable, value):
+        self.variable = variable
+        self.value = value
+
+    def to_dict(self):
+        return {'variable': self.variable, 'value': self.value}
+
+    @staticmethod
+    def from_dict(data):
+        return Globals(data['variable'], data['value'])
+
+
+def gvarstatus(variable):
+    try:
+        result = collection.find_one({'variable': variable})
+        if result:
+            return result['value']
+        else:
+            return None
+    except BaseException:
+        return None
+
+
+def addgvar(variable, value):
+    if collection.find_one({'variable': variable}):
+        delgvar(variable)
+    data = Globals(variable, value).to_dict()
+    collection.insert_one(data)
+
+
+def delgvar(variable):
+    result = collection.delete_one({'variable': variable})
+    if result.deleted_count > 0:
+        return True
+    else:
+        return False

pixlib/Pix/database/gmutedb.py

@@ -0,0 +1,16 @@
+from pixlib.Pix.database import db_x
+
+gmuteh = db_x["GMUTE"]
+
+
+async def is_gmuted(sender_id):
+    kk = await gmuteh.find_one({"sender_id": sender_id})
+    return bool(kk)
+
+
+async def gmute(sender_id, reason="#GMuted"):
+    await gmuteh.insert_one({"sender_id": sender_id, "reason": reason})
+
+
+async def ungmute(sender_id):
+    await gmuteh.delete_one({"sender_id": sender_id})

pixlib/Pix/database/notesdb.py

@@ -0,0 +1,73 @@
+import codecs
+import pickle
+from pixlib.Pix.database import db_x
+from typing import Dict, List, Union
+
+notesdb = db_x["notes"]
+
+def obj_to_str(obj):
+    if not obj:
+        return False
+    string = codecs.encode(pickle.dumps(obj), "base64").decode()
+    return string
+
+
+def str_to_obj(string: str):
+    obj = pickle.loads(codecs.decode(string.encode(), "base64"))
+    return obj
+
+
+async def get_notes_count() -> dict:
+    chats_count = 0
+    notes_count = 0
+    async for chat in notesdb.find({"chat_id": {"$exists": 1}}):
+        notes_name = await get_note_names(chat["chat_id"])
+        notes_count += len(notes_name)
+        chats_count += 1
+    return {"chats_count": chats_count, "notes_count": notes_count}
+
+
+async def _get_notes(chat_id: int) -> Dict[str, int]:
+    _notes = await notesdb.find_one({"chat_id": chat_id})
+    if not _notes:
+        return {}
+    return _notes["notes"]
+
+
+async def get_note_names(chat_id: int) -> List[str]:
+    _notes = []
+    for note in await _get_notes(chat_id):
+        _notes.append(note)
+    return _notes
+
+
+async def get_note(chat_id: int, name: str) -> Union[bool, dict]:
+    name = name.lower().strip()
+    _notes = await _get_notes(chat_id)
+    if name in _notes:
+        return _notes[name]
+    return False
+
+
+async def save_note(chat_id: int, name: str, note: dict):
+    name = name.lower().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 delete_note(chat_id: int, name: str) -> bool:
+    notesd = await _get_notes(chat_id)
+    name = name.lower().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

pixlib/Pix/database/pm_permit.py

@@ -0,0 +1,23 @@
+from pixlib.Pix.database import db_x
+
+def get_approved():
+    return db_x.get_key("PMPERMIT") or []
+
+
+def approve_user(id):
+    ok = get_approved()
+    if id in ok:
+        return True
+    ok.append(id)
+    return db_x.set_key("PMPERMIT", ok)
+
+
+def disapprove_user(id):
+    ok = get_approved()
+    if id in ok:
+        ok.remove(id)
+        return db_x.set_key("PMPERMIT", ok)
+
+
+def is_approved(id):
+    return id in get_approved()

pixlib/Pix/database/pmpermit.py

@@ -0,0 +1,82 @@
+from pixlib.Pix.database import db_x
+
+db_y = db_x["PMPERMIT"]
+
+PMPERMIT_MESSAGE = (
+    "**warning! please read this message carefully..\n\n**"
+     "**I'm Pixsuvy I'm here to protect my master from spam**"
+     "**if you are not a spammer, please wait!.\n\n**"
+     "**don't spam or you will be blocked, so be careful when sending messages!**"
+)
+
+BLOCKED = "**Spammer, blocked!**"
+
+LIMIT = 5
+
+
+async def set_pm(value: bool):
+    doc = {"_id": 1, "pmpermit": value}
+    doc2 = {"_id": "Approved", "users": []}
+    r = await db_y.find_one({"_id": 1})
+    r2 = await db_y.find_one({"_id": "Approved"})
+    if r:
+        await db_y.update_one({"_id": 1}, {"$set": {"pmpermit": value}})
+    else:
+        await db_y.insert_one(doc)
+    if not r2:
+        await db_y.insert_one(doc2)
+
+
+async def set_permit_message(text):
+    await db_y.update_one({"_id": 1}, {"$set": {"pmpermit_message": text}})
+
+
+async def set_block_message(text):
+    await db_y.update_one({"_id": 1}, {"$set": {"block_message": text}})
+
+
+async def set_limit(limit):
+    await db_y.update_one({"_id": 1}, {"$set": {"limit": limit}})
+
+
+async def get_pm_settings():
+    result = await db_y.find_one({"_id": 1})
+    if not result:
+        return False
+    pmpermit = result["pmpermit"]
+    pm_message = result.get("pmpermit_message", PMPERMIT_MESSAGE)
+    block_message = result.get("block_message", BLOCKED)
+    limit = result.get("limit", LIMIT)
+    return pmpermit, pm_message, limit, block_message
+
+
+async def allow_user(chat):
+    doc = {"_id": "Approved", "users": [chat]}
+    r = await db_y.find_one({"_id": "Approved"})
+    if r:
+        await db_y.update_one({"_id": "Approved"}, {"$push": {"users": chat}})
+    else:
+        await db_y.insert_one(doc)
+
+
+async def get_approved_users():
+    results = await db_y.find_one({"_id": "Approved"})
+    if results:
+        return results["users"]
+    else:
+        return []
+
+
+async def deny_user(chat):
+    await db_y.update_one({"_id": "Approved"}, {"$pull": {"users": chat}})
+
+
+async def pm_guard():
+    result = await db_y.find_one({"_id": 1})
+    if not result:
+        return False
+    if not result["pmpermit"]:
+        return False
+    else:
+        return True
+

pixlib/Pix/database/slr.py

@@ -0,0 +1,24 @@
+from pixlib.Pix.database import db_x
+
+db = db_x
+
+collection = db['slr']
+async def pix_user(chat):
+    doc = {"_id": "slr", "users": [chat]}
+    r = await collection.find_one({"_id": "slr"})
+    if r:
+        await collection.update_one({"_id": "slr"}, {"$push": {"users": chat}})
+    else:
+        await collection.insert_one(doc)
+
+
+async def get_pix_users():
+    results = await collection.find_one({"_id": "slr"})
+    if results:
+        return results["users"]
+    else:
+        return []
+
+
+async def unpix_user(chat):
+    await collection.update_one({"_id": "slr"}, {"$pull": {"users": chat}})

pixlib/Pix/database/sudodb.py

@@ -0,0 +1,27 @@
+from pixlib.Pix.database import db_x
+
+sudoersdb = db_x["sudo"]
+
+async def get_sudoers() -> list:
+    sudoers = await sudoersdb.find_one({"sudo": "sudo"})
+    if not sudoers:
+        return []
+    return sudoers["sudoers"]
+
+
+async def add_sudo(user_id: int) -> bool:
+    sudoers = await get_sudoers()
+    sudoers.append(user_id)
+    await sudoersdb.update_one(
+        {"sudo": "sudo"}, {"$set": {"sudoers": sudoers}}, upsert=True
+    )
+    return True
+
+
+async def remove_sudo(user_id: int) -> bool:
+    sudoers = await get_sudoers()
+    sudoers.remove(user_id)
+    await sudoersdb.update_one(
+        {"sudo": "sudo"}, {"$set": {"sudoers": sudoers}}, upsert=True
+    )
+    return True

pixlib/Pix/filter.py

@@ -0,0 +1,57 @@
+import re
+from re import findall
+from re import sub as re_sub
+from pykeyboard import InlineKeyboard
+from pyrogram.types import InlineKeyboardButton as Ikb
+
+def ikb(data: dict, row_width: int = 2):
+    return keyboard(data.items(), row_width=row_width)
+
+def get_urls_from_text(text: str) -> bool:
+    regex = r"""(?i)\b((?:https?://|www\d{0,3}[.]|[a-z0-9.\-]
+                [.][a-z]{2,4}/)(?:[^\s()<>]+|\(([^\s()<>]+|(
+                \([^\s()<>]+\)))*\))+(?:\(([^\s()<>]+|(\([^\
+                ()<>]+\)))*\)|[^\s`!()\[\]{};:'".,<>?«»“”‘’]))""".strip()
+    return [x[0] for x in findall(regex, str(text))]
+
+is_url = get_urls_from_text
+
+chat_filters_group = 1
+
+def keyboard(buttons_list, row_width: int = 2):
+    buttons = InlineKeyboard(row_width=row_width)
+    data = [
+        (
+            Ikb(text=str(i[0]), callback_data=str(i[1]))
+            if not is_url(i[1])
+            else Ikb(text=str(i[0]), url=str(i[1]))
+        )
+        for i in buttons_list
+    ]
+    buttons.add(*data)
+    return buttons
+
+def extract_text_and_keyb(ikb, text: str, row_width: int = 2):
+    keyboard = {}
+    try:
+        text = text.strip()
+        if text.startswith("`"):
+            text = text[1:]
+        if text.endswith("`"):
+            text = text[:-1]
+
+        text, keyb = text.split("~")
+
+        keyb = findall(r"\[.+\,.+\]", keyb)
+        for btn_str in keyb:
+            btn_str = re_sub(r"[\[\]]", "", btn_str)
+            btn_str = btn_str.split(",")
+            btn_txt, btn_url = btn_str[0], btn_str[1].strip()
+
+            if not get_urls_from_text(btn_url):
+                continue
+            keyboard[btn_txt] = btn_url
+        keyboard = ikb(keyboard, row_width)
+    except Exception:
+        return
+    return text, keyboard

pixlib/Pix/helper/PyroHelpers.py

@@ -0,0 +1,65 @@
+from pyrogram.types import Message, User
+from pyrogram import Client, enums
+
+async def get_ub_chats(
+    client: Client,
+    chat_types: list = [
+        enums.ChatType.GROUP,
+        enums.ChatType.SUPERGROUP,
+        enums.ChatType.CHANNEL,
+    ],
+    is_id_only=True,
+):
+    ub_chats = []
+    async for dialog in client.get_dialogs():
+        if dialog.chat.type in chat_types:
+            if is_id_only:
+                ub_chats.append(dialog.chat.id)
+            else:
+                ub_chats.append(dialog.chat)
+        else:
+            continue
+    return ub_chats
+
+def ReplyCheck(message: Message):
+    reply_id = None
+
+    if message.reply_to_message:
+        reply_id = message.reply_to_message.id
+
+    elif not message.from_user.is_self:
+        reply_id = message.id
+
+    return reply_id
+
+
+def SpeedConvert(size):
+    power = 2 ** 10
+    zero = 0
+    units = {0: "", 1: "Kbit/s", 2: "Mbit/s", 3: "Gbit/s", 4: "Tbit/s"}
+    while size > power:
+        size /= power
+        zero += 1
+    return f"{round(size, 2)} {units[zero]}"
+
+
+def GetFromUserID(message: Message):
+    return message.from_user.id
+
+
+def GetChatID(message: Message):
+    return message.chat.id
+
+
+def GetUserMentionable(user: User):
+    if user.username:
+        username = "@{}".format(user.username)
+    else:
+        if user.last_name:
+            name_string = "{} {}".format(user.first_name, user.last_name)
+        else:
+            name_string = "{}".format(user.first_name)
+
+        username = "<a href='tg://user?id={}'>{}</a>".format(user.id, name_string)
+
+    return username

pixlib/Pix/helper/__init__.py

@@ -0,0 +1,20 @@
+import os
+import sys
+from pyrogram import Client
+
+from pixlib.Pix.helper.adminHelpers import *
+from pixlib.Pix.helper.aiohttp_helper import*
+from pixlib.Pix.helper.basic import *
+from pixlib.Pix.helper.constants import *
+from pixlib.Pix.helper.data import *
+from pixlib.Pix.helper.inline import *
+from pixlib.Pix.helper.interval import *
+from pixlib.Pix.helper.parser import *
+from pixlib.Pix.helper.PyroHelpers import *
+from pixlib.Pix.helper.utility import *
+from pixlib.Pix.helper.what import *
+from pixlib.Pix.helper.pluginhelper import *
+
+def restart():
+    os.execvp(sys.executable, [sys.executable, "-m", "Pix"])
+

pixlib/Pix/helper/adminHelpers.py

@@ -0,0 +1,68 @@
+import asyncio
+from time import time
+
+from pyrogram.types import Message
+
+from pyrogram import Client 
+from pixlib.Pix.helper.interval import IntervalHelper
+
+
+async def CheckAdmin(message: Message):
+    """Check if we are an admin."""
+    admin = "administrator"
+    creator = "creator"
+    ranks = [admin, creator]
+
+    SELF = await Client.get_chat_member(
+        chat_id=message.chat.id, user_id=message.from_user.id
+    )
+
+    if SELF.status not in ranks:
+        await message.edit("__I'm not Admin!__")
+        await asyncio.sleep(2)
+        await message.delete()
+
+    else:
+        if SELF.status is not admin:
+            return True
+        elif SELF.can_restrict_members:
+            return True
+        else:
+            await message.edit("__No Permissions to restrict Members__")
+            await asyncio.sleep(2)
+            await message.delete()
+
+
+async def CheckReplyAdmin(message: Message):
+    """Check if the message is a reply to another user."""
+    if not message.reply_to_message:
+        await message.edit("The command needs to be a reply")
+        await asyncio.sleep(2)
+        await message.delete()
+    elif message.reply_to_message.from_user.is_self:
+        await message.edit(f"I can't {message.command[0]} myself.")
+        await asyncio.sleep(2)
+        await message.delete()
+    else:
+        return True
+
+    return False
+
+
+async def Timer(message: Message):
+    if len(message.command) > 1:
+        secs = IntervalHelper(message.command[1])
+        return int(str(time()).split(".")[0] + secs.to_secs()[0])
+    else:
+        return 0
+
+
+async def TimerString(message: Message):
+    secs = IntervalHelper(message.command[1])
+    return f"{secs.to_secs()[1]} {secs.to_secs()[2]}"
+
+
+async def RestrictFailed(message: Message):
+    await message.edit(f"I can't {message.command} this user.")
+    await asyncio.sleep(2)
+    await message.delete()

pixlib/Pix/helper/aiohttp_helper.py

@@ -0,0 +1,36 @@
+import json
+
+import aiohttp
+
+
+class AioHttp:
+    @staticmethod
+    async def get_json(link):
+        async with aiohttp.ClientSession() as session:
+            async with session.get(link) as resp:
+                return await resp.json()
+
+    @staticmethod
+    async def get_text(link):
+        async with aiohttp.ClientSession() as session:
+            async with session.get(link) as resp:
+                return await resp.text()
+
+    @staticmethod
+    async def get_json_from_text(link):
+        async with aiohttp.ClientSession() as session:
+            async with session.get(link) as resp:
+                text = await resp.text()
+                return json.loads(text)
+
+    @staticmethod
+    async def get_raw(link):
+        async with aiohttp.ClientSession() as session:
+            async with session.get(link) as resp:
+                return await resp.read()
+
+    @staticmethod
+    async def get_url(link):
+        async with aiohttp.ClientSession() as session:
+            async with session.get(link) as resp:
+                return resp.url

pixlib/Pix/helper/basic.py

@@ -0,0 +1,55 @@
+from pyrogram.types import Message
+
+
+def get_user(message: Message, text: str) -> [int, str, None]:
+    """Get User From Message"""
+    if text is None:
+        asplit = None
+    else:
+        asplit = text.split(" ", 1)
+    user_s = None
+    reason_ = None
+    if message.reply_to_message:
+        user_s = message.reply_to_message.from_user.id
+        reason_ = text if text else None
+    elif asplit is None:
+        return None, None
+    elif len(asplit[0]) > 0:
+        if message.entities:
+            if len(message.entities) == 1:
+                required_entity = message.entities[0]
+                if required_entity.type == "text_mention":
+                    user_s = int(required_entity.user.id)
+                else:
+                    user_s = int(asplit[0]) if asplit[0].isdigit() else asplit[0]
+        else:
+            user_s = int(asplit[0]) if asplit[0].isdigit() else asplit[0]
+        if len(asplit) == 2:
+            reason_ = asplit[1]
+    return user_s, reason_
+
+
+def get_text(message: Message) -> [None, str]:
+    """Extract Text From Commands"""
+    text_to_return = message.text
+    if message.text is None:
+        return None
+    if " " in text_to_return:
+        try:
+            return message.text.split(None, 1)[1]
+        except IndexError:
+            return None
+    else:
+        return None
+
+
+async def edit_or_reply(message: Message, *args, **kwargs) -> Message:
+    apa = (
+        message.edit_text
+        if bool(message.from_user and message.from_user.is_self or message.outgoing)
+        else (message.reply_to_message or message).reply_text
+    )
+    return await apa(*args, **kwargs)
+
+
+eor = edit_or_reply