516 lines
18 KiB
Python
516 lines
18 KiB
Python
# Ultroid - UserBot
|
|
# Copyright (C) 2020 TeamUltroid
|
|
#
|
|
# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
|
|
# PLease read the GNU Affero General Public License in
|
|
# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
|
|
|
|
"""
|
|
✘ Commands Available -
|
|
|
|
• `{i}destroy <reply to animated sticker>`
|
|
To destroy the sticker.
|
|
|
|
• `{i}tiny <reply to media>`
|
|
To create Tiny stickers.
|
|
|
|
• `{i}convert <gif/img/sticker>`
|
|
Reply to animated sticker.
|
|
|
|
• `{i}kang <reply to image/sticker>`
|
|
Kang the sticker (add to your pack).
|
|
|
|
• `{i}round <reply to any media>`
|
|
To extract round sticker.
|
|
|
|
• `{i}waifu <text>`
|
|
paste text on random stickers.
|
|
|
|
"""
|
|
|
|
import asyncio
|
|
import io
|
|
import os
|
|
import random
|
|
import re
|
|
import urllib.request
|
|
from os import remove
|
|
|
|
import cv2
|
|
import numpy as np
|
|
from PIL import Image, ImageDraw
|
|
from telethon.errors import ChatSendInlineForbiddenError, ChatSendStickersForbiddenError
|
|
from telethon.tl.types import (
|
|
DocumentAttributeFilename,
|
|
DocumentAttributeSticker,
|
|
MessageMediaPhoto,
|
|
)
|
|
|
|
from . import *
|
|
|
|
EMOJI_PATTERN = re.compile(
|
|
"["
|
|
"\U0001F1E0-\U0001F1FF" # flags (iOS)
|
|
"\U0001F300-\U0001F5FF" # symbols & pictographs
|
|
"\U0001F600-\U0001F64F" # emoticons
|
|
"\U0001F680-\U0001F6FF" # transport & map symbols
|
|
"\U0001F700-\U0001F77F" # alchemical symbols
|
|
"\U0001F780-\U0001F7FF" # Geometric Shapes Extended
|
|
"\U0001F800-\U0001F8FF" # Supplemental Arrows-C
|
|
"\U0001F900-\U0001F9FF" # Supplemental Symbols and Pictographs
|
|
"\U0001FA00-\U0001FA6F" # Chess Symbols
|
|
"\U0001FA70-\U0001FAFF" # Symbols and Pictographs Extended-A
|
|
"\U00002702-\U000027B0" # Dingbats
|
|
"]+"
|
|
)
|
|
|
|
|
|
def deEmojify(inputString: str) -> str:
|
|
"""Remove emojis and other non-safe characters from string"""
|
|
return re.sub(EMOJI_PATTERN, "", inputString)
|
|
|
|
|
|
@ultroid_cmd(
|
|
pattern="waifu ?(.*)",
|
|
)
|
|
async def waifu(animu):
|
|
xx = await eor(animu, "`Processing...`")
|
|
# """Creates random anime sticker!"""
|
|
text = animu.pattern_match.group(1)
|
|
if not text:
|
|
if animu.is_reply:
|
|
text = (await animu.get_reply_message()).message
|
|
else:
|
|
await xx.edit("`You haven't written any article, Waifu is going away.`")
|
|
return
|
|
waifus = [32, 33, 37, 40, 41, 42, 58, 20]
|
|
finalcall = "#" + (str(random.choice(waifus)))
|
|
try:
|
|
sticcers = await ultroid_bot.inline_query(
|
|
"stickerizerbot", f"{finalcall}{(deEmojify(text))}"
|
|
)
|
|
await sticcers[0].click(
|
|
animu.chat_id,
|
|
reply_to=animu.reply_to_msg_id,
|
|
silent=True if animu.is_reply else False,
|
|
hide_via=True,
|
|
)
|
|
await xx.delete()
|
|
except ChatSendInlineForbiddenError:
|
|
await xx.edit("`Boss ! I cant use inline things here...`")
|
|
except ChatSendStickersForbiddenError:
|
|
await xx.edit("Sorry boss, I can't send Sticker Here !!")
|
|
|
|
|
|
@ultroid_cmd(
|
|
pattern="convert ?(.*)",
|
|
)
|
|
async def uconverter(event):
|
|
xx = await eor(event, "`Processing...`")
|
|
a = await event.get_reply_message()
|
|
input = event.pattern_match.group(1)
|
|
b = await event.client.download_media(a, "resources/downloads/")
|
|
if "gif" in input:
|
|
cmd = ["lottie_convert.py", b, "something.gif"]
|
|
file = "something.gif"
|
|
elif "sticker" in input:
|
|
cmd = ["lottie_convert.py", b, "something.webp"]
|
|
file = "something.webp"
|
|
elif "img" in input:
|
|
cmd = ["lottie_convert.py", b, "something.png"]
|
|
file = "something.png"
|
|
else:
|
|
await xx.edit("**Please select from gif/sticker/img**")
|
|
process = await asyncio.create_subprocess_exec(
|
|
*cmd, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE
|
|
)
|
|
stdout, stderr = await process.communicate()
|
|
stderr.decode().strip()
|
|
stdout.decode().strip()
|
|
os.remove(b)
|
|
await event.client.send_file(event.chat_id, file, force_document=False)
|
|
os.remove(file)
|
|
await xx.delete()
|
|
|
|
|
|
@ultroid_cmd(
|
|
pattern="kang",
|
|
)
|
|
async def hehe(args):
|
|
xx = await eor(args, "`Processing...`")
|
|
user = await ultroid_bot.get_me()
|
|
if not user.username:
|
|
user.username = user.first_name
|
|
message = await args.get_reply_message()
|
|
photo = None
|
|
emojibypass = False
|
|
is_anim = False
|
|
emoji = None
|
|
if message and message.media:
|
|
if isinstance(message.media, MessageMediaPhoto):
|
|
await xx.edit(f"`{random.choice(KANGING_STR)}`")
|
|
photo = io.BytesIO()
|
|
photo = await ultroid_bot.download_media(message.photo, photo)
|
|
elif "image" in message.media.document.mime_type.split("/"):
|
|
await xx.edit(f"`{random.choice(KANGING_STR)}`")
|
|
photo = io.BytesIO()
|
|
await ultroid_bot.download_file(message.media.document, photo)
|
|
if (
|
|
DocumentAttributeFilename(file_name="sticker.webp")
|
|
in message.media.document.attributes
|
|
):
|
|
emoji = message.media.document.attributes[1].alt
|
|
emojibypass = True
|
|
elif "video" in message.media.document.mime_type.split("/"):
|
|
await xx.edit(f"`{random.choice(KANGING_STR)}`")
|
|
xy = await message.download_media()
|
|
y = cv2.VideoCapture(xy)
|
|
heh, lol = y.read()
|
|
cv2.imwrite("ult.webp", lol)
|
|
photo = "ult.webp"
|
|
elif "tgsticker" in message.media.document.mime_type:
|
|
await xx.edit(f"`{random.choice(KANGING_STR)}`")
|
|
await ultroid_bot.download_file(
|
|
message.media.document, "AnimatedSticker.tgs"
|
|
)
|
|
|
|
attributes = message.media.document.attributes
|
|
for attribute in attributes:
|
|
if isinstance(attribute, DocumentAttributeSticker):
|
|
emoji = attribute.alt
|
|
|
|
emojibypass = True
|
|
is_anim = True
|
|
photo = 1
|
|
else:
|
|
await xx.edit("`Unsupported File!`")
|
|
return
|
|
else:
|
|
await xx.edit("`I can't kang that...`")
|
|
return
|
|
|
|
if photo:
|
|
splat = args.text.split()
|
|
if not emojibypass:
|
|
emoji = "🔰"
|
|
pack = 1
|
|
if len(splat) == 3:
|
|
pack = splat[2] # User sent ultroid_both
|
|
emoji = splat[1]
|
|
elif len(splat) == 2:
|
|
if splat[1].isnumeric():
|
|
pack = int(splat[1])
|
|
else:
|
|
emoji = splat[1]
|
|
|
|
packname = f"ult_{user.id}_{pack}"
|
|
packnick = f"@{user.username}'s Pack {pack}"
|
|
cmd = "/newpack"
|
|
file = io.BytesIO()
|
|
|
|
if not is_anim:
|
|
image = await resize_photo(photo)
|
|
file.name = "sticker.png"
|
|
image.save(file, "PNG")
|
|
else:
|
|
packname += "_anim"
|
|
packnick += " (Animated)"
|
|
cmd = "/newanimated"
|
|
|
|
response = urllib.request.urlopen(
|
|
urllib.request.Request(f"http://t.me/addstickers/{packname}")
|
|
)
|
|
htmlstr = response.read().decode("utf8").split("\n")
|
|
|
|
if (
|
|
" A <strong>Telegram</strong> user has created the <strong>Sticker Set</strong>."
|
|
not in htmlstr
|
|
):
|
|
async with ultroid_bot.conversation("Stickers") as conv:
|
|
await conv.send_message("/addsticker")
|
|
await conv.get_response()
|
|
await ultroid_bot.send_read_acknowledge(conv.chat_id)
|
|
await conv.send_message(packname)
|
|
x = await conv.get_response()
|
|
while "120" in x.text:
|
|
pack += 1
|
|
packname = f"ult_{user.id}_{pack}"
|
|
packnick = f"@{user.username}'s Pack {pack}"
|
|
await xx.edit(
|
|
"`Switching to Pack "
|
|
+ str(pack)
|
|
+ " due to insufficient space`"
|
|
)
|
|
await conv.send_message(packname)
|
|
x = await conv.get_response()
|
|
if x.text == "Invalid pack selected.":
|
|
await conv.send_message(cmd)
|
|
await conv.get_response()
|
|
await ultroid_bot.send_read_acknowledge(conv.chat_id)
|
|
await conv.send_message(packnick)
|
|
await conv.get_response()
|
|
await ultroid_bot.send_read_acknowledge(conv.chat_id)
|
|
if is_anim:
|
|
await conv.send_file("AnimatedSticker.tgs")
|
|
remove("AnimatedSticker.tgs")
|
|
else:
|
|
file.seek(0)
|
|
await conv.send_file(file, force_document=True)
|
|
await conv.get_response()
|
|
await conv.send_message(emoji)
|
|
await ultroid_bot.send_read_acknowledge(conv.chat_id)
|
|
await conv.get_response()
|
|
await conv.send_message("/publish")
|
|
if is_anim:
|
|
await conv.get_response()
|
|
await conv.send_message(f"<{packnick}>")
|
|
await conv.get_response()
|
|
await ultroid_bot.send_read_acknowledge(conv.chat_id)
|
|
await conv.send_message("/skip")
|
|
await ultroid_bot.send_read_acknowledge(conv.chat_id)
|
|
await conv.get_response()
|
|
await conv.send_message(packname)
|
|
await ultroid_bot.send_read_acknowledge(conv.chat_id)
|
|
await conv.get_response()
|
|
await ultroid_bot.send_read_acknowledge(conv.chat_id)
|
|
await xx.edit(
|
|
f"`Sticker added in a Different Pack !\
|
|
\nThis Pack is Newly created!\
|
|
\nYour pack can be found [here](t.me/addstickers/{packname})",
|
|
parse_mode="md",
|
|
)
|
|
return
|
|
if is_anim:
|
|
await conv.send_file("AnimatedSticker.tgs")
|
|
remove("AnimatedSticker.tgs")
|
|
else:
|
|
file.seek(0)
|
|
await conv.send_file(file, force_document=True)
|
|
rsp = await conv.get_response()
|
|
if "Sorry, the file type is invalid." in rsp.text:
|
|
await xx.edit(
|
|
"`Failed to add sticker, use` @Stickers `bot to add the sticker manually.`"
|
|
)
|
|
return
|
|
await conv.send_message(emoji)
|
|
await ultroid_bot.send_read_acknowledge(conv.chat_id)
|
|
await conv.get_response()
|
|
await conv.send_message("/done")
|
|
await conv.get_response()
|
|
await ultroid_bot.send_read_acknowledge(conv.chat_id)
|
|
else:
|
|
await xx.edit("`Brewing a new Pack...`")
|
|
async with ultroid_bot.conversation("Stickers") as conv:
|
|
await conv.send_message(cmd)
|
|
await conv.get_response()
|
|
await ultroid_bot.send_read_acknowledge(conv.chat_id)
|
|
await conv.send_message(packnick)
|
|
await conv.get_response()
|
|
await ultroid_bot.send_read_acknowledge(conv.chat_id)
|
|
if is_anim:
|
|
await conv.send_file("AnimatedSticker.tgs")
|
|
remove("AnimatedSticker.tgs")
|
|
else:
|
|
file.seek(0)
|
|
await conv.send_file(file, force_document=True)
|
|
rsp = await conv.get_response()
|
|
if "Sorry, the file type is invalid." in rsp.text:
|
|
await xx.edit(
|
|
"`Failed to add sticker, use` @Stickers `bot to add the sticker manually.`"
|
|
)
|
|
return
|
|
await conv.send_message(emoji)
|
|
await ultroid_bot.send_read_acknowledge(conv.chat_id)
|
|
await conv.get_response()
|
|
await conv.send_message("/publish")
|
|
if is_anim:
|
|
await conv.get_response()
|
|
await conv.send_message(f"<{packnick}>")
|
|
|
|
await conv.get_response()
|
|
await ultroid_bot.send_read_acknowledge(conv.chat_id)
|
|
await conv.send_message("/skip")
|
|
await ultroid_bot.send_read_acknowledge(conv.chat_id)
|
|
await conv.get_response()
|
|
await conv.send_message(packname)
|
|
await ultroid_bot.send_read_acknowledge(conv.chat_id)
|
|
await conv.get_response()
|
|
await ultroid_bot.send_read_acknowledge(conv.chat_id)
|
|
await xx.edit(
|
|
f"`Kanged!`\
|
|
\n`Emoji` - {emoji}\
|
|
\n`Sticker Pack` [here](t.me/addstickers/{packname})",
|
|
parse_mode="md",
|
|
)
|
|
try:
|
|
os.remove(photo)
|
|
except BaseException:
|
|
pass
|
|
|
|
|
|
@ultroid_cmd(
|
|
pattern="round$",
|
|
)
|
|
async def ultdround(event):
|
|
ureply = await event.get_reply_message()
|
|
xx = await eor(event, "`Processing...`")
|
|
if not (ureply and (ureply.media)):
|
|
await xx.edit("`Reply to any media`")
|
|
return
|
|
ultt = await ureply.download_media()
|
|
if ultt.endswith(".tgs"):
|
|
await xx.edit("`Ooo Animated Sticker 👀...`")
|
|
cmd = ["lottie_convert.py", ultt, "ult.png"]
|
|
file = "ult.png"
|
|
process = await asyncio.create_subprocess_exec(
|
|
*cmd, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE
|
|
)
|
|
stdout, stderr = await process.communicate()
|
|
stderr.decode().strip()
|
|
stdout.decode().strip()
|
|
elif ultt.endswith((".gif", ".mp4", ".mkv")):
|
|
await xx.edit("`Processing...`")
|
|
img = cv2.VideoCapture(ultt)
|
|
heh, lol = img.read()
|
|
cv2.imwrite("ult.png", lol)
|
|
file = "ult.png"
|
|
else:
|
|
file = ultt
|
|
img = Image.open(file).convert("RGB")
|
|
npImage = np.array(img)
|
|
h, w = img.size
|
|
alpha = Image.new("L", img.size, 0)
|
|
draw = ImageDraw.Draw(alpha)
|
|
draw.pieslice([0, 0, h, w], 0, 360, fill=255)
|
|
npAlpha = np.array(alpha)
|
|
npImage = np.dstack((npImage, npAlpha))
|
|
Image.fromarray(npImage).save("ult.webp")
|
|
await event.client.send_file(
|
|
event.chat_id, "ult.webp", force_document=False, reply_to=event.reply_to_msg_id
|
|
)
|
|
await xx.delete()
|
|
os.remove(file)
|
|
os.remove("ult.webp")
|
|
os.remove(ultt)
|
|
|
|
|
|
@ultroid_cmd(
|
|
pattern="destroy$",
|
|
)
|
|
async def ultdestroy(event):
|
|
ult = await event.get_reply_message()
|
|
if not (ult and ("tgsticker" in ult.media.document.mime_type)):
|
|
await eor(event, "`Reply to Animated Sticker Only...`")
|
|
return
|
|
roid = await event.client.download_media(ult, "ultroid.tgs")
|
|
xx = await eor(event, "`Processing...`")
|
|
os.system("lottie_convert.py ultroid.tgs json.json")
|
|
json = open("json.json", "r")
|
|
jsn = json.read()
|
|
json.close()
|
|
jsn = (
|
|
jsn.replace("[100]", "[200]")
|
|
.replace("[10]", "[40]")
|
|
.replace("[-1]", "[-10]")
|
|
.replace("[0]", "[15]")
|
|
.replace("[1]", "[20]")
|
|
.replace("[2]", "[17]")
|
|
.replace("[3]", "[40]")
|
|
.replace("[4]", "[37]")
|
|
.replace("[5]", "[60]")
|
|
.replace("[6]", "[70]")
|
|
.replace("[7]", "[40]")
|
|
.replace("[8]", "[37]")
|
|
.replace("[9]", "[110]")
|
|
)
|
|
open("json.json", "w").write(jsn)
|
|
os.system("lottie_convert.py json.json ultroid.tgs")
|
|
await event.client.send_file(
|
|
event.chat_id,
|
|
file="ultroid.tgs",
|
|
force_document=False,
|
|
reply_to=event.reply_to_msg_id,
|
|
)
|
|
await xx.delete()
|
|
os.remove("ultroid.tgs")
|
|
os.remove("json.json")
|
|
os.remove(roid)
|
|
|
|
|
|
@ultroid_cmd(
|
|
pattern="tiny$",
|
|
)
|
|
async def ultiny(event):
|
|
reply = await event.get_reply_message()
|
|
if not (reply and (reply.media)):
|
|
await eor(event, "`Reply To Media`")
|
|
return
|
|
xx = await eor(event, "`processing...`")
|
|
ik = await ultroid_bot.download_media(reply)
|
|
im1 = Image.open("resources/extras/ultroid_blank.png")
|
|
if ik.endswith(".tgs"):
|
|
await event.client.download_media(reply, "ult.tgs")
|
|
os.system("lottie_convert.py ult.tgs json.json")
|
|
json = open("json.json", "r")
|
|
jsn = json.read()
|
|
json.close()
|
|
jsn = jsn.replace("512", "2000")
|
|
open("json.json", "w").write(jsn)
|
|
os.system("lottie_convert.py json.json ult.tgs")
|
|
file = "ult.tgs"
|
|
os.remove("json.json")
|
|
elif ik.endswith((".gif", ".mp4")):
|
|
iik = cv2.VideoCapture(ik)
|
|
dani, busy = iik.read()
|
|
cv2.imwrite("i.png", busy)
|
|
fil = "i.png"
|
|
im = Image.open(fil)
|
|
z, d = im.size
|
|
if z == d:
|
|
xxx, yyy = 200, 200
|
|
else:
|
|
t = z + d
|
|
a = z / t
|
|
b = d / t
|
|
aa = (a * 100) - 50
|
|
bb = (b * 100) - 50
|
|
xxx = 200 + 5 * aa
|
|
yyy = 200 + 5 * bb
|
|
k = im.resize((int(xxx), int(yyy)))
|
|
k.save("k.png", format="PNG", optimize=True)
|
|
im2 = Image.open("k.png")
|
|
back_im = im1.copy()
|
|
back_im.paste(im2, (150, 0))
|
|
back_im.save("o.webp", "WEBP", quality=95)
|
|
file = "o.webp"
|
|
os.remove(fil)
|
|
os.remove("k.png")
|
|
else:
|
|
im = Image.open(ik)
|
|
z, d = im.size
|
|
if z == d:
|
|
xxx, yyy = 200, 200
|
|
else:
|
|
t = z + d
|
|
a = z / t
|
|
b = d / t
|
|
aa = (a * 100) - 50
|
|
bb = (b * 100) - 50
|
|
xxx = 200 + 5 * aa
|
|
yyy = 200 + 5 * bb
|
|
k = im.resize((int(xxx), int(yyy)))
|
|
k.save("k.png", format="PNG", optimize=True)
|
|
im2 = Image.open("k.png")
|
|
back_im = im1.copy()
|
|
back_im.paste(im2, (150, 0))
|
|
back_im.save("o.webp", "WEBP", quality=95)
|
|
file = "o.webp"
|
|
os.remove("k.png")
|
|
await event.client.send_file(event.chat_id, file, reply_to=event.reply_to_msg_id)
|
|
await xx.delete()
|
|
os.remove(file)
|
|
os.remove(ik)
|
|
|
|
|
|
HELP.update({f"{__name__.split('.')[1]}": f"{__doc__.format(i=Var.HNDLR)}"})
|