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} мин.")
