def main(token, root_dir, rpc, whitelist, proxy):
if proxy:
request_kwargs = {
'proxy_url': 'socks5://{}:{}'.format(proxy['address'],
proxy['port']),
'urllib3_proxy_kwargs': {
'username': proxy['username'],
'password': proxy['password'],
}
}
else:
request_kwargs = None
t_service = TorrentService(rpc['address'], rpc['port'], rpc['username'],
rpc['password'])
f_service = FilesService(root_dir)
a_service = AddService(f_service, t_service)
s_service = SystemService(root_dir)
updater = Updater(token, use_context=True, request_kwargs=request_kwargs)
dp = updater.dispatcher
fallbacks = [
CallbackQueryHandler(cancel, pattern='^cancel$'),
MessageHandler(
Filters.regex(r'^Torrents$') & Filters.chat(username=whitelist),
t_service.torrent_list),
MessageHandler(
Filters.regex(r'^Files$') & Filters.chat(username=whitelist),
f_service.file_list),
MessageHandler(Filters.document & Filters.chat(username=whitelist),
a_service.add_torrent_file),
MessageHandler(
Filters.regex(r'^magnet:\?') & Filters.chat(username=whitelist),
a_service.add_torrent_magnet),
MessageHandler(
Filters.regex(r'^System commands$')
& Filters.chat(username=whitelist), s_service.commands_list)
]
torrents_handler = ConversationHandler(
entry_points=[
MessageHandler(
Filters.regex(r'^Torrents$')
& Filters.chat(username=whitelist), t_service.torrent_list)
],
states={
TORRENTLIST: [
CallbackQueryHandler(t_service.torrent_info,
pattern='^t_info_\d+$')
],
TORRENTINFO: [
CallbackQueryHandler(t_service.move_top,
pattern='^t_top_\d+$'),
CallbackQueryHandler(t_service.move_up, pattern='^t_up_\d+$'),
CallbackQueryHandler(t_service.move_down,
pattern='^t_down_\d+$'),
CallbackQueryHandler(t_service.move_bottom,
pattern='^t_bottom_\d+$'),
CallbackQueryHandler(t_service.resume_torrent,
pattern='^t_resume_\d+$'),
CallbackQueryHandler(t_service.resume_torrent_now,
pattern='^t_resume_now_\d+$'),
CallbackQueryHandler(t_service.stop_torrent,
pattern='^t_stop_\d+$'),
CallbackQueryHandler(t_service.verify_torrent,
pattern='^t_verify_(\d+?)$'),
CallbackQueryHandler(t_service.remove_torrent_confirm,
pattern='^t_remove_confirm_\d+$')
],
REMOVETORRENT: [
CallbackQueryHandler(t_service.remove_torrent,
pattern='^t_remove_\d+$'),
CallbackQueryHandler(t_service.remove_torrent_complete,
pattern='^t_remove_complete_\d+$')
]
},
fallbacks=fallbacks)
files_handler = ConversationHandler(
entry_points=[
MessageHandler(
Filters.regex(r'^Files$') & Filters.chat(username=whitelist),
f_service.file_list)
],
states={
FILESLIST: [
CallbackQueryHandler(f_service.file_list,
pattern='^t_file_info_[0-9]*$'),
CallbackQueryHandler(f_service.file_list_back,
pattern='^t_file_info_back$'),
CallbackQueryHandler(f_service.remove_file_confirm,
pattern='^t_file_delete_confirm$')
],
REMOVEFILECONFIRM: [
CallbackQueryHandler(f_service.remove_file,
pattern='^t_file_delete$')
]
},
fallbacks=fallbacks)
add_handler = ConversationHandler(
entry_points=[
MessageHandler(Filters.document & Filters.chat(username=whitelist),
a_service.add_torrent_file),
MessageHandler(
Filters.regex(r'^magnet:\?')
& Filters.chat(username=whitelist),
a_service.add_torrent_magnet)
],
states={
ADDFOLDERLIST: [
CallbackQueryHandler(a_service.choose_dir_for_torrent,
pattern='^a_folder_info_[0-9]*$'),
CallbackQueryHandler(a_service.choose_dir_for_torrent_back,
pattern='^a_folder_info_back$'),
CallbackQueryHandler(a_service.choose_dir_for_torrent_finish,
pattern='^a_folder_info_finish$')
]
},
fallbacks=fallbacks)
commands_handler = ConversationHandler(
entry_points=[
MessageHandler(
Filters.regex(r'^System commands$')
& Filters.chat(username=whitelist), s_service.commands_list)
],
states={
SYSTEMCOMMANDS: [
CallbackQueryHandler(s_service.restart_minidlna,
pattern='^restart_minidlna$'),
CallbackQueryHandler(s_service.reboot, pattern='^reboot$'),
CallbackQueryHandler(s_service.poweroff, pattern='^poweroff$'),
CallbackQueryHandler(s_service.get_free_space,
pattern='^free_space$')
]
},
fallbacks=fallbacks)
dp.add_handler(torrents_handler)
dp.add_handler(files_handler)
dp.add_handler(add_handler)
dp.add_handler(commands_handler)
dp.add_handler(
CommandHandler('start', start, Filters.chat(username=whitelist)))
dp.add_error_handler(error)
updater.start_polling()
updater.idle()
def help_command(update, context):
message = emoji.emojize(
":eyes:"
) + """ This is a bot that stalks influencers on twitter.\n
Use /update to get new followings by influencers that are followed.
Use /add *usernamehere* to add another influencer to follow.\n\n""" + emoji.emojize(
":eyes:"
) + " Currently followed influencers: " + twitterbotv2.getCurrentInfluencers(
)
context.bot.send_message(chat_id=update.effective_chat.id, text=message)
#handles commands such as /start, /update
from telegram.ext import CommandHandler, MessageHandler, Filters, PrefixHandler
start_handler = CommandHandler('start', start)
dispatcher.add_handler(start_handler)
update_handler = CommandHandler('update', request)
append_handler = PrefixHandler("/", "add", append)
dispatcher.add_handler(append_handler)
dispatcher.add_handler(update_handler)
dispatcher.add_handler(CommandHandler("help", help_command))
dispatcher.add_handler(MessageHandler(Filters.text & ~Filters.command, append))
from telegram.ext import MessageHandler, Filters
request_handler = MessageHandler(Filters.text & (~Filters.command), request)
updater.start_polling()
âž© Admin only:
- `/addblacklist <triggers>`*:* Add a trigger to the blacklist. Each line is considered one trigger, so using different lines will allow you to add multiple triggers.
- `/unblacklist <triggers>`*:* Remove triggers from the blacklist. Same newline logic applies here, so you can remove multiple triggers at once.
- `/blacklistmode <off/del/warn/ban/kick/mute/tban/tmute>`*:* Action to perform when someone sends blacklisted words.
"""
BLACKLIST_HANDLER = DisableAbleCommandHandler(
"blacklist", blacklist, pass_args=True, admin_ok=True
)
ADD_BLACKLIST_HANDLER = CommandHandler("addblacklist", add_blacklist)
UNBLACKLIST_HANDLER = CommandHandler("unblacklist", unblacklist)
BLACKLISTMODE_HANDLER = CommandHandler("blacklistmode", blacklist_mode, pass_args=True)
BLACKLIST_DEL_HANDLER = MessageHandler(
(Filters.text | Filters.command | Filters.sticker | Filters.photo) & Filters.group,
del_blacklist,
allow_edit=True,
)
dispatcher.add_handler(BLACKLIST_HANDLER)
dispatcher.add_handler(ADD_BLACKLIST_HANDLER)
dispatcher.add_handler(UNBLACKLIST_HANDLER)
dispatcher.add_handler(BLACKLISTMODE_HANDLER)
dispatcher.add_handler(BLACKLIST_DEL_HANDLER, group=BLACKLIST_GROUP)
__handlers__ = [
BLACKLIST_HANDLER,
ADD_BLACKLIST_HANDLER,
UNBLACKLIST_HANDLER,
BLACKLISTMODE_HANDLER,
(BLACKLIST_DEL_HANDLER, BLACKLIST_GROUP),
from telegram.ext import Updater, CommandHandler, MessageHandler, Filters
last_uploaded_photo = ""
def echo(bot, update):
global last_uploaded_photo
try:
chat_id = update.message.chat_id
bot_chat = bot.getChat(chat_id=chat_id)
if bot_chat['photo']['small_file_id'] != last_uploaded_photo:
bot.setChatPhoto(chat_id=chat_id, photo=open("telegram.jpg", "rb"))
last_uploaded_photo = bot.getChat(
chat_id=chat_id)['photo']['small_file_id']
except Exception as e:
print(e)
TOKEN = ""
updater = Updater(token=TOKEN)
dispatcher = updater.dispatcher
dispatcher.add_handler(MessageHandler(Filters.all, echo))
dispatcher.add_handler(CommandHandler("start", echo))
updater.start_polling(clean=True)
✪ /goodbye*:* same usage and args as `/welcome`.
✪ /setwelcome <sometext>*:* set a custom welcome message. If used replying to media, uses that media.
✪ /setgoodbye <sometext>*:* set a custom goodbye message. If used replying to media, uses that media.
✪ /resetwelcome*:* reset to the default welcome message.
✪ /resetgoodbye*:* reset to the default goodbye message.
✪ /cleanwelcome <on/off>*:* On new member, try to delete the previous welcome message to avoid spamming the chat.
✪ /welcomemutehelp*:* gives information about welcome mutes.
✪ /cleanservice <on/off*:* deletes telegrams welcome/left service messages.
*Example:*
user joined chat, user left chat.
*Welcome markdown:*
✪ `/welcomehelp`*:* view more formatting information for custom welcome/goodbye messages.
"""
NEW_MEM_HANDLER = MessageHandler(Filters.status_update.new_chat_members,
new_member)
LEFT_MEM_HANDLER = MessageHandler(Filters.status_update.left_chat_member,
left_member)
WELC_PREF_HANDLER = CommandHandler("welcome", welcome, filters=Filters.group)
GOODBYE_PREF_HANDLER = CommandHandler("goodbye",
goodbye,
filters=Filters.group)
SET_WELCOME = CommandHandler("setwelcome", set_welcome, filters=Filters.group)
SET_GOODBYE = CommandHandler("setgoodbye", set_goodbye, filters=Filters.group)
RESET_WELCOME = CommandHandler("resetwelcome",
reset_welcome,
filters=Filters.group)
RESET_GOODBYE = CommandHandler("resetgoodbye",
reset_goodbye,
filters=Filters.group)
WELCOMEMUTE_HANDLER = CommandHandler("welcomemute",
if button_mode == 1:
add_like_buttons(
bot, lang, config, chat_id, message_id, message,
helper_database.get_default_button_options(chat_id))
else:
add_compact_comment(bot, chat_id, config, message_id, message)
elif mode == 3:
logger.msg(
{
"channel_id": chat_id,
"msg_id": message_id,
"mode": mode,
"button": button_mode,
"action": "new channel post"
},
tag="channel",
log_level=90)
add_inplace_comment(
bot, chat_id, config, message_id, message,
(helper_database.get_default_button_options(chat_id)
if button_mode == 1 else []))
class FilterChannelPost(BaseFilter):
def filter(self, message):
return message.chat.type == "channel"
channel_post_filter = FilterChannelPost()
_handler = MessageHandler(channel_post_filter, channel_post_msg)
def main():
print("Starting bot")
global pp, updater, globalsns
globalsns = shelve.open(PERSISTENCE_GLOBAL_SNS_FILENAME, writeback=True)
# Create the Updater and pass it your bot's token.
pp = PicklePersistence(filename=PERSISTENCE_USER_FILENAME,
store_user_data=True,
store_chat_data=False,
on_flush=True)
updater = Updater(TELEGRAM_TOKEN,
persistence=pp,
user_sig_handler=stop_rta_thread)
start_rta_update_thread()
# Get the dispatcher to register handlers
dp = updater.dispatcher
updater.dispatcher.add_handler(
CommandHandler('start', start, pass_user_data=True))
updater.dispatcher.add_handler(
CommandHandler('dist', show_dist, pass_user_data=True))
updater.dispatcher.add_handler(
CommandHandler('send', send_stake, pass_user_data=True,
pass_args=True))
updater.dispatcher.add_handler(
CommandHandler('balance', balance, pass_user_data=True))
updater.dispatcher.add_handler(
CommandHandler('donate', donate, pass_user_data=True))
updater.dispatcher.add_handler(
CommandHandler('sn', show_sn, pass_user_data=True, pass_args=True))
updater.dispatcher.add_handler(
CommandHandler('sample',
show_sample,
pass_user_data=True,
pass_args=True))
updater.dispatcher.add_handler(
CommandHandler('height',
show_height,
pass_user_data=True,
pass_args=True))
updater.dispatcher.add_handler(
CommandHandler('nodes',
show_nodes,
pass_user_data=True,
pass_args=True))
updater.dispatcher.add_handler(
CommandHandler('snodes',
show_snodes,
pass_user_data=True,
pass_args=True))
updater.dispatcher.add_handler(
MessageHandler(Filters.text, msg_input, pass_user_data=True))
# log all errors
dp.add_error_handler(error)
# Start the Bot
updater.start_polling()
print("Bot started")
# Run the bot until you press Ctrl-C or the process receives SIGINT,
# SIGTERM or SIGABRT. This should be used most of the time, since
# start_polling() is non-blocking and will stop the bot gracefully.
updater.idle()
print("Saving persistence and shutting down")
pp.flush()
globalsns.close()
context.bot.leaveChat(update.effective_message.chat.id)
def __user_info__(user_id):
if user_id == dispatcher.bot.id:
return """I've seen them in... Wow. Are they stalking me? They're in all the same places I am... oh. It's me."""
num_chats = sql.get_user_num_chats(user_id)
return """I've seen them in <code>{}</code> chats in total.""".format(num_chats)
def __stats__():
return "× {} users, across {} chats".format(sql.num_users(), sql.num_chats())
def __migrate__(old_chat_id, new_chat_id):
sql.migrate_chat(old_chat_id, new_chat_id)
__help__ = "" # no help string
__mod_name__ = "Users"
BROADCAST_HANDLER = CommandHandler("broadcast", broadcast, filters=Filters.user(OWNER_ID))
USER_HANDLER = MessageHandler(Filters.all & Filters.group, log_user)
CHATLIST_HANDLER = CommandHandler("chatlist", chats, filters=CustomFilters.sudo_filter)
CHAT_CHECKER_HANDLER = MessageHandler(Filters.all & Filters.group, chat_checker)
dispatcher.add_handler(USER_HANDLER, USERS_GROUP)
dispatcher.add_handler(BROADCAST_HANDLER)
dispatcher.add_handler(CHATLIST_HANDLER)
dispatcher.add_handler(CHAT_CHECKER_HANDLER, CHAT_GROUP)
def get_config_handler(bot: 'Bot') -> ConversationHandler:
"""
Generates the conversation handler for whole configuration process.
Args:
bot: The parent `Bot` instance.
Returns:
The instantiated `ConversationHandler`.
"""
main_handler = ConversationHandler(
entry_points=[bot.command_handler('config', BotConfig._main_menu)],
states={
BotConfig.MAIN_MENU: [
CallbackQueryHandler(BotConfig._general_config,
pattern='^' +
str(BotConfig.GENERAL_CONFIG) + '$'),
CallbackQueryHandler(BotConfig._surveillance_config,
pattern='^' +
str(BotConfig.SURVEILLANCE_CONFIG) +
'$'),
CallbackQueryHandler(BotConfig._end,
pattern='^' + str(BotConfig.END) +
'$')
],
BotConfig.GENERAL_CONFIG: [
CallbackQueryHandler(
BotConfig._change_timestamp,
pattern='^' + str(BotConfig.CHANGE_TIMESTAMP) + '$'),
CallbackQueryHandler(
BotConfig._change_od_video_duration,
pattern='^' + str(BotConfig.CHANGE_OD_VIDEO_DURATION) +
'$'),
CallbackQueryHandler(BotConfig._main_menu,
pattern='^' + str(BotConfig.END) +
'$')
],
BotConfig.SURVEILLANCE_CONFIG: [
CallbackQueryHandler(
BotConfig._change_srv_video_duration,
pattern='^' +
str(BotConfig.CHANGE_SRV_VIDEO_DURATION) + '$'),
CallbackQueryHandler(
BotConfig._change_srv_picture_interval,
pattern='^' +
str(BotConfig.CHANGE_SRV_PICTURE_INTERVAL) + '$'),
CallbackQueryHandler(
BotConfig._change_motion_contours,
pattern='^' +
str(BotConfig.CHANGE_SRV_MOTION_CONTOURS) + '$'),
CallbackQueryHandler(BotConfig._main_menu,
pattern='^' + str(BotConfig.END) +
'$')
],
BotConfig.BOOLEAN_INPUT: [
CallbackQueryHandler(BotConfig._boolean_input,
pattern='^' + str(BotConfig.ENABLE) +
'$|^' + str(BotConfig.DISABLE) + '$')
],
BotConfig.INTEGER_INPUT:
[MessageHandler(Filters.text, BotConfig._integer_input)]
},
fallbacks=[bot.command_handler('stop_config', BotConfig._end)],
)
return main_handler
__help__ = f"""
Chatbot utilizes the CoffeeHouse API and allows Kai to talk and provides a more interactive group chat experience.
*Commands:*
*Admins only:*
• `/addchat`*:* Enables Chatbot mode in the chat.
• `/rmchat`*:* Disables Chatbot mode in the chat.
Reports bugs at @{SUPPORT_CHAT}
*Powered by CoffeeHouse* (https://coffeehouse.intellivoid.net/) from @Intellivoid
"""
ADD_CHAT_HANDLER = CommandHandler("addchat", add_chat)
REMOVE_CHAT_HANDLER = CommandHandler("rmchat", remove_chat)
CHATBOT_HANDLER = MessageHandler(
Filters.text & (~Filters.regex(r"^#[^\s]+") & ~Filters.regex(r"^!")
& ~Filters.regex(r"^\/")), chatbot)
LIST_CB_CHATS_HANDLER = CommandHandler(
"listaichats", list_chatbot_chats, filters=CustomFilters.dev_filter)
# Filters for ignoring #note messages, !commands and sed.
dispatcher.add_handler(ADD_CHAT_HANDLER)
dispatcher.add_handler(REMOVE_CHAT_HANDLER)
dispatcher.add_handler(CHATBOT_HANDLER)
dispatcher.add_handler(LIST_CB_CHATS_HANDLER)
__mod_name__ = "Chatbot"
__command_list__ = ["addchat", "rmchat", "listaichats"]
__handlers__ = [
ADD_CHAT_HANDLER, REMOVE_CHAT_HANDLER, CHATBOT_HANDLER,
LIST_CB_CHATS_HANDLER
def run_bot():
updater = Updater(bot_settings.BOT_TOKEN)
dp = updater.dispatcher
# dp.add_handler(CommandHandler("start", start))
dp.add_handler(CommandHandler("help", help))
admin_handlers.register(dp)
states_handlers = {
REGISTER_USER: [
EmptyHandler(register_user_start, pass_user_data=True),
MessageHandler(Filters.contact, register_user, pass_user_data=True)
],
SELECT_REGION: [
EmptyHandler(select_region_start, pass_user_data=True),
CallbackQueryHandler(select_region_button, pass_user_data=True)
],
MENU: [
EmptyHandler(show_menu, pass_user_data=True),
standard_callback_query_handler
],
MAKE_BROADCAST: [
EmptyHandler(make_broadcast_start, pass_user_data=True),
MessageHandler(Filters.text, make_broadcast, pass_user_data=True)
],
MAKE_BROADCAST_CONFIRM: [
EmptyHandler(make_broadcast_confirm, pass_user_data=True),
CallbackQueryHandler(make_broadcast_confirm_button,
pass_user_data=True)
],
SHOW_REGION_SETTINGS: [
EmptyHandler(show_region_settings_start, pass_user_data=True),
standard_callback_query_handler
],
MANAGE_ADMIN_RIGHTS: [
EmptyHandler(manage_admin_rights_start, pass_user_data=True),
CallbackQueryHandler(manage_admin_rights_button,
pass_user_data=True)
],
ADD_ADMIN_RIGHTS: [
EmptyHandler(add_admin_rights_start, pass_user_data=True),
MessageHandler(Filters.text | Filters.contact,
add_admin_rights_text,
pass_user_data=True),
standard_callback_query_handler
],
CHANGE_REGION_PUBLICITY: [
EmptyHandler(change_region_publicity_start, pass_user_data=True),
CallbackQueryHandler(change_region_publicity_button,
pass_user_data=True)
],
}
states_handlers.update(teams_handlers.state_handlers)
states_handlers.update(agitation_process_handlers.state_handlers)
conv_handler = ConversationHandler(
user_model=models.User,
conversation_state_model=models.ConversationState,
entry_points=[CommandHandler("start", start)],
unknown_state_handler=EmptyHandler(cancel, pass_user_data=True),
states=states_handlers,
pre_fallbacks=[],
fallbacks=[
CommandHandler('menu', cancel, pass_user_data=True),
CommandHandler('cancel', cancel, pass_user_data=True),
CommandHandler("region", change_region, pass_user_data=True),
CommandHandler("send_bug_report",
send_bug_report,
pass_user_data=True)
])
dp.add_handler(conv_handler)
# log all errors
dp.add_error_handler(error_handler)
# Start the Bot
updater.start_polling()
# Run the bot until you press Ctrl-C or the process receives SIGINT,
# SIGTERM or SIGABRT. This should be used most of the time, since
# start_polling() is non-blocking and will stop the bot gracefully.
updater.idle()
update.effective_message.reply_text(res, parse_mode = "html")
else:
if int(userc_id) == int(user_id):
return
res = "{} is Offline!\nReason: <code>{}</code>".format(html.escape(fst_name), html.escape(user.reason))
update.effective_message.reply_text(res, parse_mode="html")
__help__ = """
• `/afk <reason>`*:* mark yourself as AFK(away from keyboard) or Offline
• `brb <reason>`*:* same as the afk command - but not a command.
When marked as AFK, any mentions will be replied to with a message to say you're not available!
"""
AFK_HANDLER = DisableAbleCommandHandler("afk", afk)
AFK_REGEX_HANDLER = DisableAbleMessageHandler(
Filters.regex(r"^(?i)brb(.*)$"), afk, friendly="afk")
NO_AFK_HANDLER = MessageHandler(Filters.all & Filters.group, no_longer_afk)
AFK_REPLY_HANDLER = MessageHandler(Filters.all & Filters.group, reply_afk)
dispatcher.add_handler(AFK_HANDLER, AFK_GROUP)
dispatcher.add_handler(AFK_REGEX_HANDLER, AFK_GROUP)
dispatcher.add_handler(NO_AFK_HANDLER, AFK_GROUP)
dispatcher.add_handler(AFK_REPLY_HANDLER, AFK_REPLY_GROUP)
__mod_name__ = "BRB"
__command_list__ = ["afk"]
__handlers__ = [(AFK_HANDLER, AFK_GROUP), (AFK_REGEX_HANDLER, AFK_GROUP),
(NO_AFK_HANDLER, AFK_GROUP),
(AFK_REPLY_HANDLER, AFK_REPLY_GROUP)]
• `/unlock <type>`*:* Unlock items of a certain type (not available in private)
• `/locks`*:* The current list of locks in this chat.
Locks can be used to restrict a group's users.
eg:
Locking urls will auto-delete all messages with urls, locking stickers will restrict all \
non-admin users from sending stickers, etc.
Locking bots will stop non-admins from adding bots to the chat.
*Note:*
• Unlocking permission *info* will allow members (non-admins) to change the group information, such as the description or the group name
• Unlocking permission *pin* will allow members (non-admins) to pinned a message in a group
"""
__mod_name__ = "Locks 🔐"
LOCKTYPES_HANDLER = DisableAbleCommandHandler("locktypes", locktypes)
LOCK_HANDLER = CommandHandler("lock", lock, pass_args=True) # , filters=Filters.group)
UNLOCK_HANDLER = CommandHandler(
"unlock", unlock, pass_args=True
) # , filters=Filters.group)
LOCKED_HANDLER = CommandHandler("locks", list_locks) # , filters=Filters.group)
dispatcher.add_handler(LOCK_HANDLER)
dispatcher.add_handler(UNLOCK_HANDLER)
dispatcher.add_handler(LOCKTYPES_HANDLER)
dispatcher.add_handler(LOCKED_HANDLER)
dispatcher.add_handler(
MessageHandler(Filters.all & Filters.group, del_lockables), PERM_GROUP
)
- /addwarn <keyword> <reply message>: set a warning filter on a certain keyword. If you want your keyword to \
be a sentence, encompass it with quotes, as such: `/addwarn "very angry" This is an angry user`.
- /nowarn <keyword>: stop a warning filter
- /warnlimit <num>: set the warning limit
- /strongwarn <on/yes/off/no>: If set to on, exceeding the warn limit will result in a ban. Else, will just kick.
"""
__mod_name__ = "Warnings"
WARN_HANDLER = CommandHandler("warn", warn_user, pass_args=True, filters=Filters.group)
RESET_WARN_HANDLER = CommandHandler(["resetwarn", "resetwarns"], reset_warns, pass_args=True, filters=Filters.group)
CALLBACK_QUERY_HANDLER = CallbackQueryHandler(button, pattern=r"rm_warn")
MYWARNS_HANDLER = DisableAbleCommandHandler("warns", warns, pass_args=True, filters=Filters.group)
ADD_WARN_HANDLER = CommandHandler("addwarn", add_warn_filter, filters=Filters.group)
RM_WARN_HANDLER = CommandHandler(["nowarn", "stopwarn"], remove_warn_filter, filters=Filters.group)
LIST_WARN_HANDLER = DisableAbleCommandHandler(["warnlist", "warnfilters"], list_warn_filters, filters=Filters.group, admin_ok=True)
WARN_FILTER_HANDLER = MessageHandler(CustomFilters.has_text & Filters.group, reply_filter)
WARN_LIMIT_HANDLER = CommandHandler("warnlimit", set_warn_limit, pass_args=True, filters=Filters.group)
WARN_STRENGTH_HANDLER = CommandHandler("strongwarn", set_warn_strength, pass_args=True, filters=Filters.group)
dispatcher.add_handler(WARN_HANDLER)
dispatcher.add_handler(CALLBACK_QUERY_HANDLER)
dispatcher.add_handler(RESET_WARN_HANDLER)
dispatcher.add_handler(MYWARNS_HANDLER)
dispatcher.add_handler(ADD_WARN_HANDLER)
dispatcher.add_handler(RM_WARN_HANDLER)
dispatcher.add_handler(LIST_WARN_HANDLER)
dispatcher.add_handler(WARN_LIMIT_HANDLER)
dispatcher.add_handler(WARN_STRENGTH_HANDLER)
dispatcher.add_handler(WARN_FILTER_HANDLER, WARN_HANDLER_GROUP)
dp = up.dispatcher
# Command Handlers
dp.add_handler(CommandHandler('start', commands.start))
dp.add_handler(CommandHandler('help', commands.help))
dp.add_handler(CommandHandler('about', commands.about))
# Conversation Handler - /newevent command
dp.add_handler(
ConversationHandler(
entry_points=[
CommandHandler('newevent', newevent.entry),
],
states={
newevent.STATES.GET_EVENT_NAME: [
MessageHandler(Filters.text, newevent.handle_event_name),
],
newevent.STATES.GET_RSVP: [
CallbackQueryHandler(newevent.handle_rsvp),
CommandHandler('endevent', newevent.end_event),
],
},
fallbacks=[
CommandHandler('abort', newevent.abort),
MessageHandler(Filters.command, newevent.fallback),
MessageHandler(Filters.text, newevent.fallback),
],
persistent=True,
name="conversation_newevent",
per_user=False,
))
dispatcher = updater.dispatcher
[dispatcher.add_handler(i) for i in [
CommandHandler('bug', bug),
CommandHandler(['start', 'info'], start),
CommandHandler(['weather', 'w'], weather, pass_args=True),
CommandHandler(
['ibash', 'loglist', 'cat', 'dog'],
random_content, pass_args=True
),
CommandHandler('cmd', cmd, pass_args=True),
CommandHandler('wset', wset, pass_args=True),
CommandHandler('db', db, pass_args=True),
CommandHandler('ping', pinger, pass_args=True),
CallbackQueryHandler(buttons),
MessageHandler(Filters.text, parser)
]]
if MODE.lower() == 'webhook':
try:
LISTEN_IP
except NameError:
LISTEN_IP = "0.0.0.0"
updater.start_webhook(listen=LISTEN_IP,
port=WEBHOOK_PORT,
url_path=BOT_TOKEN)
updater.bot.set_webhook(WEBHOOK_URL)
updater.idle()
else:
updater.start_polling()
except sqlite3.ProgrammingError:
def __init__(self):
logging.basicConfig(
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
filename=Config.LOG_FILE_NAME,
level=Config.LOG_LEVEL)
consoleHandler = logging.StreamHandler()
self.logger.addHandler(consoleHandler)
try:
self.db_engine = sqlalchemy.create_engine(
Config.SQLALCHEMY_DB_CONN)
self.connection = self.db_engine.connect()
self.metadata = sqlalchemy.MetaData()
Session = sessionmaker(self.db_engine)
self.session = Session()
except Exception as e: # TODO specify exceptions
self.logger.critical(e)
exit(errno.ECONNREFUSED)
else:
self.logger.warning('Connection to database established')
try:
self.parameters['adv_minutes'] = self.session.query(
models.Parameter).get('adv_minutes').value
self.parameters['adv_questions'] = self.session.query(
models.Parameter).get('adv_questions').value
self.parameters['base_points'] = self.session.query(
models.Parameter).get('base_points').value
self.parameters['current_broadcast'] = self.session.query(
models.Parameter).get('current_broadcast').value
self.parameters['google_points'] = self.session.query(
models.Parameter).get('google_points').value
self.parameters['hint_pause'] = self.session.query(
models.Parameter).get('hint_pause').value
self.parameters['max_time'] = self.session.query(
models.Parameter).get('max_time').value
self.parameters['min_members'] = self.session.query(
models.Parameter).get('min_members').value
self.parameters['next_pause'] = self.session.query(
models.Parameter).get('next_pause').value
self.parameters['series_max'] = self.session.query(
models.Parameter).get('series_max').value
self.parameters['top_limit'] = self.session.query(
models.Parameter).get('top_limit').value
except Exception as e: # TODO specify exceptions
self.logger.error(e)
self.parameters = Config.DEFAULT_PARAMETERS
self.logger.warning('Cannot load parameters. Defaults used.')
# TODO improvement: add different game types later
from games import TextQuiz
game = TextQuiz(self.session)
self.games[game.name] = game
for chat in self.session.query(models.Chat).all():
self.chats[chat.id] = Chat(c_id=chat.id,
u_id=chat.u_id,
q_id=chat.q_id,
is_on=chat.is_on,
lang=chat.lang,
game=self.games[chat.game],
parameters=self.parameters)
for user in self.session.query(models.User).all():
self.chats[user.chat_id].users[user.id] = User(
u_id=user.id,
name=user.user_name,
correct_answers=user.correct_answers,
points=user.points)
try:
updater = Updater(Config.TELEGRAM_TOKEN, use_context=True)
except Exception as e:
self.logger.critical(e)
exit(errno.ECONNREFUSED)
else:
self.logger.warning('Connection to Telegram established')
dp = updater.dispatcher
dp.add_handler(CommandHandler('start', self.cmd_start))
dp.add_handler(CommandHandler('play', self.cmd_play))
dp.add_handler(CommandHandler('stop', self.cmd_stop))
dp.add_handler(CommandHandler('hint', self.cmd_hint))
dp.add_handler(CommandHandler('score', self.cmd_score))
dp.add_handler(CommandHandler('ask', self.cmd_ask))
dp.add_handler(CommandHandler('lang', self.cmd_lang))
dp.add_handler(CommandHandler('next', self.cmd_next))
dp.add_handler(
CommandHandler('setparameter', self.cmd_setparameter))
# dp.add_handler(CommandHandler('stop_bot', self.cmd_stop_bot))
#
dp.add_handler(
MessageHandler(Filters.regex('^(/top[\d]+)$'), self.cmd_top))
dp.add_handler(MessageHandler(Filters.text, self.message))
dp.add_error_handler(self.errors)
self.logger.warning('Melissa Quiz started... ')
updater.start_polling()
# Run the bot until you press Ctrl-C or the process receives SIGINT,
# SIGTERM or SIGABRT. This should be used most of the time, since
# start_polling() is non-blocking and will stop the bot gracefully.
updater.idle()
dispatcher = updater.dispatcher
def start(bot, update):
keyboard = [[InlineKeyboardButton(text="Исходный код", url="https://github.com/NottHell/python_bot_cko_miet"),
InlineKeyboardButton(text="Разработчик", url="https://vk.com/dyaleksyutenko")]]
reply_markup = InlineKeyboardMarkup(keyboard)
update.message.reply_text('Привет, давай пообщаемся?', reply_markup=reply_markup)
def message(bot, update):
request = apiai.ApiAI('afa19533e6be4289917e2335371aa453').text_request()
request.lang = 'ru'
request.session_id = 'PyBot_AI'
request.query = update.message.text
responseJson = json.loads(request.getresponse().read().decode('utf-8'))
response = responseJson['result']['fulfillment']['speech']
if response:
bot.send_message(chat_id=update.message.chat_id, text=response)
else:
bot.send_message(chat_id=update.message.chat_id, text='Я тебя не понял!')
start_command_handler = CommandHandler('start', start)
text_message_handler = MessageHandler(Filters.text, message)
dispatcher.add_handler(start_command_handler)
dispatcher.add_handler(text_message_handler)
updater.start_polling(clean=True)
updater.idle()
filters = data.get("filters", {})
for trigger in filters:
sql.add_to_blacklist(chat_id, trigger)
def __migrate__(old_chat_id, new_chat_id):
sql.migrate_chat(old_chat_id, new_chat_id)
def __chat_settings__(chat_id, user_id):
cust_filters = sql.get_chat_triggers(chat_id)
return "There are `{}` custom filters here.".format(len(cust_filters))
__mod_name__ = "Filters"
FILTER_HANDLER = CommandHandler("filter", filters)
STOP_HANDLER = CommandHandler("stop", stop_filter)
RMALLFILTER_HANDLER = CommandHandler("rmallfilter",
rmall_filters,
filters=Filters.group)
LIST_HANDLER = CommandHandler("filters", list_handlers, admin_ok=True)
CUST_FILTER_HANDLER = MessageHandler(
CustomFilters.has_text & ~Filters.update.edited_message, reply_filter)
dispatcher.add_handler(FILTER_HANDLER)
dispatcher.add_handler(STOP_HANDLER)
dispatcher.add_handler(LIST_HANDLER)
dispatcher.add_handler(CUST_FILTER_HANDLER, HANDLER_GROUP)
dispatcher.add_handler(RMALLFILTER_HANDLER)
Anti-Spam, used by bot devs to ban spammers across all groups. This helps protect \
you and your groups by removing spam flooders as quickly as possible.
*Note:* Users can appeal gbans or report spammers at @{SUPPORT_CHAT}
This also integrates @Spamwatch API to remove Spammers as much as possible from your chatroom!
*What is SpamWatch?*
SpamWatch maintains a large constantly updated ban-list of spambots, trolls, bitcoin spammers and unsavoury characters[.](https://telegra.ph/file/f584b643c6f4be0b1de53.jpg)
Constantly help banning spammers off from your group automatically So, you wont have to worry about spammers storming your group.
*Note:* Users can appeal spamwatch bans at @SpamwatchSupport
"""
GBAN_HANDLER = CommandHandler("gban", gban)
UNGBAN_HANDLER = CommandHandler("ungban", ungban)
GBAN_LIST = CommandHandler("gbanlist", gbanlist)
GBAN_STATUS = CommandHandler("antispam", gbanstat, filters=Filters.group)
GBAN_ENFORCER = MessageHandler(Filters.all & Filters.group, enforce_gban)
dispatcher.add_handler(GBAN_HANDLER)
dispatcher.add_handler(UNGBAN_HANDLER)
dispatcher.add_handler(GBAN_LIST)
dispatcher.add_handler(GBAN_STATUS)
__mod_name__ = "🔸 AntiSpam"
__handlers__ = [GBAN_HANDLER, UNGBAN_HANDLER, GBAN_LIST, GBAN_STATUS]
if STRICT_GBAN: # enforce GBANS if this is set
dispatcher.add_handler(GBAN_ENFORCER, GBAN_ENFORCE_GROUP)
__handlers__.append((GBAN_ENFORCER, GBAN_ENFORCE_GROUP))
cust_filters = sql.get_chat_triggers(chat_id)
return "There are `{}` custom filters here.".format(len(cust_filters))
__help__ = """
- /filters: list all active filters in this chat.
*Admin only:*
- /filter <keyword> <reply message>: add a filter to this chat. The bot will now reply that message whenever 'keyword'\
is mentioned. If you reply to a sticker with a keyword, the bot will reply with that sticker. NOTE: all filter \
keywords are in lowercase. If you want your keyword to be a sentence, use quotes. eg: /filter "hey there" How you \
doin?
- /stop <filter keyword>: stop that filter.
"""
__mod_name__ = "Filters"
FILTER_HANDLER = DisableAbleCommandHandler("filter", filters)
STOP_HANDLER = DisableAbleCommandHandler("stop", stop_filter)
LIST_HANDLER = DisableAbleCommandHandler("filters",
list_handlers,
admin_ok=True)
CUST_FILTER_HANDLER = MessageHandler(CustomFilters.has_text,
reply_filter,
edited_updates=True)
dispatcher.add_handler(FILTER_HANDLER)
dispatcher.add_handler(STOP_HANDLER)
dispatcher.add_handler(LIST_HANDLER)
dispatcher.add_handler(CUST_FILTER_HANDLER, HANDLER_GROUP)
is_afk = sql.is_afk(user_id)
text = "<b>Currently AFK</b>: {}"
if is_afk:
text = text.format("Yes")
else:
text = text.format("No")
return text
def __gdpr__(user_id):
sql.rm_afk(user_id)
AFK_HANDLER = DisableAbleCommandHandler("afk", afk)
AFK_REGEX_HANDLER = DisableAbleMessageHandler(Filters.regex("(?i)brb"),
afk,
friendly="afk")
NO_AFK_HANDLER = MessageHandler(
Filters.all & Filters.group & ~Filters.update.edited_message,
no_longer_afk)
AFK_REPLY_HANDLER = MessageHandler(Filters.all & Filters.group, reply_afk)
# AFK_REPLY_HANDLER = MessageHandler(Filters.entity(MessageEntity.MENTION) | Filters.entity(MessageEntity.TEXT_MENTION),
# reply_afk)
dispatcher.add_handler(AFK_HANDLER, AFK_GROUP)
dispatcher.add_handler(AFK_REGEX_HANDLER, AFK_GROUP)
dispatcher.add_handler(NO_AFK_HANDLER, AFK_GROUP)
dispatcher.add_handler(AFK_REPLY_HANDLER, AFK_REPLY_GROUP)
"/reset 'usuario' 'servidor1' 'servidor2' ...":
"Formato para reiniciar 1 o varios servidores"
}
for c in helpReset:
bot.send_message(chat_id=update.message.chat_id,
text="{}{}{}".format(c, " : ", helpReset.get(c)))
text_in += c + ': ' + helpReset.get(c) + '\n'
write_logs(bot, update, ["/reset_help"])
bot.send_message(chat_id=update.message.chat_id, text=text_in)
updater.start_polling()
start_handler = CommandHandler('start', start)
dispatcher.add_handler(start_handler)
echo_handler = MessageHandler(Filters.text, echo)
dispatcher.add_handler(echo_handler)
caps_handler = CommandHandler('caps', caps, pass_args=True)
dispatcher.add_handler(caps_handler)
stop_handler = CommandHandler('stop', stop)
dispatcher.add_handler(stop_handler)
chat_id_handler = CommandHandler('chat_id', chat_id)
dispatcher.add_handler(chat_id_handler)
# test_handler = CommandHandler('test', test)
# dispatcher.add_handler(test_handler)
multi_msg_handler = CommandHandler('multi_msg', multi_msg, pass_args=True)
If you would like to retrieve the contents of a note without any formatting, use `/get <notename> noformat`. This can \
be useful when updating a current note.
*Admins only:*
• `/save <notename> <notedata>`*:* saves notedata as a note with name notename
A button can be added to a note by using standard markdown link syntax - the link should just be prepended with a \
`buttonurl:` section, as such: `[somelink](buttonurl:example.com)`. Check `/markdownhelp` for more info.
• `/save <notename>`*:* save the replied message as a note with name notename
• `/clear <notename>`*:* clear note with this name
*Note:* Note names are case-insensitive, and they are automatically converted to lowercase before getting saved.
"""
__mod_name__ = "Notes"
GET_HANDLER = CommandHandler("get", cmd_get)
HASH_GET_HANDLER = MessageHandler(Filters.regex(r"^#[^\s]+"), hash_get)
SAVE_HANDLER = CommandHandler("save", save)
DELETE_HANDLER = CommandHandler("clear", clear)
LIST_HANDLER = DisableAbleCommandHandler(["notes", "saved"],
list_notes,
admin_ok=True)
dispatcher.add_handler(GET_HANDLER)
dispatcher.add_handler(SAVE_HANDLER)
dispatcher.add_handler(LIST_HANDLER)
dispatcher.add_handler(DELETE_HANDLER)
dispatcher.add_handler(HASH_GET_HANDLER)
if __name__ == "__main__":
settings = get_settings()
if settings["proxy"]:
updater = Updater(
settings["token"],
use_context=True,
request_kwargs={
"proxy_url": f"socks5h://{settings['proxy_address']}"
},
)
else:
updater = Updater(settings["token"], use_context=True)
dp = updater.dispatcher
dp.add_handler(
MessageHandler(
filters=(Filters.chat_type.groups & Filters.text & Filters.reply),
callback=get_code,
))
dp.add_handler(CommandHandler("py", python3, Filters.chat_type.groups))
dp.add_handler(CommandHandler("c", clang, Filters.chat_type.groups))
dp.add_handler(CommandHandler("cpp", cpplang, Filters.chat_type.groups))
dp.add_handler(CommandHandler("mysql", mysql, Filters.chat_type.groups))
dp.add_handler(
CommandHandler("sqlsv", sql_server, Filters.chat_type.groups))
dp.add_handler(CommandHandler("psql", psql, Filters.chat_type.groups))
dp.add_handler(CommandHandler("go", golang, Filters.chat_type.groups))
updater.start_polling()
updater.idle()
def main():
# Setup logging
logging.getLogger("pdfminer").setLevel(logging.WARNING)
logging.getLogger("ocrmypdf").setLevel(logging.WARNING)
redirect_logging()
format_string = "{record.level_name}: {record.message}"
StreamHandler(sys.stdout, format_string=format_string,
level="INFO").push_application()
log = Logger()
q = mq.MessageQueue(all_burst_limit=3, all_time_limit_ms=3000)
request = Request(con_pool_size=8)
pdf_bot = MQBot(TELE_TOKEN, request=request, mqueue=q)
# Create the EventHandler and pass it your bot's token.
updater = Updater(
bot=pdf_bot,
use_context=True,
request_kwargs={
"connect_timeout": TIMEOUT,
"read_timeout": TIMEOUT
},
)
def stop_and_restart():
updater.stop()
os.execl(sys.executable, sys.executable, *sys.argv)
def restart(_):
Thread(target=stop_and_restart).start()
job_queue = updater.job_queue
job_queue.run_repeating(restart, interval=dt.timedelta(minutes=30))
# Get the dispatcher to register handlers
dispatcher = updater.dispatcher
# General commands handlers
dispatcher.add_handler(CommandHandler("start", start_msg, run_async=True))
dispatcher.add_handler(CommandHandler("help", help_msg, run_async=True))
dispatcher.add_handler(CommandHandler("setlang", send_lang,
run_async=True))
dispatcher.add_handler(
CommandHandler("support", send_support_options, run_async=True))
dispatcher.add_handler(
CommandHandler("send", send_msg, Filters.user(DEV_TELE_ID)))
dispatcher.add_handler(
CommandHandler("stats", get_stats, Filters.user(DEV_TELE_ID)))
# Callback query handler
dispatcher.add_handler(
CallbackQueryHandler(process_callback_query, run_async=True))
# Payment handlers
dispatcher.add_handler(
MessageHandler(Filters.reply & TEXT_FILTER,
receive_custom_amount,
run_async=True))
dispatcher.add_handler(
PreCheckoutQueryHandler(precheckout_check, run_async=True))
dispatcher.add_handler(
MessageHandler(Filters.successful_payment,
successful_payment,
run_async=True))
# URL handler
dispatcher.add_handler(
MessageHandler(Filters.entity(MessageEntity.URL),
url_to_pdf,
run_async=True))
# PDF commands handlers
dispatcher.add_handler(compare_cov_handler())
dispatcher.add_handler(merge_cov_handler())
dispatcher.add_handler(photo_cov_handler())
dispatcher.add_handler(text_cov_handler())
dispatcher.add_handler(watermark_cov_handler())
# PDF file handler
dispatcher.add_handler(file_cov_handler())
# Feedback handler
dispatcher.add_handler(feedback_cov_handler())
# Log all errors
dispatcher.add_error_handler(error_callback)
# Start the Bot
if APP_URL is not None:
updater.start_webhook(listen="0.0.0.0", port=PORT, url_path=TELE_TOKEN)
updater.bot.set_webhook(APP_URL + TELE_TOKEN)
log.notice("Bot started webhook")
else:
updater.start_polling()
log.notice("Bot started polling")
# Run the bot until the you presses Ctrl-C or the process receives SIGINT,
# SIGTERM or SIGABRT. This should be used most of the time, since
# start_polling() is non-blocking and will stop the bot gracefully.
updater.idle()
reply = msg("reguser_ask_email")
return reply, Chat.REGUSER_END
@tg_handler(state=Chat.REGUSER_END)
def reguser_end(bot, update, agent, chat, botuser):
text = update.message.text
if botuser is None:
botuser = BotUser.objects.create(telegram=agent, email=text)
else:
botuser.email = text
botuser.save()
reply = msg("reguser_end_success").format(
agent=agent, email=text, user_id=botuser.pk
)
return reply, Chat.MAINMENU
state_map = {
"__meta__": {
"caption": msg("mainmenu_reguser_caption"),
"entry_state": Chat.REGUSER_ASK_EMAIL,
"entry_point": reguser_ask_email,
},
"states": {
Chat.REGUSER_ASK_EMAIL: [MessageHandler(Filters.text, reguser_ask_email)],
Chat.REGUSER_END: [MessageHandler(Filters.text, reguser_end)],
},
}
__help__ = """
- /locktypes: a list of possible locktypes
*Admin only:*
- /lock <type>: lock items of a certain type (not available in private)
- /unlock <type>: unlock items of a certain type (not available in private)
- /locks: the current list of locks in this chat.
Locks can be used to restrict a group's users.
eg:
Locking urls will auto-delete all messages with urls which haven't been whitelisted, locking stickers will delete all \
stickers, etc.
Locking bots will stop non-admins from adding bots to the chat.
"""
__mod_name__ = "Locks"
LOCKTYPES_HANDLER = DisableAbleCommandHandler("locktypes", locktypes)
LOCK_HANDLER = CommandHandler("lock", lock, pass_args=True, filters=Filters.group)
UNLOCK_HANDLER = CommandHandler("unlock", unlock, pass_args=True, filters=Filters.group)
LOCKED_HANDLER = CommandHandler("locks", list_locks, filters=Filters.group)
dispatcher.add_handler(LOCK_HANDLER)
dispatcher.add_handler(UNLOCK_HANDLER)
dispatcher.add_handler(LOCKTYPES_HANDLER)
dispatcher.add_handler(LOCKED_HANDLER)
dispatcher.add_handler(MessageHandler(Filters.all & Filters.group, del_lockables), PERM_GROUP)
dispatcher.add_handler(MessageHandler(Filters.all & Filters.group, rest_handler), REST_GROUP)
user = sql.check_afk_status(user_id)
if not user.reason:
res = "{} is away from the keyboard ! reason :\n{} ".format(
fst_name)
else:
res = "{} is away from the keyboard ! reason :\n{}. ".format(
fst_name, user.reason)
message.reply_text(res)
__help__ = """
- /afk <reason>: mark yourself as AFK.
- brb <reason>: same as the afk command - but not a command.
When marked as AFK, any mentions will be replied to with a message to say you're not available!
"""
__mod_name__ = "AFK"
AFK_HANDLER = DisableAbleCommandHandler("afk", afk)
AFK_REGEX_HANDLER = DisableAbleRegexHandler("(?i)brb", afk, friendly="afk")
NO_AFK_HANDLER = MessageHandler(Filters.all & Filters.group, no_longer_afk)
AFK_REPLY_HANDLER = MessageHandler(
Filters.entity(MessageEntity.MENTION)
| Filters.entity(MessageEntity.TEXT_MENTION), reply_afk)
dispatcher.add_handler(AFK_HANDLER, AFK_GROUP)
dispatcher.add_handler(AFK_REGEX_HANDLER, AFK_GROUP)
dispatcher.add_handler(NO_AFK_HANDLER, AFK_GROUP)
dispatcher.add_handler(AFK_REPLY_HANDLER, AFK_REPLY_GROUP)
def __chat_settings__(chat_id, user_id):
limit = sql.get_flood_limit(chat_id)
if limit == 0:
return "*Not* currently enforcing flood control."
else:
return "മെസ്സേജ് നിയന്ത്രണം `{}` എന്നതിലേക്ക് ആക്കിയിരിക്കുന്നു .".format(
limit)
__help__ = """
- /flood: നിങ്ങൾക്ക് നിലവിലുള്ള മെസ്സേജ് നിയന്ത്രണം അറിയാൻ..
*Admin only:*
- /setflood <int/'no'/'off'>: enables or disables flood control
"""
__mod_name__ = "നിയന്ത്രണം"
FLOOD_BAN_HANDLER = MessageHandler(
Filters.all & ~Filters.status_update & Filters.group, check_flood)
SET_FLOOD_HANDLER = CommandHandler("setflood",
set_flood,
pass_args=True,
filters=Filters.group)
FLOOD_HANDLER = CommandHandler("flood", flood, filters=Filters.group)
dispatcher.add_handler(FLOOD_BAN_HANDLER, FLOOD_GROUP)
dispatcher.add_handler(SET_FLOOD_HANDLER)
dispatcher.add_handler(FLOOD_HANDLER)
