Upload 4 files

Akeno/plugins/chatgpt.py

@@ -0,0 +1,113 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright 2020-2024 (c) Randy W @xtdevs, @xtsea
+#
+# from : https://github.com/TeamKillerX
+# Channel : @RendyProjects
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+from pyrogram import Client, filters
+from pyrogram.types import *
+from pyrogram import *
+from config import GOOGLE_API_KEY, CMD_HANDLER
+
+from Akeno.utils.logger import LOGS
+from Akeno.utils.handler import Akeno
+from Akeno.utils.chat import chat_message
+from RyuzakiLib import RendyDevChat, FullStackDev, GeminiLatest
+
+@Akeno(
+    ~filters.scheduled
+    & filters.command(["askf"], CMD_HANDLER)
+    & filters.me
+    & ~filters.forwarded
+)
+async def googlegm(client: Client, message: Message):
+    if not message.reply_to_message:
+        await message.reply_text("Please reply to message photo")
+        return
+    user_message = message.reply_to_message
+    caption = user_message.caption or "What's this?"
+    if not user_message.photo:
+        await message.reply_text("Not allowed text")
+        return
+    try:
+        replys = await message.reply_text("Prossing.....")
+        if user_message.photo:
+            file_path = await user_message.download()
+        if not GOOGLE_API_KEY:
+            return await replys.edit_text("Required .env `GOOGLE_API_KEY`")
+        x = GeminiLatest(api_keys=GOOGLE_API_KEY)
+        response = x.get_response_image(caption, file_path)
+        await replys.edit_text(response)
+        return
+    except Exception as e:
+        LOGS.error(str(e))
+        await replys.edit_text(str(e))
+        return
+
+@Akeno(
+    ~filters.scheduled
+    & filters.command(["askm"], CMD_HANDLER)
+    & filters.me
+    & ~filters.forwarded
+)
+async def chatgpt_images(client: Client, message: Message):
+    question = message.text.split(" ", 1)[1] if len(message.command) > 1 else None
+    if not question:
+        return await message.reply_text("Give ask from CHATGPT images")
+    try:
+        replys = await message.reply_text("Prossing.....")
+        response = await RendyDevChat.image_generator(question)
+        x = response["randydev"].get("url")
+        for i, url in enumerate(x, start=1):
+            await FullStackDev.fast(url, filename=f"original_{i}.png")
+        await message.reply_media_group(
+            [
+                InputMediaPhoto(f"original_1.png"),
+                InputMediaPhoto(f"original_2.png"),
+                InputMediaPhoto(f"original_3.png"),
+                InputMediaPhoto(f"original_4.png")
+            ],
+        )
+        await replys.delete()
+    except Exception as e:
+        LOGS.error(str(e))
+        return await message.reply_text(str(e))
+
+@Akeno(
+    ~filters.scheduled
+    & filters.command(["ask"], CMD_HANDLER)
+    & filters.me
+    & ~filters.forwarded
+)
+async def chatgpt(client: Client, message: Message):
+    question = message.text.split(" ", 1)[1] if len(message.command) > 1 else None
+    if not question:
+        return await message.reply_text("Give ask from CHATGPT")
+    try:
+        messager = await chat_message(question)
+        if len(messager) > 4096:
+            with open("chat.txt", "w+", encoding="utf8") as out_file:
+                out_file.write(messager)
+            await message.reply_document(
+                document="chat.txt",
+                disable_notification=True
+            )
+            os.remove("chat.txt")
+        else:
+            await message.reply_text(messager)
+    except Exception as e:
+        LOGS.error(str(e))
+        return await message.reply_text(str(e))

Akeno/plugins/gban.py

