yasirarism/MissKatyPyro
1
0
Fork 0
mirror of https://github.com/yasirarism/MissKatyPyro.git synced 2026-01-03 11:04:51 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Try fix some error

Browse source
This commit is contained in:
yasir 2023-02-01 20:58:54 +07:00
parent b6d5f54c18
commit b9c3852098
24 changed files with 226 additions and 198 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
database/__init__.py
View file

@ -9,5 +9,14 @@ from motor.motor_asyncio import AsyncIOMotorClient as MongoClient
from misskaty.vars import DATABASE_URI from misskaty.vars import DATABASE_URI
from .afk_db import *
from .filters_db import *
from .imdb_db import *
from .karma_db import *
from .notes_db import *
from .sangmata_db import *
from .users_chats_db import *
from .warn_db import *
mongo = MongoClient(DATABASE_URI) mongo = MongoClient(DATABASE_URI)
dbname = mongo.MissKatyDB dbname = mongo.MissKatyDB

1
misskaty/__init__.py
View file

@ -15,7 +15,6 @@ getLogger("pyrogram").setLevel(ERROR)
MOD_LOAD = [] MOD_LOAD = []
MOD_NOLOAD = [] MOD_NOLOAD = []
HELPABLE = {} HELPABLE = {}
DL_TASK = {}
cleanmode = {} cleanmode = {}
botStartTime = time.time() botStartTime = time.time()

3
misskaty/core/decorator/errors.py
View file

