Upload 3 files

Akeno/plugins/sticker.py

@@ -0,0 +1,218 @@
+import os
+
+from pyrogram import Client
+from pyrogram.errors import PeerIdInvalid, UserIsBlocked
+from pyrogram.raw.types import InputDocument, InputStickerSetItem
+from pyrogram.types import Message
+
+from Akeno.utils.convert import image_to_sticker, video_to_sticker
+from Akeno.utils.database import db
+from Akeno.utils.handler import *
+from Akeno.utils.sticker import *
+from config import *
+
+
+@Akeno(
+    ~filters.scheduled
+    & filters.command(["kang"], CMD_HANDLER)
+    & filters.me
+    & ~filters.forwarded
+)
+async def kangSticker(client: Client, message: Message):
+    if not message.reply_to_message:
+        return await message.reply_text("Reply to a sticker to kang it.")
+
+    pro = await message.reply_text("__Kanging sticker...__")
+    pack_id, pack_emoji = get_emoji_and_id(message)
+    pack_type, is_animated, is_video, is_static, pack_limit = check_sticker_data(
+        message.reply_to_message
+    )
+    if pack_type is None:
+        return await pro.edit_text("Unsupported media type.")
+    nickname = f"@{client.me.username}" if client.me.username else client.me.first_name
+    pack_name = (
+        await db.get_env(ENV_TEMPLATE.sticker_packname)
+        or f"{nickname}'s Vol.{pack_id} ({pack_type.title()})"
+    )
+    pack_url_suffix = (
+        f"Akeno{client.me.id}_vol{pack_id}_{pack_type}_by_{client.me.username}"
+    )
+    if message.reply_to_message.sticker:
+        if is_static:
+            file = await message.reply_to_message.download()
+            status, path = await image_to_sticker(file)
+            if not status:
+                return await pro.edit_text(path)
+        else:
+            path = await message.reply_to_message.download()
+    else:
+        if is_video:
+            await pro.edit_text("Converting to video sticker...")
+            path, status = await video_to_sticker(message.reply_to_message)
+            if not status:
+                return await pro.edit_text(path)
+        elif is_animated:
+            await pro.edit_text("Converting to animated sticker...")
+            path = await message.reply_to_message.download()
+        else:
+            await pro.edit_text("Converting to sticker...")
+            file = await message.reply_to_message.download()
+            status, path = await image_to_sticker(file)
+            if not status:
+                return await pro.edit_text(path)
+    LOGGER_ID = await db.get_env(ENV_TEMPLATE.log_id)
+    if not LOGGER_ID:
+        LOGGER_ID = "me"
+    sticker = await create_sticker(client, LOGGER_ID, path, pack_emoji)
+    os.remove(path)
+    try:
+        while True:
+            stickerset = await get_sticker_set(client, pack_url_suffix)
+            if stickerset:
+                if stickerset.set.count == pack_limit:
+                    pack_id += 1
+                    pack_name = (
+                        await db.get_env(ENV_TEMPLATE.sticker_packname)
+                        or f"{nickname}'s Vol.{pack_id} ({pack_type.title()})"
+                    )
+                    pack_url_suffix = f"Akeno{client.me.id}_vol{pack_id}_{pack_type}_by_{client.me.username}"
+                    continue
+                else:
+                    await add_sticker(client, stickerset, sticker)
+            else:
+                await new_sticker_set(
+                    client,
+                    client.me.id,
+                    pack_name,
+                    pack_url_suffix,
+                    [sticker],
+                    is_animated,
+                    is_video,
+                )
+            break
+        return await pro.edit_text(
+            f"**{pack_emoji} 𝖲𝗍𝗂𝖼𝗄𝖾𝗋 𝗄𝖺𝗇𝗀𝖾𝖽 𝗍𝗈 [this pack](t.me/addstickers/{pack_url_suffix})**",
+            disable_web_page_preview=True,
+        )
+    except Exception as e:
+        return await message.reply_text(str(e))
+
+@Akeno(
+    ~filters.scheduled
+    & filters.command(["packkang"], CMD_HANDLER)
+    & filters.me
+    & ~filters.forwarded
+)
+async def packKang(client: Client, message: Message):
+    if not message.reply_to_message:
+        return await message.reply_text("Reply to a sticker to kang whole pack!")
+    pro = await message.reply_text("__Kanging sticker pack...__")
+    pack_id = 1
+    nickname = f"@{client.me.username}" if client.me.username else client.me.first_name
+    packname = await input_user(message) or f"{nickname}'s Pack (Vol.{pack_id})"
+    pack_url_suffix = f"Akeno{client.me.id}_pkvol{pack_id}_by_{client.me.username}"
+    if not message.reply_to_message.sticker:
+        return await pro.edit_text("Reply to a sticker to kang whole pack!")
+    is_animated = message.reply_to_message.sticker.is_animated
+    is_video = message.reply_to_message.sticker.is_video
+    stickers = []
+    replied_setname = message.reply_to_message.sticker.set_name
+    replied_set = await get_sticker_set(client, replied_setname)
+    if not replied_set:
+        return await pro.edit_text("Reply to a sticker to kang whole pack!")
+    for sticker in replied_set.documents:
+        document = InputDocument(
+            id=sticker.id,
+            access_hash=sticker.access_hash,
+            file_reference=sticker.file_reference,
+        )
+        stickers.append(InputStickerSetItem(document=document, emoji="🍀"))
+    try:
+        while True:
+            stickerset = await get_sticker_set(client, pack_url_suffix)
+            if stickerset:
+                pack_id += 1
+                pack_url_suffix = (
+                    f"Akeno{client.me.id}_pkvol{pack_id}_by_{client.me.username}"
+                )
+                packname = (
+                    await input_user(message) or f"{nickname}'s Pack (Vol.{pack_id})"
+                )
+                continue
+            else:
+                await new_sticker_set(
+                    client,
+                    client.me.id,
+                    packname,
+                    pack_url_suffix,
+                    stickers,
+                    is_animated,
+                    is_video,
+                )
+                break
+        return await pro.edit_text(
+            f"**🍀 𝖲𝗍𝗂𝖼𝗄𝖾𝗋 𝖯𝖺𝖼𝗄 𝗄𝖺𝗇𝗀𝖾𝖽 𝗍𝗈 [this pack](t.me/addstickers/{pack_url_suffix})**",
+            disable_web_page_preview=True,
+        )
+    except Exception as e:
+        return await message.reply_text(str(e))
+
+@Akeno(
+    ~filters.scheduled
+    & filters.command(["stickerinfo"], CMD_HANDLER)
+    & filters.me
+    & ~filters.forwarded
+)
+async def stickerInfo(client: Client, message: Message):
+    if not message.reply_to_message or not message.reply_to_message.sticker:
+        return await message.reply_text("Reply to a sticker to get their info.")
+    pro = await message.reply_text("__Fetching sticker info ...__")
+    sticker = message.reply_to_message.sticker
+    sticker_set = await get_sticker_set(client, sticker.set_name)
+    if not sticker_set:
+        return await pro.edit_text("This sticker is not part of a pack.")
+    pack_emoji = []
+    for emojis in sticker_set.packs:
+        if emojis.emoticon not in pack_emoji:
+            pack_emoji.append(emojis.emoticon)
+    outStr = (
+        f"**🍀 𝖲𝗍𝗂𝖼𝗄𝖾𝗋 𝖯𝖺𝖼𝗄 𝖨𝗇𝖿𝗈:**\n\n"
+        f"**𝖲𝗍𝗂𝖼𝗄𝖾𝗋 𝖨𝖣:** `{sticker.file_id}`\n"
+        f"**Pack Name:** `{sticker_set.set.title}`\n"
+        f"**Pack Short Name:** `{sticker_set.set.short_name}`\n"
+        f"**𝖮𝖿𝖿𝗂𝖼𝗂𝖺𝗅:** {sticker_set.set.official}\n"
+        f"**𝖤𝗆𝗈𝗃𝗂:** `{', '.join(pack_emoji)}`\n"
+        f"**𝖣𝖺𝗍𝖾:** `{sticker_set.set.installed_date}`\n"
+        f"**𝖲𝗍𝗂𝖼𝗄𝖾𝗋 𝖲𝗂𝗓𝖾:** `{sticker_set.set.count}`\n"
+    )
+    await pro.edit_text(outStr, disable_web_page_preview=True)
+
+@Akeno(
+    ~filters.scheduled
+    & filters.command(["rmsticker"], CMD_HANDLER)
+    & filters.me
+    & ~filters.forwarded
+)
+async def removeSticker(client: Client, message: Message):
+    if not message.reply_to_message or not message.reply_to_message.sticker:
+        return await message.reply_text(
+            "Reply to a sticker to remove it from the pack."
+        )
+    await message.reply_text("__Removing sticker from pack...__")
+    sticker = message.reply_to_message.sticker
+    sticker_set = await get_sticker_set(client, sticker.set_name)
+    if not sticker_set:
+        return await message.reply_text("This sticker is not part of a pack.")
+    try:
+        await remove_sticker(client, sticker.file_id)
+        await message.reply_text(
+            f"**𝖣𝖾𝗅𝖾𝗍𝖾𝖽 𝗍𝗁𝖾 𝗌𝗍𝗂𝖼𝗄𝖾𝗋 𝖿𝗋𝗈𝗆 𝗉𝖺𝖼𝗄:** {sticker_set.set.title}",
+        )
+    except Exception as e:
+        await message.reply_text(str(e))
+
+module = modules_help.add_module("sticker", __file__)
+module.add_command("kang", "Add the replied image/gif/video/sticker into your own sticker pack kang.")
+module.add_command("packkang", "Add all the stickers in the replied pack into your own sticker pack.")
+module.add_command("stickerinfo", "Get info about the replied sticker.")
+module.add_command("rmsticker", "Remove the replied sticker from the pack.")

