def setup(dp: Dispatcher): # Команды dp.register_message_handler(start_from_command, commands=['start']) dp.register_callback_query_handler( start_from_callback, lambda c: c.data and c.data.startswith('main_menu'))
class KokkoroTelegramBot(KokkoroBot): def __init__(self, config): self.config = config super().kkr_load_modules(self.config) # KokkoroBot init self.bot = Bot(config.bot.telegram.TELEGRAM_TOKEN) self.dp = Dispatcher(self.bot) async def tg_msg_handler(raw_event: types.Message): await self.kkr_on_message(raw_event) self.dp.register_message_handler(tg_msg_handler) @overrides(KokkoroBot) def kkr_event_adaptor(self, raw_event: types.Message) -> EventInterface: return TelegramEvent(raw_event) @overrides(KokkoroBot) async def kkr_send(self, ev: TelegramEvent, msg: SupportedMessageType, at_sender=False, filename="image.png"): if isinstance(msg, str): await ev.get_raw_event().answer(msg) else: raise NotImplementedError @overrides(KokkoroBot) def kkr_run(self): executor.start_polling(self.dp, skip_updates=True)
class TelegramBot(Bot): def _init_bot(self): self._bot = TelegramBotClient(token=TELEGRAM_API_TOKEN) self._dp = Dispatcher(self._bot) self.actions = {action.command: action() for action in all_actions} self.commands_list = [f"/{action.command} {action.params} - {action.description}" for action in all_actions] self._dp.register_message_handler(self._handle_update) async def _handle_update(self, message: types.Message): command = message.get_command(pure=True) if command and command in self.actions.keys(): action = self.actions.get(command) args = message.get_args().strip().split() # set params in cache [USER_COMMANDS_CACHE[f'command:{message.chat["id"]}'].add(arg) for arg in args] flag, response = action.execute(USER_COMMANDS_CACHE[f'command:{message.chat["id"]}']) # flush cache if success if flag: del USER_COMMANDS_CACHE[f'command:{message.chat["id"]}'] await message.answer(response) else: await message.answer("Hi! available commands are:\n\n" + "\n".join(self.commands_list)) def run(self): executor.start_polling(self._dp, skip_updates=True)
def setup(dp: Dispatcher, loop: AbstractEventLoop = None, *args, **kwargs): logging.info('Initialize default module') loop.create_task( forever_run( function=check_connection, interval=CONNECTION_CHECKER_INTERVAL, )) dp.register_message_handler(cmd_start, Command('start'), state='*') dp.register_message_handler(cmd_help, Command('help'), state='*') dp.register_message_handler(cmd_cancel, Command('cancel'), state='*') dp.register_message_handler( cmd_start, lambda message: [user for user in message.new_chat_members if bot_id == user.id], content_types=ContentType.NEW_CHAT_MEMBERS, ) dp.register_message_handler( cmd_start, content_types=ContentType.GROUP_CHAT_CREATED, ) dp.register_callback_query_handler( answer_callback_empty_button_handler, lambda query: query.data == 'None', )
def register_base(dp: Dispatcher): dp.register_message_handler(cmd_start, commands="start", state="*") dp.register_message_handler( input_suggesting_msg, content_types=ContentType.ANY, state=UserStates.Input_suggesting_msg, )
def get_seats_number(dp: Dispatcher): async def _get_seats_number(message: types.Message, state: FSMContext): logger.info('User %s has set seats: %s', message.from_user.username, message.text) async with state.proxy() as data: seats = message.text.split(',') data['seats'] = seats logger.info('Current state: %s', data) markup = types.ReplyKeyboardMarkup(resize_keyboard=True, selective=True) markup.add("OK", "CANCEL") await TicketOrderState.next() msg = md.text(md.text('Всё правильно?'), md.text(md.italic('Станция отправления: '), md.code(data['from_station'])), md.text(md.italic('Станция прибытия: '), md.code(data['to_station'])), md.text(md.italic('Дата отправления: '), md.code(data['date'])), md.text(md.italic('Номер вагона: '), md.code(data['wagon_number'])), md.text(md.italic('Бронируемые места: '), md.code(','.join(data['seats']))), sep='\n') await message.reply(msg, reply_markup=markup, parse_mode=types.ParseMode.MARKDOWN) dp.register_message_handler(_get_seats_number, state=TicketOrderState.seats)
async def register_handlers(dp: Dispatcher): """Registration all handlers before processing update.""" dp.register_message_handler(start, commands=['start']) dp.register_message_handler(echo) log.debug('Handlers are registered.')
def register_handlers(dp: Dispatcher): dp.register_message_handler(entry_point, state=GlobalStates.add_tasks_btn) dp.register_message_handler(enter_group_id, state=AddTasksStates.enter_group_id) dp.register_callback_query_handler( check_for_admin, markups.add_tasks_factory.filter(data="0"), state=AddTasksStates.check_for_admin)
def get_bot() -> Tuple[Bot, Dispatcher]: bot = Bot(token=config.telegram_token) dp = Dispatcher(bot) dp.register_message_handler(process_messages, content_types=[ContentType.DOCUMENT]) return bot, dp
async def main(): bot = Bot(token=TOKEN) try: disp = Dispatcher(bot=bot) disp.register_message_handler(start_handler, commands={"cat", "dog"}) await disp.start_polling() finally: await bot.close()
def register(dp: Dispatcher, config: typing.Dict[typing.Any, typing.Any]) -> bool: dp.register_message_handler(I18nHandlers.cmd_i18n_choose) dp.register_callback_query_handler(I18nHandlers.query_change_language, i18n_cb.filter(type='lang_choice')) return True
def get_final_confirmation(dp: Dispatcher): def _filter_ok_response(message: types.Message): return message.text == 'OK' def _filter_cancel_response(message: types.Message): return message.text == 'CANCEL' async def _cancel_order_from_confirmation(message: types.Message, state: FSMContext): current_state = await state.get_state() if current_state is None: return await state.finish() await message.reply('Бронирование отменено. Заходьте ще.', reply_markup=types.ReplyKeyboardRemove()) async def _get_final_confirmation(message: types.Message, state: FSMContext): async with state.proxy() as data: ticket_order = TrainOrder( from_station_id=data['from_station'], to_station_id=data['to_station'], train_code=data['train_code'], date=data['date'], wagon_number=data['wagon_number'], wagon_class='Б', wagon_type=data['wagon_type'], wagon_railway=35, ) for seat in data['seats']: ticket_order.add_seat(seat) job_id = make_ticket_order_job_id(message.from_user.username, ticket_order.from_station_id, ticket_order.to_station_id, ticket_order.date) logger.info('Creating periodic job with id: %s', job_id) client_id = f'{message.from_user.username}-{message.from_user.id}' train_service = TrainService(client_id) scheduler.add_job( poll_ticket_service_task, 'interval', args=(message, ticket_order, train_service), seconds=(POLL_PERIOD * 60) + POLL_ADDITIONAL_SECS, next_run_time=datetime.now() + timedelta(seconds=3), id=job_id) await message.reply( f'OK! Стартую бронирование. Идентификатор бронирования: {md.italic(job_id)}', reply_markup=types.ReplyKeyboardRemove(), parse_mode=types.ParseMode.MARKDOWN) await state.finish() dp.register_message_handler(_get_final_confirmation, _filter_ok_response, state=TicketOrderState.is_ok) dp.register_message_handler(_cancel_order_from_confirmation, _filter_cancel_response, state=TicketOrderState.is_ok)
def register_adminmode_handlers(dp: Dispatcher, admin_chat_id: int): dp.register_message_handler(reply_to_user, IsReplyFilter(is_reply=True), IDFilter(chat_id=admin_chat_id), content_types=types.ContentTypes.ANY) dp.register_message_handler(has_no_reply, IsReplyFilter(is_reply=False), IDFilter(chat_id=admin_chat_id), content_types=types.ContentTypes.ANY)
def register(self, registry: DialogRegistryProto, dp: Dispatcher, *args, **filters) -> None: if "state" not in filters: filters["state"] = "*" dp.register_callback_query_handler(self._callback_handler, *args, **filters) if "content_types" not in filters: filters["content_types"] = ContentTypes.ANY dp.register_message_handler(self._message_handler, *args, **filters)
def register_handlers_location(dp: Dispatcher): dp.register_message_handler(location_start, Text(startswith='🌍'), state='*') dp.register_message_handler(location_search, state=SetLocation.waiting_loc_name) dp.register_callback_query_handler(location_confirm, Text(endswith='city'), state=SetLocation.confirm_loc_name)
def setup(dp: Dispatcher, loop: AbstractEventLoop=None, *args, **kwargs): logging.info('Initialize default module') dp.register_message_handler(cmd_help, Command('help'), state='*') dp.register_message_handler(cmd_cancel, Command('cancel'), state='*') dp.register_callback_query_handler( answer_callback_empty_button_handler, lambda query: query.data == 'None' )
def register_usermode_handlers(dp: Dispatcher): dp.register_message_handler(cmd_start_user, commands="start") dp.register_message_handler(cmd_help_user, commands="help") dp.register_message_handler(text_message, content_types=ContentType.TEXT) dp.register_message_handler(supported_media, content_types=[ ContentType.ANIMATION, ContentType.AUDIO, ContentType.PHOTO, ContentType.DOCUMENT, ContentType.VIDEO, ContentType.VOICE ]) dp.register_message_handler(unsupported_types, content_types=ContentType.ANY)
async def start_telegram_bot(bot: Bot, handlers: Handlers): print('start server') try: disp = Dispatcher(bot=bot) disp.register_message_handler(handlers.start_handler, commands={"start", "restart"}) await disp.start_polling() finally: await bot.close()
async def main(bot_token: str): bot = Bot(token=bot_token) try: disp = Dispatcher(bot=bot) disp.register_message_handler(re_start_handler, commands={"start", "restart"}) # disp.register_message_handler(re_start_handler, content_types=) await disp.start_polling() finally: await bot.close()
def register_handlers_fsm(dp: Dispatcher): # text state dp.register_message_handler(process_text,state=Form.text) # Geo state dp.register_message_handler(process_geo_text_check,Text(equals="Вести вручную", ignore_case=False), state=Form.geo) dp.register_message_handler(process_geo_text, state=Form.geo,content_types=ContentType.TEXT) dp.register_message_handler(process_geo_link, state=Form.geo,content_types=ContentType.LOCATION) # Photo get date dp.register_message_handler(process_photo,state=Form.photo, content_types=ContentType.PHOTO)
def setup(dp: Dispatcher): dp.register_message_handler(bot_start, CommandStart(), state='*') chat.setup(dp) inline_commands.setup(dp) dp.register_callback_query_handler( card_buttons_handler, lambda callback: callback.data.split("::")[0] == "card", state='*')
async def main(): logging.basicConfig(level=logging.INFO) storage = MemoryStorage() bot = Bot(token=API_TOKEN) dp = Dispatcher(bot, storage=storage) dialog = InpuDialog() dialog.register_handler(dp) dp.register_message_handler(dialog.start) await dp.start_polling()
def register_handler(self, dp: Dispatcher, *args, **kwargs): dp.register_message_handler(self.handle_message, state=self.states, content_types=ContentTypes.ANY, *args, **kwargs) dp.register_callback_query_handler(self.handle_callback, state=self.states, *args, **kwargs)
def register(dp: Dispatcher, config: typing.Dict[typing.Any, typing.Any]) -> bool: dp.register_message_handler(BroadcastHandlers.cmd_calendar, commands=['calendar']) dp.register_callback_query_handler( BroadcastHandlers.query_change_calendar, calendar_cb.filter(action='change')) dp.register_callback_query_handler( BroadcastHandlers.query_day, calendar_cb.filter(action='select_day')) return True
def register_adminmode_handlers(dp: Dispatcher, admin_chat_id: int): dp.register_message_handler(unsupported_reply_types, IsReplyFilter(is_reply=True), IDFilter(chat_id=admin_chat_id), content_types=types.ContentTypes.POLL) dp.register_message_handler(get_user_info, IsReplyFilter(is_reply=True), IDFilter(chat_id=admin_chat_id), commands=["get", "who"]) dp.register_message_handler(admin_help, IDFilter(chat_id=admin_chat_id), commands="help") dp.register_message_handler(reply_to_user, IsReplyFilter(is_reply=True), IDFilter(chat_id=admin_chat_id), content_types=types.ContentTypes.ANY) dp.register_message_handler(has_no_reply, IsReplyFilter(is_reply=False), IDFilter(chat_id=admin_chat_id), content_types=types.ContentTypes.ANY)
async def main(): bot = Bot(token='BOT TOKEN HERE') dp = Dispatcher(bot=bot) dp.register_message_handler(message_handler, content_types=types.ContentTypes.ANY) try: await dp.start_polling() finally: await bot.session.close()
def setup(dp: Dispatcher): dp.register_message_handler(from_command, commands=['swatermark']) dp.register_callback_query_handler( from_callback, lambda c: c.data and c.data.startswith('watermark_from_settings')) dp.register_message_handler(process, state=SWatermarkState.sget_pic, content_types=ContentTypes.PHOTO)
def register_handlers_register(dp: Dispatcher) -> None: dp.register_message_handler(register_start, commands='register', state='*') dp.register_message_handler(register_start, Text(equals='регистрация', ignore_case=True), state='*') dp.register_message_handler(register_nickname, state=OrderRegister.waiting_for_nickname) dp.register_message_handler(register_password, state=OrderRegister.waiting_for_password) dp.register_message_handler(register_password_again, state=OrderRegister.waiting_for_password_again)
def register_handlers_bonds(dp: Dispatcher): """ Регистрация хэндлеров \n See example: https://mastergroosha.github.io/telegram-tutorial-2/fsm/ :param dp: Dispatcher :return: None """ dp.register_message_handler(bonds_introduce, commands="bonds", state="*") dp.register_callback_query_handler(bonds_next_item, state=GetBondsStates.next_item_step)
async def main(): # real main logging.basicConfig(level=logging.INFO) storage = MemoryStorage() bot = Bot(token=API_TOKEN) dp = Dispatcher(bot, storage=storage) registry = DialogRegistry(dp) registry.register(dialog) dp.register_message_handler(start, text="/start", state="*") await dp.start_polling()