Merge pull request #10 from TimNekk/develop

Made imports more generic
TimNekk · Aug 14, 2022 · 1142829 · 1142829
2 parents 324cd10 + dd7daa7
commit 1142829
Show file tree

Hide file tree

Showing 9 changed files with 51 additions and 50 deletions.
diff --git a/bot.py b/bot.py
@@ -6,10 +6,11 @@
 from aiogram.types import AllowedUpdates
 from loguru import logger
 
+
 from tgbot.config import load_config
-from tgbot.filters import register_filters
-from tgbot.handlers import register_handlers
-from tgbot.middlewares import register_middlewares
+from tgbot import filters
+from tgbot import handlers
+from tgbot import middlewares
 from tgbot.misc import logging
 from tgbot.models import db
 from tgbot.models.user_tg import UserTG
@@ -35,9 +36,9 @@ async def main() -> None:
     await db.on_startup(config.db.uri)
     UserTG.bot = bot
 
-    await register_middlewares(dp, config)
-    register_filters(dp)
-    register_handlers(dp)
+    await middlewares.register(dp, config)
+    filters.register(dp)
+    handlers.register(dp)
 
     await set_bot_command(bot, config)
     await send_to_admins(bot, "Бот запущен")

diff --git a/tgbot/filters/__init__.py b/tgbot/filters/__init__.py
@@ -4,6 +4,6 @@
 from .command import CommandFilter
 
 
-def register_filters(dp: Dispatcher) -> None:
+def register(dp: Dispatcher) -> None:
     dp.filters_factory.bind(AdminFilter)
     dp.filters_factory.bind(CommandFilter)
diff --git a/tgbot/handlers/__init__.py b/tgbot/handlers/__init__.py
@@ -1,11 +1,11 @@
 from aiogram import Dispatcher
 
-from .admin import register_admin_handlers
-from .start import register_start_handlers
-from .subscription import register_subscription_handlers
+from tgbot.handlers import admin
+from tgbot.handlers import start
+from tgbot.handlers import subscription
 
 
-def register_handlers(dp: Dispatcher) -> None:
-    register_admin_handlers(dp)
-    register_start_handlers(dp)
-    register_subscription_handlers(dp)
+def register(dp: Dispatcher) -> None:
+    admin.register(dp)
+    start.register(dp)
+    subscription.register(dp)
diff --git a/tgbot/handlers/admin/__init__.py b/tgbot/handlers/admin/__init__.py
@@ -1,9 +1,9 @@
 from aiogram import Dispatcher
 
-from .send_all import register_send_all_handlers
-from .ping import register_ping_handlers
+from tgbot.handlers.admin import send_all
+from tgbot.handlers.admin import ping
 
 
-def register_admin_handlers(dp: Dispatcher) -> None:
-    register_send_all_handlers(dp)
-    register_ping_handlers(dp)
+def register(dp: Dispatcher) -> None:
+    send_all.register(dp)
+    ping.register(dp)
diff --git a/tgbot/handlers/admin/ping.py b/tgbot/handlers/admin/ping.py
@@ -8,8 +8,8 @@
 from tgbot.states import PingState
 
 
-async def ping(message: types.Message, state: FSMContext, user: UserTG, config: Config) -> None:
-    delta = get_time_delta(message.date)
+async def _ping(message: types.Message, state: FSMContext, user: UserTG, config: Config) -> None:
+    delta = _get_time_delta(message.date)
     aim = 10
     results = [delta]
 