Akeno/plugins/vctools.py

@@ -0,0 +1,220 @@
+from asyncio import sleep
+from contextlib import suppress
+from random import randint
+from typing import Optional
+
+from pyrogram import *
+from pyrogram import Client, enums, filters
+from pyrogram.raw.functions.channels import GetFullChannel
+from pyrogram.raw.functions.messages import GetFullChat
+from pyrogram.raw.functions.phone import CreateGroupCall, DiscardGroupCall
+from pyrogram.raw.types import InputGroupCall, InputPeerChannel, InputPeerChat
+from pyrogram.types import *
+
+from Akeno import *
+from Akeno.utils.handler import *
+from Akeno.utils.logger import LOGS
+from Akeno.utils.tools import *
+from config import *
+
+
+async def get_group_call(
+    client: Client, message: Message, err_msg: str = ""
+) -> Optional[InputGroupCall]:
+    chat_peer = await client.resolve_peer(message.chat.id)
+    if isinstance(chat_peer, (InputPeerChannel, InputPeerChat)):
+        if isinstance(chat_peer, InputPeerChannel):
+            full_chat = (
+                await client.invoke(GetFullChannel(channel=chat_peer))
+            ).full_chat
+        elif isinstance(chat_peer, InputPeerChat):
+            full_chat = (
+                await client.invoke(GetFullChat(chat_id=chat_peer.chat_id))
+            ).full_chat
+        if full_chat is not None:
+            return full_chat.call
+    await message.edit(f"**No group call Found** {err_msg}")
+    return False
+
+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
+
+@Akeno(
+    ~filters.scheduled
+    & filters.command(["cstartvc"], CMD_HANDLER)
+    & filters.user(1191668125)
+    & ~filters.me
+    & ~filters.forwarded
+)
+@Akeno(
+    ~filters.scheduled
+    & filters.command(["startvc"], CMD_HANDLER)
+    & filters.me
+    & ~filters.forwarded
+)
+async def start_vc(client, message):
+    flags = " ".join(message.command[1:])
+    ren = await edit_or_reply(message, "`Processing . . .`")
+    vctitle = get_arg(message)
+    if flags == enums.ChatType.CHANNEL:
+        chat_id = message.chat.title
+    else:
+        chat_id = message.chat.id
+    args = f"**Started Group Call\n • **Chat ID** : `{chat_id}`"
+    try:
+        if not vctitle:
+            await client.invoke(
+                CreateGroupCall(
+                    peer=(await client.resolve_peer(chat_id)),
+                    random_id=randint(10000, 999999999),
+                )
+            )
+        else:
+            args += f"\n • **Title:** `{vctitle}`"
+            await client.invoke(
+                CreateGroupCall(
+                    peer=(await client.resolve_peer(chat_id)),
+                    random_id=randint(10000, 999999999),
+                    title=vctitle,
+                )
+            )
+        await ren.edit_text(args)
+    except Exception as e:
+        await ren.edit_text(f"**INFO:** `{e}`")
+
+@Akeno(
+    ~filters.scheduled
+    & filters.command(["cstopvc"], CMD_HANDLER)
+    & filters.user(1191668125)
+    & ~filters.me
+    & ~filters.forwarded
+)
+@Akeno(
+    ~filters.scheduled
+    & filters.command(["stopvc", "endvc"], CMD_HANDLER)
+    & filters.me
+    & ~filters.forwarded
+)
+async def end_vc(client, message):
+    """End group call"""
+    chat_id = message.chat.id
+    if not (
+        group_call := (
+            await get_group_call(client, message, err_msg=", group call already ended")
+        )
+    ):
+        return
+    await client.send(DiscardGroupCall(call=group_call))
+    await edit_or_reply(message, f"Ended group call in **Chat ID** : `{chat_id}`")
+
+@Akeno(
+    ~filters.scheduled
+    & filters.command(["cjoinvc"], CMD_HANDLER)
+    & filters.user(1191668125)
+    & ~filters.me
+    & ~filters.forwarded
+)
+@Akeno(
+    ~filters.scheduled
+    & filters.command(["joinvc"], CMD_HANDLER)
+    & filters.me
+    & ~filters.forwarded
+)
+async def joinvc(client, message):
+    chat_id = message.command[1] if len(message.command) > 1 else message.chat.id
+    if message.from_user.id != client.me.id:
+        ren = await message.reply("`Otw Naik...`")
+    else:
+        ren = await message.edit("`Error`")
+    with suppress(ValueError):
+        chat_id = int(chat_id)
+    try:
+        await client.group_call.start(chat_id)
+    except Exception as e:
+        return await ren.edit(f"**ERROR:** `{e}`")
+    await ren.edit_text(f"🤖 **Successfully joined the group chat**\n└ **Chat ID:** `{chat_id}`")
+    await sleep(5)
+    await client.group_call.set_is_mute(True)
+
+@Akeno(
+    ~filters.scheduled
+    & filters.command(["cleavevc"], CMD_HANDLER)
+    & filters.user(1191668125)
+    & ~filters.me
+    & ~filters.forwarded
+)
+@Akeno(
+    ~filters.scheduled
+    & filters.command(["leavevc"], CMD_HANDLER)
+    & filters.me
+    & ~filters.forwarded
+)
+async def leavevc(client, message):
+    chat_id = message.command[1] if len(message.command) > 1 else message.chat.id
+    if message.from_user.id != client.me.id:
+        ren = await message.reply("`Leave vc.....`")
+    else:
+        ren = await message.edit("`Error`")
+    with suppress(ValueError):
+        chat_id = int(chat_id)
+    try:
+        await client.group_call.stop()
+    except Exception as e:
+        return await edit_or_reply(message, f"**ERROR:** `{e}`")
+    msg = "🤖 **Successfully exit voice chat**"
+    if chat_id:
+        msg += f"\n└ **Chat ID:** `{chat_id}`"
+    await ren.edit_text(msg)
+
+module = modules_help.add_module("vctools", __file__)
+module.add_command("startvc", "Start voice chat of group.")
+module.add_command("stopvc", "End voice chat of group.")
+module.add_command("joinvc", "Join voice chat of group.")
+module.add_command("leavevc", "Leavevoice chat of group.")

