def add_mute(upd: Updater, handlers_group: int):
logger.info("registering mute handlers")
dp = upd.dispatcher
dp.add_handler(
CommandHandler(
"mute",
mute,
filters=Filters.chat(username=get_group_chat_id().strip("@"))
& admin_filter,
run_async=True,
),
handlers_group,
)
dp.add_handler(CommandHandler("mute", mute_self, run_async=True),
handlers_group)
dp.add_handler(
CommandHandler(
"unmute",
unmute,
filters=Filters.chat(username=get_group_chat_id().strip("@"))
& admin_filter,
run_async=True,
),
handlers_group,
)
def test_filters_chat_id(self, message):
assert not Filters.chat(chat_id=-1)(message)
message.chat.id = -1
assert Filters.chat(chat_id=-1)(message)
message.chat.id = -2
assert Filters.chat(chat_id=[-1, -2])(message)
assert not Filters.chat(chat_id=[-3, -4])(message)
def test_filters_chat_username(self, message):
assert not Filters.chat(username='******')(message)
message.chat.username = '******'
assert Filters.chat(username='******')(message)
assert Filters.chat(username='******')(message)
assert Filters.chat(username=['chat1', 'chat', 'chat2'])(message)
assert not Filters.chat(username=['@chat1', 'chat_2'])(message)
def test_filters_chat_id(message):
assert not Filters.chat(chat_id=-1)(message)
message.chat.id = -1
assert Filters.chat(chat_id=-1)(message)
message.chat.id = -2
assert Filters.chat(chat_id=[-1, -2])(message)
assert not Filters.chat(chat_id=[-3, -4])(message)
def test_filters_chat_id(self, update):
assert not Filters.chat(chat_id=-1)(update)
update.message.chat.id = -1
assert Filters.chat(chat_id=-1)(update)
update.message.chat.id = -2
assert Filters.chat(chat_id=[-1, -2])(update)
assert not Filters.chat(chat_id=[-3, -4])(update)
def test_filters_chat_id(self):
self.assertFalse(Filters.chat(chat_id=-1)(self.message))
self.message.chat.id = -1
self.assertTrue(Filters.chat(chat_id=-1)(self.message))
self.message.chat.id = -2
self.assertTrue(Filters.chat(chat_id=[-1, -2])(self.message))
self.assertFalse(Filters.chat(chat_id=-1)(self.message))
def test_filters_chat_username(message):
assert not Filters.chat(username='******')(message)
message.chat.username = '******'
assert Filters.chat(username='******')(message)
assert Filters.chat(username='******')(message)
assert Filters.chat(username=['chat1', 'chat', 'chat2'])(message)
assert not Filters.chat(username=['@chat1', 'chat_2'])(message)
def test_filters_chat_id(self):
self.assertFalse(Filters.chat(chat_id=-1)(self.message))
self.message.chat.id = -1
self.assertTrue(Filters.chat(chat_id=-1)(self.message))
self.message.chat.id = -2
self.assertTrue(Filters.chat(chat_id=[-1, -2])(self.message))
self.assertFalse(Filters.chat(chat_id=-1)(self.message))
def test_filters_chat_username(self):
self.assertFalse(Filters.chat(username='******')(self.message))
self.message.chat.username = '******'
self.assertTrue(Filters.chat(username='******')(self.message))
self.assertTrue(Filters.chat(username='******')(self.message))
self.assertTrue(Filters.chat(username=['chat1', 'chat', 'chat2'])(self.message))
self.assertFalse(Filters.chat(username=['@chat1', 'chat_2'])(self.message))
def test_filters_chat_username(self, update):
assert not Filters.chat(username='******')(update)
update.message.chat.username = '******'
assert Filters.chat(username='******')(update)
assert Filters.chat(username='******')(update)
assert Filters.chat(username=['chat1', 'chat', 'chat2'])(update)
assert not Filters.chat(username=['@chat1', 'chat_2'])(update)
def main() -> None:
""" MQTT setup """
mqttClient.loop_start()
mqttClient.subscribe(ESPRFID_MQTT_TOPIC)
mqttClient.subscribe(ESPRFID_MQTT_TOPIC + '/send')
mqttClient.subscribe(ESPRFID_MQTT_TOPIC + '/sync')
mqttClient.subscribe(ESPRFID_MQTT_TOPIC + '/accesslist')
mqttClient.on_message = on_mqtt_message
''' Telegram Bot setup '''
chat_filter = Filters.text & Filters.chat(DOORBOT_CHAT_ID)
# /help
dispatcher.add_handler(CommandHandler('help', help_command, chat_filter))
# /open
dispatcher.add_handler(CommandHandler('open', open_command, chat_filter))
# /[unknown command]
dispatcher.add_handler(
MessageHandler(Filters.command & chat_filter, unknown_command))
# Callback from Inline Keyboard
dispatcher.add_handler(CallbackQueryHandler(callback_message))
# Other messages
dispatcher.add_handler(
MessageHandler(~Filters.command & chat_filter, text_message))
# Other chat
dispatcher.add_handler(
MessageHandler(~Filters.chat(DOORBOT_CHAT_ID), unknown_chat))
updater.start_polling()
updater.idle()
def test_filters_chat_username(self):
self.assertFalse(Filters.chat(username='******')(self.message))
self.message.chat.username = '******'
self.assertTrue(Filters.chat(username='******')(self.message))
self.assertTrue(Filters.chat(username='******')(self.message))
self.assertTrue(
Filters.chat(username=['chat1', 'chat', 'chat2'])(self.message))
self.assertFalse(
Filters.chat(username=['@chat1', 'chat_2'])(self.message))
def get_filter(users: Iterable[User]):
username, chat_id = set(), set()
for user in users:
if isinstance(user, str):
username.add(user)
elif isinstance(user, int):
chat_id.add(user)
return Filters.chat(username=username, allow_empty=True) & Filters.chat(
chat_id=chat_id, allow_empty=True)
def test_filters_chat_id(self, update):
assert not Filters.chat(chat_id=1)(update)
update.message.chat.id = 1
assert Filters.chat(chat_id=1)(update)
update.message.chat.id = 2
assert Filters.chat(chat_id=[1, 2])(update)
assert not Filters.chat(chat_id=[3, 4])(update)
update.message.chat = None
assert not Filters.chat(chat_id=[3, 4])(update)
def main():
"""Start the bot."""
# Create the EventHandler and pass it your bot's token.
updater = Updater(token)
j = updater.job_queue
# Get the dispatcher to register handlers
dp = updater.dispatcher
# on different commands - answer in Telegram
dp.add_handler(CommandHandler("start", start))
dp.add_handler(CommandHandler("help", help))
dp.add_handler(CommandHandler("execute", execute, pass_args=True))
dp.add_handler(
CommandHandler("todo",
todoadd,
filters=Filters.chat(chat_id=userid),
pass_args=True))
dp.add_handler(
CommandHandler("deletetodo",
deletetodo,
filters=Filters.chat(chat_id=userid),
pass_args=True))
dp.add_handler(
CommandHandler("noteadd",
noteadd,
filters=Filters.chat(chat_id=userid),
pass_args=True))
dp.add_handler(
CommandHandler("deletenote",
deletenote,
filters=Filters.chat(chat_id=userid),
pass_args=True))
dp.add_handler(
CommandHandler("eventadd",
eventadd,
filters=Filters.chat(chat_id=userid),
pass_args=True))
# daily message
job_minute = j.run_daily(
bonjour, datetime.time(hour=dailyjob_hour, minute=dailyjob_min))
# on noncommand i.e message - echo the message on Telegram
dp.add_handler(MessageHandler(Filters.text, ifbot))
# log all errors
dp.add_error_handler(error)
# 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()
def __register_whitelist__(self, whitelist):
if whitelist:
chat_id_filter = Filters.chat(
list(filter(lambda x: isinstance(x, int), whitelist)))
chat_username_filter = Filters.chat(
list(filter(lambda x: isinstance(x, str), whitelist)))
self.__filters__ = merge_filters_and(
self.__filters__, chat_id_filter | chat_username_filter)
for u in whitelist:
if isinstance(u, int):
self.__bot__.send_message(u, self.__about_this_bot__())
def init(dispatcher: Dispatcher):
"""Provide handlers initialization."""
dispatcher.add_handler(
CommandHandler('vip',
vip,
filters=Filters.chat(config.USER_IDS[0]),
pass_args=True))
dispatcher.add_handler(
CommandHandler('unvip',
unvip,
filters=Filters.chat(config.USER_IDS[0]),
pass_args=True))
def init(dispatcher: Dispatcher):
"""Provide handlers initialization."""
dispatcher.add_handler(
MessageHandler(Filters.group & Filters.chat(config.GROUP_IDS), process_message))
dispatcher.add_handler(
MessageHandler(Filters.chat(config.USER_IDS[0]) & (Filters.text | Filters.caption),
process_message_from_authorised_user))
dispatcher.add_handler(
MessageHandler((~Filters.group) & (Filters.text | Filters.photo | Filters.document), process_message))
dispatcher.add_handler(CallbackQueryHandler(ignore_callback, pattern=r'^#$'))
dispatcher.add_handler(CallbackQueryHandler(get_warning))
def main():
pers = PicklePersistence("persistence")
defaults = Defaults(parse_mode="HTML", disable_notification=True)
updater = Updater("", defaults=defaults, persistence=pers)
dp = updater.dispatcher
dp.add_handler(MessageHandler(Filters.update.channel_post & Filters.chat(CHANNEL_ID), new_post))
dp.add_handler(MessageHandler(Filters.update.edited_channel_post & Filters.chat(CHANNEL_ID), edited_post))
dp.add_handler(MessageHandler(Filters.status_update.pinned_message & Filters.chat(GROUP_ID), del_msg))
if "messages" not in dp.bot_data:
dp.bot_data = {"messages": {}}
updater.start_polling()
updater.idle()
def main():
updater = Updater(cfg['TELEGRAM']['token'], use_context=True)
for obj in objects:
for key in list(obj.getCommands().keys()):
updater.dispatcher.add_handler(
CommandHandler(key,
obj.getCommands()[key],
~Filters.chat(BANNED_CHANNELS)))
updater.dispatcher.add_handler(
MessageHandler(~Filters.chat(BANNED_CHANNELS), allMessages))
updater.start_polling()
updater.idle()
def main() -> None:
"""Start the bot."""
updater = Updater(token)
startup(updater)
# Get the dispatcher to register handlers
dispatcher = updater.dispatcher
# dispatcher.add_handler(CommandHandler(
# "start", start, Filters.user(username="******")))
dispatcher.add_handler(CommandHandler(
"users", users, Filters.chat(chat_id=chat_ids)))
dispatcher.add_handler(CommandHandler(
"pwd", pwd, Filters.chat(chat_id=chat_ids)))
dispatcher.add_handler(CommandHandler(
"gep", get_execution_policy, Filters.chat(chat_id=chat_ids)))
dispatcher.add_handler(CommandHandler(
"uptime", uptime, Filters.chat(chat_id=chat_ids)))
dispatcher.add_handler(CommandHandler(
"get_screen", get_screen, Filters.chat(chat_id=chat_ids)))
dispatcher.add_handler(CommandHandler("terminal", terminal, Filters.chat(chat_id=chat_ids), pass_args=True))
dispatcher.add_handler(CommandHandler("ls", list_dir, Filters.chat(chat_id=chat_ids), pass_args=True))
dispatcher.add_handler(CommandHandler("cd", cd_folder, Filters.chat(chat_id=chat_ids), pass_args=True))
# on noncommand i.e message - echo the message on Telegram
# dispatcher.add_handler(MessageHandler(
# Filters.text & ~Filters.command, echo))
updater.start_polling()
updater.idle()
def main():
"""Start the bot."""
# Create the EventHandler and pass it your bot's token.
updater = Updater(TKN)
# Get the dispatcher to register handlers
dp = updater.dispatcher
# on different commands - answer in Telegram
# dp.add_handler(CommandHandler("start", start))
# dp.add_handler(CommandHandler("help", help))
# on noncommand i.e message - echo the message on Telegram
dp.add_handler(MessageHandler(
Filters.chat(144149077) & Filters.text, echo))
# log all errors
dp.add_error_handler(error)
# 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()
def main():
print('Bot started')
updater = Updater("884268402:AAHekHDw4T3Badp3LKmBSnsNQ9BUDiwf56M",
use_context=True)
# Get the dispatcher to register handlers
dp = updater.dispatcher
tjan_filter = TjanFilter()
no_you_filter = NoYouFilter()
dp.add_handler(
MessageHandler(Filters.status_update.new_chat_members, welcome))
# & Filters.chat(chat_id=-1001114719696), welcome))
dp.add_handler(
CommandHandler("aboutGroup",
aboutGroup,
filters=Filters.chat(chat_id=-1001114719696)))
dp.add_handler(MessageHandler(tjan_filter, tjan))
dp.add_handler(MessageHandler(Filters.user(username='******'), unca))
# DruzjDruzishka Caendaley
dp.add_handler(MessageHandler(no_you_filter, noyou))
dp.add_handler(CommandHandler('poloznjak', poloznjak))
dp.add_handler(CommandHandler('otbros', otbros))
# log all errors
dp.add_error_handler(error)
# Start the Bot
updater.start_polling(clean=True)
# 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()
def main():
# Create the Updater and pass it your bot's token.
# Make sure to set use_context=True to use the new context based callbacks
# Post version 12 this will no longer be necessary
updater = Updater(str(os.environ['TOKEN']), use_context=True)
# Get the dispatcher to register handlers
dp = updater.dispatcher
# on different commands - answer in Telegram
dp.add_handler(CommandHandler("start", start))
dp.add_handler(CommandHandler("help", help))
dp.add_handler(CommandHandler("id", id))
dp.add_handler(MessageHandler(
Filters.chat(int(os.environ['CHAT_ID'])), hodor))
updater.dispatcher.add_handler(CallbackQueryHandler(button))
# on noncommand i.e message - echo the message on Telegram
# log all errors
dp.add_error_handler(error)
# Start the Bot
updater.start_polling()
# Block until the user 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()
def set_handlers(dispatcher):
message_filters = Filters.chat(chat_id=CHANNEL_ID)
message_handler = MessageHandler(
filters=message_filters,
callback=chat_message_handler,
)
dispatcher.add_handler(message_handler)
def poll():
# monitoring
prometheus_server(8080)
# chat whitelist
whitelist = None
if os.getenv("TG_SINGLE_CHAT"):
whitelist = Filters.chat(chat_id=int(os.getenv("TG_SINGLE_CHAT")))
persistence = PicklePersistence(filename="data.pkl")
updater = Updater(os.getenv("TG_TOKEN"), persistence=persistence)
dp = updater.dispatcher
# on different commands - answer in Telegram
dp.add_handler(CommandHandler("start", start, filters=whitelist))
dp.add_handler(CommandHandler("stop", stop, filters=whitelist))
# on noncommand i.e message - check if it was correct
dp.add_handler(MessageHandler(Filters.text, check))
# log all errors
dp.add_error_handler(lambda update, context: logger.error(
f"(on update {update}) {context.error}"))
# start the bot
updater.start_polling()
updater.idle()
def start_bot(token):
# Create the Updater and pass it your bot's token.
updater = Updater(token, workers=1) # we have too small ram on oPi zero...
# Get the dispatcher to register handlers
dispatcher = updater.dispatcher
dispatcher.add_handler(MessageHandler(~Filters.chat(chatId), unknownChat))
# on different commands - answer in Telegram
dispatcher.add_handler(CommandHandler('start', start))
dispatcher.add_handler(CallbackQueryHandler(button))
dispatcher.add_handler(CommandHandler('keyboard', keyboard))
dispatcher.add_handler(CommandHandler('keyoff', keyboard_off))
dispatcher.add_handler(CommandHandler("help", help_command))
dispatcher.add_handler(CommandHandler("status", status))
dispatcher.add_handler(CommandHandler("photo", get_photo))
dispatcher.add_handler(CommandHandler("gif", get_gif))
dispatcher.add_handler(CommandHandler("video", get_video))
dispatcher.add_handler(CommandHandler("pause", pause_printing))
dispatcher.add_handler(CommandHandler("resume", resume_printing))
dispatcher.add_handler(CommandHandler("cancel", cancel_printing))
dispatcher.add_handler(CommandHandler("poweroff", power_off))
dispatcher.add_handler(CommandHandler("light", light_toggle))
dispatcher.add_handler(CommandHandler("files", get_gcode_files))
# on noncommand i.e message - echo the message on Telegram
dispatcher.add_handler(MessageHandler(Filters.text & ~Filters.command, echo))
dispatcher.add_handler(MessageHandler(Filters.document & ~Filters.command, upload_file))
# Start the Bot
updater.start_polling()
return updater
def main():
updater = Updater(TOKEN, use_context=True)
dp = updater.dispatcher
dp.add_handler(CommandHandler('start', start))
dp.add_handler(CommandHandler('help', help))
dp.add_handler(CommandHandler('kosher', kosher))
dp.add_handler(CommandHandler('splclue', splclue, filters=Filters.chat(GROUP_ID)))
dp.add_handler(MessageHandler(Filters.regex(clue_regex) & Filters.chat(GROUP_ID), get_clues))
dp.add_handler(MessageHandler(Filters.regex(emoji_regex), grin))
updater.start_polling()
updater.idle()
def get_handlers(cls) -> List[MessageHandler]:
"""Возвращает хендлеры загрузчика."""
filters = (~Filters.command) & (Filters.chat(cls.loader.channel))
return [MessageHandler(
Filters.video & filters,
cls.upload,
)]
def setup_dispatcher(dp):
dp.add_handler(CommandHandler('start', start))
dp.add_handler(MessageHandler(Filters.chat_type.private, forward_to_chat))
dp.add_handler(
MessageHandler(
Filters.chat(TELEGRAM_SUPPORT_CHAT_ID) & Filters.reply,
forward_to_user))
return dp
def register(self, dispatcher):
user_filter = Filters.chat(username='******')
dispatcher.add_handler(CommandHandler(['add'], self.add_command, user_filter, pass_args=True))
dispatcher.add_handler(CommandHandler(['list'], self.list_command, user_filter, pass_args=True))
dispatcher.add_handler(CommandHandler(['reset'], self.reset_command, user_filter, pass_args=True))
dispatcher.add_handler(CommandHandler(['remove'], self.remove_command, user_filter, pass_args=True))
dispatcher.add_handler(CommandHandler(['forceupdate'], self.forceupdate_command, user_filter, pass_args=True))
dispatcher.add_handler(MessageHandler(Filters.all, self.fallback))
def change_handlers(dp):
dp.handlers.clear()
dp.handlers = {
0:
[CommandHandler("upload", upload, Filters.chat(TRANSLATION_CHAT_ID))],
1: [],
2: []
}
def manager_app():
handlers = [
*join_options_handlers,
CommandHandler('start', start),
CommandHandler('rank', custom_rank),
CommandHandler('ranks', display_ranks),
CommandHandler('addemoji', add_emoji),
CommandHandler('churn', get_churn_list),
CommandHandler('get_stats', group_data.get_stats),
CommandHandler('activity',
activity.activity_command,
filters=Filters.group),
CommandHandler('statistics', statistics_command,
filters=Filters.group),
CommandHandler('action', set_action, filters=Filters.group),
CommandHandler('getd', get_file_data, filters=Filters.chat(dev_group)),
MessageHandler(Filters.animation | Filters.sticker,
sticker_and_gif_commands),
join_options_welcomes_command,
CommandHandler('tag_del',
mention_options.delete_messages,
filters=Filters.group),
MessageHandler(Filters.group & Filters.text,
mention_options.define_message_as_mention),
CallbackQueryHandler(stats.buttons, pattern='^stats '),
CallbackQueryHandler(group_data.buttons, pattern='^group_data '),
CallbackQueryHandler(advanced_commands_buttons, pattern='^setAction '),
CallbackQueryHandler(del_action, pattern='^delAction ')
]
conv_handler = ConversationHandler(
entry_points=[
CallbackQueryHandler(custom_helper_callback,
pattern='^customHelper ')
],
states={
GET_CLIENT_STR:
[MessageHandler(Filters.regex('^tg.hl@'), get_client_str)]
},
fallbacks=[],
allow_reentry=False)
handlers.append(conv_handler)
for handler in handlers:
dispatcher.add_handler(handler)
# conv_handler = ConversationHandler(
# entry_points=[CommandHandler('stt', start)],
# states={
#
# },
# fallbacks=[CommandHandler('cn', start)],
# allow_reentry=True
#
# )
#
# dp.add_handler(conv_handler)
print(12)
u.start_polling(clean=True)
def main():
updater = Updater(CONFIG["Telegram"]["bot_token"], use_context=True)
dispatcher = updater.dispatcher
dispatcher.add_handler(
MessageHandler(
Filters.chat(CONFIG.getint("Telegram", "chat_id")) & Filters.text
& Filters.command, cmd))
updater.start_polling()
updater.idle()
def test_filters_chat(self):
with pytest.raises(ValueError, match='chat_id or username'):
Filters.chat(chat_id=-1, username='******')
with pytest.raises(ValueError, match='chat_id or username'):
Filters.chat()
def test_filters_chat(self):
with self.assertRaisesRegexp(ValueError, 'chat_id or username'):
Filters.chat(chat_id=-1, username='******')
with self.assertRaisesRegexp(ValueError, 'chat_id or username'):
Filters.chat()
