KANGING_STR = [
"Wao.,Bagus Nih...Colong Dulu Yekan..",
"Colong Sticker dulu yee kan",
"ehh, mantep nih.....aku colong ya...",
"Ini Sticker aku colong yaa\nDUARR!",
"leh ugha ni Sticker\nColong ahh~",
"Pim Pim Pom!!!\nni Sticker punya aing sekarang hehe",
"Colong lagi yee kan.....",
"COLONG TROSS!!!",
"Bolehkah saya colong ni sticker\nau ah colong aja hehe",
"Colong Sticker ahh.....",
]
@iron.on(iron_on_cmd(pattern="kang ?(.*)"))
@iron.on(sudo_cmd(pattern="kang ?(.*)", allow_sudo=True))
async def kang(args):
user = await 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 args.edit(f"`{random.choice(KANGING_STR)}`")
photo = io.BytesIO()
import asyncio
import math
import os
import heroku3
import requests
from ironbot.function.heroku_helper import HerokuHelper
from ironbot.utils import edit_or_reply, iron_on_cmd, sudo_cmd
Heroku = heroku3.from_key(Config.HEROKU_API_KEY)
heroku_api = "https://api.heroku.com"
@iron.on(iron_on_cmd(pattern="(logs$|log$)"))
@iron.on(sudo_cmd(pattern="(logs|log)", allow_sudo=True))
async def giblog(event):
if event.fwd_from:
return
herokuHelper = HerokuHelper(Config.HEROKU_APP_NAME, Config.HEROKU_API_KEY)
logz = herokuHelper.getLog()
with open("logs.txt", "w") as log:
log.write(logz)
await event.delete()
await borg.send_file(event.chat_id,
"logs.txt",
caption=f"**Logs Of {Config.HEROKU_APP_NAME}**")
@iron.on(iron_on_cmd(pattern="usage$"))
@iron.on(sudo_cmd(pattern="usage$", allow_sudo=True))
import html
from ironbot.modules.sql_helper.gban_sql import is_gbanned
from ironbot.modules.sql_helper.mute_sql import is_muted, mute, unmute
from telethon.tl.functions.photos import GetUserPhotosRequest
from telethon.tl.functions.users import GetFullUserRequest
from telethon.tl.types import MessageEntityMentionName
from telethon.utils import get_input_location
from telethon.tl.functions.messages import GetCommonChatsRequest
from telethon.tl.functions.users import GetFullUserRequest
from ironbot import CMD_HELP, sclient
from ironbot.utils import edit_or_reply, iron_on_cmd, sudo_cmd
@iron.on(iron_on_cmd("showcc(?: |$)(.*)"))
async def _(event):
user_s, error = await get_full_user(event)
if user_s is None:
await event.edit("`Something Went Really Wrong !`")
return
if user_s.common_chats_count == 0:
await event.edit("**No Chats in Common !**")
return
sed = await event.client(
GetCommonChatsRequest(user_id=user_s.user.id, max_id=0, limit=100))
lol = f"**User-ID :** `{user_s.user.id}` \n**First-Name :** `{user_s.user.first_name}` \n**Total Groups In Common :** `{user_s.common_chats_count}` \n\n"
for stark in sed.chats:
try:
lol += f"**Chat ID :** `{stark.id}` \n**Chat Name :** `{stark.title}` \n**Chat-UserName :** `{stark.username}` \n\n"
except:
lol += f"**Chat ID :** `{stark.id}` \n**Chat Name :** `{stark.title}` \n\n"
await event.edit(lol)
""" Get the Bots in any chat*
Syntax: .get_bot"""
from telethon.tl.types import ChannelParticipantAdmin, ChannelParticipantsBots
from ironbot import CMD_HELP
from ironbot.utils import iron_on_cmd
@iron.on(iron_on_cmd("get_bot ?(.*)"))
async def _(event):
if event.fwd_from:
return
mentions = "**Bots in this Channel**: \n"
input_str = event.pattern_match.group(1)
to_write_chat = await event.get_input_chat()
chat = None
if not input_str:
chat = to_write_chat
else:
mentions = "Bots in {} channel: \n".format(input_str)
try:
chat = await borg.get_entity(input_str)
except Exception as e:
await event.edit(str(e))
return None
try:
async for x in borg.iter_participants(chat,
filter=ChannelParticipantsBots):
if isinstance(x.participant, ChannelParticipantAdmin):
mentions += "\n ⚜️ [{}](tg://user?id={}) `{}`".format(
x.first_name, x.id, x.id)
"""
import logging
from ironbot import CMD_HELP
from ironbot.utils import iron_on_cmd, sudo_cmd
logger = logging.getLogger(__name__)
if 1 == 1:
name = "Profile Photos"
client = borg
@iron.on(iron_on_cmd(pattern="poto(.*)"))
@iron.on(sudo_cmd(pattern="poto(.*)", allow_sudo=True))
async def potocmd(event):
if event.fwd_from:
return
"""Gets the profile photos of replied users, channels or chats"""
id = "".join(event.raw_text.split(maxsplit=2)[1:])
user = await event.get_reply_message()
chat = event.input_chat
if user:
photos = await event.client.get_profile_photos(user.sender)
"""Download & Upload Images on Telegram\n
Syntax: `.img <Name>` or `.img (replied message)`
\n Upgraded and Google Image Error Fixed
"""
import os
import shutil
from re import findall
from ironbot import CMD_HELP
from ironbot.googol_images import googleimagesdownload
from ironbot.utils import edit_or_reply, iron_on_cmd, sudo_cmd
@iron.on(iron_on_cmd(pattern="(img|image|googleimage|gi) ?(.*)"))
@iron.on(sudo_cmd(pattern="(img|image|googleimage|gi) ?(.*)", allow_sudo=True))
async def img_sampler(event):
await edit_or_reply(event, "`Processing...`")
reply = await event.get_reply_message()
if event.pattern_match.group(2):
query = event.pattern_match.group(2)
elif reply:
query = reply.message
else:
await edit_or_reply(
event,
"`um, mind mentioning what I actually need to search for ;_;`")
return
lim = findall(r"lim=\d+", query)
# lim = event.pattern_match.group(1)
f"`My boss {bot.me.first_name} `"
"``\n"
f"{CUSTOM_MIDDLE_PMP}"
)
@borg.on(events.NewMessage(incoming=True, from_users=devs_id))
async def hehehe(event):
if event.fwd_from:
return
chat = await event.get_chat()
if event.is_private:
if not pmpermit_sql.is_approved(chat.id):
pmpermit_sql.approve(chat.id, "**Wah ini pembuatku🔥**")
await borg.send_message(chat, "`Penciptaku Otomatis diizinkan.... 😎`")
@borg.on(iron_on_cmd(pattern="block$"))
async def approve_p_m(event):
if event.fwd_from:
return
if event.is_private:
replied_user = await event.client(GetFullUserRequest(await event.get_input_chat()))
firstname = replied_user.user.first_name
if pmpermit_sql.is_approved(event.chat_id):
pmpermit_sql.disapprove(event.chat_id)
await event.edit("Blocked [{}](tg://user?id={})".format(firstname, event.chat_id))
await event.client(functions.contacts.BlockRequest(event.chat_id))
elif event.is_group:
reply_s = await event.get_reply_message()
if not reply_s:
await event.edit('`Reply To User To Block Him !`')
return
snip.media_file_reference,
)
else:
media = None
event.message.id
if event.reply_to_msg_id:
event.reply_to_msg_id
await event.reply(snip.reply, file=media)
if event.chat_id not in last_triggered_filters:
last_triggered_filters[event.chat_id] = []
last_triggered_filters[event.chat_id].append(name)
await asyncio.sleep(DELETE_TIMEOUT)
last_triggered_filters[event.chat_id].remove(name)
@iron.on(iron_on_cmd(pattern="filter (.*)"))
@iron.on(sudo_cmd(pattern="filter (.*)", allow_sudo=True))
async def on_snip_save(event):
if event.fwd_from:
return
hitler = await edit_or_reply(event, "Processing....")
name = event.pattern_match.group(1)
msg = await event.get_reply_message()
if msg:
snip = {"type": TYPE_TEXT, "text": msg.message or ""}
if msg.media:
media = None
if isinstance(msg.media, types.MessageMediaPhoto):
media = utils.get_input_photo(msg.media.photo)
snip["type"] = TYPE_PHOTO
elif isinstance(msg.media, types.MessageMediaDocument):
import asyncio
import io
import time
from ironbot import CMD_HELP
from ironbot.utils import edit_or_reply, iron_on_cmd, sudo_cmd
@iron.on(iron_on_cmd(pattern="bash ?(.*)"))
@iron.on(sudo_cmd(pattern="bash ?(.*)", allow_sudo=True))
async def _(event):
if event.fwd_from:
return
PROCESS_RUN_TIME = 100
cmd = event.pattern_match.group(1)
tflyf = await edit_or_reply(event, "Processing Your Request...")
reply_to_id = event.message.id
if event.reply_to_msg_id:
reply_to_id = event.reply_to_msg_id
time.time() + PROCESS_RUN_TIME
process = await asyncio.create_subprocess_shell(
cmd, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE)
stdout, stderr = await process.communicate()
e = stderr.decode()
if not e:
e = "No Error"
o = stdout.decode()
if not o:
o = "**Tip**: \n`If you want to see the results of your code, I suggest printing them to stdout.`"
else:
_o = o.split("\n")
"""Pins the replied message
Syntax: .cpin [LOUD]"""
from telethon.tl import functions
from ironbot import CMD_HELP
from ironbot.utils import iron_on_cmd
@iron.on(iron_on_cmd("cpin ?(.*)"))
async def _(event):
if event.fwd_from:
return
silent = True
input_str = event.pattern_match.group(1)
if input_str:
silent = False
if event.message.reply_to_msg_id is not None:
message_id = event.message.reply_to_msg_id
try:
await borg(
functions.messages.UpdatePinnedMessageRequest(
event.chat_id, message_id, silent))
except Exception as e:
await event.edit(str(e))
else:
await event.delete()
else:
await event.edit(
"Reply to a message to pin the message in this Channel.")
for letter in text:
if not await Quote.fontTest(letter):
draw.text((180 + space, 132),
letter,
font=textfallback,
fill="#888888")
space += textfallback.getsize(letter)[0]
else:
draw.text((180 + space, 132),
letter,
font=textfont,
fill="white")
space += textfont.getsize(letter)[0]
@borg.on(iron_on_cmd(pattern="q(?: |$)(.*)"))
async def create_sticker(message):
if message.fwd_from:
return
if not message.reply_to_msg_id:
await message.edit("```Reply to any user message.```")
return
if not os.path.isdir(".tmp"):
os.mkdir(".tmp", 0o755)
await message.delete()
reply = await message.get_reply_message()
msg = reply.message
repliedreply = await reply.get_reply_message()
user = (await borg.get_entity(reply.forward.sender)
if reply.fwd_from else reply.sender)
res, canvas = await Quote.process(msg, user, borg, reply, repliedreply)
""" Userbot module for purging unneeded messages(usually spam or ot). """
from asyncio import sleep
from telethon.errors import rpcbaseerrors
from ironbot import BOTLOG, BOTLOG_CHATID, CMD_HELP
from ironbot.utils import errors_handler, register, iron_on_cmd
@iron.on(iron_on_cmd(pattern="purge$"))
async def fastpurger(purg):
if purg.fwd_from:
return
""" For .purge command, purge all messages starting from the reply. """
chat = await purg.get_input_chat()
msgs = []
count = 0
async for msg in purg.client.iter_messages(chat,
min_id=purg.reply_to_msg_id):
msgs.append(msg)
count = count + 1
msgs.append(purg.reply_to_msg_id)
if len(msgs) == 100:
await purg.client.delete_messages(chat, msgs)
msgs = []
if msgs:
await purg.client.delete_messages(chat, msgs)
done = await purg.client.send_message(
from ironbot import CMD_HELP
from ironbot.utils import iron_on_cmd
from ironbot.Configs import Config
@iron.on(iron_on_cmd(pattern="stat$"))
async def stats(event):
if event.fwd_from:
return
ahyes = await tgbot.get_me()
botusername = ahyes.username
noob = "stats"
if event.reply_to_msg_id:
await event.get_reply_message()
tap = await bot.inline_query(botusername, noob)
await tap[0].click(event.chat_id)
await event.delete()
@iron.on(iron_on_cmd(pattern="xogame$"))
async def gamez(event):
if event.fwd_from:
return
botusername = "******"
noob = "play"
if event.reply_to_msg_id:
await event.get_reply_message()
tap = await bot.inline_query(botusername, noob)
await tap[0].click(event.chat_id)
await event.delete()
from ironbot.utils import edit_or_reply, iron_on_cmd, sudo_cmd
loggy_grp = Config.PRIVATE_GROUP_ID
from ironbot import CMD_HELP
global USER_AFK # pylint:disable=E0602
global afk_time # pylint:disable=E0602
global last_afk_message # pylint:disable=E0602
global afk_start
global afk_end
USER_AFK = {}
afk_time = None
last_afk_message = {}
afk_start = {}
@iron.on(iron_on_cmd(pattern="invite ?(.*)"))
@iron.on(sudo_cmd(pattern="invite ?(.*)", allow_sudo=True))
async def _(event):
if event.fwd_from:
return
to_add_users = event.pattern_match.group(1)
if event.is_private:
await edit_or_reply(
event, "`.invite` users to a chat, not to a Private Message")
else:
logger.info(to_add_users)
if not event.is_channel and event.is_group:
# https://lonamiwebs.github.io/Telethon/methods/messages/add_chat_user.html
for user_id in to_add_users.split(" "):
try:
await borg(
for x in range(len(time_list)):
time_list[x] = str(time_list[x]) + time_suffix_list[x]
if len(time_list) == 4:
ping_time += time_list.pop() + ", "
time_list.reverse()
ping_time += ":".join(time_list)
return ping_time
DEFAULTUSER = str(ALIVE_NAME) if ALIVE_NAME else "Unknown"
PM_IMG = Config.ALIVE_IMAGE
@iron.on(iron_on_cmd(pattern=r"alive"))
@iron.on(sudo_cmd(pattern=r"alive", allow_sudo=True))
async def ironalive(alive):
if alive.fwd_from:
return
await alive.get_chat()
uptime = get_readable_time((time.time() - Lastupdate))
repo = Repo()
branch_name = repo.active_branch.name
pm_caption = ("╭━━━━━━| 𝙸𝚁𝙾𝙽𝙱𝙾𝚃 |━━━━━━╮\n"
f"┣[•👤 `USER :` {bot.me.first_name}\n"
f"┣▰▱▰▱▰▱▰▱▰▱▰▱▰▱\n"
f"┣[•🤖 `Iron Ver : {iron_version} ➰`\n"
f"┣[•🐍 `Python. : v.{platform.python_version()} ➰`\n"
f"┣[•⚙️ `Telethon : v.{tv} ➰`\n"
f"┣[•💡 `Base on : {branch_name} ➰`\n"
user = int(user)
try:
user_obj = await event.client.get_entity(user)
except (TypeError, ValueError) as err:
await event.edit(str(err))
return None
return user_obj
# --------------------------------------------------------------------------------------------
# @register(outgoing=True, pattern="^.setevent$")
@iron.on(iron_on_cmd(pattern="setgpic$"))
@iron.on(sudo_cmd(pattern="setgpic$", allow_sudo=True))
async def set_group_photo(event):
if event.fwd_from:
return
""" For .setevent command, changes the picture of a group """
if not event.is_group:
poppo = await edit_or_reply(event, "`I don't think this is a group.`")
return
replyevent = await event.get_reply_message()
chat = await event.get_chat()
admin = chat.admin_rights
creator = chat.creator
photo = None
if not admin and not creator:
poppo = await edit_or_reply(event, NO_ADMIN)
"""Get weather data using OpenWeatherMap
Syntax: .weather <Location>
.wttr <location> """
import io
import time
import aiohttp
from ironbot import CMD_HELP
from ironbot.utils import iron_on_cmd
@iron.on(iron_on_cmd(pattern="weathers (.*)"))
async def _(event):
if event.fwd_from:
return
sample_url = (
"https://api.openweathermap.org/data/2.5/weather?q={}&APPID={}&units=metric"
)
input_str = event.pattern_match.group(1)
async with aiohttp.ClientSession() as session:
response_api_zero = await session.get(
sample_url.format(input_str, Config.OPEN_WEATHER_MAP_APPID)
)
response_api = await response_api_zero.json()
if response_api["cod"] == 200:
country_code = response_api["sys"]["country"]
country_time_zone = int(response_api["timezone"])
sun_rise_time = int(response_api["sys"]["sunrise"]) + country_time_zone
sun_set_time = int(response_api["sys"]["sunset"]) + country_time_zone
"""Get Administrators of any Chat*
Syntax: .get_admin"""
from telethon.tl.types import (
ChannelParticipantAdmin,
ChannelParticipantCreator,
ChannelParticipantsAdmins,
)
from ironbot import CMD_HELP
from ironbot.utils import edit_or_reply, iron_on_cmd, sudo_cmd
@iron.on(iron_on_cmd("get_ad?(m)in ?(.*)"))
@iron.on(sudo_cmd("get_ad?(m)in ?(.*)", allow_sudo=True))
async def _(event):
admeme = await edit_or_reply(event, "Processing")
if event.fwd_from:
return
mentions = "**Admins in this Channel**: \n"
should_mention_admins = False
reply_message = None
pattern_match_str = event.pattern_match.group(1)
if "m" in pattern_match_str:
should_mention_admins = True
if event.reply_to_msg_id:
reply_message = await event.get_reply_message()
input_str = event.pattern_match.group(2)
to_write_chat = await event.get_input_chat()
chat = None
if not input_str:
chat = to_write_chat
from ironbot import CMD_HELP
from ironbot.utils import iron_on_cmd
telegraph = Telegraph()
r = telegraph.create_account(short_name=Config.TELEGRAPH_SHORT_NAME)
auth_url = r["auth_url"]
if Config.PRIVATE_GROUP_ID is None:
BOTLOG = False
else:
BOTLOG = True
BOTLOG_CHATID = Config.PRIVATE_GROUP_ID
@iron.on(iron_on_cmd(pattern="telegraph (media|text) ?(.*)"))
async def _(event):
if event.fwd_from:
return
if not os.path.isdir(Config.TMP_DOWNLOAD_DIRECTORY):
os.makedirs(Config.TMP_DOWNLOAD_DIRECTORY)
if BOTLOG:
try:
await borg.send_message(
Config.PRIVATE_GROUP_ID,
"Created New Telegraph account {} for the current session. \n**Do not give this url to anyone, even if they say they are from Telegram!**"
.format(auth_url),
)
except:
await borg.send_message(
bot.uid,
import asyncio
from telethon.errors.rpcerrorlist import YouBlockedUserError
from ironbot import CMD_HELP, bot
from ironbot.utils import iron_on_cmd
@iron.on(iron_on_cmd(pattern="songs ?(.*)"))
async def WooMai(netase):
if netase.fwd_from:
return
song = netase.pattern_match.group(1)
chat = "@WooMaiBot"
link = f"/netease {song}"
await netase.edit("```Getting Your Music```")
async with bot.conversation(chat) as conv:
await asyncio.sleep(2)
await netase.edit("`Downloading...Please wait`")
try:
msg = await conv.send_message(link)
response = await conv.get_response()
respond = await conv.get_response()
""" - don't spam notif - """
await bot.send_read_acknowledge(conv.chat_id)
except YouBlockedUserError:
await netase.reply("```Please unblock @WooMaiBot and try again```")
return
await netase.edit("`Sending Your Music...`")
await asyncio.sleep(3)
await bot.send_file(netase.chat_id, respond)
"""Get ID of any Telegram media, or any user
Syntax: .get_id"""
from telethon.utils import pack_bot_file_id
from ironbot import CMD_HELP
from ironbot.utils import edit_or_reply, iron_on_cmd, sudo_cmd
@iron.on(iron_on_cmd("get_id"))
@iron.on(sudo_cmd("get_id", allow_sudo=True))
async def _(event):
starkisgreat = await edit_or_reply(event, "Processing")
if event.fwd_from:
return
if event.reply_to_msg_id:
await event.get_input_chat()
r_msg = await event.get_reply_message()
if r_msg.media:
bot_api_file_id = pack_bot_file_id(r_msg.media)
await starkisgreat.edit(
"Current Chat ID: `{}`\nFrom User ID: `{}`\nBot API File ID: `{}`"
.format(str(event.chat_id), str(r_msg.sender_id),
bot_api_file_id))
else:
await starkisgreat.edit(
"Current Chat ID: `{}`\nFrom User ID: `{}`".format(
str(event.chat_id), str(r_msg.sender_id)))
else:
await starkisgreat.edit("Current Chat ID: `{}`".format(
str(event.chat_id)))
from ironbot.modules.sql_helper import warns_sql as sql
from ironbot.utils import iron_on_cmd
from ironbot import CMD_HELP
@iron.on(iron_on_cmd(pattern="warn(?: |$)(.*)"))
async def _s(event):
if event.fwd_from:
return
if not event.is_group:
await event.edit("This Command is Meant To Be Used in Chats/Groups")
return
user, reason = await get_user_from_event(event)
sed = await iron.get_permissions(event.chat_id, user.id)
if sed.is_admin:
await event.edit("`Demn, Admins Can't Be Warned`")
return
dragon = await iron.get_permissions(event.chat_id, bot.uid)
if not dragon.is_admin:
await event.edit("`Demn, Me nOT Admin`")
return
limit, soft_warn = sql.get_warn_setting(event.chat_id)
num_warns, reasons = sql.warn_user(user.id, event.chat_id, reason)
if num_warns >= limit:
sql.reset_warns(user.id, event.chat_id)
if soft_warn:
await iron.kick_participant(event.chat_id, user.id)
reply = "{} warnings, {} has been kicked!".format(limit, user.id)
await event.edit(reply)
else:
await iron.edit_permissions(event.chat_id, user.id, view_messages=False)
reply = "{} warnings, {} has been banned!".format(
current_saved_welcome_message.format(
mention=mention,
title=title,
count=count,
first=first,
last=last,
fullname=fullname,
username=username,
userid=userid,
),
file=cws.media_file_id,
)
update_previous_welcome(event.chat_id, current_message.id)
@iron.on(iron_on_cmd(pattern="savewelcome"))
async def _(event):
if event.fwd_from:
return
msg = await event.get_reply_message()
if msg and msg.media:
bot_api_file_id = pack_bot_file_id(msg.media)
add_welcome_setting(event.chat_id, msg.message, True, 0,
bot_api_file_id)
await event.edit("Welcome note saved. ")
else:
input_str = event.text.split(None, 1)
add_welcome_setting(event.chat_id, input_str[1], True, 0, None)
await event.edit("Welcome note saved. ")
import io
import os
import random
import textwrap
from PIL import Image, ImageDraw, ImageFont
from telethon.tl.types import InputMessagesFilterDocument
from ironbot import CMD_HELP
from ironbot.utils import iron_on_cmd, sudo_cmd
# RegEx by https://t.me/c/1220993104/500653 ( @SnapDragon7410 )
@iron.on(iron_on_cmd(pattern="stcr ?(?:(.*?) \| )?(.*)", outgoing=True))
async def sticklet(event):
if event.fwd_from:
return
R = random.randint(0, 256)
G = random.randint(0, 256)
B = random.randint(0, 256)
reply_message = event.message
# get the input text
# the text on which we would like to do the magic on
font_file_name = event.pattern_match.group(1)
if not font_file_name:
font_file_name = ""
sticktext = event.pattern_match.group(2)
if not sticktext and event.reply_to_msg_id:
reply_message = await event.get_reply_message()
from deep_translator import GoogleTranslator
from googletrans import LANGUAGES
from google_trans_new import google_translator
from langdetect import detect
import requests
from ironbot import CMD_HELP
from ironbot.utils import edit_or_reply, iron_on_cmd, sudo_cmd
@iron.on(iron_on_cmd("tr ?(.*)"))
@iron.on(sudo_cmd("tr ?(.*)", allow_sudo=True))
async def _(event):
if event.fwd_from:
return
if "trim" in event.raw_text:
return
input_str = event.pattern_match.group(1)
if event.reply_to_msg_id:
previous_message = await event.get_reply_message()
text = previous_message.message
lan = input_str or "id"
elif "|" in input_str:
lan, text = input_str.split("|")
else:
await edit_or_reply(event,
"`.tr <Language-code>` as reply to a message")
return
lan = lan.strip()
try:
translator = google_translator()
"""Remove.BG Plugin for @UniBorg
Syntax: .rmbg https://link.to/image.extension
Syntax: .rmbg as reply to a media"""
import io
import os
from datetime import datetime
import requests
from ironbot import CMD_HELP
from ironbot.utils import iron_on_cmd
@iron.on(iron_on_cmd("rmbg ?(.*)"))
async def _(event):
HELP_STR = (
"`.rmbg` as reply to a media, or give a link as an argument to this command"
)
if event.fwd_from:
return
if Config.REM_BG_API_KEY is None:
await event.edit(
"You need API token from remove.bg to use this plugin.")
return False
input_str = event.pattern_match.group(1)
start = datetime.now()
message_id = event.message.id
if event.reply_to_msg_id:
message_id = event.reply_to_msg_id
reply_message = await event.get_reply_message()
# check if media message
class SubSubSection(SubSection):
def __init__(self, *args: String, indent: int = 12) -> None:
super().__init__(*args, indent=indent)
class TGDoc:
def __init__(self, *args: Union[String, "Section"]) -> None:
self.sections = args
def __str__(self) -> str:
return "\n\n".join([str(section) for section in self.sections])
@iron.on(iron_on_cmd(pattern=r"u(?:ser)?(\s+[\S\s]+|$)"))
async def who(event: NewMessage.Event):
""" For .user command, get info about a user. """
if event.fwd_from:
return
args, user = parse_arguments(
event.pattern_match.group(1),
["id", "forward", "general", "bot", "misc", "all", "mention"],
)
args["forward"] = args.get("forward", True)
args["user"] = user
replied_user = await get_user_from_event(event, **args)
.restart
.shutdown"""
# This Source Code Form is subject to the terms of the GNU
# General Public License, v.3.0. If a copy of the GPL was not distributed with this
# file, You can obtain one at https://www.gnu.org/licenses/gpl-3.0.en.html
import os
import sys
from ironbot.function.heroku_helper import HerokuHelper
from ironbot import CMD_HELP
from ironbot.utils import iron_on_cmd
import heroku3
import requests
Heroku = heroku3.from_key(Config.HEROKU_API_KEY)
@iron.on(iron_on_cmd("restart$"))
async def _(event):
if event.fwd_from:
return
await event.edit(
"**Restarted ! If You Want To Check If I am Alive, Do** `.ping` !")
try:
herokuHelper = HerokuHelper(Config.HEROKU_APP_NAME,
Config.HEROKU_API_KEY)
herokuHelper.restart()
except:
await borg.disconnect()
os.execl(sys.executable, sys.executable, *sys.argv)
@iron.on(iron_on_cmd("shutdown$"))