@@ -20,7 +20,7 @@ async def ping(message: types.Message, state: FSMContext, user: UserTG, config:
             await user.send_message("<b>Минимальное количество раз:</b> 1")
             return
 
-    text = get_request_text(config.tg_bot.commands.ping.command, aim, len(results) - 1)
+    text = _get_request_text(config.tg_bot.commands.ping.command, aim, len(results) - 1)
     base_message = await user.send_message(text)
 
     await PingState.waiting_for_ping.set()
@@ -29,8 +29,8 @@ async def ping(message: types.Message, state: FSMContext, user: UserTG, config:
                             base_message_id=base_message.message_id)
 
 
-async def get_ping_data(message: types.Message, state: FSMContext, user: UserTG, config: Config) -> None:
-    delta = get_time_delta(message.date)
+async def _get_ping_data(message: types.Message, state: FSMContext, user: UserTG, config: Config) -> None:
+    delta = _get_time_delta(message.date)
 
     await message.delete()
 
@@ -42,25 +42,25 @@ async def get_ping_data(message: types.Message, state: FSMContext, user: UserTG,
     if results and len(results) < aim:
         results.append(delta)
         await state.update_data(results=results)
-        text = get_request_text(config.tg_bot.commands.ping.command, aim, len(results) - 1)
+        text = _get_request_text(config.tg_bot.commands.ping.command, aim, len(results) - 1)
         await user.edit_message_text(text, base_message_id)
     else:
         await user.delete_message(base_message_id)
         average_ping = round(sum(results) / len(results) * 1000)
-        circle = get_color_circle(average_ping)
+        circle = _get_color_circle(average_ping)
         await user.send_message(f"{circle} <b>Средний пинг:</b> <code>{average_ping}</code> ms")
         await state.finish()
 
 
-def get_request_text(commend: str, aim: int, results_len: int) -> str:
+def _get_request_text(commend: str, aim: int, results_len: int) -> str:
     return f"Отправьте /{commend} еще {aim - results_len} раз"
 
 
-def get_time_delta(receive_time: datetime) -> float:
+def _get_time_delta(receive_time: datetime) -> float:
     return (datetime.now() - receive_time).total_seconds()
 
 
-def get_color_circle(average_ping: int) -> str:
+def _get_color_circle(average_ping: int) -> str:
     if average_ping <= 1200:
         return "🟢"
     elif average_ping <= 2000:
@@ -69,12 +69,12 @@ def get_color_circle(average_ping: int) -> str:
         return "🔴"
 
 
-def register_ping_handlers(dp: Dispatcher) -> None:
+def register(dp: Dispatcher) -> None:
     config: Config = dp.bot.get("config")
-    dp.register_message_handler(ping,
+    dp.register_message_handler(_ping,
                                 command=config.tg_bot.commands.ping,
                                 is_admin=True)
-    dp.register_message_handler(get_ping_data,
+    dp.register_message_handler(_get_ping_data,
                                 command=config.tg_bot.commands.ping,
                                 is_admin=True,
                                 state=PingState.waiting_for_ping)
diff --git a/tgbot/handlers/admin/send_all.py b/tgbot/handlers/admin/send_all.py
@@ -11,15 +11,15 @@
 from tgbot.states import SendAllState
 
 
-async def handle_send_all(message: types.Message, user: UserTG, state: FSMContext) -> None:
+async def _handle_send_all(message: types.Message, user: UserTG, state: FSMContext) -> None:
     text = "<b>Отправьте сообщение для рассылки</b>"
     initial_message = await user.send_message(text)
 
     await SendAllState.waiting_for_message.set()
     await state.update_data(initial_message_id=initial_message.message_id)
 
 
-async def confirm_send(message: types.Message, user: UserTG, state: FSMContext) -> None:
+async def _confirm_send(message: types.Message, user: UserTG, state: FSMContext) -> None:
     data = await state.get_data()
     initial_message_id: int = data.get("initial_message_id")
 
@@ -34,7 +34,7 @@ async def confirm_send(message: types.Message, user: UserTG, state: FSMContext)
     await state.update_data(broadcast_message_id=broadcast_message.message_id)
 
 
-async def ask_to_change_buttons(call: types.CallbackQuery, user: UserTG, state: FSMContext) -> None:
+async def _ask_to_change_buttons(call: types.CallbackQuery, user: UserTG, state: FSMContext) -> None:
     text = """
 Введите <b>ВСЕ</b> кнопки в формате:
 
@@ -51,7 +51,7 @@ async def ask_to_change_buttons(call: types.CallbackQuery, user: UserTG, state:
     await state.update_data(buttons_message_id=buttons_message.message_id)
 
 
-async def change_buttons(message: types.Message, user: UserTG, state: FSMContext) -> None:
+async def _change_buttons(message: types.Message, user: UserTG, state: FSMContext) -> None:
     data = await state.get_data()
     buttons_message_id: int = data.get("buttons_message_id")
     broadcast_message_id: int = data.get("broadcast_message_id")
@@ -71,7 +71,7 @@ async def change_buttons(message: types.Message, user: UserTG, state: FSMContext
     await SendAllState.waiting_for_confirm.set()
 
 
-async def cancel(call: types.CallbackQuery, state: FSMContext) -> None:
+async def _cancel(call: types.CallbackQuery, state: FSMContext) -> None:
     data = await state.get_data()
     broadcast_message_id: int = data.get("broadcast_message_id")
     await state.finish()
@@ -80,7 +80,7 @@ async def cancel(call: types.CallbackQuery, state: FSMContext) -> None:
     await call.bot.delete_message(call.message.chat.id, broadcast_message_id)
 
 
-async def start_broadcast(call: types.CallbackQuery, user: UserTG, state: FSMContext) -> None:
+async def _start_broadcast(call: types.CallbackQuery, user: UserTG, state: FSMContext) -> None:
     data = await state.get_data()
     broadcast_message_id: int = data.get("broadcast_message_id")
     keyboard: types.InlineKeyboardMarkup = data.get("keyboard")
@@ -96,27 +96,27 @@ async def start_broadcast(call: types.CallbackQuery, user: UserTG, state: FSMCon
     await user.send_message("<b>Рассылка закончилась!</b>")
 
 
-def register_send_all_handlers(dp: Dispatcher) -> None:
+def register(dp: Dispatcher) -> None:
     config: Config = dp.bot.get("config")
-    dp.register_message_handler(handle_send_all,
+    dp.register_message_handler(_handle_send_all,
                                 command=config.tg_bot.commands.send_all,
                                 is_admin=True)
-    dp.register_message_handler(confirm_send,
+    dp.register_message_handler(_confirm_send,
                                 content_types=ContentType.ANY,
                                 is_admin=True,
                                 state=SendAllState.waiting_for_message)
-    dp.register_callback_query_handler(ask_to_change_buttons,
+    dp.register_callback_query_handler(_ask_to_change_buttons,
                                        send_all.setup_callback_data.filter(action=send_all.Action.BUTTONS()),
                                        is_admin=True,
                                        state=SendAllState.waiting_for_confirm)
-    dp.register_callback_query_handler(cancel,
+    dp.register_callback_query_handler(_cancel,
                                        send_all.setup_callback_data.filter(action=send_all.Action.CANCEL()),
                                        is_admin=True,
                                        state=SendAllState.waiting_for_confirm)
-    dp.register_message_handler(change_buttons,
+    dp.register_message_handler(_change_buttons,
                                 is_admin=True,
                                 state=SendAllState.waiting_for_buttons)
-    dp.register_callback_query_handler(start_broadcast,
+    dp.register_callback_query_handler(_start_broadcast,
                                        send_all.setup_callback_data.filter(action=send_all.Action.SEND()),
                                        is_admin=True,
                                        state=SendAllState.waiting_for_confirm)
diff --git a/tgbot/handlers/start.py b/tgbot/handlers/start.py
@@ -12,5 +12,5 @@ async def start(message: types.Message, user: UserTG) -> None:
     await user.send_message(text)
 
 
-def register_start_handlers(dp: Dispatcher) -> None:
+def register(dp: Dispatcher) -> None:
     dp.register_message_handler(start, CommandStart())
diff --git a/tgbot/handlers/subscription.py b/tgbot/handlers/subscription.py
@@ -7,11 +7,11 @@
 
 
 @do_not_answer()
-async def handle_subscription_callback(call: types.CallbackQuery, user: UserTG) -> None:
+async def _handle_subscription_callback(call: types.CallbackQuery, user: UserTG) -> None:
     await call.answer(text="Доступ разрешен. Можете пользоваться ботом.")
     await call.message.delete()
     await start(call.message, user)
 
 
-def register_subscription_handlers(dp: Dispatcher) -> None:
-    dp.register_callback_query_handler(handle_subscription_callback, subscription.callback_data.filter())
+def register(dp: Dispatcher) -> None:
+    dp.register_callback_query_handler(_handle_subscription_callback, subscription.callback_data.filter())
diff --git a/tgbot/middlewares/__init__.py b/tgbot/middlewares/__init__.py
@@ -9,7 +9,7 @@
 from .subscription import SubscriptionMiddleware
 
 
-async def register_middlewares(dp: Dispatcher, config: Config) -> None:
+async def register(dp: Dispatcher, config: Config) -> None:
     dp.setup_middleware(EnvironmentMiddleware(config=config))
     dp.setup_middleware(ACLMiddleware())
     dp.setup_middleware(LoggingMiddleware())