Upload 4 files

Akeno/plugins/alive.py

@@ -1,16 +1,17 @@
-import random
+import asyncio
 import os
+import random
 import time
-import asyncio
+
+from pyrogram import *
 from pyrogram import Client, filters
 from pyrogram.types import *
-from pyrogram import *
-from Akeno.utils.images import generate_alive_image
-from Akeno.utils.handler import *
-from Akeno.utils.database import db
+
+from Akeno import StartTime, __version__
 from Akeno.plugins.ping import get_readable_time
-from Akeno import __version__
-from Akeno import StartTime
+from Akeno.utils.database import db
+from Akeno.utils.handler import *
+from Akeno.utils.images import generate_alive_image
 from config import *
 
 FONT_PATH = "resources/fonts/Montserrat.ttf"
@@ -53,23 +54,7 @@ async def alive(client: Client, message: Message):
     pro = await message.reply_text("Processing ...")
     img = await db.get_env(ENV_TEMPLATE.alive_pic)
     if not img:
-        if message.from_user.photo:
-            user_pfp = await client.download_media(message.from_user.photo.big_file_id)
-            del_path = True
-        else:
-            user_pfp = "resources/images/logo.png"
-            del_path = False
-        img = [
-            generate_alive_image(
-                message.from_user.first_name,
-                user_pfp,
-                del_path,
-                FONT_PATH
-            )
-        ]
-    else:
-        img = img.split(" ")
-    img = random.choice(img)
+        img = "https://telegra.ph/file/316e8e52a723e06d59bbf.jpg"
     uptime = get_readable_time(time.time() - StartTime)
     caption = await alive_template(client.me.first_name, uptime)
     if img.endswith(".mp4"):
@@ -77,7 +62,11 @@ async def alive(client: Client, message: Message):
     else:
         await message.reply_photo(img, caption=caption)
     await pro.delete()
-    try:
-        os.remove(img)
-    except:
-        pass
+    if os.path.exists(img):
+        try:
+            os.remove(img)
+        except:
+            pass
+
+module = modules_help.add_module("alive", __file__)
+module.add_command("alive", "Get the alive message of the bot.")

Akeno/plugins/logger.py

@@ -0,0 +1,42 @@
+import asyncio
+import os
+import random
+import time
+import datetime
+from pyrogram import *
+from pyrogram import Client, filters
+from pyrogram.types import *
+
+from Akeno.utils.database import db
+from Akeno.utils.handler import *
+from Akeno.utils.logger import LOGS
+from config import *
+
+@Akeno(filters.incoming & filters.group & filters.mentioned & ~filters.service)
+async def tag_logger(client: Client, message: Message):
+    tag_gc = await db.get_env(ENV_TEMPLATE.tag_logger)
+    if not tag_gc:
+        return
+    if message.from_user.is_bot:
+        return
+    if not message.mentioned:
+        return
+    msg = await message.forward(int(tag_gc), True)
+    await client.send_message(
+        int(tag_gc),
+        f"{message.from_user.mention} **tagged** {client.me.mention} **in** {message.chat.title} (`{message.chat.id}`) Go to {message.link}",
+        disable_web_page_preview=True,
+        reply_to_message_id=msg.id
+    )
+
+@Akeno(filters.incoming & filters.private & ~filters.bot & ~filters.service)
+async def pm_logger(client: Client, message: Message):
+    if message.from_user.id == 777000:
+        return
+    logger = await db.get_env(ENV_TEMPLATE.pm_logger)
+    try:
+        if logger:
+            if message.chat.id != client.me.id:
+                await message.forward(int(logger), True)
+    except Exception as e:
+        LOGS.warning(f"PM Logger Err: {e}")

Akeno/plugins/ping.py

@@ -1,6 +1,6 @@
 import asyncio
-import time
 import random
+import time
 from datetime import datetime as dt
 
 from pyrogram import Client, filters
@@ -8,10 +8,11 @@ from pyrogram.types import *
 from pyrogram.types import Message
 
 from Akeno import StartTime
-from Akeno.utils.handler import *
 from Akeno.utils.database import db
+from Akeno.utils.handler import *
 from config import *
 
+
 def get_readable_time(seconds: int) -> str:
     count = 0
     readable_time = ""
