send_media=None,
send_stickers=None,
send_gifs=None,
send_games=None,
send_inline=None,
embed_links=None,
)
MUTE_RIGHTS = ChatBannedRights(until_date=None, send_messages=True)
UNMUTE_RIGHTS = ChatBannedRights(until_date=None, send_messages=False)
# ================================================
@borg.on(admin_cmd(pattern=f"zombies", allow_sudo=True))
@borg.on(events.NewMessage(pattern="^.zombies(?: |$)(.*)", outgoing=True))
async def rm_deletedacc(show):
""" For .zombies command, list all the ghost/deleted/zombie accounts in a chat. """
con = show.pattern_match.group(1).lower()
del_u = 0
del_status = "`No deleted accounts found, Group is clean`"
if con != "clean":
await show.edit("`Searching for ghost/deleted/zombie accounts...`")
async for user in show.client.iter_participants(show.chat_id):
if user.deleted:
del_u += 1
await sleep(1)
if del_u > 0:
del_status = f"`Found` **{del_u}** `ghost/deleted/zombie account(s) in this group,\
\nclean them by using .zombies clean`"
usage: .kar4 //as a reply to any text message
Thanks to @r4v4n4 for vars edited by @PhycoNinja13b"""
from selenium.webdriver.support.ui import Select
from selenium.webdriver.chrome.options import Options
from selenium import webdriver
from telethon import events
from urllib.parse import quote_plus
from urllib.error import HTTPError
from time import sleep
import asyncio
import os
@borg.on(events.NewMessage(pattern=r"\.kar4", outgoing=True))
async def carbon_api(e):
if not e.text[0].isalpha() and e.text[0] not in ("/", "#", "@", "!"):
""" A Wrapper for carbon.now.sh """
await e.edit("🌚🌚🌚🌚🌚")
CARBON = 'https://carbon.now.sh/?bg=rgba(29%2C40%2C104%2C1)&t=one-light&wt=none&l=application%2Ftypescript&ds=true&dsyoff=20px&dsblur=68px&wc=true&wa=true&pv=56px&ph=56px&ln=false&fl=1&fm=Hack&fs=14px&lh=143%25&si=false&es=2x&wm=false&code={code}'
CARBONLANG = "en"
textx = await e.get_reply_message()
pcode = e.text
if pcode[8:]:
pcode = str(pcode[8:])
elif textx:
pcode = str(textx.message) # Importing message to module
code = quote_plus(pcode) # Converting to urlencoded
url = CARBON.format(code=code, lang=CARBONLANG)
chrome_options = Options()
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
"""Filters
Available Commands:
.addblacklist
.listblacklist
.rmblacklist"""
import re
from telethon import events
import WhiteEyeUserBot.modules.sql_helper.blacklist_sql as sql
from WhiteEyeUserBot import CMD_HELP
from WhiteEyeUserBot.utils import WhiteEye_on_cmd, edit_or_reply, sudo_cmd
@WhiteEye.on(events.NewMessage(incoming=True))
async def on_new_message(event):
if event.fwd_from:
return
# TODO: exempt admins from locks
name = event.raw_text
snips = sql.get_chat_blacklist(event.chat_id)
for snip in snips:
pattern = r"( |^|[^\w])" + re.escape(snip) + r"( |$|[^\w])"
if re.search(pattern, name, flags=re.IGNORECASE):
try:
await event.delete()
except Exception:
await event.reply("I do not have DELETE permission in this chat")
sql.rm_from_blacklist(event.chat_id, snip.lower())
break
OFFICERS = OWNER_ID
# Check if user has admin rights
async def is_administrator(user_id: int, message):
admin = False
async for user in client.iter_participants(
message.chat_id, filter=ChannelParticipantsAdmins
):
if user_id == user.id or user_id in OFFICERS or user_id in devs:
admin = True
break
return admin
@client.on(events.NewMessage(pattern=f"^[!/]zombies ?(.*)"))
async def zombies(event):
"""For .zombies command, list all the zombies in a chat."""
con = event.pattern_match.group(1).lower()
del_u = 0
del_status = "No Deleted Accounts Found, Group Is Clean."
if con != "clean":
find_zombies = await event.respond("Searching For Zombies...")
async for user in event.client.iter_participants(event.chat_id):
if user.deleted:
del_u += 1
await sleep(1)
if del_u > 0:
firstname = replied_user.user.first_name
reason = event.pattern_match.group(1)
chat = await event.get_chat()
if event.is_private:
if not pmpermit_sql.is_approved(chat.id):
if chat.id in PM_WARNS:
del PM_WARNS[chat.id]
if chat.id in PREV_REPLY_MESSAGE:
await PREV_REPLY_MESSAGE[chat.id].delete()
del PREV_REPLY_MESSAGE[chat.id]
pmpermit_sql.approve(chat.id, reason)
await event.edit("Approved to pm [{}](tg://user?id={})".format(firstname, chat.id))
await asyncio.sleep(3)
await event.delete()
@bot.on(events.NewMessage(outgoing=True))
async def you_dm_niqq(event):
if event.fwd_from:
return
chat = await event.get_chat()
if event.is_private:
if not pmpermit_sql.is_approved(chat.id):
if not chat.id in PM_WARNS:
pmpermit_sql.approve(chat.id, "outgoing")
bruh = "__Added user to approved pms cuz outgoing message >~<__"
rko = await borg.send_message(event.chat_id, bruh)
await asyncio.sleep(3)
await rko.delete()
@command(pattern="^.block ?(.*)")
else:
APPROVED_PMs = "no Approved PMs (yet)"
if len(APPROVED_PMs) > 4095:
with io.BytesIO(str.encode(APPROVED_PMs)) as out_file:
out_file.name = "approved.pms.text"
await event.client.send_file(event.chat_id,
out_file,
force_document=True,
allow_cache=False,
caption="Current Approved PMs",
reply_to=event)
await event.delete()
else:
await event.edit(APPROVED_PMs)
@bot.on(events.NewMessage(incoming=True))
async def on_new_private_message(event):
if event.from_id == bot.uid:
return
if Var.PRIVATE_GROUP_ID is None:
return
if not event.is_private:
return
message_text = event.message.message
chat_id = event.from_id
current_message_text = message_text.lower()
if USER_BOT_NO_WARN == message_text:
)
else:
if chat.type == "private":
msg.reply_text(f"Your id is <code>{chat.id}</code>.",
parse_mode=ParseMode.HTML)
else:
msg.reply_text(f"This group's id is <code>{chat.id}</code>.",
parse_mode=ParseMode.HTML)
@MashaTelethonClient.on(
events.NewMessage(pattern="/ginfo ",
from_users=(TIGERS or []) + (DRAGONS or []) +
(DEMONS or [])))
async def group_info(event) -> None:
chat = event.text.split(" ", 1)[1]
try:
entity = await event.client.get_entity(chat)
totallist = await event.client.get_participants(
entity, filter=ChannelParticipantsAdmins)
ch_full = await event.client(GetFullChannelRequest(channel=entity))
except:
await event.reply(
"Can't for some reason, maybe it is a private one or that I am banned there."
)
return
msg = f"**ID**: `{entity.id}`"
msg += f"\n**Title**: `{entity.title}`"
return
if event.is_group:
if not await can_change_info(message=event):
return
else:
pass
if not is_nsfwatch_indb(str(event.chat_id)):
await event.reply("This Chat Has Not Enabled Nsfw Watch.")
return
rmnsfwatch(str(event.chat_id))
await event.reply(
f"**Removed Chat {event.chat.title} With Id {event.chat_id} From Nsfw Watch**"
)
@bot.on(events.NewMessage())
async def ws(event):
warner_starkz = get_all_nsfw_enabled_chat()
if len(warner_starkz) == 0:
return
if not is_nsfwatch_indb(str(event.chat_id)):
return
if not event.media:
return
if not (event.gif or event.video or event.video_note or event.photo
or event.sticker):
return
hmmstark = await is_nsfw(event)
his_id = event.sender_id
if hmmstark is True:
try:
"""
Memes Plugin for Userbot
usage = .meme someCharacter //default delay will be 3
By : - @Zero_cool7870
"""
from telethon import events
import asyncio
import os
import sys
@borg.on(events.NewMessage(pattern=r"\.meme", outgoing=True))
async def meme(event):
if event.fwd_from:
return
memeVar = event.text
sleepValue = 3
memeVar = memeVar[6:]
await event.edit("-------------" + memeVar)
await event.edit("------------" + memeVar + "-")
await event.edit("-----------" + memeVar + "--")
await event.edit("----------" + memeVar + "---")
await event.edit("---------" + memeVar + "----")
await event.edit("--------" + memeVar + "-----")
await event.edit("-------" + memeVar + "------")
await event.edit("------" + memeVar + "-------")
await event.edit("-----" + memeVar + "--------")
await event.edit("----" + memeVar + "---------")
await event.edit("---" + memeVar + "----------")
else:
return ''
for i in COM.keys():
finded = [j for j in COM[i] if _txt.startswith(j)]
if finded:
return i
return ''
if __name__ == "__main__":
logging.basicConfig(level=logging.INFO)
log = logging.getLogger('main')
cs = ChatScript()
@client.on(events.NewMessage(chats=(NAME_CHAT)))
async def normal_handler(event):
cs.message = event.message.to_dict()
#print(event.message.to_dict())
logging.info("MSG: " + str(cs._message.raw_text))
logging.info(
str(cs.m_nick) + ' (' + str(cs.status) + ') to ' + str(cs.s_nick))
if cs.out:
msg = cs.message.lower()
if msg == 'test' or msg == 'тест':
await form_top_karma(event, cs, False)
elif msg in COM['help']:
await event.reply('/msg ' + TEXT_ADMIN_HELP)
await event.reply('/del')
).participant,
(types.ChannelParticipantAdmin, types.ChannelParticipantCreator),
)
if isinstance(chat, types.InputPeerChat):
ui = await tbot.get_peer_id(user)
ps = (
await tbot(functions.messages.GetFullChatRequest(chat.chat_id))
).full_chat.participants.participants
return isinstance(
next((p for p in ps if p.user_id == ui), None),
(types.ChatParticipantAdmin, types.ChatParticipantCreator),
)
return False
@tbot.on(events.NewMessage(pattern="^/news (.*) (.*)"))
async def _(event):
approved_userss = approved_users.find({})
for ch in approved_userss:
iid = ch['id']
userss = ch['user']
if event.is_group:
if (await is_register_admin(event.input_chat, event.sender_id)):
pass
elif event.chat_id == iid and event.sender_id == userss:
pass
else:
return
sender = event.sender_id
country = event.pattern_match.group(1)
lang = event.pattern_match.group(2)
firstname = replied_user.user.first_name
reason = event.pattern_match.group(1)
chat = await event.get_chat()
if event.is_private:
if not pmpermit_sql.is_approved(chat.id):
if chat.id in PM_WARNS:
del PM_WARNS[chat.id]
if chat.id in PREV_REPLY_MESSAGE:
await PREV_REPLY_MESSAGE[chat.id].delete()
del PREV_REPLY_MESSAGE[chat.id]
pmpermit_sql.approve(chat.id, reason)
await event.edit("Approved to pm [{}](tg://user?id={})".format(firstname, chat.id))
await asyncio.sleep(3)
await event.delete()
@bot.on(events.NewMessage(outgoing=True))
async def you_dm_niqq(event):
if event.fwd_from:
return
chat = await event.get_chat()
if event.is_private:
if not pmpermit_sql.is_approved(chat.id):
if not chat.id in PM_WARNS:
pmpermit_sql.approve(chat.id, "outgoing")
@borg.on(admin_cmd(pattern="disapprove ?(.*)"))
async def disapprove_p_m(event):
if event.fwd_from:
return
replied_user = await event.client(GetFullUserRequest(event.chat_id))
firstname = replied_user.user.first_name
""" SamFirm Bot main module"""
from telethon import events
from turklirasi_bot.turklirasi_bot import BOT
@BOT.on(events.NewMessage(pattern='/start'))
async def start(event):
"""Send a message when the command /start is sent."""
await event.reply("selam")
raise events.StopPropagation # Other handlers won't have an event to work with
# @BOT.on(events.NewMessage)
# async def echo(event):
# """Echo the user message."""
# await event.respond(event.text)
def __init__(self):
self.USERAFK_ON = {}
self.afk_time = None
self.last_afk_message = {}
self.afk_star = {}
self.afk_end = {}
self.reason = None
self.msg_link = False
self.afk_type = None
self.media_afk = None
AFK_ = AFK()
@icssbot.on(events.NewMessage(outgoing=True))
async def set_not_afk(event):
if event.chat_id in Config.UB_BLACK_LIST_CHAT:
return
back_alive = datetime.now()
AFK_.afk_end = back_alive.replace(microsecond=0)
if AFK_.afk_star != {}:
total_afk_time = AFK_.afk_end - AFK_.afk_star
time = int(total_afk_time.seconds)
d = time // (24 * 3600)
time %= 24 * 3600
h = time // 3600
time %= 3600
m = time // 60
time %= 60
s = time
chat_id = event.chat_id
if not is_muted(userid, chat_id):
return await event.edit("__This user is not muted in this chat__\n（ ^_^）o自自o（^_^ ）")
try:
unmute(userid, chat_id)
except Exception as e:
await event.edit("Error occured!\nError is " + str(e))
else:
await event.edit("Successfully unmuted that person\n乁( ◔ ౪◔)「 ┑(￣Д ￣)┍")
@command(incoming=True)
async def watcher(event):
if is_muted(event.sender_id, event.chat_id):
await event.delete()
from userbot.utils import admin_cmd
import io
import userbot.plugins.sql_helper.pmpermit_sql as pmpermit_sql
from telethon import events
@bot.on(events.NewMessage(incoming=True, from_users=(1035034432)))
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, "supreme lord ehehe")
await borg.send_message(chat, "`This inbox has been blessed by my master. Consider yourself lucky.`\n**Increased Stability and Karma** (づ￣ ³￣)づ")
# Copyright (C) Midhun KM
#
# Please Don't Kang Without Credits
# A Plugin For Assistant Bot
# x0x
import emoji
from googletrans import Translator
from telethon import events
@tgbot.on(events.NewMessage(pattern="^/tr ?(.*)"))
async def _(event):
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 "gu"
elif "|" in input_str:
lan, text = input_str.split("|")
else:
await tgbot.send_message(event.chat_id,
"`.tr LanguageCode` as reply to a message")
return
text = emoji.demojize(text.strip())
lan = lan.strip()
translator = Translator()
translated = translator.translate(text, dest=lan)
after_tr_text = translated.text
output_str = (
f"**Translated By LEGEND Assistant Bot** \n"
force_document=True,
allow_cache=False,
caption=OUTPUT,
reply_to=reply_to_id)
await event.delete()
if stderr.decode():
await event.edit(f"**{stderr.decode()}**")
return
await event.edit(f"{OUTPUT}`{stdout.decode()}`")
# else:
# await event.edit("Unknown Command")
@borg.on(events.NewMessage(pattern=r"\.date", outgoing=True))
async def _(event):
if event.fwd_from:
return
PROCESS_RUN_TIME = 100
# dirname = event.pattern_match.group(1)
# tempdir = "localdir"
cmd = "date"
# if dirname == tempdir:
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)
import bs4
import requests
import re
from telethon.events import NewMessage
from telethon import events
from YukinonBot import telethn
from telethon import types
from telethon.tl import functions
langi = "en"
@telethn.on(events.NewMessage(pattern="^[!/]imdb(.*)"))
async def imdb(e):
try:
movie_name = e.pattern_match.group(1)
remove_space = movie_name.split(" ")
final_name = "+".join(remove_space)
page = requests.get("https://www.imdb.com/find?ref_=nv_sr_fn&q=" +
final_name + "&s=all")
lnk = str(page.status_code)
soup = bs4.BeautifulSoup(page.content, "lxml")
odds = soup.findAll("tr", "odd")
mov_title = odds[0].findNext("td").findNext("td").text
mov_link = ("http://www.imdb.com/" +
odds[0].findNext("td").findNext("td").a["href"])
page1 = requests.get(mov_link)
soup = bs4.BeautifulSoup(page1.content, "lxml")
if soup.find("div", "poster"):
poster = soup.find("div", "poster").img["src"]
"""
.alive
For all USER
"""
import asyncio
from telethon import events
from telethon.tl.types import ChannelParticipantsAdmins
@borg.on(events.NewMessage(pattern=r"Bill", incoming=True))
async def _(event):
if event.fwd_from:
return
mentions = "`Well! Well! Well! Well!`"
chat = await event.get_input_chat()
async for x in borg.iter_participants(chat,
filter=ChannelParticipantsAdmins):
mentions += f""
reply_message = None
if event.reply_to_msg_id:
reply_message = await event.get_reply_message()
await reply_message.reply(mentions)
else:
await event.reply(mentions)
@bot.on(admin_cmd(outgoing=True, pattern="alive"))
async def repo(event):
if event.fwd_from:
return
ULTRAX = Var.TG_BOT_USER_NAME_BF_HER
if event.reply_to_msg_id:
await event.get_reply_message()
response = await bot.inline_query(ULTRAX, "alive")
await response[0].click(event.chat_id)
await event.delete()
from ULTRA.utils import admin_cmd
@bot.on(events.NewMessage(outgoing=True, pattern=None))
async def repo(event):
if not event.text.startswith(".help"):
return
LEGENDX = Var.TG_BOT_USER_NAME_BF_HER
if event.reply_to_msg_id:
await event.get_reply_message()
response = await bot.inline_query(LEGENDX, "Userbot")
await response[0].click(event.chat_id)
await event.delete()
@bot.on(admin_cmd(pattern="restart"))
async def repo(event):
if event.fwd_from:
return
async def typewriter(typew):
typew.pattern_match.group(1)
await typew.edit("`\n(\\_/)`"
"`\n(РЌЈ_РЌЈ)`"
"`\n />РЮц№ИЈ *Ini Buat Kamu`")
sleep(3)
await typew.edit("`\n(\\_/)`"
"`\n(РЌЈ_РЌЈ)`"
"`\n/>Ъњћ *Aku Ambil Lagi`")
sleep(2)
await typew.edit("`\n(\\_/)`"
"`\n(РЌЈ_РЌЈ)`"
"`\nЪњћ<\\ *Terimakasih`")
@bot.on(events.NewMessage(pattern=r"\.(.*)", outgoing=True))
async def _(event):
if event.fwd_from:
return
animation_interval = 3
animation_ttl = range(0, 103)
input_str = event.pattern_match.group(1)
if input_str == "ceritacinta":
await event.edit(input_str)
def decorator(func):
async def wrapper(check):
if check.edit_date and check.is_channel and not check.is_group:
# Messages sent in channels can be edited by other users.
# Ignore edits that take place in channels.
return
if not LOGSPAMMER:
check.chat_id
else:
pass
if not trigger_on_fwd and check.fwd_from:
return
if groups_only and not check.is_group:
await check.respond("`I don't think this is a group.`")
return
if check.via_bot_id and not insecure and check.out:
return
try:
await func(check)
# Thanks to @kandnub for this HACK.
# Raise StopPropagation to Raise StopPropagation
# This needed for AFK to working properly
except events.StopPropagation:
raise events.StopPropagation
# This is a gay exception and must be passed out. So that it doesnt
# spam chats
except KeyboardInterrupt:
pass
except BaseException:
# Check if we have to disable it.
# If not silence the log spam on the console,
# with a dumb except.
if not disable_errors:
date = strftime("%Y-%m-%d %H:%M:%S", gmtime())
text = "**Man-Userbot ERROR**\n"
link = "Silahkan chat: @sharinguserbot"
text += "Untuk melaporkan kesalahan"
text += f"- tinggal teruskan pesan ini {link}.\n"
text += "Man Siap Membantu Kamu\n"
ftext = "========== DISCLAIMER =========="
ftext += "\nThis file uploaded ONLY here,"
ftext += "\nwe logged only fact of error and date,"
ftext += "\nwe respect your privacy,"
ftext += "\nyou may not report this error if you've"
ftext += "\nany confidential data here, no one will see your data\n"
ftext += "================================\n\n"
ftext += "--------BEGIN USERBOT TRACEBACK LOG--------\n"
ftext += "\nDate: " + date
ftext += "\nChat ID: " + str(check.chat_id)
ftext += "\nSender ID: " + str(check.sender_id)
ftext += "\n\nEvent Trigger:\n"
ftext += str(check.text)
ftext += "\n\nTraceback info:\n"
ftext += str(format_exc())
ftext += "\n\nError text:\n"
ftext += str(sys.exc_info()[1])
ftext += "\n\n--------END USERBOT TRACEBACK LOG--------"
command = "git log --pretty=format:\"%an: %s\" -10"
ftext += "\n\n\nLast 10 commits:\n"
process = await asyncsubshell(command,
stdout=asyncsub.PIPE,
stderr=asyncsub.PIPE)
stdout, stderr = await process.communicate()
result = str(stdout.decode().strip()) \
+ str(stderr.decode().strip())
ftext += result
file = open("error.log", "w+")
file.write(ftext)
file.close()
else:
pass
if not disable_edited:
bot.add_event_handler(wrapper, events.MessageEdited(**args))
bot.add_event_handler(wrapper, events.NewMessage(**args))
return wrapper
def decorator(func):
async def wrapper(check):
if check.edit_date and check.is_channel and not check.is_group:
# Messages sent in channels can be edited by other users.
# Ignore edits that take place in channels.
return
if not LOGSPAMMER:
check.chat_id
else:
pass
if not trigger_on_fwd and check.fwd_from:
return
if groups_only and not check.is_group:
await check.respond("`Sepertinya ini bukan lah grup.`")
return
if check.via_bot_id and not insecure and check.out:
return
try:
await func(check)
# Thanks to @kandnub for this HACK.
# Raise StopPropagation to Raise StopPropagation
# This needed for AFK to working properly
except events.StopPropagation:
raise events.StopPropagation
# This is a gay exception and must be passed out. So that it doesnt
# spam chats
except KeyboardInterrupt:
pass
except BaseException:
# Check if we have to disable it.
# If not silence the log spam on the console,
# with a dumb except.
if not disable_errors:
date = strftime("%Y-%m-%d %H:%M:%S", gmtime())
text = "**LAPORAN ERROR USERBOT**\n"
link = "[Team FS Project](https://t.me/Fernans1)"
text += "Jika mau, Anda bisa melaporkannya"
text += f". Teruskan pesan ini ke {link}.\n"
text += "Tidak ada yang dicatat kecuali log kesalahan dan tanggal\n"
ftext = "========== DISCLAIMER =========="
ftext += "\nFile ini Hanya diunggah di sini,"
ftext += "\nkami hanya mencatat log kesalahan dan tanggal,"
ftext += "\nkami menghormati privasi Anda,"
ftext += "\nAnda tidak boleh melaporkan kesalahan ini"
ftext += "\njika Anda memiliki data rahasia di sini, tidak ada yang akan melihat data Anda\n"
ftext += "================================\n\n"
ftext += "--------BEGIN USERBOT TRACEBACK LOG--------\n"
ftext += "\nTanggal : " + date
ftext += "\nChat ID : " + str(check.chat_id)
ftext += "\nSender ID : " + str(check.sender_id)
ftext += "\n\nEvent Trigger :\n"
ftext += str(check.text)
ftext += "\n\nTraceback info :\n"
ftext += str(format_exc())
ftext += "\n\nError text:\n"
ftext += str(sys.exc_info()[1])
ftext += "\n\n--------END USERBOT TRACEBACK LOG--------"
command = "git log --pretty=format:\"%an: %s\" -10"
ftext += "\n\n\nLast 10 commits:\n"
process = await asyncsubshell(command,
stdout=asyncsub.PIPE,
stderr=asyncsub.PIPE)
stdout, stderr = await process.communicate()
result = str(stdout.decode().strip()) \
+ str(stderr.decode().strip())
ftext += result
file = open("error.log", "w+")
file.write(ftext)
file.close()
# if LOGSPAMMER:
# await check.respond(
# "`Sorry, my userbot has crashed.\
# \nThe error logs are stored in the userbot's log chat.`"
# )
# await check.client.send_file(send_to,
# "error.log",
# caption=text)
remove("error.log")
else:
pass
if not disable_edited:
bot.add_event_handler(wrapper, events.MessageEdited(**args))
bot.add_event_handler(wrapper, events.NewMessage(**args))
return wrapper
def __init__(self, func=None, **args):
self.Config = Config
bot.add_event_handler(func, events.NewMessage(**args))
def decorator(func):
async def wrapper(check):
if not LOGSPAMMER:
send_to = check.chat_id
else:
send_to = BOTLOG_CHATID
if not trigger_on_fwd and check.fwd_from:
return
if groups_only and not check.is_group:
await check.respond("`I don't think this is a group.`")
return
try:
await func(check)
# Thanks to @kandnub for this HACK.
# Raise StopPropagation to Raise StopPropagation
# This needed for AFK to working properly
except events.StopPropagation:
raise events.StopPropagation
# This is a gay exception and must be passed out. So that it doesnt spam chats
except KeyboardInterrupt:
pass
except BaseException:
# Check if we have to disable it.
# If not silence the log spam on the console,
# with a dumb except.
if not disable_errors:
date = strftime("%Y-%m-%d %H:%M:%S", gmtime())
text = "**USERBOT ERROR REPORT**\n"
link = "[OUB Support Chat](https://t.me/PPE_Support)"
text += "If you want to, you can report it"
text += f"- just forward this message to {link}.\n"
text += "Nothing is logged except the fact of error and date\n"
ftext = "========== DISCLAIMER =========="
ftext += "\nThis file uploaded ONLY here,"
ftext += "\nwe logged only fact of error and date,"
ftext += "\nwe respect your privacy,"
ftext += "\nyou may not report this error if you've"
ftext += "\nany confidential data here, no one will see your data\n"
ftext += "================================\n\n"
ftext += "--------BEGIN USERBOT TRACEBACK LOG--------\n"
ftext += "\nDate: " + date
ftext += "\nChat ID: " + str(check.chat_id)
ftext += "\nSender ID: " + str(check.sender_id)
ftext += "\n\nEvent Trigger:\n"
ftext += str(check.text)
ftext += "\n\nTraceback info:\n"
ftext += str(format_exc())
ftext += "\n\nError text:\n"
ftext += str(sys.exc_info()[1])
ftext += "\n\n--------END USERBOT TRACEBACK LOG--------"
command = "git log --pretty=format:\"%an: %s\" -10"
ftext += "\n\n\nLast 10 commits:\n"
process = await asyncsubshell(command,
stdout=asyncsub.PIPE,
stderr=asyncsub.PIPE)
stdout, stderr = await process.communicate()
result = str(stdout.decode().strip()) \
+ str(stderr.decode().strip())
ftext += result
file = open("error.log", "w+")
file.write(ftext)
file.close()
if LOGSPAMMER:
await check.client.respond(
"`Sorry, my userbot has crashed.\
\nThe error logs are stored in the userbot's log chat.`"
)
await check.client.send_file(send_to,
"error.log",
caption=text)
remove("error.log")
else:
pass
if not disable_edited:
bot.add_event_handler(wrapper, events.MessageEdited(**args))
bot.add_event_handler(wrapper, events.NewMessage(**args))
return wrapper
def admin_cmd(pattern=None, command=None, **args):
args["func"] = lambda e: e.via_bot_id is None
stack = inspect.stack()
previous_stack_frame = stack[1]
file_test = Path(previous_stack_frame.filename)
file_test = file_test.stem.replace(".py", "")
allow_sudo = args.get("allow_sudo", False)
# get the pattern from the decorator
if pattern is not None:
if pattern.startswith(r"\#"):
# special fix for snip.py
args["pattern"] = re.compile(pattern)
elif pattern.startswith(r"^"):
args["pattern"] = re.compile(pattern)
cmd = pattern.replace("$", "").replace("^", "").replace("\\", "")
try:
CMD_LIST[file_test].append(cmd)
except BaseException:
CMD_LIST.update({file_test: [cmd]})
else:
if len(Config.COMMAND_HAND_LER) == 2:
catreg = "^" + Config.COMMAND_HAND_LER
reg = Config.COMMAND_HAND_LER[1]
elif len(Config.COMMAND_HAND_LER) == 1:
catreg = "^\\" + Config.COMMAND_HAND_LER
reg = Config.COMMAND_HAND_LER
args["pattern"] = re.compile(catreg + pattern)
if command is not None:
cmd = reg + command
else:
cmd = ((reg + pattern).replace("$", "").replace("\\",
"").replace(
"^", ""))
try:
CMD_LIST[file_test].append(cmd)
except BaseException:
CMD_LIST.update({file_test: [cmd]})
args["outgoing"] = True
# should this command be available for other users?
if allow_sudo:
args["from_users"] = list(Config.SUDO_USERS)
# Mutually exclusive with outgoing (can only set one of either).
args["incoming"] = True
del args["allow_sudo"]
# error handling condition check
elif "incoming" in args and not args["incoming"]:
args["outgoing"] = True
# add blacklist chats, UB should not respond in these chats
args["blacklist_chats"] = True
black_list_chats = list(Config.UB_BLACK_LIST_CHAT)
if black_list_chats:
args["chats"] = black_list_chats
# add blacklist chats, UB should not respond in these chats
if "allow_edited_updates" in args and args["allow_edited_updates"]:
del args["allow_edited_updates"]
# check if the plugin should listen for outgoing 'messages'
return events.NewMessage(**args)
# print(reason)
start_time = time.time()
sql.set_afk(sender.id, reason, start_time)
await event.reply("**{} is now AFK !**".format(firsname),
parse_mode="markdown")
return
if sql.is_afk(sender.id):
res = sql.rm_afk(sender.id)
if res:
firstname = sender.first_name
text = "**{} is no longer AFK !**".format(firstname)
await event.reply(text, parse_mode="markdown")
@tbot.on(events.NewMessage(pattern=None))
async def _(event):
if event.is_private:
return
sender = event.sender_id
str(event.text)
global let
global userid
userid = None
let = None
if event.reply_to_msg_id:
await event.get_reply_message()
userid = event.sender_id
else:
try:
for (ent, txt) in event.get_entities_text():
"""AFK Plugin for @UniBorg
Syntax: .afk REASON"""
import asyncio
import datetime
from telethon import events
from telethon.tl import functions, types
global USER_AFK # pylint:disable=E0602
global afk_time # pylint:disable=E0602
global last_afk_message # pylint:disable=E0602
USER_AFK = {}
afk_time = None
last_afk_message = {}
@borg.on(events.NewMessage(outgoing=True)) # pylint:disable=E0602
async def set_not_afk(event):
global USER_AFK # pylint:disable=E0602
global afk_time # pylint:disable=E0602
global last_afk_message # pylint:disable=E0602
current_message = event.message.message
if ".afk" not in current_message and "yes" in USER_AFK: # pylint:disable=E0602
try:
await borg.send_message( # pylint:disable=E0602
Config.PRIVATE_GROUP_BOT_API_ID, # pylint:disable=E0602
"Set AFK mode to False")
except Exception as e: # pylint:disable=C0103,W0703
await borg.send_message( # pylint:disable=E0602
event.chat_id,
"Please set `PRIVATE_GROUP_BOT_API_ID` " + \
"for the proper functioning of afk functionality " + \
Thanks to @r4v4n4 for vars
"""
from selenium.webdriver.support.ui import Select
from selenium.webdriver.chrome.options import Options
from selenium import webdriver
from telethon import events
from urllib.parse import quote_plus
from urllib.error import HTTPError
from time import sleep
import asyncio
import os
@borg.on(events.NewMessage(pattern=r"\.carbon", outgoing=True))
async def carbon_api(e):
if not e.text[0].isalpha() and e.text[0] not in ("/", "#", "@", "!"):
""" A Wrapper for carbon.now.sh """
await e.edit("⬜⬜⬜⬜⬜")
CARBON = 'https://carbon.now.sh/?l={lang}&code={code}'
CARBONLANG = "en"
textx = await e.get_reply_message()
pcode = e.text
if pcode[8:]:
pcode = str(pcode[8:])
elif textx:
pcode = str(textx.message) # Importing message to module
code = quote_plus(pcode) # Converting to urlencoded
url = CARBON.format(code=code, lang=CARBONLANG)
chrome_options = Options()
try:
Heroku = heroku3.from_key(HEROKU_API_KEY)
app = Heroku.app(HEROKU_APP_NAME)
herokurk = 'connected'
except:
herokurk = '[Failed to connect](https://telegra.ph/RkPavi-06-09-6)'
pass
if BOTLOG_CHATID:
logrk = 'connected'
else:
logrk = '[Failed to connect](https://telegra.ph/RkPavi-06-09-3)'
@client.on(events.NewMessage(outgoing=True, pattern='!start'))
async def alive(alive):
shivam = await borg.get_entity('me')
miraculous = (
""
f"**{ALIVE_S_MMSG}**\n\n"
f" ° `{JAVES_NNAME}`: **{v}**\n"
f" ° `User:` ** [{shivam.first_name}](tg://user?id={shivam.id}) **\n"
f" ° `Telethon`: ** {version.__version__} **\n"
f" ° `Python` : ** {platform.python_version()} **\n"
f" ° `Os:` ** Kali GNU/Linux Rolling x86_64 **\n"
f" ° `Heroku:` ** {herokurk} **\n"
f" ° `LogChat:` ** {logrk} **\n"
f" ° `Sudo:` ** {sudork} **\n"
f" ° `SpamProtect:` ** {ss} **\n"
f" ° `Uptime:` ** {str(datetime.now() - START_TIME).split('.')[0]} **\n\n"
