)
for i in range(len(subscriptions)):
for a in range(len(result)):
res = result[a]
await myapibot.send_message(subscriptions[i][1], res)
async def get_updates(wait_for):
print("Function \"get_updates\" is working")
while True:
await asyncio.sleep(wait_for)
subscriptions = list(db.get_subscriptions_updates())
update = CSGOupdate.get_updates()
if update[0]:
content = ''
for i in update[1]['content']:
content = content + i + "\n\n"
result = f"{update[1]['name'][0]}\n{update[1]['date'][0]}\n\n{content}Read on blog csgo:\n{update[1]['url']}"
for i in range(len(subscriptions)):
await myapibot.send_message(subscriptions[i][1], result)
async def startup(x):
asyncio.create_task(get_news(10 * 60))
asyncio.create_task(get_matches(4 * 60 * 60))
asyncio.create_task(get_updates(2 * 60 * 60))
if __name__ == '__main__':
executor.start_polling(bot, skip_updates=True, on_startup=startup)
import logging
import coloredlogs
from aiogram import executor
from application import utils
from application.config import config
if __name__ == '__main__':
log_level = logging.getLevelName(config.log_level)
coloredlogs.install(level=log_level)
logging.basicConfig(level=log_level)
bot, dp = utils.get_bot()
executor.start_polling(dp)
from aiogram import executor
from database import create_db
from loader import dp
import middlewares, filters, handlers
from utils.notify_admins import on_startup_notify
async def on_startup(dispatcher):
# Уведомляет про запуск
await create_db()
await on_startup_notify(dispatcher)
if __name__ == '__main__':
executor.start_polling(dp, on_startup=on_startup)
@dp.callback_query_handler(lambda call: call.data == 'personal_info')
async def personal_info(call):
await bs.personal_info(call)
@dp.callback_query_handler(lambda call: True)
async def get_cat_or_products(call):
if call.data == START_KB['categories']:
return await bs.view_root_categories(call.message)
await bs.show_categories(call.data, message=call.message)
@dp.message_handler(lambda message: message.text == START_KB['promo'])
async def show_promo_products(message):
await bs.show_promo_products(message)
@dp.message_handler(lambda message: message.text == START_KB['personal'])
async def personal(message):
await bs.personal(message)
if __name__ == '__main__':
os.makedirs('logs', exist_ok=True)
logging.basicConfig(filename='logs/log_' +
datetime.date.today().strftime("%Y_%m_%d") +
'_bot.log',
datefmt="%Y_%m_%d %H:%M:%S",
level=logging.DEBUG)
executor.start_polling(dp, skip_updates=False)
await message.answer(f"Что-то пошло не так. Пожалуйста, попробуйте ещё раз. Проблема с dice №{msg.dice.value}")
return
# Проверяем, выигрышная комбинация или нет, обновляем счёт
is_win, delta = casino.is_winning_combo(dice_combo)
new_score = user_score + delta
await state.update_data(score=new_score)
# Готовим сообщение о выигрыше/проигрыше и
score_msg = f"Вы выиграли {delta} очков!" if is_win else "К сожалению, вы не выиграли."
# Имитируем задержку и отправляем ответ пользователю
await sleep(const.THROTTLE_TIME_SPIN)
await msg.reply(f"Ваша комбинация: {', '.join(dice_combo)} (№{msg.dice.value})\n{score_msg} "
f"Ваш счёт: <b>{new_score}</b>.", parse_mode=types.ParseMode.HTML)
async def set_commands(dispatcher):
commands = [
types.BotCommand(command="start", description="Перезапустить казино"),
types.BotCommand(command="spin", description="Показать клавиатуру и сделать бросок"),
types.BotCommand(command="stop", description="Убрать клавиатуру"),
types.BotCommand(command="help", description="Справочная информация")
]
await bot.set_my_commands(commands)
if __name__ == "__main__":
dp.middleware.setup(ThrottlingMiddleware())
executor.start_polling(dp, skip_updates=True, on_startup=set_commands)
from loader import bot, storage
async def on_startup(dp):
import filters
import middlewares
filters.setup(dp)
middlewares.setup(dp)
from utils.notify_admins import on_startup_notify
await on_startup_notify(dp)
async def on_shutdown(dp):
await bot.close()
await storage.close()
if __name__ == '__main__':
from aiogram import executor
from handlers import dp
executor.start_polling(dp, on_startup=on_startup, on_shutdown=on_shutdown)
def main():
executor.start_polling(dp, skip_updates=True)
def start_polling(self):
executor.start_polling(self.dispatcher, skip_updates=True)
from aiogram import executor
from config import admin_id
from loader import bot
async def send_to_admin(*args, **kwargs):
await bot.send_message(chat_id=admin_id, text="Бот запущен")
async def on_shutdown(dp):
await bot.close()
if __name__ == '__main__':
from handlers import dp
executor.start_polling(
dp,
on_shutdown=on_shutdown,
# on_startup=send_to_admin,
)
def run(self):
executor.start_polling(self.dp, skip_updates=True)
def Bot():
async def send_lessons(message: types.Message):
uid = message.from_user.id
if not uid in users_ids:
await message.reply(strings.left)
return
if not users.get_state(uid):
await message.reply(strings.send_start)
return
user_state = users.get_state(uid)
if user_state != 'main_menu':
await message.reply(text=strings.use_buttons)
return
await message.reply(text=strings.choose_subject, reply_markup=keyboard('lessons'))
@disp.message_handler(commands=['add_user'])
async def add_user(message: types.Message):
uid = message.from_user.id
if not uid in admins_id:
await bot.send_message(text=strings.no_adm)
return
text = message.text
text = text[len('/add_user '): len(text)]
try:
add_id = int(text)
users_ids.append(add_id)
await message.reply(text=strings.succesfully_updated)
except:
await message.reply(text=strings.incorrect_id)
@disp.message_handler(commands=['add_admin'])
async def add_admin(message: types.Message):
uid = message.from_user.id
if not uid in admins_id:
await bot.send_message(text=strings.no_adm)
return
text = message.text
text = text[len('/add_admin '): len(text)]
try:
add_id = int(text)
admins_id.append(add_id)
await message.reply(text=strings.succesfully_updated)
except:
await message.reply(text=strings.incorrect_id)
@disp.message_handler(commands=['send_main'])
async def send_main(message: types.Message):
await message.reply(text="ok", reply_markup=keyboard('main'))
users.set_state(message.from_user.id, 'main_menu')
@disp.message_handler(commands=['change_timetable'])
async def change_timetable(message: types.Message):
if not message.from_user.id in admins_id:
await message.reply(strings.not_adm)
return
text = message.text
text = text[len('/change_timetable '): len(text)]
if len(text) < 5:
await message.reply(strings.bad)
return
day_num = int(text[0])
text = text[2:len(text)]
lessons = list(text.split('.'))
timetable[day_num].clear()
for lesson in lessons:
timetable[day_num].append(lesson)
await message.reply(text=strings.succesfully_updated)
@disp.message_handler(commands=['start'])
async def start(message: types.Message):
uid = message.from_user.id
if not uid in users_ids:
return
users.set_state(uid, 'main_menu')
await message.reply(text=strings.start_message, reply_markup=keyboard('main'))
@disp.message_handler(text_on_button('main', 0))
async def get_all_task(message: types.Message):
uid = message.from_user.id
if not uid in users_ids:
await message.reply(strings.left)
return
await send_msg(user_id=uid, text=hometask.get_hometask())
@disp.message_handler(text_on_button('main', 1))
async def get_subject_task(message: types.Message):
await send_lessons(message)
users.set_state(message.from_user.id, 'get_subject_task')
#message.reply(users.get_state())
@disp.message_handler(text_on_button('main', 2))
async def add_task(message: types.Message):
await send_lessons(message)
users.set_state(message.from_user.id, 'add_task')
@disp.message_handler(text_on_button('main', 3))
async def clear_task(message: types.Message):
await send_lessons(message)
users.set_state(message.from_user.id, 'clear_task')
@disp.message_handler(text_on_button('done', 0))
async def done(message: types.Message):
uid = message.from_user.id
if not uid in users_ids:
await message.reply(strings.left)
return
if not users.get_state(uid):
await message.reply(strings.send_start)
return
user_state = users.get_state(uid)
if user_state != 'adding_task' and user_state != 'clear_task':
await message.reply(strings.use_buttons)
return
if user_state == 'clear_task':
hometask.clear_photos(del_subject_name[uid])
hometask.clear_files(del_subject_name[uid])
await message.reply(strings.done, reply_markup=keyboard('lessons'))
return
elif user_state == 'adding_task':
text = updates_by_user[uid]['text']
if text != "":
hometask.update_task(updates_by_user[uid]['subject_name'], text)
files = updates_by_user[uid]['files']
if files != []:
hometask.update_files(updates_by_user[uid]['subject_name'], files)
photos = updates_by_user[uid]['photos']
if photos != []:
hometask.update_photos(
updates_by_user[uid]['subject_name'], photos)
updates_by_user[uid]['subject_name'] = ""
updates_by_user[uid]['files'] = []
updates_by_user[uid]['photos'] = []
updates_by_user[uid]['text'] = ""
users.set_state(uid, 'add_task')
await bot.send_message(chat_id=uid, text=strings.done, reply_markup=keyboard('lessons'))
@disp.message_handler(text_on_button('done', 1))
async def cancel(message: types.Message):
uid = message.from_user.id
if not uid in users_ids:
await message.reply(strings.left)
return
if not users.get_state(uid):
await message.reply(strings.send_start)
return
user_state = users.get_state(uid)
if user_state == 'clear_task':
await message.reply(text=strings.cancel, reply_markup=keyboard('lessons'))
elif user_state == 'adding_task':
await message.reply(text=strings.cancel, reply_markup=keyboard('lessons'))
users.set_state(uid, 'add_task')
else:
await message.reply(text=strings.use_buttons)
return
@disp.message_handler(text_is_lesson_name())
async def lesson_name_sended(message: types.Message):
uid = message.from_user.id
if not uid in users_ids:
await message.reply(strings.left)
return
if not users.get_state(uid):
await message.reply(strings.send_start)
return
user_state = users.get_state(uid)
if user_state == 'get_subject_task':
await message.reply(text=hometask.get_task(message.text))
for file_id in hometask.get_files(message.text):
await bot.send_document(chat_id=uid, document=file_id)
for photo in hometask.get_photos(message.text):
await bot.send_photo(chat_id=uid, photo=photo)
elif user_state == 'add_task':
users.set_state(uid, 'adding_task')
updates_by_user[uid]['subject_name'] = message.text
await message.reply(text=strings.send_task, reply_markup=keyboard('done'))
elif user_state == 'adding_task':
await message.reply(text=strings.incorrect_task)
return
elif user_state == 'clear_task':
del_subject_name[uid] = message.text
await message.reply(text=strings.sure, reply_markup=keyboard('done'))
return
else:
await message.reply(text=strings.use_buttons)
@disp.message_handler(text_on_button('lessons', 13))
async def back(message: types.Message):
uid = message.from_user.id
if not uid in users_ids:
await message.reply(strings.left)
return
if not users.get_state(uid):
await message.reply(strings.send_start)
return
user_state = users.get_state(uid)
if user_state == 'main_menu':
await message.reply(text=strings.no_back)
elif user_state == 'get_subject_task' or user_state == 'add_task' or user_state == 'clear_task':
users.set_state(uid, 'main_menu')
await message.reply(text=strings.back, reply_markup=keyboard('main'))
elif user_state == 'adding_task':
return
else:
await message.reply(text="0_0, send me message")
@disp.message_handler(content_types=['photo'])
async def photo_handler(message: types.Message):
uid = message.from_user.id
if not uid in users_ids:
await message.reply(strings.left)
return
if not users.get_state(uid):
await message.reply(strings.send_start)
return
user_state = users.get_state(uid)
if user_state != 'adding_task':
await message.reply(strings.use_buttons)
return
file_id = message.photo[0].file_id
updates_by_user[uid]['photos'].append(file_id)
info_str = info_message(message, 'photo')
await bot.send_message(chat_id=INFOCHATID, text=info_str)
await bot.send_photo(chat_id=INFOCHATID, photo=file_id)
@disp.message_handler(content_types=['document'])
async def files_handler(message: types.Message):
uid = message.from_user.id
if not uid in users_ids:
await message.reply(strings.left)
return
if not users.get_state(uid):
await message.reply(strings.send_start)
return
user_state = users.get_state(uid)
if user_state != 'adding_task':
await message.reply(strings.use_buttons)
return
file_id = message.document.file_id
updates_by_user[uid]['files'].append(file_id)
info_str = info_message(message, 'files')
await bot.send_message(chat_id=INFOCHATID, text=info_str)
await bot.send_document(chat_id=INFOCHATID, document=file_id)
@disp.message_handler()
async def others(message: types.Message):
uid = message.from_user.id
if not uid in users_ids:
await message.reply(strings.left)
return
if not users.get_state(uid):
await message.reply(strings.send_start)
return
user_state = users.get_state(uid)
bad_states = ['main_menu', 'get_subject_task', 'add_task', 'clear_task']
if user_state in bad_states:
await message.reply(text=strings.use_buttons)
else:
if user_state == 'adding_task':
infostr = info_message(message, 'text')
await bot.send_message(chat_id=INFOCHATID, text=infostr)
if updates_by_user[uid]['text']:
updates_by_user[uid]['text'] += strings.tab + \
(str(message.text)) + "\n"
else:
updates_by_user[uid]['text'] += (str(message.text))
(disp.loop or asyncio.get_event_loop()).create_task(day_updating())
(disp.loop or asyncio.get_event_loop()).create_task(updates_from_sg())
executor.start_polling(disp)
def handle(self, *args, **options):
dp.middleware.setup(ThrottlingMiddleware())
executor.start_polling(dp)
import logging
from decouple import config
from aiogram import Dispatcher, executor, types
from bot import BeltisBot, bot
async def warn_startup(startup):
await bot.send_message(1021953062, "Bot startado")
if __name__ == '__main__':
logging.basicConfig(level=logging.INFO)
dp = Dispatcher(bot)
main = BeltisBot(dp)
executor.start_polling(dp, skip_updates=True, on_startup=warn_startup)
async def rewrite_confiramation(query: types.CallbackQuery):
"""Handler to understand whether user wants to rewrite his new service or not"""
if query.data == "REWRITEyes":
current_state = dp.current_state(user=query.from_user.id)
await current_state.set_state(AddService.NAME)
await query.message.answer(
"👌Хорошо начнем с начала.А именно с названия")
else:
current_state = dp.current_state(user=query.from_user.id)
await current_state.reset_state()
await query.message.answer("😒Ну ладно")
@dp.callback_query_handler(lambda query: True, state="*")
@freeze_check
async def client_confirmation(query: types.CallbackQuery):
"""A callback hander to make the record inactive and done"""
author_name = await utils.update_data_and_get_author(
params={"pk": query.data}, json_data={"status": True})
author_name_to_send = author_name if author_name else "Имя не указано"
await bot.edit_message_text(
text=f"✅Заказ для {author_name_to_send} - выполнен",
message_id=query.message.message_id,
chat_id=query.message.chat.id)
executor.start_polling(dp, skip_updates=True, timeout=10)
# Choosed Russian language
@dispatcher.callback_query_handler(text="rus_lang")
async def eng_ans(message: types.Message):
user_id = message.from_user.id
db.cursor.execute(f"SELECT * FROM users WHERE tg_id = {user_id}")
msg_id = db.cursor.fetchone()[9]
await bot.delete_message(user_id, msg_id)
await bot.send_message(user_id, "Выбран Русский язык")
db.set_lang(user_id, "rus")
db.change_state(user_id, 2)
await bot.send_message(user_id, "Отправьте своё ФИО в формате \"Фамилия Имя Отчество\"")
# (Admin) accept user withdraw
@dispatcher.callback_query_handler(text="pay_accept")
async def accept_pay(query: types.CallbackQuery):
message = query.message
who_want_id = message.text.split(" ")[0]
db.cursor.execute(f"UPDATE users SET balance = balance - {message.text.split('wants to withdraw ')[1].replace('$', '').replace('€', '').replace('£', '')}")
db.db.commit()
# PAYOUT
await bot.send_message(int(who_want_id), f"Payed {message.text.split(' ')[-1]}")
# ===========================================
# Start bot
if __name__ == '__main__':
executor.start_polling(dispatcher)
exit()
from aiogram import executor
from handler import dp, send_to_admin
if __name__ == "__main__":
executor.start_polling(dp, on_startup=send_to_admin, timeout=720)
# - *- config: utf-8 - *-
import asyncio
from aiogram import Bot, Dispatcher, executor
from config import BOT_TOKEN
import sys
reload(sys)
sys.setdefaultencoding('utf-8')
# loop = asyncio.get_event_loop()
# Поток нам не нужен, т.к. он и так создается в диспатчере.
bot = Bot(BOT_TOKEN, parse_mode="HTML")
dp = Dispatcher(bot)
if __name__ == '__main__':
from handlers import dp, send_to_admin
executor.start_polling(dp, on_startup=send_to_admin)
@dp.message_handler(commands=['flushall'])
async def hey(message: types.Message):
r.flushall()
await message.answer("All deleted")
@dp.message_handler(content_types=['text'])
async def hey(message: types.Message):
await message.answer(message.text)
async def scheduler():
"""КАКИМ-ТО ОБРАЗОМ В get_tasks НУЖНО ПЕРЕДАТЬ user_id"""
pass
# if Jsoner.get_tasks(None, None, r):
# aioschedule.every().day.at("14:33").do(sender)
# aioschedule.every().day.at("18:10").do(sender)
# while True:
# await aioschedule.run_pending()
# await asyncio.sleep(1)
async def on_startup(x):
asyncio.create_task(scheduler())
if __name__ == '__main__':
executor.start_polling(dp, skip_updates=False, on_startup=on_startup)
async def send_message():
await bot.send_message(645798848, "test")
async def send_schedule_today():
users = get_users_to_send_schedule()
for user in users:
institute_schedule = menu.get_today_schedule(user)
mess_text = menu.get_mess_text("сегодня", institute_schedule)
await bot.send_message(user.user_id, mess_text, parse_mode=types.ParseMode.HTML)
async def scheduler():
schedule.every().day.at("07:00").do(send_schedule_today)
# schedule.every().day.at("22:45").do(send_schedule_today)
# schedule.every(5).seconds.do(send_schedule_today)
while True:
await schedule.run_pending()
# await asyncio.sleep(1)
await asyncio.sleep(600)
if __name__ == '__main__':
loop = asyncio.get_event_loop()
tasks = [
asyncio.ensure_future(scheduler()),
asyncio.ensure_future(executor.start_polling(dispatcher=dp, skip_updates=True))
]
loop.run_until_complete(asyncio.wait(tasks))
loop.close()
def handle(self, *args, **options):
from aiogram import executor
from telegram_config.handlers import dp
executor.start_polling(dp, on_startup=on_startup)
def run():
nonlocal self
self.logger.debug('Running start')
self.loop = asyncio.new_event_loop()
self.loop.set_exception_handler(self.handle_exception)
asyncio.set_event_loop(self.loop)
self.bot = Bot(token=self.config['BotToken'])
self.dp = Dispatcher(self.bot)
@self.dp.message_handler(content_types=ContentType.ANY)
@self.dp.edited_message_handler(content_types=ContentType.ANY)
async def handle_msg(message: types.Message):
from_user = message.from_user
_chat_type = ChatType.GROUP if message.chat.id < 0 else ChatType.PRIVATE
if message.text:
text = message.text
elif message.caption:
text = message.caption
else:
text = ''
message_entities = self.parse_entities(message)
unified_message = UnifiedMessage(
platform=self.name,
message=text,
message_entities=message_entities,
chat_id=message.chat.id,
chat_type=_chat_type,
name=from_user.full_name,
user_id=from_user.id,
message_id=message.message_id)
self.get_chat_attributes(message, unified_message.chat_attrs)
set_ingress_message_id(src_platform=self.name,
src_chat_id=message.chat.id,
src_chat_type=_chat_type,
src_message_id=message.message_id,
user_id=message.from_user.id)
if message.content_type == ContentType.TEXT:
await UMRDriver.receive(unified_message)
elif message.content_type == ContentType.PHOTO:
url, file_id = await self.tg_get_image(
message.photo[-1].file_id)
unified_message.image = url
unified_message.file_id = file_id
await UMRDriver.receive(unified_message)
elif message.content_type == ContentType.STICKER:
url, file_id = await self.tg_get_image(
message.sticker.file_id)
unified_message.image = url
unified_message.file_id = file_id
await UMRDriver.receive(unified_message)
elif message.content_type == ContentType.ANIMATION:
url, file_id = await self.tg_get_image(
message.animation.file_id)
unified_message.image = url
unified_message.file_id = file_id
await UMRDriver.receive(unified_message)
else:
unified_message.message = '[Unsupported message]'
await UMRDriver.receive(unified_message)
executor.start_polling(self.dp, skip_updates=True, loop=self.loop)
def run():
log.info(f"Starting Telegram Bot")
executor.start_polling(dp, skip_updates=True)
from aiogram import Bot, Dispatcher, executor, types
import follow_add_proxy
bot = Bot(token = '')
dispatcher = Dispatcher(bot)
@dispatcher.message_handler(commands=['start', 'help'])
async def send_welcome(message: types.Message):
"""
запускаем парсер
"""
await message.answer("Запускаем парсер:/stop,чтобы остановить")
global start_follow
start_follow = True
while start_follow:
try:
await message.answer(follow_add_proxy.main())
except Exception as e:
print(e)
@dispatcher.message_handler(commands=['stop'])
async def send_buy(message: types.Message):
global start_follow
start_follow = False
follow_add_proxy.del_list()
await message.answer('Buy')
if __name__ == '__main__':
executor.start_polling(dispatcher, skip_updates=True)
def run(self, *args, **kwargs):
return executor.start_polling(self.dispatcher,
skip_updates=self.__skip_updates)
def main():
executor.start_polling(dp, skip_updates=True, on_startup=on_startup)
pass
db.decrement_counter(user_id, name)
count -= 1
if count != 1:
await asyncio.sleep(interval * 60 - 3)
task_list.pop(name)
db.edit_task(user_id=user_id, name=name, flag='archived')
async def delay_posting(data):
now_today = datetime.datetime.utcnow() + datetime.timedelta(hours=3)
time_start = data['time_start']
delay = (time_start - now_today).seconds
await asyncio.sleep(delay)
db.edit_task(user_id=data['user_id'], name=data['name'], flag='work')
t = bot.loop.create_task(launch_posting(data))
task_list[data['name']] = t
async def database_cleaner():
while True:
db.cleaning()
await asyncio.sleep(12 * 3600)
if __name__ == '__main__':
# bot.loop.create_task(database_cleaner())
executor.start_polling(dp, skip_updates=True, on_shutdown=shutdown)
# -*- coding: utf-8 -*-
import asyncio
from aiogram import Bot, Dispatcher, executor
from aiogram.contrib.fsm_storage.memory import MemoryStorage
from config import API_TOKEN, PROXY_URL
loop = asyncio.get_event_loop()
bot = Bot(API_TOKEN, parse_mode="HTML")
storage = MemoryStorage()
dp = Dispatcher(bot, storage=storage, loop=loop)
if __name__ == '__main__':
from handlers import *
executor.start_polling(dp, on_startup=send_to_admin, skip_updates=True)
from data.config import SKIP_UPDATES, NUM_BUTTONS
from loguru import logger
from loader import dp
from utils.notify_admins import on_startup_notify
from utils.set_bot_commands import set_default_commands
from utils.logger_config import setup_logger
from middlewares import setup_middlewares
async def on_startup(dispatcher: Dispatcher):
setup_logger()
logger.info("Установка обработчиков...")
# Установка обработчиков производится посредством декораторов. Для этого достаточно просто импортировать модуль
import handlers
setup_middlewares(dispatcher)
await on_startup_notify(dispatcher)
await set_default_commands(dispatcher)
logger.info(f"Бот успешно запущен...")
if __name__ == '__main__':
if NUM_BUTTONS in range(2, 8):
executor.start_polling(dp,
on_startup=on_startup,
skip_updates=SKIP_UPDATES)
else:
raise AttributeError(
'количество кнопок не может быть меньше 2х или больше 7и')
reply_markup=kb.greet_kb)
@dp.message_handler(commands=['help'])
async def send_help(message: types.Message):
"""
This handler will be called when user sends `/help` command
"""
await message.reply("Привет!\nЯ высылаю точный курс с сайта cbr.ru!\nдалее здесь будет справка.",
reply_markup=kb.help_kb)
@dp.message_handler(commands=['usd'])
async def send_euro(message: types.Message):
"""
This handler will be called when user sends `/euro` command
"""
await message.answer("Курс доллара США - " + func_cource_of_usd() + ' рублей')
@dp.message_handler(commands=['euro'])
async def send_euro(message: types.Message):
"""
This handler will be called when user sends `/euro` command
"""
await message.answer("Курс евро - " + func_cource_of_euro() + ' рублей')
if __name__ == '__main__':
executor.start_polling(dp, skip_updates=True)
import_module("hitsuki.utils.db_structure_migrator")
async def start(_):
log.debug("Starting before serving task for all modules...")
loop.create_task(before_srv_task(loop))
if not get_bool_key("DEBUG_MODE"):
log.debug("Waiting 2 seconds...")
await asyncio.sleep(2)
async def start_webhooks(_):
url = os.getenv('WEBHOOK_URL') + f"/{TOKEN}"
await bot.set_webhook(url)
return await start(_)
log.info("Starting loop..")
log.info("Aiogram: Using polling method")
if os.getenv('WEBHOOKS', False):
port = os.getenv('WEBHOOKS_PORT', 8080)
executor.start_webhook(dp,
f'/{TOKEN}',
on_startup=start_webhooks,
port=port)
else:
executor.start_polling(dp, loop=loop, on_startup=start)