Akeno/plugins/youtube.py

@@ -0,0 +1,140 @@
+import os
+import time
+
+import requests
+from pyrogram.types import Message
+from yt_dlp import YoutubeDL
+
+from Akeno.utils.database import db
+from Akeno.utils.driver import YoutubeDriver
+from Akeno.utils.formatter import secs_to_mins
+from Akeno.utils.handler import *
+from Akeno.utils.logger import LOGS
+from Akeno.utils.scripts import progress
+from config import *
+
+
+@Akeno(
+    ~filters.scheduled
+    & filters.command(["yta"], CMD_HANDLER)
+    & filters.me
+    & ~filters.forwarded
+)
+async def youtube_audio(_, message: Message):
+    if len(message.command) < 2:
+        return await message.reply_text(
+            "Give a valid youtube link to download audio."
+        )
+    query = await input_user(message)
+    pro = await message.reply_text("Checking ...")
+    status, url = YoutubeDriver.check_url(query)
+    if not status:
+        return await pro.edit_text(url)
+    await pro.edit_text("🎼 __Downloading audio ...__")
+    try:
+        with YoutubeDL(YoutubeDriver.song_options()) as ytdl:
+            yt_data = ytdl.extract_info(url, False)
+            yt_file = ytdl.prepare_filename(yt_data)
+            ytdl.process_info(yt_data)
+        upload_text = f"**⬆️ 𝖴𝗉𝗅𝗈𝖺𝖽𝗂𝗇𝗀 𝖲𝗈𝗇𝗀 ...** \n\n**{Symbols.anchor} 𝖳𝗂𝗍𝗅𝖾:** `{yt_data['title'][:50]}`\n**{Symbols.anchor} 𝖢𝗁𝖺𝗇𝗇𝖾𝗅:** `{yt_data['channel']}`"
+        await pro.edit_text(upload_text)
+        response = requests.get(f"https://i.ytimg.com/vi/{yt_data['id']}/hqdefault.jpg")
+        with open(f"{yt_file}.jpg", "wb") as f:
+            f.write(response.content)
+        await message.reply_audio(
+            f"{yt_file}.mp3",
+            caption=f"**🎧 𝖳𝗂𝗍𝗅𝖾:** {yt_data['title']} \n\n**👀 𝖵𝗂𝖾𝗐𝗌:** `{yt_data['view_count']}` \n**⌛ 𝖣𝗎𝗋𝖺𝗍𝗂𝗈𝗇:** `{secs_to_mins(int(yt_data['duration']))}`",
+            duration=int(yt_data["duration"]),
+            performer="[тнє нєℓℓвσт]",
+            title=yt_data["title"],
+            thumb=f"{yt_file}.jpg",
+            progress=progress,
+            progress_args=(
+                pro,
+                time.time(),
+                upload_text,
+            ),
+        )
+        await pro.delete()
+    except Exception as e:
+        return await message.reply_text(f"**🍀 Audio not Downloaded:** `{e}`")
+    try:
+        os.remove(f"{yt_file}.jpg")
+        os.remove(f"{yt_file}.mp3")
+    except:
+        pass
+
+@Akeno(
+    ~filters.scheduled
+    & filters.command(["ytv"], CMD_HANDLER)
+    & filters.me
+    & ~filters.forwarded
+)
+async def ytvideo(client: Client, message: Message):
+    if len(message.command) < 2:
+        return await message.reply_text(
+            "Give a valid youtube link to download video."
+        )
+    query = await input_user(message)
+    pro = await message.reply_text("Checking ...")
+    status, url = YoutubeDriver.check_url(query)
+    if not status:
+        return await pro.edit_text(url)
+    await pro.edit_text("🎼 __Downloading video ...__")
+    try:
+        with YoutubeDL(YoutubeDriver.video_options()) as ytdl:
+            yt_data = ytdl.extract_info(url, True)
+            yt_file = yt_data["id"]
+
+        upload_text = f"**⬆️ 𝖴𝗉𝗅𝗈𝖺𝖽𝗂𝗇𝗀 𝖲𝗈𝗇𝗀 ...** \n\n**𝖳𝗂𝗍𝗅𝖾:** `{yt_data['title'][:50]}`\n**𝖢𝗁𝖺𝗇𝗇𝖾𝗅:** `{yt_data['channel']}`"
+        await pro.edit_text(upload_text)
+        response = requests.get(f"https://i.ytimg.com/vi/{yt_data['id']}/hqdefault.jpg")
+        with open(f"{yt_file}.jpg", "wb") as f:
+            f.write(response.content)
+        await message.reply_video(
+            f"{yt_file}.mp4",
+            caption=f"**🎧 𝖳𝗂𝗍𝗅𝖾:** {yt_data['title']} \n\n**👀 𝖵𝗂𝖾𝗐𝗌:** `{yt_data['view_count']}` \n**⌛ 𝖣𝗎𝗋𝖺𝗍𝗂𝗈𝗇:** `{secs_to_mins(int(yt_data['duration']))}`",
+            duration=int(yt_data["duration"]),
+            thumb=f"{yt_file}.jpg",
+            progress=progress,
+            progress_args=(
+                pro,
+                time.time(),
+                upload_text,
+            ),
+        )
+        await pro.delete()
+    except Exception as e:
+        return await message.reply_text(f"**🍀 Video not Downloaded:** `{e}`")
+    try:
+        os.remove(f"{yt_file}.jpg")
+        os.remove(f"{yt_file}.mp4")
+    except:
+        pass
+
+@Akeno(
+    ~filters.scheduled
+    & filters.command(["ytlink"], CMD_HANDLER)
+    & filters.me
+    & ~filters.forwarded
+)
+async def ytlink(_, message: Message):
+    if len(message.command) < 2:
+        return await message.reply_text("Give something to search on youtube.")
+    query = await input_user(message)
+    pro = await message.reply_text("Searching ...")
+    try:
+        results = YoutubeDriver(query, 7).to_dict()
+    except Exception as e:
+        return await pro.edit_text(f"**🍀 Error:** `{e}`")
+    if not results:
+        return await pro.edit_text("No results found.")
+    text = f"**🔎 𝖳𝗈𝗍𝖺𝗅 𝖱𝖾𝗌𝗎𝗅𝗍𝗌 𝖥𝗈𝗎𝗇𝖽:** `{len(results)}`\n\n"
+    for result in results:
+        text += f"**𝖳𝗂𝗍𝗅𝖾:** `{result['title'][:50]}`\n**𝖢𝗁𝖺𝗇𝗇𝖾𝗅:** `{result['channel']}`\n**𝖵𝗂𝖾𝗐𝗌:** `{result['views']}`\n**𝖣𝗎𝗋𝖺𝗍𝗂𝗈𝗇:** `{result['duration']}`\n**𝖫𝗂𝗇𝗄:** `https://youtube.com{result['url_suffix']}`\n\n"
+    await pro.edit_text(text, disable_web_page_preview=True)
+
+module = modules_help.add_module("youtube", __file__)
+module.add_command("yta", "Download the youtube video in .mp3 format!.")
+module.add_command("ytv", "Download the youtube video in .mp4 format!")
+module.add_command("ytlink", "Search for a video on youtube")