@ -42,8 +42,7 @@ def capture_err(func):
try: try:
return await func(client, message, *args, **kwargs) return await func(client, message, *args, **kwargs)
except ChatWriteForbidden: except ChatWriteForbidden:
await app.leave_chat(message.chat.id) return await app.leave_chat(message.chat.id)
return
except Exception as err: except Exception as err:
exc = traceback.format_exc() exc = traceback.format_exc()
error_feedback = split_limits( error_feedback = split_limits(

38
misskaty/core/decorator/pyro_cooldown.py Normal file
View file

@ -0,0 +1,38 @@
from pyrogram import filters
from datetime import datetime
import datetime as dtime
import asyncio, time
data = {}
async def task(msg, warn = False, sec = None):
try:await msg.delete()
except:pass
if warn:
user = msg.from_user
ids = await msg.reply(f"Sorry {user.mention}, you're in cooldown now, wait for {sec}s to use command again..")
await asyncio.sleep(sec)
await ids.edit(f"Alright {user.mention}, your cooldown is over you can command again.")
await asyncio.sleep(1)
await ids.delete()
def wait(sec):
async def ___(flt, cli, msg):
user_id = msg.from_user.id
if user_id in data:
if msg.date >= data[user_id]['timestamp'] + flt.data:
data[user_id] = {'timestamp' : msg.date, 'warned' : False}
return True
else:
if not data[user_id]['warned']:
data[user_id]['warned'] = True
asyncio.ensure_future(task(msg, True, flt.data)) # for super accuracy use (future - time.time())
return False # cause we dont need delete again
asyncio.ensure_future(task(msg))
return False
else:
data.update({user_id : {'timestamp' : msg.date, 'warned' : False}})
return True
return filters.create(___, data=sec)

15
misskaty/helper/__init__.py
View file

@ -1,2 +1,13 @@
from .misc import paginate_modules from .ffmpeg_helper import *
from .tools import bot_sys_stats from .files import *
from .functions import *
from .http import *
from .human_read import *
from .kuso_utils import *
from .media_helper import *
from .misc import *
from .pyro_progress import *
from .stickerset import *
from .time_gap import *
from .tools import *
from .ytdl_helper import *

1
misskaty/helper/tools.py
View file

@ -2,7 +2,6 @@ import os
import random import random
import string import string
import time import time
import json
import logging import logging
from http.cookies import SimpleCookie from http.cookies import SimpleCookie
from urllib.parse import urlparse from urllib.parse import urlparse

34
misskaty/plugins/admin.py
View file

@ -71,7 +71,7 @@ async def admin_cache_func(_, cmu):
# Purge CMD # Purge CMD
@app.on_message(filters.command("purge", COMMAND_HANDLER) & ~filters.private) @app.on_message(filters.command("purge", COMMAND_HANDLER) & filters.group)
@adminsOnly("can_delete_messages") @adminsOnly("can_delete_messages")
async def purge(_, message): async def purge(_, message):
try: try:
@ -124,7 +124,7 @@ async def purge(_, message):
# Kick members # Kick members
@app.on_message(filters.command(["kick", "dkick"], COMMAND_HANDLER) & ~filters.private) @app.on_message(filters.command(["kick", "dkick"], COMMAND_HANDLER) & filters.group)
@adminsOnly("can_restrict_members") @adminsOnly("can_restrict_members")
async def kickFunc(client, message): async def kickFunc(client, message):
user_id, reason = await extract_user_and_reason(message) user_id, reason = await extract_user_and_reason(message)
@ -153,7 +153,7 @@ async def kickFunc(client, message):
# Ban/DBan/TBan User # Ban/DBan/TBan User
@app.on_message(filters.command(["ban", "dban", "tban"], COMMAND_HANDLER) & ~filters.private) @app.on_message(filters.command(["ban", "dban", "tban"], COMMAND_HANDLER) & filters.group)
@adminsOnly("can_restrict_members") @adminsOnly("can_restrict_members")
async def banFunc(client, message): async def banFunc(client, message):
user_id, reason = await extract_user_and_reason(message, sender_chat=True) user_id, reason = await extract_user_and_reason(message, sender_chat=True)
@ -203,7 +203,7 @@ async def banFunc(client, message):
# Unban members # Unban members
@app.on_message(filters.command("unban", COMMAND_HANDLER) & ~filters.private) @app.on_message(filters.command("unban", COMMAND_HANDLER) & filters.group)
@adminsOnly("can_restrict_members") @adminsOnly("can_restrict_members")
async def unban_func(_, message): async def unban_func(_, message):
# we don't need reasons for unban, also, we # we don't need reasons for unban, also, we
@ -227,7 +227,7 @@ async def unban_func(_, message):
# Ban users listed in a message # Ban users listed in a message
@app.on_message(filters.user(SUDO) & filters.command("listban", COMMAND_HANDLER) & ~filters.private) @app.on_message(filters.user(SUDO) & filters.command("listban", COMMAND_HANDLER) & filters.group)
async def list_ban_(c, message): async def list_ban_(c, message):
userid, msglink_reason = await extract_user_and_reason(message) userid, msglink_reason = await extract_user_and_reason(message)
if not userid or not msglink_reason: if not userid or not msglink_reason:
@ -276,7 +276,7 @@ async def list_ban_(c, message):
# Unban users listed in a message # Unban users listed in a message
@app.on_message(filters.user(SUDO) & filters.command("listunban", COMMAND_HANDLER) & ~filters.private) @app.on_message(filters.user(SUDO) & filters.command("listunban", COMMAND_HANDLER) & filters.group)
async def list_unban_(c, message): async def list_unban_(c, message):
userid, msglink = await extract_user_and_reason(message) userid, msglink = await extract_user_and_reason(message)
if not userid or not msglink: if not userid or not msglink:
@ -317,7 +317,7 @@ async def list_unban_(c, message):
# Delete messages # Delete messages
@app.on_message(filters.command("del", COMMAND_HANDLER) & ~filters.private) @app.on_message(filters.command("del", COMMAND_HANDLER) & filters.group)
@adminsOnly("can_delete_messages") @adminsOnly("can_delete_messages")
async def deleteFunc(_, message): async def deleteFunc(_, message):
if not message.reply_to_message: if not message.reply_to_message:
@ -330,7 +330,7 @@ async def deleteFunc(_, message):
# Promote Members # Promote Members
@app.on_message(filters.command(["promote", "fullpromote"], COMMAND_HANDLER) & ~filters.private) @app.on_message(filters.command(["promote", "fullpromote"], COMMAND_HANDLER) & filters.group)
@adminsOnly("can_promote_members") @adminsOnly("can_promote_members")
async def promoteFunc(client, message): async def promoteFunc(client, message):
try: try:
@ -374,7 +374,7 @@ async def promoteFunc(client, message):
# Demote Member # Demote Member
@app.on_message(filters.command("demote", COMMAND_HANDLER) & ~filters.private) @app.on_message(filters.command("demote", COMMAND_HANDLER) & filters.group)
@adminsOnly("can_promote_members") @adminsOnly("can_promote_members")
async def demote(client, message): async def demote(client, message):
user_id = await extract_user(message) user_id = await extract_user(message)
@ -400,7 +400,7 @@ async def demote(client, message):
# Pin Messages # Pin Messages
@app.on_message(filters.command(["pin", "unpin"], COMMAND_HANDLER) & ~filters.private) @app.on_message(filters.command(["pin", "unpin"], COMMAND_HANDLER) & filters.group)
@adminsOnly("can_pin_messages") @adminsOnly("can_pin_messages")
async def pin(_, message): async def pin(_, message):
if not message.reply_to_message: if not message.reply_to_message:
@ -426,7 +426,7 @@ async def pin(_, message):
# Mute members # Mute members
@app.on_message(filters.command(["mute", "tmute"], COMMAND_HANDLER) & ~filters.private) @app.on_message(filters.command(["mute", "tmute"], COMMAND_HANDLER) & filters.group)
@adminsOnly("can_restrict_members") @adminsOnly("can_restrict_members")
async def mute(client, message): async def mute(client, message):
try: try:
@ -472,7 +472,7 @@ async def mute(client, message):
# Unmute members # Unmute members
@app.on_message(filters.command("unmute", COMMAND_HANDLER) & ~filters.private) @app.on_message(filters.command("unmute", COMMAND_HANDLER) & filters.group)
@adminsOnly("can_restrict_members") @adminsOnly("can_restrict_members")
async def unmute(_, message): async def unmute(_, message):
user_id = await extract_user(message) user_id = await extract_user(message)
@ -484,7 +484,7 @@ async def unmute(_, message):
# Ban deleted accounts # Ban deleted accounts
@app.on_message(filters.command("ban_ghosts", COMMAND_HANDLER) & ~filters.private) @app.on_message(filters.command("ban_ghosts", COMMAND_HANDLER) & filters.group)
@adminsOnly("can_restrict_members") @adminsOnly("can_restrict_members")
async def ban_deleted_accounts(_, message): async def ban_deleted_accounts(_, message):
chat_id = message.chat.id chat_id = message.chat.id
@ -507,7 +507,7 @@ async def ban_deleted_accounts(_, message):
await m.edit("There are no deleted accounts in this chat") await m.edit("There are no deleted accounts in this chat")
@app.on_message(filters.command(["warn", "dwarn"], COMMAND_HANDLER) & ~filters.private) @app.on_message(filters.command(["warn", "dwarn"], COMMAND_HANDLER) & filters.group)
@adminsOnly("can_restrict_members") @adminsOnly("can_restrict_members")
async def warn_user(client, message): async def warn_user(client, message):
user_id, reason = await extract_user_and_reason(message) user_id, reason = await extract_user_and_reason(message)
@ -609,7 +609,7 @@ async def unban_user(_, cq):
# Remove Warn # Remove Warn
@app.on_message(filters.command("rmwarn", COMMAND_HANDLER) & ~filters.private) @app.on_message(filters.command("rmwarn", COMMAND_HANDLER) & filters.group)
@adminsOnly("can_restrict_members") @adminsOnly("can_restrict_members")
async def remove_warnings(_, message): async def remove_warnings(_, message):
if not message.reply_to_message: if not message.reply_to_message:
@ -628,7 +628,7 @@ async def remove_warnings(_, message):
# Warns # Warns
@app.on_message(filters.command("warns", COMMAND_HANDLER) & ~filters.private) @app.on_message(filters.command("warns", COMMAND_HANDLER) & filters.group)
@capture_err @capture_err
async def check_warns(_, message): async def check_warns(_, message):
user_id = await extract_user(message) user_id = await extract_user(message)
@ -644,7 +644,7 @@ async def check_warns(_, message):
# Report User in Group # Report User in Group
@app.on_message((filters.command("report", COMMAND_HANDLER) | filters.command(["admins", "admin"], prefixes="@")) & ~filters.private) @app.on_message((filters.command("report", COMMAND_HANDLER) | filters.command(["admins", "admin"], prefixes="@")) & filters.group)
@capture_err @capture_err
async def report_user(_, message): async def report_user(_, message):
if not message.reply_to_message: if not message.reply_to_message:

22
misskaty/plugins/afk.py
View file

@ -13,11 +13,13 @@ import time
from pyrogram import filters from pyrogram import filters
from database.afk_db import add_afk, cleanmode_off, cleanmode_on, is_afk, remove_afk from database.afk_db import (add_afk, cleanmode_off, cleanmode_on, is_afk,
remove_afk)
from misskaty import app from misskaty import app
from misskaty.core.decorator.errors import capture_err from misskaty.core.decorator.errors import capture_err
from misskaty.core.decorator.permissions import adminsOnly from misskaty.core.decorator.permissions import adminsOnly
from misskaty.helper.human_read import get_readable_time2 from misskaty.core.message_utils import kirimPesan
from misskaty.helper import get_readable_time2
from misskaty.vars import COMMAND_HANDLER from misskaty.vars import COMMAND_HANDLER
from utils import put_cleanmode from utils import put_cleanmode
@ -33,7 +35,7 @@ Just type something in group to remove AFK Status."""
@app.on_message(filters.command(["afk"], COMMAND_HANDLER)) @app.on_message(filters.command(["afk"], COMMAND_HANDLER))
async def active_afk(_, message): async def active_afk(_, message):
if message.sender_chat: if message.sender_chat:
return return await kirimPesan(message, "This feature not supported for channel.")
user_id = message.from_user.id user_id = message.from_user.id
verifier, reasondb = await is_afk(user_id) verifier, reasondb = await is_afk(user_id)
if verifier: if verifier:
@ -176,24 +178,24 @@ async def active_afk(_, message):
} }
await add_afk(user_id, details) await add_afk(user_id, details)
send = await message.reply_text(f"{message.from_user.mention} [<code>{message.from_user.id}</code>] is now AFK!.") send = await kirimPesan(message, f"{message.from_user.mention} [<code>{message.from_user.id}</code>] is now AFK!.")
await put_cleanmode(message.chat.id, send.id) await put_cleanmode(message.chat.id, send.id)
@app.on_message(filters.command("afkdel") & ~filters.private) @app.on_message(filters.command("afkdel", COMMAND_HANDLER) & filters.group)
@adminsOnly("can_change_info") @adminsOnly("can_change_info")
async def afk_state(_, message): async def afk_state(_, message):
usage = "**Usage:**\n/afkdel [ENABLE|DISABLE]" usage = "**Usage:**\n/afkdel [ENABLE|DISABLE] to enable or disable auto delete message."
if len(message.command) == 1: if len(message.command) == 1:
return await message.reply_text(usage) return await kirimPesan(message, usage)
chat_id = message.chat.id chat_id = message.chat.id
state = message.text.split(None, 1)[1].strip() state = message.text.split(None, 1)[1].strip()
state = state.lower() state = state.lower()
if state == "enable": if state == "enable":
await cleanmode_on(chat_id) await cleanmode_on(chat_id)
await message.reply_text("Enabled auto delete AFK message.") await kirimPesan(message, "Enabled auto delete AFK message in this chat.")
elif state == "disable": elif state == "disable":
await cleanmode_off(chat_id) await cleanmode_off(chat_id)
await message.reply_text("Disabled auto delete AFK message.") await kirimPesan(message, "Disabled auto delete AFK message.")
else: else:
await message.reply_text(usage) await kirimPesan(message, usage)

1
misskaty/plugins/auto_approve.py
View file

@ -13,6 +13,7 @@ from misskaty import app
from misskaty.core.decorator.errors import capture_err from misskaty.core.decorator.errors import capture_err
# Filters Approve User by bot in channel @YMovieZNew
@capture_err @capture_err
@app.on_chat_join_request(filters.chat(-1001686184174)) @app.on_chat_join_request(filters.chat(-1001686184174))
async def approve_join_chat(c, m): async def approve_join_chat(c, m):

8
misskaty/plugins/banned.py
View file

@ -3,6 +3,7 @@ from pyrogram.types import InlineKeyboardButton, InlineKeyboardMarkup, Message
from database.users_chats_db import db from database.users_chats_db import db
from misskaty import app from misskaty import app
from misskaty.core.message_utils import kirimPesan
from misskaty.vars import SUPPORT_CHAT from misskaty.vars import SUPPORT_CHAT
from utils import temp from utils import temp
@ -24,7 +25,7 @@ disabled_group = filters.create(disabled_chat)
@app.on_message(filters.private & banned_user & filters.incoming) @app.on_message(filters.private & banned_user & filters.incoming)
async def ban_reply(bot, message): async def ban_reply(bot, message):
ban = await db.get_ban_status(message.from_user.id) ban = await db.get_ban_status(message.from_user.id)
await message.reply(f'Sorry Dude, You are Banned to use Me. \nBan Reason: {ban["ban_reason"]}') await kirimPesan(message, f'Sorry Dude, You are Banned to use Me. \nBan Reason: {ban["ban_reason"]}')
@app.on_message(filters.group & disabled_group & filters.incoming) @app.on_message(filters.group & disabled_group & filters.incoming)
@ -32,8 +33,9 @@ async def grp_bd(bot, message):
buttons = [[InlineKeyboardButton("Support", url=f"https://t.me/{SUPPORT_CHAT}")]] buttons = [[InlineKeyboardButton("Support", url=f"https://t.me/{SUPPORT_CHAT}")]]
reply_markup = InlineKeyboardMarkup(buttons) reply_markup = InlineKeyboardMarkup(buttons)
vazha = await db.get_chat(message.chat.id) vazha = await db.get_chat(message.chat.id)
k = await message.reply( k = await kirimPesan(
text=f"CHAT NOT ALLOWED 🐞\n\nMy admins has restricted me from working here ! If you want to know more about it contact support..\nReason : <code>{vazha['reason']}</code>.", message,
f"CHAT NOT ALLOWED 🐞\n\nMy admins has restricted me from working here ! If you want to know more about it contact support..\nReason : <code>{vazha['reason']}</code>.",
reply_markup=reply_markup, reply_markup=reply_markup,
) )
try: try:

9
misskaty/plugins/broadcast.py
View file

@ -6,6 +6,7 @@ from pyrogram import filters
from database.users_chats_db import db from database.users_chats_db import db
from misskaty import app from misskaty import app
from misskaty.core.message_utils import *
from misskaty.vars import SUDO from misskaty.vars import SUDO
from utils import broadcast_messages from utils import broadcast_messages
@ -14,7 +15,7 @@ from utils import broadcast_messages
async def broadcast(bot, message): async def broadcast(bot, message):
users = await db.get_all_users() users = await db.get_all_users()
b_msg = message.reply_to_message b_msg = message.reply_to_message
sts = await message.reply_text(text="Broadcasting your messages...") sts = await kirimPesan(message, "Broadcasting your messages...")
start_time = time.time() start_time = time.time()
total_users = await db.total_users_count() total_users = await db.total_users_count()
done = 0 done = 0
@ -28,7 +29,7 @@ async def broadcast(bot, message):
if pti: if pti:
success += 1 success += 1
elif pti is False: elif pti is False:
if sh == "Bocked": if sh == "Blocked":
blocked += 1 blocked += 1
elif sh == "Deleted": elif sh == "Deleted":
deleted += 1 deleted += 1
@ -37,6 +38,6 @@ async def broadcast(bot, message):
done += 1 done += 1
await asyncio.sleep(2) await asyncio.sleep(2)
if not done % 20: if not done % 20:
await sts.edit(f"Broadcast in progress:\n\nTotal Users {total_users}\nCompleted: {done} / {total_users}\nSuccess: {success}\nBlocked: {blocked}\nDeleted: {deleted}") await editPesan(sts, f"Broadcast in progress:\n\nTotal Users {total_users}\nCompleted: {done} / {total_users}\nSuccess: {success}\nBlocked: {blocked}\nDeleted: {deleted}")
time_taken = datetime.timedelta(seconds=int(time.time() - start_time)) time_taken = datetime.timedelta(seconds=int(time.time() - start_time))
await sts.edit(f"Broadcast Completed:\nCompleted in {time_taken} seconds.\n\nTotal Users {total_users}\nCompleted: {done} / {total_users}\nSuccess: {success}\nBlocked: {blocked}\nDeleted: {deleted}") await editPesan(sts, f"Broadcast Completed:\nCompleted in {time_taken} seconds.\n\nTotal Users {total_users}\nCompleted: {done} / {total_users}\nSuccess: {success}\nBlocked: {blocked}\nDeleted: {deleted}")

18
misskaty/plugins/bypass.py
View file

@ -15,10 +15,9 @@ from pyrogram.errors import EntitiesTooLong, MessageTooLong
from pyrogram.types import InlineKeyboardButton, InlineKeyboardMarkup from pyrogram.types import InlineKeyboardButton, InlineKeyboardMarkup
from misskaty import app from misskaty import app
from misskaty.core.message_utils import *
from misskaty.core.decorator.errors import capture_err from misskaty.core.decorator.errors import capture_err
from misskaty.helper.http import http from misskaty.helper import http, get_readable_file_size, rentry
from misskaty.helper.human_read import get_readable_file_size
from misskaty.helper.tools import rentry
from misskaty.vars import COMMAND_HANDLER from misskaty.vars import COMMAND_HANDLER
LIST_LINK = """ LIST_LINK = """
@ -89,15 +88,15 @@ def wetransfer_bypass(url: str) -> str:
@capture_err @capture_err
async def bypass(_, message): async def bypass(_, message):
if len(message.command) == 1: if len(message.command) == 1:
return await message.reply(f"Gunakan perintah /{message.command[0]} untuk bypass url") return await kirimPesan(message, f"Gunakan perintah /{message.command[0]} untuk bypass url")
url = message.command[1] url = message.command[1]
urllib.parse.urlparse(url).netloc urllib.parse.urlparse(url).netloc
msg = await message.reply("Bypassing URL..", quote=True) msg = await kirimPesan(message, "Bypassing URL..", quote=True)
mention = f"**Bypasser:** {message.from_user.mention} ({message.from_user.id})" mention = f"**Bypasser:** {message.from_user.mention} ({message.from_user.id})"
if re.match(r"https?://(store.kde.org|www.pling.com)\/p\/(\d+)", url): if re.match(r"https?://(store.kde.org|www.pling.com)\/p\/(\d+)", url):
data = await pling_bypass(url) data = await pling_bypass(url)
try: try:
await msg.edit(f"{data}\n\n{mention}") await editPesan(msg, f"{data}\n\n{mention}")
except (MessageTooLong, EntitiesTooLong): except (MessageTooLong, EntitiesTooLong):
result = await rentry(data) result = await rentry(data)
markup = InlineKeyboardMarkup( markup = InlineKeyboardMarkup(
@ -108,13 +107,14 @@ async def bypass(_, message):
] ]
] ]
) )
await msg.edit( await editPesan(
msg,
f"{result}\n\nBecause your bypassed url is too long, so your link will be pasted to rentry.\n{mention}", f"{result}\n\nBecause your bypassed url is too long, so your link will be pasted to rentry.\n{mention}",
reply_markup=markup, reply_markup=markup,
disable_web_page_preview=True, disable_web_page_preview=True,
) )
elif "we.tl" or "wetransfer.com" in url: elif "we.tl" or "wetransfer.com" in url:
data = wetransfer_bypass(url) data = wetransfer_bypass(url)
await msg.edit(f"{data}\n\n{mention}") await editPesan(msg, f"{data}\n\n{mention}")
else: else:
await msg.edit("Unsupported URL..") await editPesan(msg, "Unsupported URL..")

9
misskaty/plugins/chatbot.py → misskaty/plugins/chatbot_ai.py
View file

@ -3,13 +3,14 @@ from pyrogram.errors import MessageNotModified
from misskaty import app from misskaty import app
from misskaty.helper.http import http from misskaty.helper.http import http
from misskaty.core.message_utils import *
from misskaty.vars import COMMAND_HANDLER, OPENAI_API from misskaty.vars import COMMAND_HANDLER, OPENAI_API
@app.on_message(filters.command("ask", COMMAND_HANDLER)) @app.on_message(filters.command("ask", COMMAND_HANDLER))
async def chatbot(c, m): async def chatbot(c, m):
if len(m.command) == 1: if len(m.command) == 1:
return await m.reply(f"Gunakan perintah <code>/{m.command[0]} [pertanyaan]</code> untuk menanyakan pertanyaan menggunakan AI.") return await kirimPesan(m, f"Gunakan perintah <code>/{m.command[0]} [pertanyaan]</code> untuk menanyakan pertanyaan menggunakan AI.")
pertanyaan = m.text.split(" ", maxsplit=1)[1] pertanyaan = m.text.split(" ", maxsplit=1)[1]
headers = { headers = {
"Content-Type": "application/json", "Content-Type": "application/json",
@ -22,11 +23,11 @@ async def chatbot(c, m):
"max_tokens": 200, "max_tokens": 200,
"temperature": 0, "temperature": 0,
} }
msg = await m.reply("Wait a moment looking for your answer..") msg = await kirimPesan(m, "Wait a moment looking for your answer..")
try: try:
response = (await http.post("https://api.openai.com/v1/completions", headers=headers, json=json_data)).json() response = (await http.post("https://api.openai.com/v1/completions", headers=headers, json=json_data)).json()
await msg.edit(response["choices"][0]["text"]) await editPesan(msg, response["choices"][0]["text"])
except MessageNotModified: except MessageNotModified:
pass pass
except Exception: except Exception:
await msg.edit("Yahh, sorry i can't get your answer.") await editPesan(msg, "Yahh, sorry i can't get your answer.")

2
misskaty/plugins/detect_afk.py
View file

@ -27,7 +27,7 @@ from utils import put_cleanmode
) )
async def chat_watcher_func(_, message): async def chat_watcher_func(_, message):
if message.sender_chat: if message.sender_chat:
return return await message.reply("This feature not supported for channel.")
userid = message.from_user.id userid = message.from_user.id
user_name = message.from_user.first_name user_name = message.from_user.first_name
if message.entities: if message.entities:

61
misskaty/plugins/filters.py
View file

@ -25,22 +25,19 @@ import re
from pyrogram import filters from pyrogram import filters
from database.filters_db import ( from database.filters_db import (delete_filter, get_filter, get_filters_names,
delete_filter, save_filter)
get_filter,
get_filters_names,
save_filter,
)
from misskaty import app from misskaty import app
from misskaty.core.decorator.errors import capture_err from misskaty.core.decorator.errors import capture_err
from misskaty.core.decorator.permissions import adminsOnly from misskaty.core.decorator.permissions import adminsOnly
from misskaty.core.keyboard import ikb from misskaty.core.keyboard import ikb
from misskaty.core.message_utils import *
from misskaty.helper.functions import extract_text_and_keyb from misskaty.helper.functions import extract_text_and_keyb
__MODULE__ = "Filters" __MODULE__ = "Filters"
__HELP__ = """/filters To Get All The Filters In The Chat. __HELP__ = """/filters To Get All The Filters In The Chat.
/addfilter [FILTER_NAME] To Save A Filter (Can be a sticker or text). /addfilter [FILTER_NAME] : To Save A Filter (Can be a sticker or text).
/stopfilter [FILTER_NAME] To Stop A Filter. /stopfilter [FILTER_NAME] : To Stop A Filter.
You can use markdown or html to save text too. You can use markdown or html to save text too.
""" """
@ -48,51 +45,51 @@ You can use markdown or html to save text too.
@app.on_message(filters.command("addfilter") & ~filters.private) @app.on_message(filters.command("addfilter") & ~filters.private)
@adminsOnly("can_change_info") @adminsOnly("can_change_info")
async def save_filters(_, message): async def save_filters(_, m):
if len(message.command) == 1 or not message.reply_to_message: if len(m.command) == 1 or not m.reply_to_message:
return await message.reply_text("**Usage:**\nReply to a text or sticker with /filter [FILTER_NAME] to save it.") return await kirimPesan(m, "**Usage:**\nReply to a text or sticker with /filter [FILTER_NAME] to save it.")
if not message.reply_to_message.text and not message.reply_to_message.sticker: if not m.reply_to_message.text and not m.reply_to_message.sticker:
return await message.reply_text("__**You can only save text or stickers in filters for now.**__") return await kirimPesan(m, "__**You can only save text or stickers in filters for now.**__")
name = message.text.split(None, 1)[1].strip() name = m.text.split(None, 1)[1].strip()
if not name: if not name:
return await message.reply_text("**Usage:**\n__/filter [FILTER_NAME]__") return await kirimPesan(m, "**Usage:**\n__/filter [FILTER_NAME]__")
chat_id = message.chat.id chat_id = m.chat.id
_type = "text" if message.reply_to_message.text else "sticker" _type = "text" if m.reply_to_message.text else "sticker"
_filter = { _filter = {
"type": _type, "type": _type,
"data": message.reply_to_message.text.markdown if _type == "text" else message.reply_to_message.sticker.file_id, "data": m.reply_to_message.text.markdown if _type == "text" else m.reply_to_message.sticker.file_id,
} }
await save_filter(chat_id, name, _filter) await save_filter(chat_id, name, _filter)
await message.reply(f"__**Saved filter {name}.**__") await kirimPesan(m, f"__**Saved filter {name}.**__")
@app.on_message(filters.command("filters") & ~filters.private) @app.on_message(filters.command("filters") & ~filters.private)
@capture_err @capture_err
async def get_filterss(_, message): async def get_filterss(_, m):
_filters = await get_filters_names(message.chat.id) _filters = await get_filters_names(m.chat.id)
if not _filters: if not _filters:
return await message.reply_text("**No filters in this chat.**") return await kirimPesan(m, "**No filters in this chat.**")
_filters.sort() _filters.sort()
msg = f"List of filters in {message.chat.title} - {message.chat.id}\n" msg = f"List of filters in {m.chat.title} - {m.chat.id}\n"
for _filter in _filters: for _filter in _filters:
msg += f"**-** `{_filter}`\n" msg += f"**-** `{_filter}`\n"
await message.reply_text(msg) await kirimPesan(m, msg)
@app.on_message(filters.command("stopfilter") & ~filters.private) @app.on_message(filters.command("stopfilter") & ~filters.private)
@adminsOnly("can_change_info") @adminsOnly("can_change_info")
async def del_filter(_, message): async def del_filter(_, m):
if len(message.command) < 2: if len(m.command) < 2:
return await message.reply_text("**Usage:**\n__/stop [FILTER_NAME]__") return await kirimPesan(m, "**Usage:**\n__/stop [FILTER_NAME]__")
name = message.text.split(None, 1)[1].strip() name = m.text.split(None, 1)[1].strip()
if not name: if not name:
return await message.reply_text("**Usage:**\n__/stop [FILTER_NAME]__") return await kirimPesan(m, "**Usage:**\n__/stop [FILTER_NAME]__")
chat_id = message.chat.id chat_id = m.chat.id
deleted = await delete_filter(chat_id, name) deleted = await delete_filter(chat_id, name)
if deleted: if deleted:
await message.reply_text(f"**Deleted filter {name}.**") await kirimPesan(m, f"**Deleted filter {name}.**")
else: else:
await message.reply_text("**No such filter.**") await kirimPesan(m, "**No such filter.**")
@app.on_message( @app.on_message(

89
misskaty/plugins/genss.py
View file

@ -15,10 +15,11 @@ from shutil import rmtree
from pyrogram import enums, filters from pyrogram import enums, filters
from pyrogram.errors import FloodWait from pyrogram.errors import FloodWait
from misskaty import BOT_USERNAME, DL_TASK, app from misskaty import BOT_USERNAME, app
from misskaty.core.message_utils import *
from misskaty.core.decorator.pyro_cooldown import wait
from misskaty.core.decorator.errors import capture_err from misskaty.core.decorator.errors import capture_err
from misskaty.helper.ffmpeg_helper import genss_link, take_ss from misskaty.helper import genss_link, progress_for_pyrogram, take_ss
from misskaty.helper.pyro_progress import progress_for_pyrogram
from misskaty.vars import COMMAND_HANDLER from misskaty.vars import COMMAND_HANDLER
LOGGER = getLogger(__name__) LOGGER = getLogger(__name__)
@ -31,21 +32,16 @@ __HELP__ = """"
""" """
@app.on_message(filters.command(["genss"], COMMAND_HANDLER)) @app.on_message(filters.command(["genss"], COMMAND_HANDLER) & wait(30))
@capture_err @capture_err
async def genss(client, message): async def genss(client, m):
replied = message.reply_to_message replied = m.reply_to_message
if replied is not None: if replied is not None:
vid = [replied.video, replied.document] vid = [replied.video, replied.document]
media = next((v for v in vid if v is not None), None) media = next((v for v in vid if v is not None), None)
if media is None: if media is None:
return await message.reply("Reply to a Telegram Video or document as video to generate screenshoot!") return await kirimPesan(m, "Reply to a Telegram Video or document as video to generate screenshoot!")
process = await message.reply_text("`Processing, please wait..`") process = await kirimPesan(m, "`Processing, please wait..`")
if DL_TASK.get(message.from_user.id):
return await process.edit("Sorry to avoid flood and error, bot only process one task per user at a time.")
if not DL_TASK.get(message.from_user.id):
DL_TASK[message.from_user.id] = True
c_time = time.time() c_time = time.time()
the_real_download_location = await replied.download( the_real_download_location = await replied.download(
@ -54,40 +50,31 @@ async def genss(client, message):
) )
if the_real_download_location is not None: if the_real_download_location is not None:
try: try:
await client.edit_message_text( await editPesan(process, f"File video berhasil didownload dengan path <code>{the_real_download_location}</code>.")
text=f"File video berhasil didownload dengan path <code>{the_real_download_location}</code>.",
chat_id=message.chat.id,
message_id=process.id,
)
await sleep(2) await sleep(2)
images = await take_ss(the_real_download_location) images = await take_ss(the_real_download_location)
await client.edit_message_text( await editPesan(process, "Mencoba mengupload, hasil generate screenshot..")
text="Mencoba mengupload, hasil generate screenshot..", await client.send_chat_action(chat_id=m.chat.id, action=enums.ChatAction.UPLOAD_PHOTO)
chat_id=message.chat.id,
message_id=process.id,
)
await client.send_chat_action(chat_id=message.chat.id, action=enums.ChatAction.UPLOAD_PHOTO)
try: try:
await gather( await gather(
*[ *[
message.reply_document(images, reply_to_message_id=message.id), m.reply_document(images, reply_to_message_id=m.id),
message.reply_photo(images, reply_to_message_id=message.id), m.reply_photo(images, reply_to_message_id=m.id),
] ]
) )
except FloodWait as e: except FloodWait as e:
await sleep(e.value) await sleep(e.value)
await gather( await gather(
*[ *[
message.reply_document(images, reply_to_message_id=message.id), m.reply_document(images, reply_to_message_id=m.id),
message.reply_photo(images, reply_to_message_id=message.id), m.reply_photo(images, reply_to_message_id=m.id),
] ]
) )
await message.reply( await kirimPesan(
f"☑️ Uploaded [1] screenshoot.\n\n{message.from_user.first_name} (<code>{message.from_user.id}</code>)\n#️⃣ #ssgen #id{message.from_user.id}\n\nSS Generate by @{BOT_USERNAME}", m, f"☑️ Uploaded [1] screenshoot.\n\n{m.from_user.first_name} (<code>{m.from_user.id}</code>)\n#️⃣ #ssgen #id{message.from_user.id}\n\nSS Generate by @{BOT_USERNAME}",
reply_to_message_id=message.id, reply_to_message_id=m.id,
) )
del DL_TASK[message.from_user.id]
await process.delete() await process.delete()
try: try:
os.remove(images) os.remove(images)
@ -96,46 +83,40 @@ async def genss(client, message):
pass pass
except Exception: except Exception:
exc = traceback.format_exc() exc = traceback.format_exc()
await message.reply(f"Gagal generate screenshot.\n\n{exc}") await kirimPesan(m, f"Gagal generate screenshot.\n\n{exc}")
del DL_TASK[message.from_user.id]
try: try:
os.remove(images) os.remove(images)
os.remove(the_real_download_location) os.remove(the_real_download_location)
except: except:
pass pass
else: else:
await message.reply("Reply to a Telegram media to get screenshots from media..") await kirimPesan(m, "Reply to a Telegram media to get screenshots from media..")
@app.on_message(filters.command(["genss_link"], COMMAND_HANDLER)) @app.on_message(filters.command(["genss_link"], COMMAND_HANDLER))
@capture_err @capture_err
async def genss_link(client, message): async def genss_link(client, m):
if len(m.command) == 1:
return await kirimPesan(m, f"Use <code>/{m.command[0]} link</code> to generate screenshot from URL.")
try: try:
link = message.text.split(" ")[1] link = m.text.split(" ")[1]
if link.startswith("https://file.yasirweb.my.id"): process = await kirimPesan(m, "`Processing, please wait..`")
link = link.replace("https://file.yasirweb.my.id", "https://file.yasiraris.workers.dev") tmp_directory_for_each_user = f"./MissKaty_Genss/{str(m.from_user.id)}"
if link.startswith("https://link.yasirweb.my.id"):
link = link.replace("https://link.yasirweb.my.id", "https://yasirrobot.herokuapp.com")
process = await message.reply_text("`Processing, please wait..`")
tmp_directory_for_each_user = f"./MissKaty_Genss/{str(message.from_user.id)}"
if not os.path.isdir(tmp_directory_for_each_user): if not os.path.isdir(tmp_directory_for_each_user):
os.makedirs(tmp_directory_for_each_user) os.makedirs(tmp_directory_for_each_user)
images = await genss_link(process, link, tmp_directory_for_each_user, 5, 8) images = await genss_link(process, link, tmp_directory_for_each_user, 5, 8)
await sleep(2) await sleep(2)
await client.edit_message_text( await editPesan(process, "Mencoba mengupload, hasil generate screenshot..")
text="Mencoba mengupload, hasil generate screenshot..", await client.send_chat_action(chat_id=m.chat.id, action=enums.ChatAction.UPLOAD_PHOTO)
chat_id=message.chat.id,
message_id=process.id,
)
await client.send_chat_action(chat_id=message.chat.id, action=enums.ChatAction.UPLOAD_PHOTO)
try: try:
await message.reply_media_group(images, reply_to_message_id=message.id) await m.reply_media_group(images, reply_to_message_id=m.id)
except FloodWait as e: except FloodWait as e:
await sleep(e.value) await sleep(e.value)
await message.reply_media_group(images, reply_to_message_id=message.id) await m.reply_media_group(images, reply_to_message_id=m.id)
await message.reply( await kirimPesan(
m,
f"☑️ Uploaded [8] screenshoot.\n\nGenerated by @{BOT_USERNAME}.", f"☑️ Uploaded [8] screenshoot.\n\nGenerated by @{BOT_USERNAME}.",
reply_to_message_id=message.id, reply_to_message_id=m.id,
) )
await process.delete() await process.delete()
try: try:
@ -144,7 +125,7 @@ async def genss_link(client, message):
pass pass
except Exception: except Exception:
exc = traceback.format_exc() exc = traceback.format_exc()
await message.reply(f"Gagal generate screenshot.\n\n{exc}") await kirimPesan(m, f"Gagal generate screenshot.\n\n{exc}")
try: try:
rmtree(tmp_directory_for_each_user) rmtree(tmp_directory_for_each_user)
except: except:

2
misskaty/plugins/grup_tools.py
View file

@ -326,7 +326,7 @@ async def kickme(_, message):
try: try:
await message.chat.ban_member(message.from_user.id) await message.chat.ban_member(message.from_user.id)
txt = f"Pengguna {message.from_user.mention} menendang dirinya sendiri. Mungkin dia sedang frustasi 😕" txt = f"Pengguna {message.from_user.mention} menendang dirinya sendiri. Mungkin dia sedang frustasi 😕"
txt += f"\n<b>Alasan</b>: {reason}" if reason else "" txt += f"\n<b>Alasan</b>: {reason}" if reason else "-"
await message.reply_text(txt) await message.reply_text(txt)
await message.chat.unban_member(message.from_user.id) await message.chat.unban_member(message.from_user.id)
except RPCError as ef: except RPCError as ef:

31
misskaty/plugins/mediainfo.py
View file

@ -12,28 +12,23 @@ import time
from os import remove as osremove from os import remove as osremove
from pyrogram import filters from pyrogram import filters
from pyrogram.errors import FloodWait
from pyrogram.types import InlineKeyboardButton, InlineKeyboardMarkup from pyrogram.types import InlineKeyboardButton, InlineKeyboardMarkup
from misskaty import app, DL_TASK from misskaty import app
from misskaty.helper.media_helper import post_to_telegraph, runcmd from misskaty.core.message_utils import *
from misskaty.helper.pyro_progress import progress_for_pyrogram from misskaty.core.decorator.pyro_cooldown import wait
from misskaty.helper import post_to_telegraph, runcmd, progress_for_pyrogram
from misskaty.vars import COMMAND_HANDLER from misskaty.vars import COMMAND_HANDLER
from utils import get_file_id from utils import get_file_id
@app.on_message(filters.command(["mediainfo"], COMMAND_HANDLER)) @app.on_message(filters.command(["mediainfo"], COMMAND_HANDLER) & wait(30))
async def mediainfo(client, message): async def mediainfo(client, message):
if message.reply_to_message and message.reply_to_message.media: if message.reply_to_message and message.reply_to_message.media:
process = await message.reply_text("`Sedang memproses, lama waktu tergantung ukuran file kamu...`", quote=True) process = await kirimPesan(message, "`Sedang memproses, lama waktu tergantung ukuran file kamu...`", quote=True)
file_info = get_file_id(message.reply_to_message) file_info = get_file_id(message.reply_to_message)
if file_info is None: if file_info is None:
return await process.edit_text("Balas ke format media yang valid") return await editPesan(process, "Balas ke format media yang valid")
if DL_TASK.get(message.from_user.id):
return await process.edit("Sorry to avoid flood and error, bot only process one task per user at a time.")
if not DL_TASK.get(message.from_user.id):
DL_TASK[message.from_user.id] = 1
c_time = time.time() c_time = time.time()
file_path = await message.reply_to_message.download( file_path = await message.reply_to_message.download(
@ -54,11 +49,7 @@ async def mediainfo(client, message):
text_ = file_info.message_type text_ = file_info.message_type
link = post_to_telegraph(title, body_text) link = post_to_telegraph(title, body_text)
markup = InlineKeyboardMarkup([[InlineKeyboardButton(text=text_, url=link)]]) markup = InlineKeyboardMarkup([[InlineKeyboardButton(text=text_, url=link)]])
try: await kirimPesan(message, "ℹ️ <b>MEDIA INFO</b>", reply_markup=markup, quote=True)
await message.reply("ℹ️ <b>MEDIA INFO</b>", reply_markup=markup, quote=True)
except FloodWait as f:
await asyncio.sleep(f.value)
del DL_TASK[message.from_user.id]
await process.delete() await process.delete()
try: try:
osremove(file_path) osremove(file_path)
@ -67,11 +58,11 @@ async def mediainfo(client, message):
else: else:
try: try:
link = message.text.split(" ", maxsplit=1)[1] link = message.text.split(" ", maxsplit=1)[1]
process = await message.reply_text("`Mohon tunggu sejenak...`") process = await kirimPesan(message, "`Mohon tunggu sejenak...`")
try: try:
output = subprocess.check_output(["mediainfo", f"{link}"]).decode("utf-8") output = subprocess.check_output(["mediainfo", f"{link}"]).decode("utf-8")
except Exception: except Exception:
return await process.edit("Sepertinya link yang kamu kirim tidak valid, pastikan direct link dan bisa di download.") return await editPesan(process, "Sepertinya link yang kamu kirim tidak valid, pastikan direct link dan bisa di download.")
title = "MissKaty Bot Mediainfo" title = "MissKaty Bot Mediainfo"
body_text = f""" body_text = f"""
<pre>{output}</pre> <pre>{output}</pre>
@ -92,4 +83,4 @@ async def mediainfo(client, message):
) )
await process.delete() await process.delete()
except IndexError: except IndexError:
return await message.reply_text("Gunakan command /mediainfo [link], atau reply telegram media dengan /mediainfo.") return await kirimPesan(message, "Gunakan command /mediainfo [link], atau reply telegram media dengan /mediainfo.")

2
misskaty/plugins/nightmode.py
View file

@ -190,7 +190,7 @@ async def job_open_ymoviez():
@app.on_callback_query(filters.regex(r"^nightmd$")) @app.on_callback_query(filters.regex(r"^nightmd$"))
async def _callbackanightmd(c: Client, q: CallbackQuery): async def callbackanightmd(c: Client, q: CallbackQuery):
await q.answer( await q.answer(
f"🔖 Hai, Aku {BOT_USERNAME} dibuat menggunakan Framework Pyrogram v{__version__} dan Python 3.10.\n\nMau buat bot seperti ini? Yuuk belajar di @botindonesia\nOwner: @YasirArisM", f"🔖 Hai, Aku {BOT_USERNAME} dibuat menggunakan Framework Pyrogram v{__version__} dan Python 3.10.\n\nMau buat bot seperti ini? Yuuk belajar di @botindonesia\nOwner: @YasirArisM",
show_alert=True, show_alert=True,

15
misskaty/plugins/ocr.py
View file

@ -11,6 +11,7 @@ from pyrogram import filters
from telegraph import upload_file from telegraph import upload_file
from misskaty import app from misskaty import app
from misskaty.core.message_utils import *
from misskaty.core.decorator.errors import capture_err from misskaty.core.decorator.errors import capture_err
from misskaty.helper.http import http from misskaty.helper.http import http
from misskaty.vars import COMMAND_HANDLER from misskaty.vars import COMMAND_HANDLER
@ -21,15 +22,15 @@ __HELP__ = "/ocr [reply to photo] - Read Text From Image"
@app.on_message(filters.command(["ocr"], COMMAND_HANDLER)) @app.on_message(filters.command(["ocr"], COMMAND_HANDLER))
@capture_err @capture_err
async def ocr(_, message): async def ocr(_, m):
reply = message.reply_to_message reply = m.reply_to_message
if not reply or not reply.photo and not reply.sticker: if not reply or not reply.photo and not reply.sticker:
return await message.reply_text(f"Reply photo with /{message.command[0]} command") return await kirimPesan(m, f"Reply photo with /{m.command[0]} command")
msg = await message.reply("Reading image...") msg = await kirimPesan(m, "Reading image...")
try: try:
file_path = await reply.download() file_path = await reply.download()
if reply.sticker: if reply.sticker:
file_path = await reply.download(f"ocr{message.from_user.id}.jpg") file_path = await reply.download(f"ocr_{m.from_user.id}.jpg")
response = upload_file(file_path) response = upload_file(file_path)
url = f"https://telegra.ph{response[0]}" url = f"https://telegra.ph{response[0]}"
req = ( req = (
@ -38,8 +39,8 @@ async def ocr(_, message):
follow_redirects=True, follow_redirects=True,
) )
).json() ).json()
await msg.edit(f"Hasil OCR:\n<code>{req['text']}</code>") await editPesan(msg, f"Hasil OCR:\n<code>{req['text']}</code>")
os.remove(file_path) os.remove(file_path)
except Exception as e: except Exception as e:
await msg.edit(str(e)) await editPesan(msg, str(e))
os.remove(file_path) os.remove(file_path)

5
misskaty/plugins/sangmata.py
View file

@ -1,6 +1,8 @@
from misskaty import app
from pyrogram import filters from pyrogram import filters
from database.sangmata_db import * from database.sangmata_db import *
from misskaty import app
from misskaty.core.decorator.permissions import adminsOnly
from misskaty.vars import COMMAND_HANDLER from misskaty.vars import COMMAND_HANDLER
__MODULE__ = "SangMata" __MODULE__ = "SangMata"
@ -37,6 +39,7 @@ async def cek_mataa(_, m):
@app.on_message( @app.on_message(
filters.group & filters.command("sangmata_set", COMMAND_HANDLER) & ~filters.bot & ~filters.via_bot filters.group & filters.command("sangmata_set", COMMAND_HANDLER) & ~filters.bot & ~filters.via_bot
) )
@adminsOnly("can_change_info")
async def set_mataa(_, m): async def set_mataa(_, m):
if len(m.command) == 1: if len(m.command) == 1:
return await m.reply(f"Use <code>/{m.command[0]} on</code>, to enable sangmata. If you want disable, you can use off parameter.") return await m.reply(f"Use <code>/{m.command[0]} on</code>, to enable sangmata. If you want disable, you can use off parameter.")

3
misskaty/plugins/sed.py
View file

@ -6,13 +6,12 @@ import html
import regex import regex
from pyrogram import filters from pyrogram import filters
from pyrogram.errors import MessageEmpty from pyrogram.errors import MessageEmpty
from pyrogram.types import Message
from misskaty import app from misskaty import app
@app.on_message(filters.regex(r"^s/(.+)?/(.+)?(/.+)?") & filters.reply) @app.on_message(filters.regex(r"^s/(.+)?/(.+)?(/.+)?") & filters.reply)
async def sed(c: app, m: Message): async def sed(c, m):
exp = regex.split(r"(?<![^\\]\\)/", m.text) exp = regex.split(r"(?<![^\\]\\)/", m.text)
pattern = exp[1] pattern = exp[1]
replace_with = exp[2].replace(r"\/", "/") replace_with = exp[2].replace(r"\/", "/")

25
misskaty/plugins/stickers.py
View file

@ -5,22 +5,15 @@ import shutil
import tempfile import tempfile
from PIL import Image from PIL import Image
from pyrogram import emoji, filters from pyrogram import emoji, filters, enums
from pyrogram.errors import BadRequest, PeerIdInvalid, StickersetInvalid from pyrogram.errors import BadRequest, PeerIdInvalid, StickersetInvalid
from pyrogram.file_id import FileId from pyrogram.file_id import FileId
from pyrogram.raw.functions.messages import GetStickerSet, SendMedia from pyrogram.raw.functions.messages import GetStickerSet, SendMedia
from pyrogram.raw.functions.stickers import ( from pyrogram.raw.functions.stickers import (AddStickerToSet, CreateStickerSet,
AddStickerToSet, RemoveStickerFromSet)
CreateStickerSet, from pyrogram.raw.types import (DocumentAttributeFilename, InputDocument,
RemoveStickerFromSet, InputMediaUploadedDocument,
) InputStickerSetItem, InputStickerSetShortName)
from pyrogram.raw.types import (
DocumentAttributeFilename,
InputDocument,
InputMediaUploadedDocument,
InputStickerSetItem,
InputStickerSetShortName,
)
from pyrogram.types import InlineKeyboardButton, InlineKeyboardMarkup from pyrogram.types import InlineKeyboardButton, InlineKeyboardMarkup
from misskaty import BOT_USERNAME, app from misskaty import BOT_USERNAME, app
@ -30,7 +23,7 @@ from misskaty.vars import COMMAND_HANDLER, LOG_CHANNEL
__MODULE__ = "Stickers" __MODULE__ = "Stickers"
__HELP__ = """ __HELP__ = """
/kang [Reply to sticker] - Add sticker to your pack. /kang [Reply to sticker] - Add sticker to your pack.
/unkang [Reply to sticker] - Remove sticker from your pack. /unkang [Reply to sticker] - Remove sticker from your pack (Only can remove sticker that added by this bot.).
/getsticker - Convert sticker to png. /getsticker - Convert sticker to png.
/stickerid - View sticker ID /stickerid - View sticker ID
""" """
@ -125,8 +118,8 @@ async def kang_sticker(c, m):
# mime_type: image/webp # mime_type: image/webp
resize = True resize = True
elif reply.document.mime_type in ( elif reply.document.mime_type in (
MessageMediaType.VIDEO, enums.MessageMediaType.VIDEO,
MessageMediaType.ANIMATION, enums.MessageMediaType.ANIMATION,
): ):
# mime_type: application/video # mime_type: application/video
videos = True videos = True

21
misskaty/plugins/webss.py
View file

@ -7,6 +7,7 @@ from PIL import Image
from pyrogram import filters from pyrogram import filters
from misskaty import app from misskaty import app
from misskaty.core.message_utils import *
from misskaty.core.decorator.errors import capture_err from misskaty.core.decorator.errors import capture_err
from misskaty.helper.http import http from misskaty.helper.http import http
from misskaty.vars import COMMAND_HANDLER from misskaty.vars import COMMAND_HANDLER
@ -19,19 +20,19 @@ __HELP__ = """
@app.on_message(filters.command(["webss"], COMMAND_HANDLER)) @app.on_message(filters.command(["webss"], COMMAND_HANDLER))
@capture_err @capture_err
async def take_ss(_, message): async def take_ss(_, m):
if len(message.command) == 1: if len(m.command) == 1:
return await message.reply("Give A Url To Fetch Screenshot.") return await kirimPesan(m, "Give A Url To Fetch Screenshot.")
url = message.command[1] if message.command[1].startswith("http") else f"https://{message.command[1]}" url = m.command[1] if m.command[1].startswith("http") else f"https://{m.command[1]}"
filename = f"imageToSave_{message.from_user.id}.png" filename = f"webSS_{m.from_user.id}.jpg"
m = await message.reply("Capturing screenshot...") msg = await m.reply("Capturing screenshot...")
try: try:
photo = (await http.get(f"https://yasirapi.eu.org/webss?url={url}")).json() photo = (await http.get(f"https://yasirapi.eu.org/webss?url={url}")).json()
img = Image.open(BytesIO(base64.decodebytes(bytes(photo["result"], "utf-8")))) img = Image.open(BytesIO(base64.decodebytes(bytes(photo["result"], "utf-8"))))
img.save(filename) img.save(filename)
m = await m.edit("Uploading...") await editPesan(msg, "Uploading...")
await gather(*[message.reply_document(filename), message.reply_photo(filename)]) await gather(*[m.reply_document(filename), m.reply_photo(filename)])
await m.delete() await hapusPesan(m)
os.remove(filename) os.remove(filename)
except Exception as e: except Exception as e:
await m.edit(f"Failed To Take Screenshot. {str(e)}") await editPesan(msg, f"Failed To Take Screenshot. {str(e)}")