@@ -0,0 +1,142 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright 2020-2024 (c) Randy W @xtdevs, @xtsea
+#
+# from : https://github.com/TeamKillerX
+# Channel : @RendyProjects
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# Credits Developer by @xtdevs
+# NO NEED DATABASE USING API REST DB
+
+import asyncio
+from pyrogram import Client, filters
+from pyrogram.types import Message
+from pyrogram import errors, filters
+from pyrogram import *
+from pyrogram.types import *
+from pyrogram.enums import ChatType, ChatMemberStatus as CMS
+from pyrogram.errors import FloodWait
+from pyrogram.errors import ChannelInvalid
+from pyrogram.types import ChatPermissions, Message
+from pyrogram.raw.functions.messages import DeleteHistory
+from Akeno.utils.tools import get_ub_chats
+from Akeno.utils.spamwatch import auto_post_gban, auto_check_gban
+from Akeno.utils.handler import Akeno, Akeno_chat_member_updated
+from config import FEDBAN_API_KEY, CMD_HANDLER
+
+async def input_user(message: Message) -> str:
+    """Get the input from the user"""
+    if len(message.command) < 2:
+        output = ""
+    else:
+        try:
+            output = message.text.split(" ", 1)[1].strip() or ""
+        except IndexError:
+            output = ""
+    return output
+
+@Akeno(
+    ~filters.scheduled & filters.command(["gban"], CMD_HANDLER) & filters.me & ~filters.forwarded
+)
+async def globalban(client: Client, message: Message):
+    if not message.reply_to_message:
+        if len(message.command) < 2:
+            return await message.reply_text(
+                "Reply to a user or pass a username/id to gban."
+            )
+        try:
+            user = await client.get_users(message.command[1])
+        except Exception as e:
+            return await message.reply_text(f"`{str(e)}`")
+        reason = (
+            message.text.split(None, 2)[2]
+            if len(message.text.split()) > 2
+            else "No reason provided."
+        )
+    else:
+        user = message.reply_to_message.from_user
+        reason = await input_user(message) or "No reason provided."
+    if user.is_self:
+        return await message.reply_text("I can't gban myself.")
+    if user.id == client.me.id:
+        return await message.reply_text("I can't gban my auth user.")
+    success = 0
+    failed = 0
+    pro = await message.reply_text(f"Gban initiated on {user.mention}...")
+    if not FEDBAN_API_KEY:
+        return await pro.edit_text("Required `FEDBAN_API_KEY` from @randydev_bot use /getapikey")
+    is_banned, get_message = await auto_post_gban(user.id, reason)
+    if is_banned == True:
+        async for dialog in client.get_dialogs():
+            if dialog.chat.type in [
+                ChatType.CHANNEL,
+                ChatType.GROUP,
+                ChatType.SUPERGROUP,
+            ]:
+                try:
+                    await dialog.chat.ban_member(user.id)
+                    success += 1
+                except FloodWait as e:
+                    await pro.edit_text(
+                        f"Gban initiated on {user.mention}...\nSleeping for {e.x} seconds due to floodwait..."
+                    )
+                    await asyncio.sleep(e.x)
+                    await dialog.chat.ban_member(user.id)
+                    success += 1
+                    await pro.edit_text(f"Gban initiated on {user.mention}...")
+                except BaseException:
+                    failed += 1
+        messager = ""
+        messager += get_message
+        messager += f"\n\nSuccess: {success}\n"
+        messager += f"Failed: {failed}\n"
+        await pro.edit_text(messager)
+
+@Akeno_chat_member_updated
+async def globalbanwatcher(_, u: ChatMemberUpdated):
+    if not (member.new_chat_member and member.new_chat_member.status not in {CMS.BANNED, CMS.LEFT, CMS.RESTRICTED} and not member.old_chat_member):
+        return
+    user = member.new_chat_member.user if member.new_chat_member else member.from_user
+    response = await auto_check_gban(user.id)
+    if response[0] == True:
+        watchertext = f"**𝖦𝖻𝖺𝗇𝗇𝖾𝖽 𝖴𝗌𝖾𝗋 𝗃𝗈𝗂𝗇𝖾𝖽 𝗍𝗁𝖾 𝖼𝗁𝖺𝗍! \n\n𝖦𝖻𝖺𝗇 𝖱𝖾𝖺𝗌𝗈𝗇 𝗐𝖺𝗌:** __{response[1]}__\n\n"
+        try:
+            await _.ban_chat_member(u.chat.id, user.id)
+            watchertext += f"**𝖲𝗈𝗋𝗋𝗒 𝖨 𝖼𝖺𝗇'𝗍 𝗌𝖾𝖾 𝗒𝗈𝗎 𝗂𝗇 𝗍𝗁𝗂𝗌 𝖼𝗁𝖺��!**"
+        except BaseException:
+            watchertext += f"Reported to @admins"
+        await _.send_message(u.chat.id, watchertext)
+    return
+
+@Akeno(
+    filters.private
+    & filters.incoming
+    & ~filters.service
+    & ~filters.me
+    & ~filters.bot
+)
+async def global_spammer(client: Client, message: Message):
+    if not message or not message.from_user:
+        return
+    user_id = message.from_user.id
+    response = await auto_check_gban(user_id)
+    if response[0] == True:
+        if message.photo:
+            await message.delete()
+        elif message.video:
+            await message.delete()
+        else:
+            await client.block_user(user_id)
+    message.continue_propagation()

