def __init__(self, kernel: Kernel, token: str): self.bot = Bot(token=token) self.dispatcher = Dispatcher(self.bot, storage=MemoryStorage()) self.chat_dict = dict() self.dispatcher.register_message_handler(self.handler) self.kernel = kernel self.webhook_url = ''
class DemoBot: def __init__(self): self.__bot = Bot(config.bot_id) self.__handlers = {} self.__disp = Dispatcher(bot=self.__bot) async def __main(self): try: await self.__disp.start_polling() finally: await self.__bot.close() def run(self): print('Bot run in polling mode. Please CTRL-Break for exit...') asyncio.run(self.__main()) def register_start_handler(self,handler=None): async def internal_handler(event): if not handler is None: result = handler(event.text,self.__bot) await event.answer(result[0],parse_mode = types.ParseMode.HTML, reply_markup = result[1]) else: await event.answer(f"Hello {event.from_user.get_mention(as_html=True)} :-)",parse_mode = types.ParseMode.HTML) self.__disp.register_message_handler(internal_handler,commands = {"start","restart"}) def register_text_handler(self,handler,**aux): async def internal__handler(event,regexp): result = handler(event.text) await event.answer(result,parse_mode = types.ParseMode.HTML) self.__disp.register_message_handler(internal__handler,**aux)
def bot(config: ConfigParser) -> Dispatcher: bot = Bot(config['TELEGRAM']['TOKEN']) dispatcher = Dispatcher(bot) dispatcher.register_message_handler(partial(register, config), commands=["register"]) return dispatcher
def run_tg(token, proxy, agent): loop = asyncio.get_event_loop() bot = Bot(token=token, loop=loop, proxy=proxy) dp = Dispatcher(bot) tg_msg_processor = TelegramMessageProcessor(agent.register_msg) dp.message_handler()(tg_msg_processor.handle_message) executor.start_polling(dp, skip_updates=True)
def __init__(self, token): self.bot = Bot(token=token) self.dp = Dispatcher(self.bot) self.surname_predictor = Predictor(weights_path=WEIGHTS_PATH, k=3) self._commands = [] for member in dir(self): member = getattr(self, member) if hasattr(member, 'handler'): args, kwargs = member.handler commands = kwargs.get('commands') if commands: self._commands.extend(map(lambda x: '/' + x, commands)) self.dp.message_handler(*args, **kwargs)(member)
async def on_process_callback_query(self, cb: types.CallbackQuery, data: dict): """ This handler is called when dispatcher receives a message """ # Get current handler handler = current_handler.get() # Get dispatcher from context dispatcher = Dispatcher.get_current() # If handler was configured, get rate limit and key from handler if handler: limit = getattr(handler, 'throttling_rate_limit', self.rate_limit) key = getattr(handler, 'throttling_key', f"{self.prefix}_{handler.__name__}") else: limit = self.rate_limit key = f"{self.prefix}_callback" # Use Dispatcher.throttle method. try: await dispatcher.throttle(key, rate=limit) except Throttled as t: # Execute action await self.callback_throttled(cb, t) # Cancel current handler raise CancelHandler()
async def create_private_poll(message: types.Message): dispatcher = Dispatcher.get_current() bot = dispatcher.bot bot_config = dispatcher["config"]["bot"]["posts"] UsersMemePoll = dispatcher["app"]["polls"]["users"] user_meme_message = await bot.send_photo( chat_id=bot_config["moderate_channel_id"], photo=message.photo[1].file_id, disable_notification=UsersMemePoll.DISABLE_NOTIFICATION) question = f"{UsersMemePoll.QUESTION}: @{message.from_user.username}\n" \ f"Доп. инфа:\n" \ f"Bot: {'Да' if message.from_user.is_bot else 'Нет'} | " \ f"UserName: {message.from_user.username} | " \ f"- LastName: {message.from_user.last_name} | " \ f"- FirstName: {message.from_user.first_name}" message_with_poll = await bot.send_poll( chat_id=bot_config["moderate_channel_id"], question=question, options=UsersMemePoll.OPTIONS, disable_notification=UsersMemePoll.DISABLE_NOTIFICATION, reply_to_message_id=user_meme_message.message_id) await UsersMemePoll.add_poll(message, message_with_poll) await bot.send_message( chat_id=message.chat.id, text= "Мемас отправлен на модерацию. Благодарим вас за помощь в сборе валежника." )
async def message_throttled(self, message: types.Message, throttled: Throttled): """ Notify user only on first exceed and notify about unlocking only on last exceed """ handler = current_handler.get() dispatcher = Dispatcher.get_current() if handler: key = getattr(handler, 'throttling_key', f"{self.prefix}_{handler.__name__}") else: key = f"{self.prefix}_message" # Calculate how many time is left till the block ends delta = throttled.rate - throttled.delta # Prevent flooding if throttled.exceeded_count <= 2: await message.reply('<b>Antiflood:</b> \n\nСлишком много запросов.' ) # Sleep. await asyncio.sleep(delta) # Check lock status thr = await dispatcher.check_key(key) # If current message is not last with current key - do not send message if thr.exceeded_count == throttled.exceeded_count: await message.reply('Unlocked.')
def init_bot(): """ """ bot = Bot(token=BOT_TOKEN) dp = Dispatcher(bot) dp.middleware.setup(LoggingMiddleware()) return bot, dp
async def exit(message: types.Message, state: FSMContext): """ `/exit - Выйти из настроек ` """ dispatcher = Dispatcher.get_current() bot = dispatcher.bot await state.reset_state() await bot.send_message(chat_id=message.chat.id, text="Если что ты знаешь, как вернуться😉")
async def start(message: types.Message): """ `/start` """ dispatcher = Dispatcher.get_current() bot = dispatcher.bot text = "Шалом паря! Сейчас мы начнём валежничать по полной😎\n" \ "Скидывай мне мемасики, а уж я разберусь что с ними делать😉" await bot.send_message(chat_id=message.chat.id, text=text)
def register_handlers_common(dp: Dispatcher): """Register common handlers in Dispatcher.""" log.info('Configuring common handlers...') dp.register_message_handler(common.cmd_start, commands='start') dp.register_message_handler(common.cmd_about, commands='about') dp.register_message_handler(common.cmd_help, commands='help') dp.register_message_handler(common.cmd_cancel, commands='cancel', state='*') dp.register_message_handler( common.cmd_cancel, Text(equals='отмена', ignore_case=True), state='*' )
async def get_user_locale(self, action, args) -> str: user = User.get_current() db = dp.get_current()['db'] try: # пробуем достать локаль из базы return await db.get_user_locale(user.id) except LocaleNotFound: # возвращаем локаль, которую вернул телеграм if user.locale: return user.locale.language return 'ru'
async def settings(message: types.Message): """ `/settings` """ dispatcher = Dispatcher.get_current() bot = dispatcher.bot text = "Ты находишься в меню настроек:\n\n" \ "/set_post_channel <channel_id> - Установить канал в который постить после модерации.\n\n" \ "/set_moderate_channel <channel_id> - Установить канал в который отправлять на модерацию.\n\n" \ "/set_timeout <timeout> - Установить таймаут между постами в канал.(устанавливается в минутах)\n\n" \ "/exit - Выйти из настроек.\n" await bot.send_message(chat_id=message.chat.id, text=text)
async def throttled_message(*args, **kwargs): dispatcher = Dispatcher.get_current() config = dispatcher["config"] throttle_time_limit = config["bot"]["posts"]["throttle_time_limit"] message = args[0] val = f'{throttle_time_limit} секунд.' if throttle_time_limit // 60 == 0 else \ f'{throttle_time_limit // 60} минут.' await message.answer( text= f"Извините, но мемасы можно отправлять раз в {val}\nПожалуйста подождите..." )
def register_common(dp: Dispatcher): dp.register_message_handler(cmd_start, commands=["start", "help"]) dp.register_message_handler( cancel_state, state='*', commands=["cancel"], ) dp.register_message_handler( cancel_state, filters.Text(equals='cancel', ignore_case=True), state='*', ) dp.register_errors_handler(errors_handler)
async def create_group_poll(message: types.Message): dispatcher = Dispatcher.get_current() bot = dispatcher.bot GroupMemePoll = dispatcher["app"]["polls"]["group"] message = await bot.send_poll( chat_id=message.chat.id, question=GroupMemePoll.QUESTION, options=GroupMemePoll.OPTIONS, disable_notification=GroupMemePoll.DISABLE_NOTIFICATION, reply_to_message_id=message.message_id) await GroupMemePoll.add_poll(message)
def __init__(self, dispatcher: Dispatcher, strings: any, parse_mode=ParseMode.MARKDOWN): """Initialize ChatProvider object Args: dispatcher: A telegram bot dispatcher. strings: A locale strings class. parse_mode: A parse mode of telegram messages (aiogram.types.ParseMode). Default value: ParseMode.MARKDOWN """ self.__dispatcher = dispatcher self.strings = strings self.parse_mode = parse_mode dispatcher.register_message_handler(self.cmd_start, commands=["start"]) dispatcher.register_message_handler(self.cmd_help, commands=["help"])
async def admin_banned(message: types.Message, state: FSMContext): dispatcher = Dispatcher.get_current() bot = dispatcher.bot remaining = Banned.is_ban(message.from_user.username) if remaining: await bot.send_message( chat_id=message.chat.id, text=f"Ты был забанен на 1 час. Осталось: {remaining} минут.") else: await state.reset_state() await admin(message, state)
async def on_process_message(self, message: types.Message, data: dict): chat = message.chat if (chat.type == types.chat.ChatType.GROUP or chat.type == types.chat.ChatType.SUPER_GROUP) and len( message.new_chat_members) == 0: dp = Dispatcher.get_current() me = await dp.bot.get_me() if me.id not in [ admin.user.id for admin in await chat.get_administrators() ]: await message.reply("Бот должен иметь права администратора") raise CancelHandler()
async def broadcast(self): if self.first: msg = "Введіть повідомлення для броадкасту:" kb = self.kb() kb.add(self.btn(Lang.back_btn)) await self.send_msg(msg, kb) elif self.message.text == Lang.back_btn: await self.to_state("admin_panel") else: dp = Dispatcher.get_current() dp.loop.create_task(broadcaster(self.message.text)) await self.to_state("admin_panel")
def main(self): log.info('run serve subcommand') token = Core.config.telegram.api_token() if type(token) is not str: log.critical( 'Can not find "telegram:api_token" in config. Exiting.') exit(1) self._bot = Bot(token=Core.config.telegram.api_token()) dp = Dispatcher(self._bot) self._processor = VolleyProcessor( YandexTranslate(Core.config.yandex_translate.api_key()), ChatScript(Core.config.chatscript.host(), Core.config.chatscript.port(), 'botan')) dp.register_message_handler(self.send_welcome, commands=['start', 'help']) dp.register_message_handler(self.everything) start_polling( dp, skip_updates=True, # on_startup=self.on_startup, # on_shutdown=self.on_shutdown )
class NLPBot(object): def __init__(self, token): self.bot = Bot(token=token) self.dp = Dispatcher(self.bot) self.surname_predictor = Predictor(weights_path=WEIGHTS_PATH, k=3) self._commands = [] for member in dir(self): member = getattr(self, member) if hasattr(member, 'handler'): args, kwargs = member.handler commands = kwargs.get('commands') if commands: self._commands.extend(map(lambda x: '/' + x, commands)) self.dp.message_handler(*args, **kwargs)(member) @message_handler(commands=['start']) @log async def start(self, message: types.Message): await message.reply("Hi!\n" "My commands are: {}".format(", ".join( self._commands))) @message_handler(commands=['surname']) @log async def surname(self, message: types.Message): args = message.text.split(' ') if len(args) < 2: return name = message.text.split(' ')[1] result = 'Surname origin of {}: \n'.format(name) output = self.surname_predictor(name) for origin, proba in output: result += '{}: {:.3f}%\n'.format(origin, proba) print("Answer: ", result) await message.reply(result) def start_polling(self): executor.start_polling(self.dp)
def register_poster_creation(dp: Dispatcher): dp.register_message_handler(in_queue_handler, state=PosterCreation.confirmation) dp.register_message_handler(poster_create_start, text="Make poster", state="*") dp.register_message_handler(qsize_handler, commands=["qsize"], state="*")
def __init__(self, dispatcher: Dispatcher, state_manager: StateManager, strings: any, data_adapter: Union[ReserveDataAdapter, None] = None, user_data_adapter: Union[UserDataAdapter, None] = None, state_type: Union[str, int, None] = "sup"): """Initialize a class instance Args: dispatcher: A telegram bot dispatcher instance instance. state_manager: A state manager class instance strings: A locale strings class. data_adapter: Optional. A reservation storage data adapter user_data_adapter: Optional. An user storage data adapter state_type: Optional, A default state type. Default value: "sup" parse_mode: Optional. A parse mode of telegram messages (ParseMode). Default value: aiogram.types.ParseMode.MARKDOWN """ super().__init__(dispatcher, state_manager, strings, data_adapter=data_adapter, user_data_adapter=user_data_adapter, state_type=state_type) self.reserve_set_types["set"] = ReserveSetType("set", 30) dispatcher.register_message_handler(self.cmd_sup, commands=["sup"]) self.book_handlers["apply"] = self.book_apply
class TelegramMessenger(MessengerInterface): def __init__(self, kernel: Kernel, token: str): self.bot = Bot(token=token) self.dispatcher = Dispatcher(self.bot, storage=MemoryStorage()) self.chat_dict = dict() self.dispatcher.register_message_handler(self.handler) self.kernel = kernel self.webhook_url = '' def start_listening(self): executor.start_polling(self.dispatcher) async def handler(self, message: types.Message): order = self.chat_dict.get(message.chat.id) if order is None: order = Order( TelegramMessageSender(message.chat.id, self.bot, self.chat_dict), self.kernel) self.chat_dict[message.chat.id] = order await order.proceed(message.text) async def on_startup(self, dp): await self.bot.set_webhook(self.webhook_url) async def on_shutdown(self, dp): await self.bot.delete_webhook() def start_webhook(self, webhook_path: str, webapp_host: str, webapp_port: int, webhook_url: str): self.webhook_url = webhook_url start_webhook( dispatcher=self.dispatcher, webhook_path=webhook_path, on_startup=self.on_startup, on_shutdown=self.on_shutdown, skip_updates=True, host=webapp_host, port=webapp_port, )
def __init__(self, token, host, port, webhook_host, webhook_path): self.token = token self.host = host self.port = port self.webhook_path = webhook_path self.webhook_url = f"{webhook_host}{webhook_path}" loop = asyncio.get_event_loop() self.bot = AiogramBot(token=token, loop=loop) self.dispatcher = Dispatcher(self.bot) self.sessions: {int: CodingSession} = dict() self.default_session = CodingSession() self.__handlers = { self.__help: ['help'], self.__echo: ['echo', 'e'], self.__handle_code: ['code', 'c'], self.__install_package: ['add', 'a'], self.__get_history: ['history', 'h'], self.__save_history: ['save', 's'], self.__clear_history: ['clear', 'c'], self.__load_history: ['load', 'l'], }
async def admin(message: types.Message, state: FSMContext): """ `/admin` """ dispatcher = Dispatcher.get_current() bot = dispatcher.bot current_state = await state.get_state() if current_state == Auth.settings: await bot.send_message( chat_id=message.chat.id, text="Ты уже избранный, и можешь все (/settings).") return await state.set_state(Auth.check_password.try_1) await bot.send_message( chat_id=message.chat.id, text="А ну-ка дядя, напиши мне то что я хочу увидеть.")
def setup_handlers(dp: Dispatcher): dp.bind_filter(InChatIds) dp.register_message_handler( cmd_start, commands=['start'], ) dp.register_message_handler( InChatIds(), current_chat_ids, commands=['chat_ids'], )
async def set_timeout(message: types.Message): """ `/set_timeout - Выйти из настроек ` """ dispatcher = Dispatcher.get_current() bot = dispatcher.bot config = dispatcher["config"] argument = message.get_args() if not argument: return await message.reply( text="Необходим аргумент <timeout>: Например: /set_timeout 4") if not argument.isdigit(): return await message.reply( text= "Аргумент <timeout> должен быть числом: Например: /set_timeout 4") config["bot"]["posts"]["time_between_posts"] = argument await bot.send_message( chat_id=message.chat.id, text=f"Установлено время между постами: {argument} мин.")