from aiogram.types import ReplyKeyboardMarkup, KeyboardButton, ReplyKeyboardRemove
from aiogram.utils import executor
from sqlalchemy import select
from sqlalchemy.exc import IntegrityError
from sqlalchemy.orm import Session
import database
import orm
BOT_TOKEN = os.getenv('BOT_TOKEN')
if not BOT_TOKEN:
sys.exit(
"No bot token was found in ENV. Set 'BOT_TOKEN' variable to your token from @BotFather"
)
bot = Bot(BOT_TOKEN)
dispatcher = Dispatcher(
bot, storage=MemoryStorage()) # TODO: Consider using more advanced storage
NEWS_TOKEN = os.getenv('NEWS_TOKEN')
if not NEWS_TOKEN:
sys.exit(
"No NewsAPI token was found in ENV. Set 'NEWS_TOKEN' variable to your token from NewsAPI"
)
class TopicSetter(StatesGroup):
process_topics = State()
class LocationSetter(StatesGroup):
process_location = State()
lph.pool_info_map['BNB.FSN-E14'].status = PoolInfo.ENABLED
lph.pool_info_map['BNB.RAVEN-F66'].status = PoolInfo.BOOTSTRAP
lph.pool_info_map['BTC.BTC'] = PoolInfo('BTC.BTC', 18555, 18555, 100,
18555 * 100,
PoolInfo.BOOTSTRAP)
await notifier_pool_churn.on_data(
ppf, None) # must notify about changes above ^^^
await notifier_pool_churn.on_data(ppf,
None) # no update at this moment!
async def main(d):
await send_to_channel_test_message(d)
if __name__ == '__main__':
logging.basicConfig(level=logging.INFO)
d = DepContainer()
d.loop = asyncio.get_event_loop()
d.cfg = Config()
d.db = DB(d.loop)
bot = Bot(token=d.cfg.telegram.bot.token, parse_mode=ParseMode.HTML)
dp = Dispatcher(bot, loop=d.loop)
loc_man = LocalizationManager()
asyncio.run(main(d))
# partially from https://github.com/aiogram/bot
from aiogram import Bot, Dispatcher, types
from app.config import load_config
from app.models.config import Config
from app.utils.log import Logger
logger = Logger(__name__)
current_config = load_config()
bot = Bot(current_config.bot_token, parse_mode=types.ParseMode.HTML)
dp = Dispatcher(bot, storage=current_config.storage.create_storage())
def setup(config: Config):
from app import filters
from app import middlewares
from app.utils import executor
logger.debug(f"As application dir using: {config.app_dir}")
middlewares.setup(dp, config)
filters.setup(dp, config)
executor.setup(config)
logger.info("Configure handlers...")
# noinspection PyUnresolvedReferences
import app.handlers
import asyncio
from aiogram import Bot, Dispatcher, executor
from aiogram.contrib.fsm_storage.memory import MemoryStorage
from config import BOT_TOKEN, PROXY, admin_id, uc_chat_id
from crl import *
DELAY = 24*3600
loop = asyncio.get_event_loop()
bot = Bot(token=BOT_TOKEN, parse_mode="HTML")
storage = MemoryStorage()
dp = Dispatcher(bot, storage=storage, loop=loop)
async def schedule(wait_time):
while True:
answer = await crl_to_tlgrm()
for crl in answer.values():
if 'ALERT' in crl:
await bot.send_message(chat_id=uc_chat_id, text=f'<b>{crl}</b>', parse_mode='HTML')
elif crl == '':
await bot.send_message(chat_id=uc_chat_id, text=f'404 файл не найден!!!', parse_mode='HTML')
else:
await bot.send_message(chat_id=uc_chat_id, text=f'<b>{crl}</b>', parse_mode='HTML')
await asyncio.sleep(wait_time)
if __name__ == '__main__':
from handlers import *
import asyncio
import logging
from aiogram import Bot
from aiogram import Dispatcher
from aiogram.contrib.fsm_storage.redis import RedisStorage2
from bot.middlewares.language_middleware import setup_middleware
from config import TOKEN
# from aiogram.contrib.fsm_storage.memory import MemoryStorage
logging.basicConfig(
format=
u'%(filename)s [LINE:%(lineno)d] #%(levelname)-8s [%(asctime)s] %(message)s',
level=logging.INFO)
loop = asyncio.get_event_loop()
# Set up storage (either in Redis or Memory)
# storage = MemoryStorage()
storage = RedisStorage2()
bot = Bot(token=TOKEN, loop=loop, parse_mode="HTML")
dp = Dispatcher(bot, storage=storage)
# Setup i18n middleware
i18n = setup_middleware(dp)
# Alias for gettext method
_ = i18n.gettext
from aiogram.contrib.fsm_storage.memory import MemoryStorage
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
from sqlalchemy.engine import Engine
from sqlalchemy import create_engine
from aiogram import Bot, Dispatcher
from dynaconf import Dynaconf
settings: Dynaconf = Dynaconf(
env='development', # change to 'production' if production
settings_files=['app/settings.toml', 'app/.secrets.toml'],
environments=True)
bot: Bot = Bot(settings.TOKEN)
storage: MemoryStorage = MemoryStorage()
dp: Dispatcher = Dispatcher(bot, storage=storage)
engine: Engine = create_engine('sqlite:///app/app.db', echo=True)
Session = sessionmaker(bind=engine)
session: Session = Session()
Base = declarative_base()
with open("config.json", "r") as fh:
raw_data = fh.read()
config = load_json(raw_data)
except Exception as e:
print("Could not open config. Error: " + str(e))
if __name__ == "__main__":
"""
Main is located on top because decorators need a dispatcher object, which is created here
"""
load_config()
if config:
bot = Bot(token=config["BOT_TOKEN"])
bot_dispatcher = Dispatcher(bot)
@bot_dispatcher.message_handler(commands=["start", "help"])
async def welcome_handler(message: types.Message) -> None:
"""Sends welcome message on /start command"""
await message.reply(config["WELCOME_MESSAGE"])
@bot_dispatcher.message_handler()
async def search_handler(message: types.Message) -> None:
"""
Checks if sent message is a EN Wiki article and sends the result back.
"""
try:
url = urlparse(message.text)
from aiogram import Bot, Dispatcher
from aiogram.contrib.fsm_storage.redis import RedisStorage2
from os import getenv
from sys import exit
token = getenv("BOT_TOKEN", None)
if not token:
exit("No bot token provided, exiting...")
# Initialize bot and dispatcher
bot = Bot(token=token, parse_mode="HTML", validate_token=True)
dp = Dispatcher(bot, storage=RedisStorage2(host="redis"))
import asyncio
from main import config
# импорт хендлеров
# import documentation.handlers
# import deadlines.handlers
# import questions.handlers
loop = asyncio.get_event_loop()
bot = Bot(config.API_KEY, parse_mode="HTML")
dispatcher = Dispatcher(bot, loop=loop, storage=MemoryStorage())
def main():
executor.start_polling(dispatcher, on_startup=on_start_message, on_shutdown=on_finish_message)
if __name__ == "__main__":
from main.handlers import dispatcher, on_start_message, on_finish_message
from documentation.handlers import show_documentation
from deadlines.handlers import show_calendar_menu, create_event
from questions.handlers import question_menu, other_questions, ask_new_question
from main.helpers.registration import enter_email
from admin.handlers import check_new_workers
main()
def __init__(self, bot_token: str, database_file: str):
self._bot: Bot = Bot(token=bot_token)
self.dispatcher: Dispatcher = Dispatcher(bot=self._bot)
self._database_file = database_file
self._setup_handlers()
import logging
from aiogram import Bot, Dispatcher, executor, types
from aiogram.bot import api
logging.basicConfig(level=logging.DEBUG)
logger = logging.getLogger(__name__)
# TODO: раскомментировать если у вас ошибка подключения к ``api.telegram.org``
# Подмена базового URL для запросов
# PATCHED_URL = "https://telegg.ru/orig/bot{token}/{method}"
# setattr(api, 'API_URL', PATCHED_URL)
# Создать глобального бота
bot = Bot(token='XXX', )
dp = Dispatcher(bot=bot, )
@dp.message_handler(commands=['help', 'help2'])
async def send_menu(message: types.Message):
""" Отправить список команд бота
"""
await message.reply(
text='''
Мои команды:
/help -- увидеть это сообщение
бла бла
''',
reply=False,
)
class CreateUserMiddleware(BaseMiddleware):
cached_user_ids = []
async def on_pre_process_message(self, message: types.Message, *args):
if message.from_user.id not in self.cached_user_ids:
await create_user(message.from_user, chat_type=message.chat.type)
self.cached_user_ids.append(message.from_user.id)
if __name__ == "__main__":
if config.SENTRY_DSN:
sentry_sdk.init(config.SENTRY_DSN)
dp = Dispatcher(bot, loop=asyncio.get_event_loop())
dp.middleware.setup(CreateUserMiddleware())
dp.register_message_handler(handlers.start,
commands=["start", "help", "ajuda", "ayuda"])
dp.register_message_handler(handlers.language, commands=["language"])
dp.register_callback_query_handler(
handlers.set_language,
lambda query: query.data in config.AVAILABLE_LANGUAGES,
)
dp.register_message_handler(handlers.projects,
commands=["projects", "project"])
dp.register_callback_query_handler(
handlers.set_project,
async def create_bot_dispatcher(bot: Bot, storage: BaseStorage,
vpn_service: VPNService, config) -> Dispatcher:
authorized = AndFilter(
ChatTypeFilter(ChatType.PRIVATE),
GroupMemberFilter(await bot.get_chat(config["users_group_id"])))
dispatcher = Dispatcher(bot=bot, storage=storage)
devices_cb = CallbackData("device", "id", "action")
@dispatcher.errors_handler()
async def error_handler(update: Update, exc: BaseException):
if update.message is not None:
chat_id = update.message.from_user.id
elif update.callback_query is not None:
chat_id = update.callback_query.from_user.id
log.exception(f"Bot failed to handle update from {chat_id}",
exc_info=exc)
keyboard_markup = InlineKeyboardMarkup(row_width=2)
keyboard_markup.add(
InlineKeyboardButton("<< Back", callback_data="list"))
await bot.send_message(
chat_id,
"Oh sorry! 😞 There is error occurred. Please contact administrator to solve this problem.",
parse_mode="markdown",
reply_markup=keyboard_markup)
if update.message is not None:
await update.message.delete()
elif update.callback_query is not None:
await update.callback_query.message.delete()
await update.callback_query.answer()
@dispatcher.message_handler(authorized, commands=["start", "restart"])
@dispatcher.callback_query_handler(authorized,
lambda query: query.data == 'list',
state="*")
async def list_handler(event: Union[Message, CallbackQuery],
state: FSMContext):
await state.finish()
if isinstance(event, Message):
await event.delete()
devices = await vpn_service.list_devices(event.from_user.id)
keyboard_markup = InlineKeyboardMarkup(row_width=2)
keyboard_markup.add(
InlineKeyboardButton("➕ Add new device", callback_data="add"),
InlineKeyboardButton("🔄 Refresh", callback_data="list"))
keyboard_markup.add(*(InlineKeyboardButton(
device.name,
callback_data=devices_cb.new(id=device.id, action="details"))
for device in devices))
await bot.send_message(event.from_user.id,
"Choose one of your devices."
if devices else "You have no devices.",
reply_markup=keyboard_markup)
if isinstance(event, CallbackQuery):
await event.message.delete()
await event.answer()
@dispatcher.callback_query_handler(authorized,
lambda query: query.data == 'add')
async def add_handler(query: CallbackQuery, state: FSMContext):
keyboard_markup = InlineKeyboardMarkup(row_width=2)
keyboard_markup.add(
InlineKeyboardButton("<< Back", callback_data="list"))
if await vpn_service.has_device_quota(query.from_user.id):
await state.set_state("device_name")
message = await bot.send_message(query.from_user.id,
f"Enter new device name:",
reply_markup=keyboard_markup)
async with state.proxy() as data:
data['message_id'] = message.message_id
else:
await bot.send_message(
query.from_user.id,
f"Can't add more than *{vpn_service.get_device_quota()}* devices",
parse_mode="markdown",
reply_markup=keyboard_markup)
await query.message.delete()
await query.answer()
@dispatcher.message_handler(authorized,
lambda message: message.text,
state="device_name")
async def device_name_handler(message: Message, state: FSMContext):
keyboard_markup = InlineKeyboardMarkup(row_width=2)
keyboard_markup.add(
InlineKeyboardButton("<< Back", callback_data="list"))
try:
device = await vpn_service.create_device(message.from_user.id,
message.text.strip())
except DeviceDuplicatedError:
await message.answer(
f"Device named *{message.text.strip()}* already exists.",
parse_mode="markdown",
reply_markup=keyboard_markup)
else:
await message.answer(
f"Device named *{device.name}* successfully created.",
parse_mode="markdown",
reply_markup=keyboard_markup)
await message.delete()
async with state.proxy() as data:
await bot.delete_message(message.from_user.id,
int(data['message_id']))
await state.finish()
@dispatcher.callback_query_handler(authorized,
devices_cb.filter(action="details"))
@dispatcher.callback_query_handler(authorized,
devices_cb.filter(action="config"))
async def details_handler(query: CallbackQuery):
cb_data = devices_cb.parse(query.data)
action = cb_data["action"]
device_id = cb_data["id"]
device = await vpn_service.get_device(query.from_user.id, device_id)
keyboard_markup = InlineKeyboardMarkup(row_width=2)
keyboard_markup.add(
InlineKeyboardButton("Get config",
callback_data=devices_cb.new(
id=device_id, action="config")),
InlineKeyboardButton("✖️ Remove",
callback_data=devices_cb.new(
id=device_id, action="remove")),
InlineKeyboardButton("<< Back", callback_data="list"))
if action == "config":
with await vpn_service.generate_device_config(
query.from_user.id, device_id) as config_stream:
await bot.send_document(query.from_user.id,
config_stream,
caption=f"*{device.name}* config",
parse_mode="markdown",
reply_markup=keyboard_markup)
else:
await bot.send_message(query.from_user.id,
f"What to do with device *{device.name}*?",
parse_mode="markdown",
reply_markup=keyboard_markup)
await query.message.delete()
await query.answer()
@dispatcher.callback_query_handler(authorized,
devices_cb.filter(action="remove"))
async def remove_handler(query: CallbackQuery):
device_id = devices_cb.parse(query.data)["id"]
device = await vpn_service.get_device(query.from_user.id, device_id)
keyboard_markup = InlineKeyboardMarkup(row_width=2)
keyboard_markup.add(
InlineKeyboardButton("✖️ Remove",
callback_data=devices_cb.new(
id=device_id, action="confirm_removal")),
InlineKeyboardButton("<< Back",
callback_data=devices_cb.new(
id=device_id, action="details")))
await bot.send_message(
query.from_user.id,
f"Are you sure to remove device *{device.name}*?",
parse_mode="markdown",
reply_markup=keyboard_markup)
await query.message.delete()
await query.answer()
@dispatcher.callback_query_handler(
authorized, devices_cb.filter(action="confirm_removal"))
async def confirm_removal_handler(query: CallbackQuery):
device_id = devices_cb.parse(query.data)["id"]
device = await vpn_service.remove_device(query.from_user.id, device_id)
keyboard_markup = InlineKeyboardMarkup(row_width=2)
keyboard_markup.add(
InlineKeyboardButton("<< Back", callback_data="list"))
await bot.send_message(query.from_user.id,
f"Device *{device.name}* was removed.",
parse_mode="markdown",
reply_markup=keyboard_markup)
await query.message.delete()
await query.answer()
@dispatcher.message_handler(authorized, commands=["user_id"])
async def chat_id_handler(message: Message):
await message.answer(f"User ID: {message.from_user.id}")
log.info("Bot dispatcher created")
return dispatcher
def __init__(self, db, host, port, bot_token):
self.__wg = WaitGroup()
self.__db = db
self.__server_address = (host, port)
self.bot = Bot(token=bot_token)
self.dispatcher = Dispatcher(self.bot)
from aiogram import Dispatcher from aiogram.contrib.middlewares.logging import LoggingMiddleware from telegram_bot.settings import dispatcher_storage from telegram_bot.telegram.bot import bot """ help - 帮助 weather - 获取实时天气（最近两天） weather_6h - 获取实时天气（最近六小时） set_location - 更新位置 subscribe - 开启订阅 unsubscribe - 关闭订阅 set_ding_bot - 新增钉钉机器人同步 delete_ding_bot - 移除钉钉同步 """ dp = Dispatcher(bot, storage=dispatcher_storage) dp.middleware.setup(LoggingMiddleware())
from aiogram import Bot, Dispatcher, types
from aiogram.contrib.fsm_storage.memory import MemoryStorage
from bot.bot_utils import mysql_connect
from bot.bot_utils import user_stat
from bot.usersession import UserSession
from settings import bot_token, db_conf
logger.add("oppiwordsbot_{time}.log")
TOKEN = bot_token[sys.argv[1:][0]]
bot = Bot(token=TOKEN, parse_mode=types.ParseMode.MARKDOWN)
db_conf = db_conf[sys.argv[1:][0]]
user_stat.conf = db_conf
mem_storage = MemoryStorage()
dp = Dispatcher(bot, storage=mem_storage)
RESTART = '"Sorry, something went wrong. Try restarting with /start, your progress is saved"'
with open('bot/app/lang.list') as f:
LANGS = f.readlines()
LANGS = [x.replace('\n', '').lower() for x in LANGS]
sessions = ExpiringDict(max_len=2000, max_age_seconds=60 * 60 * 24)
async def get_session(user_id):
if user_id in sessions.keys():
return sessions[user_id]
else:
s = await create_user_session(user_id)
return s
import asyncio
import aiohttp
from aiogram import Bot, Dispatcher, executor
from config import BOT_TOKEN, _host, _port, _login_proxy, _password_proxy, _proxy_type
from aiogram.contrib.fsm_storage.memory import MemoryStorage
# PROXY_AUTH = aiohttp.BasicAuth(login=_login_proxy, password=_password_proxy)
loop = asyncio.get_event_loop() # Создание асинхронного потока
# Тип парсинга - теги как в html
# bot = Bot(token=BOT_TOKEN, parse_mode='HTML', proxy=f'{_proxy_type}://{_host}:{_port}', proxy_auth=PROXY_AUTH)
bot = Bot(token=BOT_TOKEN, parse_mode='HTML')
dp = Dispatcher(bot=bot, loop=loop, storage=MemoryStorage()) # Доставщик сообщений
if __name__ == '__main__':
from handlers.handlers import dp, send_to_admin
executor.start_polling(dp, on_startup=send_to_admin)
import asyncio from aiogram import Bot, Dispatcher, types from aiogram.contrib.fsm_storage.memory import MemoryStorage from data import config from data.config import PARSER_DB from utils.db_api.categories_command import CategoriesCommands from utils.db_api.costs_commands import CostsCommands from utils.db_api.payments_commands import PaymentsCommands bot = Bot(token=config.BOT_TOKEN, parse_mode=types.ParseMode.HTML) storage = MemoryStorage() dp = Dispatcher(bot, storage=storage, loop=asyncio.get_event_loop()) PAYMENTS_TABLE = PaymentsCommands(PARSER_DB) CATEGORY_TABLE = CategoriesCommands(PARSER_DB) COSTS_TABLE = CostsCommands(PARSER_DB)
API_TOKEN = admin_data["api_token"]
# Create admins_id structure: [int, int]
ADMINS_IDS = [
list(adm_id.values())[0]
for adm_id in [adm_row for adm_row in admin_data["admins_ids"]]
]
# Create storage for save message state
storage = MemoryStorage()
# Configure logging
logging.basicConfig(level=logging.INFO)
# Initialize bot and dispatcher
bot = Bot(token=API_TOKEN)
dp = Dispatcher(bot, loop=loop, storage=storage)
# Display output information in images (images - True, text - False):
image_output = True
start_string = "/start - initialization message\n\n"\
"/privat - exchange rates\n\n"\
"/exmo - crypto exchange rates\n\n"\
"/weather - weather data\n\n"\
"/geoposition - take GPS location\n\n" \
"/bot - technical commands"
@dp.message_handler(commands=["start"])
@admin_check(ADMINS_IDS)
import logging.config
import aiohttp
from aiogram import Bot, Dispatcher
from aiogram.contrib.fsm_storage.redis import RedisStorage2
from aiogram.contrib.middlewares.i18n import I18nMiddleware
from babel.support import LazyProxy
from environs import Env
env = Env()
settings_name = env("BOT_SETTINGS_MODULE", "bot.settings.production")
settings = importlib.import_module(settings_name)
logging.config.dictConfig(settings.LOGGING)
bot = Bot(settings.BOT_TOKEN)
dp = Dispatcher(bot, storage=RedisStorage2(**settings.FSM_STORAGE))
i18n = I18nMiddleware(settings.I18N_DOMAIN, settings.LOCALES_DIR)
dp.middleware.setup(i18n)
_ = i18n.gettext
def N_(*args, **kwargs) -> LazyProxy:
return i18n.lazy_gettext(*args, enable_cache=False, **kwargs)
from aiogram import Bot, Dispatcher, executor, types
import asyncio
import requests
from bs4 import BeautifulSoup
from config import API_TOKEN, url, headers
import dbworker
logging.basicConfig(level=logging.INFO)
loop = asyncio.get_event_loop()
bot = Bot(token=API_TOKEN)
dp = Dispatcher(bot, loop=loop)
async def add_to_db(msg):
dbworker.init_db()
dbworker.add_user(user_id=msg.from_user.id)
@dp.message_handler(commands=["start"])
async def send_welcome(message: types.Message):
await add_to_db(message)
await message.reply("Вы добавлены для розсылки")
async def send_everyone(liga, detail_match):
users = dbworker.get_users()
import db_aps
import keyboards
import phrases
import utils
load_dotenv()
bot_logger = getLogger('avito_bot_logger')
# bot settings
proxy = os.environ.get('TG_PROXY')
bot = Bot(token=os.environ['TG_BOT_TOKEN'], proxy=proxy)
dispatcher = Dispatcher(
bot=bot,
storage=RedisStorage2(host=os.environ['DB_HOST'],
port=os.environ['DB_PORT'],
password=os.environ['DB_PASSWORD']),
)
class AddSearch(StatesGroup):
"""Add search states group."""
waiting_url = State()
class DelSearch(StatesGroup):
"""Delete search states group."""
waiting_search_number = State()
class AdminPanel(StatesGroup):
import logging from aiogram import Bot, Dispatcher from aiogram.contrib.fsm_storage.memory import MemoryStorage from aiogram.contrib.middlewares.logging import LoggingMiddleware from config import TELEGRAM_TOKEN bot = Bot(token=TELEGRAM_TOKEN) dp = Dispatcher(bot, storage=MemoryStorage()) logging.basicConfig(level=logging.INFO) logger = logging.getLogger(__name__) dp.middleware.setup(LoggingMiddleware())
from aiogram import Bot, Dispatcher
import logging
import config
import os
from aiogram.contrib.fsm_storage.mongo import MongoStorage
bot = Bot(config.TOKEN)
MongoDB = MongoStorage(host=config.Mongo.host,
port=config.Mongo.port + '/' + config.Mongo.db_name,
username=config.Mongo.username,
password=config.Mongo.password,
db_name=config.Mongo.db_name)
income_picture = os.environ.get('INCOME_PICTURE')\
if os.environ.get('INCOME_PICTURE') is not None else \
"AgACAgIAAxkDAAIHA17P-qCE0MRFPOhKAlDDl8fzEO_jAAK1rjEb-xKBSq8q47TF4U5XKYNvkS4AAwEAAwIAA3gAA-HPAwABGQQ"
async def get_inc_pic():
with open('resources/income_profile.png', 'rb') as ph:
a = await bot.send_photo(config.admins['main'], ph)
return a['photo'][1]['file_id']
dp = Dispatcher(bot, storage=MongoDB)
logging.basicConfig(level=logging.INFO)
from TelegramEDT.EDTcalendar import Calendar
from TelegramEDT.base import Base, User
from TelegramEDT.lang import lang
from TelegramEDT.logger import logger
from TelegramEDT.EDTscoped_session import scoped_session
if not isfile("token.ini"):
logger.critical("No token specified, impossible to start the bot !")
exit(1)
API_TOKEN = open("token.ini").readline().replace("\n", "")
ADMIN_ID = 148441652
TIMES = ["", "day", "next", "week", "next week"]
bot = Bot(token=API_TOKEN)
posts_cb = CallbackData("post", "id", "action")
dp = Dispatcher(bot)
engine = create_engine("sqlite:///edt.db")
session_factory = sessionmaker(bind=engine)
Session = scoped_session(session_factory)
if not isfile("edt.db"):
Base.metadata.create_all(engine)
key = reply_keyboard.ReplyKeyboardMarkup()
for k in ["Edt", "Kfet", "Setkfet", "Setedt", "Notif", "Settomuss"]:
key.add(reply_keyboard.KeyboardButton(k))
modules_active = list()
def check_id(user: types.User):
with Session as session:
from aiogram import Bot, Dispatcher, executor
from aiogram.contrib.fsm_storage.memory import MemoryStorage
from aiogram.contrib.middlewares.logging import LoggingMiddleware
from loguru import logger
from tortoise import Tortoise
import config
from app import middlewares
from app import handlers
storage = MemoryStorage()
telegram_bot = Bot(token=config.TELEGRAM_BOT_TOKEN)
dp = Dispatcher(telegram_bot, storage=storage)
def on_startup():
logger.info("Register handlers...")
# Register you handlers here.
handlers.default.setup(dp)
dp.middleware.setup(middlewares.UserMiddleware())
async def database_init():
await Tortoise.init(db_url=config.DB_URL,
modules={'models': ['app.models']})
# await Tortoise.init_models(app_label='models', models_paths=['app.models'])
await Tortoise.generate_schemas(True)
logger.info("Tortoise inited!")
if __name__ == "__main__":