Akeno/plugins/imageai.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright 2020-2024 (c) Randy W @xtdevs, @xtsea
+#
+# from : https://github.com/TeamKillerX
+# Channel : @RendyProjects
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+import requests
+import io
+from PIL import Image
+from pyrogram import Client, filters
+from pyrogram.types import *
+from pyrogram import *
+
+from Akeno.utils.logger import LOGS
+from Akeno.utils.handler import Akeno
+from config import HUGGING_TOKEN, CMD_HANDLER
+
+async def schellwithflux(args):
+    API_URL = "https://api-inference.huggingface.co/models/black-forest-labs/FLUX.1-schnell"
+    headers = {"Authorization": f"Bearer {HUGGING_TOKEN}"}
+    payload = {"inputs": args}
+    response = requests.post(API_URL, headers=headers, json=payload)
+    if not response.status_code != 200:
+        LOGS.error(f"Error status {response.status_code}")
+        return "Error Response"
+    return response.content
+
+@Akeno(
+    ~filters.scheduled
+    & filters.command(["fluxai"], CMD_HANDLER)
+    & filters.me
+    & ~filters.forwarded
+)
+async def fluxai(client: Client, message: Message):
+    question = message.text.split(" ", 1)[1] if len(message.command) > 1 else None
+    if not question:
+        return await message.reply_text("Give ask from Flux")
+    try:
+        if not HUGGING_TOKEN:
+            return await message.reply_text("Required `HUGGING_TOKEN`")
+        image_bytes = await schellwithflux(question)
+        pro = await message.reply_text("Image Generator wait...")
+        image = Image.open(io.BytesIO(image_bytes))
+        if image:
+            image.save("testing.jpg")
+            ok = await pro.edit_text("Uploading......")
+        await message.reply_photo("testing.jpg")
+        await ok.delete()
+    except Exception as e:
+        LOGS.error(str(e))
+        await pro.edit_text(str(e))

Akeno/plugins/ping.py

@@ -0,0 +1,49 @@
+import time
+import asyncio
+from pyrogram import Client, filters
+from datetime import datetime as dt
+from Akeno import StartTime
+from Akeno.utils.handler import Akeno
+from datetime import datetime as dt
+from config import CMD_HANDLER
+
+def get_readable_time(seconds: int) -> str:
+    count = 0
+    readable_time = ""
+    time_list = []
+    time_suffix_list = ["s", "m", "h", "days"]
+
+    while count < 4:
+        count += 1
+        remainder, result = divmod(seconds, 60) if count < 3 else divmod(seconds, 24)
+        if seconds == 0 and remainder == 0:
+            break
+        time_list.append(int(result))
+        seconds = int(remainder)
+
+    for x in range(len(time_list)):
+        time_list[x] = str(time_list[x]) + time_suffix_list[x]
+    if len(time_list) == 4:
+        readable_time += f"{time_list.pop()}, "
+
+    time_list.reverse()
+    readable_time += ":".join(time_list)
+
+    return readable_time
+
+@Akeno(
+    ~filters.scheduled
+    & filters.command(["ping"], CMD_HANDLER)
+    & filters.me
+    & ~filters.forwarded
+)
+async def custom_ping_handler(client: Client, message: Message):
+    uptime = get_readable_time((time.time() - StartTime))
+    start = dt.now()
+    lol = await message.reply_text("**Pong!!**")
+    await asyncio.sleep(1.5)
+    end = dt.now()
+    duration = (end - start).microseconds / 1000
+    await lol.edit_text(
+        f" **Pong !!** " f"`%sms` \n" f" **Uptime** - " f"`{uptime}` " % (duration)
+    )