@@ -37,11 +38,11 @@ def get_readable_time(seconds: int) -> str:
     return readable_time
 
 PING_TEMPLATES = [
-    """**Ping !!**
-
-    🔷  **Speed:** {speed} m/s
-    🔷  **Uptime:** {uptime}
-    🔷  **Onwer:** {owner}""",
+"""
+🔷  **Speed:** {speed} m/s
+🔷  **Uptime:** {uptime}
+🔷  **Onwer:** {owner}
+""",
 ]
 
 async def ping_template(speed: float, uptime: str, owner: str) -> str:

Akeno/plugins/quote.py

@@ -0,0 +1,120 @@
+import asyncio
+import os
+import random
+import time
+import datetime
+import base64
+import requests
+from pyrogram import *
+from pyrogram import Client, filters
+from pyrogram.types import *
+
+from Akeno.utils.database import db
+from Akeno.utils.handler import *
+from Akeno.utils.logger import LOGS
+from config import *
+
+def generate_quote(messages: list[dict]) -> tuple[bool, str]:
+    json = {
+        "type": "quote",
+        "format": "webp",
+        "backgroundColor": "#260746/#6100c2",
+        "width": 512,
+        "height": 768,
+        "scale": 2,
+        "messages": messages,
+    }
+    try:
+        response = requests.post("https://bot.lyo.su/quote/generate", json=json).json()
+        image = base64.b64decode(str(response["result"]["image"]).encode("utf-8"))
+        file_name = f"Quote_{int(time.time())}.webp"
+        with open(file_name, "wb") as f:
+            f.write(image)
+        return True, file_name
+    except Exception as e:
+        return False, str(e)
+
+def get_entities(message: Message) -> list[dict]:
+    entities = []
+    if message.entities:
+        for entity in message.entities:
+            entities.append(
+                {
+                    "type": entity.type.name.lower(),
+                    "offset": entity.offset,
+                    "length": entity.length,
+                }
+            )
+
+    return entities
+
+@Akeno(
+    ~filters.scheduled
+    & filters.command(["q"], CMD_HANDLER)
+    & filters.me
+    & ~filters.forwarded
+)
+async def quotely(client: Client, message: Message):
+    if not message.reply_to_message:
+        return await message.reply_text("Reply to a message to quote it.")
+    if message.reply_to_message.media:
+        if message.reply_to_message.caption:
+            message.reply_to_message.text = message.reply_to_message.caption
+        else:
+            return await message.reply_text("Reply to a text message to quote it.")
+    cmd = None
+    if len(message.command) > 1:
+        cmd = message.command[1].lower()
+    pro = await message.reply_text("__Generating quote...__")
+    msg_data = []
+    if cmd and cmd == "r":
+        await pro.edit_text("__Generating quote with reply...__")
+        reply_msg_id = message.reply_to_message.reply_to_message_id
+        if reply_msg_id:
+            reply_msg = await client.get_messages(message.chat.id, reply_msg_id)
+            if reply_msg and reply_msg.text:
+                replied_name = reply_msg.from_user.first_name
+                if reply_msg.from_user.last_name:
+                    replied_name += f" {reply_msg.from_user.last_name}"
+                reply_message = {
+                    "chatId": reply_msg.from_user.id,
+                    "entities": get_entities(reply_msg),
+                    "name": replied_name,
+                    "text": reply_msg.text,
+                }
+            else:
+                reply_message = {}
+        else:
+            reply_message = {}
+    else:
+        reply_message = {}
+
+    name = message.reply_to_message.from_user.first_name
+    if message.reply_to_message.from_user.last_name:
+        name += f" {message.reply_to_message.from_user.last_name}"
+    emoji_status = None
+    if message.reply_to_message.from_user.emoji_status:
+        emoji_status = str(message.reply_to_message.from_user.emoji_status.custom_emoji_id)
+    msg_data.append(
+        {
+            "entities": get_entities(message.reply_to_message),
+            "avatar": True,
+            "from": {
+                "id": message.reply_to_message.from_user.id,
+                "name": name,
+                "emoji_status": emoji_status,
+            },
+            "text": message.reply_to_message.text,
+            "replyMessage": reply_message,
+        }
+    )
+    status, path = generate_quote(msg_data)
+    if not status:
+        return await message.reply_text(f"`{path}`")
+    await message.reply_sticker(path)
+    await pro.delete()
+    os.remove(path)
+
+module = modules_help.add_module("quote", __file__)
+module.add_command("q", "Generate a quote sticker of the replied message.")
+module.add_command("q r", "Generate a quote sticker of the replied message with it's reply message.")