def enforce_gban(update: Update, context: CallbackContext):
# Not using @restrict handler to avoid spamming - just ignore if cant gban.
bot = context.bot
try:
restrict_permission = update.effective_chat.get_member(
bot.id).can_restrict_members
except Unauthorized:
return
if sql.does_chat_gban(update.effective_chat.id) and restrict_permission:
user = update.effective_user
chat = update.effective_chat
msg = update.effective_message
if user and not is_user_admin(chat, user.id):
check_and_ban(update, user.id)
return
if msg.new_chat_members:
new_members = update.effective_message.new_chat_members
for mem in new_members:
check_and_ban(update, mem.id)
if msg.reply_to_message:
user = msg.reply_to_message.from_user
if user and not is_user_admin(chat, user.id):
check_and_ban(update, user.id, should_message=False)
def punchme(update: Update, context: CallbackContext):
user_id = update.effective_message.from_user.id
if is_user_admin(update.effective_chat, user_id):
update.effective_message.reply_text(
"I wish I could... but you're an admin.")
return
res = update.effective_chat.unban_member(
user_id) # unban on current user = kick
if res:
update.effective_message.reply_text(
"*Yeah, you're right - get out idiot.*")
else:
update.effective_message.reply_text("Huh? I can't :/")
def check_update(self, update):
if isinstance(update, Update) and update.effective_message:
message = update.effective_message
if message.text and len(message.text) > 1:
fst_word = message.text.split(None, 1)[0]
if len(fst_word) > 1 and any(
fst_word.startswith(start)
for start in CMD_STARTERS):
args = message.text.split()[1:]
command = fst_word[1:].split("@")
command.append(message.bot.username)
if not (command[0].lower() in self.command
and command[1].lower()
== message.bot.username.lower()):
return None
chat = update.effective_chat
user = update.effective_user
if user.id == 1087968824:
user_id = chat.id
else:
user_id = user.id
if SpamChecker.check_user(user_id):
return None
filter_result = self.filters(update)
if filter_result:
# disabled, admincmd, user admin
if sql.is_command_disabled(chat.id,
command[0].lower()):
# check if command was disabled
is_disabled = command[
0] in ADMIN_CMDS and is_user_admin(
chat, user.id)
if not is_disabled:
return None
else:
return args, filter_result
return args, filter_result
else:
return False
def get_settings(update: Update, context: CallbackContext):
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[User]
msg = update.effective_message # type: Optional[Message]
# ONLY send settings in PM
if chat.type != chat.PRIVATE:
if is_user_admin(chat, user.id):
text = "Click on the button below to get this chat's settings, as well as yours."
msg.reply_text(text,
reply_markup=InlineKeyboardMarkup([[
InlineKeyboardButton(
text="Settings",
url="t.me/{}?start=stngs_{}".format(
context.bot.username, chat.id))
]]))
else:
text = "Click here to check your settings."
else:
send_settings(chat.id, user.id, True)
def check_user(user_id: int, bot: Bot, chat: Chat) -> Optional[str]:
if not user_id:
reply = "You don't seem to be referring to a user or the ID specified is incorrect.."
return reply
try:
member = chat.get_member(user_id)
except BadRequest as excp:
if excp.message == "User not found":
reply = "I can't seem to find this user"
return reply
else:
raise
if user_id == bot.id:
reply = "I'm not gonna MUTE myself, How high are you?"
return reply
if is_user_admin(chat, user_id, member) or user_id in TIGERS:
reply = "Can't. Find someone else to mute but not this one."
return reply
return None
def start(update: Update, context: CallbackContext):
args = context.args
uptime = get_readable_time((time.time() - StartTime))
if update.effective_chat.type == "private":
if len(args) >= 1:
if args[0].lower() == "help":
send_help(update.effective_chat.id, HELP_STRINGS)
elif args[0].lower().startswith("ghelp_"):
mod = args[0].lower().split('_', 1)[1]
if not HELPABLE.get(mod, False):
return
send_help(
update.effective_chat.id, HELPABLE[mod].__help__,
InlineKeyboardMarkup([[
InlineKeyboardButton(text="Back",
callback_data="help_back")
]]))
elif args[0].lower() == "markdownhelp":
IMPORTED["extras"].markdown_help_sender(update)
elif args[0].lower() == "disasters":
IMPORTED["disasters"].send_disasters(update)
elif args[0].lower().startswith("stngs_"):
match = re.match("stngs_(.*)", args[0].lower())
chat = dispatcher.bot.getChat(match.group(1))
if is_user_admin(chat, update.effective_user.id):
send_settings(match.group(1), update.effective_user.id,
False)
else:
send_settings(match.group(1), update.effective_user.id,
True)
elif args[0][1:].isdigit() and "rules" in IMPORTED:
IMPORTED["rules"].send_rules(update, args[0], from_pm=True)
else:
first_name = update.effective_user.first_name
update.effective_message.reply_photo(
LEGEND_IMG,
PM_START_TEXT.format(escape_markdown(first_name),
escape_markdown(context.bot.first_name)),
parse_mode=ParseMode.MARKDOWN,
disable_web_page_preview=True,
reply_markup=InlineKeyboardMarkup(
[[
InlineKeyboardButton(
text=" 👸 Invite me in your place ",
url="t.me/{}?startgroup=true".format(
context.bot.username)),
],
[
InlineKeyboardButton(
text=" ⚡ ѕσυя¢є ¢σ∂є ",
url="https://github.com/srinivasop/PIKACHU-OP"),
InlineKeyboardButton(
text=" ❤️ Channel ",
url="https://t.me/pikachubotupdates")
],
[
InlineKeyboardButton(
text=" ✨ Support ",
url="https://t.me/pikachubotsupport"),
InlineKeyboardButton(text=" 👨💻 Creator ",
url="https://t.me/@ROCKY_8218")
]]))
else:
update.effective_message.reply_text(
"🔥Hey! LUCIFER THE PRO IS ONLINE.\n⚙️All systems online and functioning normally!!\n<b>⏱ Alive time:</b> <code>{}</code>\n✨ Thanks for adding me! ✨"
.format(uptime),
parse_mode=ParseMode.HTML)
def check_flood(update, context) -> str:
user = update.effective_user # type: Optional[User]
chat = update.effective_chat # type: Optional[Chat]
msg = update.effective_message # type: Optional[Message]
if not user: # ignore channels
return ""
# ignore admins and whitelists
if is_user_admin(chat, user.id) or user.id in WOLVES or user.id in TIGERS:
sql.update_flood(chat.id, None)
return ""
# ignore approved users
if is_approved(chat.id, user.id):
sql.update_flood(chat.id, None)
return
should_ban = sql.update_flood(chat.id, user.id)
if not should_ban:
return ""
try:
getmode, getvalue = sql.get_flood_setting(chat.id)
if getmode == 1:
chat.kick_member(user.id)
execstrings = "Banned"
tag = "BANNED"
elif getmode == 2:
chat.kick_member(user.id)
chat.unban_member(user.id)
execstrings = "Kicked"
tag = "KICKED"
elif getmode == 3:
context.bot.restrict_chat_member(
chat.id, user.id, permissions=ChatPermissions(can_send_messages=False)
)
execstrings = "Muted"
tag = "MUTED"
elif getmode == 4:
bantime = extract_time(msg, getvalue)
chat.kick_member(user.id, until_date=bantime)
execstrings = "Banned for {}".format(getvalue)
tag = "TBAN"
elif getmode == 5:
mutetime = extract_time(msg, getvalue)
context.bot.restrict_chat_member(
chat.id,
user.id,
until_date=mutetime,
permissions=ChatPermissions(can_send_messages=False),
)
execstrings = "Muted for {}".format(getvalue)
tag = "TMUTE"
send_message(
update.effective_message, "Great, i like to leave flooding to natural disasters but you, you were just disappointed me.\n{}!".format(execstrings)
)
return (
"<b>{}:</b>"
"\n#{}"
"\n<b>User:</b> {}"
"\nFlooded the group.".format(
tag,
html.escape(chat.title),
mention_html(user.id, html.escape(user.first_name)),
)
)
except BadRequest:
msg.reply_text(
"I can't restrict people here, give me permissions first! Until then, I'll disable anti-flood."
)
sql.set_flood(chat.id, 0)
return (
"<b>{}:</b>"
"\n#INFO"
"\nDon't have enough permission to restrict users so automatically disabled anti-flood".format(
chat.title
)
)
def warn(user: User,
chat: Chat,
reason: str,
message: Message,
warner: User = None) -> str:
if is_user_admin(chat, user.id):
# message.reply_text("Damn admins, They are too far to be One Punched!")
return
if user.id in TIGERS:
if warner:
message.reply_text("Tigers cant be warned.")
else:
message.reply_text(
"Tiger triggered an auto warn filter!\n I can't warn tigers but they should avoid abusing this."
)
return
if user.id in WOLVES:
if warner:
message.reply_text("Wolf disasters are warn immune.")
else:
message.reply_text(
"Wolf Disaster triggered an auto warn filter!\nI can't warn wolves but they should avoid abusing this."
)
return
if warner:
warner_tag = mention_html(warner.id, warner.first_name)
else:
warner_tag = "Automated warn filter."
limit, soft_warn = sql.get_warn_setting(chat.id)
num_warns, reasons = sql.warn_user(user.id, chat.id, reason)
if num_warns >= limit:
sql.reset_warns(user.id, chat.id)
if soft_warn: # punch
chat.unban_member(user.id)
reply = (
f"<code>�</code><b>\\Punched_User//</b>\n"
f"<code> </code><b>âž© User:</b> {mention_html(user.id, user.first_name)}\n"
f"<code> </code><b>âž© Count:</b> {limit}")
else: # ban
chat.kick_member(user.id)
reply = (
f"<code>�</code><b>\\\Banned_User//</b>\n"
f"<code> </code><b>âž© User:</b> {mention_html(user.id, user.first_name)}\n"
f"<code> </code><b>âž© Count:</b> {limit}")
for warn_reason in reasons:
reply += f"\n - {html.escape(warn_reason)}"
# message.bot.send_sticker(chat.id, BAN_STICKER) # Saitama's sticker
keyboard = None
log_reason = (
f"<b>{html.escape(chat.title)}:</b>\n"
f"#WARN_BAN\n"
f"<b>Admin:</b> {warner_tag}\n"
f"<b>User:</b> {mention_html(user.id, user.first_name)}\n"
f"<b>Reason:</b> {reason}\n"
f"<b>Counts:</b> <code>{num_warns}/{limit}</code>")
else:
keyboard = InlineKeyboardMarkup([[
InlineKeyboardButton("🔘 Remove warn",
callback_data="rm_warn({})".format(user.id))
]])
reply = (
f"<code>�</code><b> \\\Warned_User//</b>\n"
f"<code> </code><b>âž© User:</b> {mention_html(user.id, user.first_name)}\n"
f"<code> </code><b>âž© Count:</b> {num_warns}/{limit}")
if reason:
reply += f"\n<code> </code><b>• Reason:</b> {html.escape(reason)}"
log_reason = (
f"<b>{html.escape(chat.title)}:</b>\n"
f"#WARN\n"
f"<b>Admin:</b> {warner_tag}\n"
f"<b>User:</b> {mention_html(user.id, user.first_name)}\n"
f"<b>Reason:</b> {reason}\n"
f"<b>Counts:</b> <code>{num_warns}/{limit}</code>")
try:
message.reply_text(reply,
reply_markup=keyboard,
parse_mode=ParseMode.HTML)
except BadRequest as excp:
if excp.message == "Reply message not found":
# Do not reply
message.reply_text(reply,
reply_markup=keyboard,
parse_mode=ParseMode.HTML,
quote=False)
else:
raise
return log_reason
def unlock(update, context) -> str:
args = context.args
chat = update.effective_chat
user = update.effective_user
message = update.effective_message
if is_user_admin(chat, message.from_user.id):
if len(args) >= 1:
ltype = args[0].lower()
if ltype in LOCK_TYPES:
# Connection check
conn = connected(context.bot,
update,
chat,
user.id,
need_admin=True)
if conn:
chat = dispatcher.bot.getChat(conn)
chat_id = conn
chat_name = chat.title
text = "Unlocked {} for everyone in {}!".format(
ltype, chat_name)
else:
if update.effective_message.chat.type == "private":
send_message(
update.effective_message,
"This command is meant to use in group not in PM",
)
return ""
chat = update.effective_chat
chat_id = update.effective_chat.id
chat_name = update.effective_message.chat.title
text = "Unlocked {} for everyone!".format(ltype)
sql.update_lock(chat.id, ltype, locked=False)
send_message(update.effective_message,
text,
parse_mode="markdown")
return ("<b>{}:</b>"
"\n#UNLOCK"
"\n<b>Admin:</b> {}"
"\nUnlocked <code>{}</code>.".format(
html.escape(chat.title),
mention_html(user.id, user.first_name),
ltype,
))
elif ltype in UNLOCK_CHAT_RESTRICTION:
# Connection check
conn = connected(context.bot,
update,
chat,
user.id,
need_admin=True)
if conn:
chat = dispatcher.bot.getChat(conn)
chat_id = conn
chat_name = chat.title
text = "Unlocked {} for everyone in {}!".format(
ltype, chat_name)
else:
if update.effective_message.chat.type == "private":
send_message(
update.effective_message,
"This command is meant to use in group not in PM",
)
return ""
chat = update.effective_chat
chat_id = update.effective_chat.id
chat_name = update.effective_message.chat.title
text = "Unlocked {} for everyone!".format(ltype)
can_change_info = chat.get_member(
context.bot.id).can_change_info
if not can_change_info:
send_message(
update.effective_message,
"I don't have permission to change group info.",
parse_mode="markdown",
)
return
current_permission = context.bot.getChat(chat_id).permissions
context.bot.set_chat_permissions(
chat_id=chat_id,
permissions=get_permission_list(
eval(str(current_permission)),
UNLOCK_CHAT_RESTRICTION[ltype.lower()],
),
)
send_message(update.effective_message,
text,
parse_mode="markdown")
return ("<b>{}:</b>"
"\n#UNLOCK"
"\n<b>Admin:</b> {}"
"\nUnlocked <code>{}</code>.".format(
html.escape(chat.title),
mention_html(user.id, user.first_name),
ltype,
))
else:
send_message(
update.effective_message,
"What are you trying to unlock...? Try /locktypes for the list of lockables.",
)
else:
send_message(update.effective_message,
"What are you trying to unlock...?")
return ""