chore: run lint and prettifier

bot/handlers/user/start.py

@@ -1,61 +1,62 @@
 import logging
 import re
-from aiogram import Router, F, types, Bot
-from aiogram.utils.text_decorations import html_decoration as hd
-from aiogram.filters import CommandStart, Command
-from aiogram.fsm.context import FSMContext
-from typing import Optional, Union
-from sqlalchemy.ext.asyncio import AsyncSession
 from datetime import datetime, timezone
-from aiogram.exceptions import TelegramAPIError, TelegramBadRequest, TelegramForbiddenError
+from typing import Optional, Union
 
+from aiogram import Bot, F, Router, types
+from aiogram.exceptions import TelegramAPIError, TelegramBadRequest, TelegramForbiddenError
+from aiogram.filters import Command, CommandStart
+from aiogram.fsm.context import FSMContext
+from aiogram.utils.text_decorations import html_decoration as hd
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from bot.keyboards.inline.user_keyboards import (
+    get_bot_interface_inline_keyboard,
+    get_channel_subscription_keyboard,
+    get_information_links_keyboard,
+    get_language_selection_keyboard,
+    get_main_menu_inline_keyboard,
+)
+from bot.middlewares.i18n import JsonI18n
+from bot.services.panel_api_service import PanelApiService
+from bot.services.promo_code_service import PromoCodeService
+from bot.services.referral_service import ReferralService
+from bot.services.subscription_service import SubscriptionService
+from bot.utils.callback_answer import safe_answer_callback
+from bot.utils.text_sanitizer import sanitize_display_name, sanitize_username
+from config.settings import Settings
 from db.dal import user_dal
 from db.models import User
 
-from bot.keyboards.inline.user_keyboards import (
-    get_main_menu_inline_keyboard,
-    get_bot_interface_inline_keyboard,
-    get_language_selection_keyboard,
-    get_channel_subscription_keyboard,
-    get_information_links_keyboard,
-)
-from bot.services.subscription_service import SubscriptionService
-from bot.services.panel_api_service import PanelApiService
-from bot.services.referral_service import ReferralService
-from bot.services.promo_code_service import PromoCodeService
-from config.settings import Settings
-from bot.middlewares.i18n import JsonI18n
-from bot.utils.text_sanitizer import sanitize_username, sanitize_display_name
-from bot.utils.callback_answer import safe_answer_callback
 router = Router(name="user_start_router")
 
 
 async def should_show_trial_button(
-        settings: Settings,
-        subscription_service: SubscriptionService,
-        session: AsyncSession,
-        user_id: int) -> bool:
+    settings: Settings,
+    subscription_service: SubscriptionService,
+    session: AsyncSession,
+    user_id: int,
+) -> bool:
     if not settings.TRIAL_ENABLED:
         return False
 
-    if hasattr(subscription_service, 'has_had_any_subscription') and callable(
-            getattr(subscription_service, 'has_had_any_subscription')):
-        return not await subscription_service.has_had_any_subscription(
-            session, user_id)
+    if hasattr(subscription_service, "has_had_any_subscription") and callable(
+        getattr(subscription_service, "has_had_any_subscription")
+    ):
+        return not await subscription_service.has_had_any_subscription(session, user_id)
 
-    logging.error(
-        "Method has_had_any_subscription is missing in SubscriptionService!"
-    )
+    logging.error("Method has_had_any_subscription is missing in SubscriptionService!")
     return False
 
 
-async def send_main_menu(target_event: Union[types.Message,
-                                             types.CallbackQuery],
-                         settings: Settings,
-                         i18n_data: dict,
-                         subscription_service: SubscriptionService,
-                         session: AsyncSession,
-                         is_edit: bool = False):
+async def send_main_menu(
+    target_event: Union[types.Message, types.CallbackQuery],
+    settings: Settings,
+    i18n_data: dict,
+    subscription_service: SubscriptionService,
+    session: AsyncSession,
+    is_edit: bool = False,
+):
     current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
     i18n: Optional[JsonI18n] = i18n_data.get("i18n_instance")
 
@@ -63,8 +64,7 @@ async def send_main_menu(target_event: Union[types.Message,
     user_full_name = hd.quote(target_event.from_user.full_name)
 
     if not i18n:
-        logging.error(
-            f"i18n_instance missing in send_main_menu for user {user_id}")
+        logging.error(f"i18n_instance missing in send_main_menu for user {user_id}")
         err_msg_fallback = "Error: Language service unavailable. Please try again later."
         if isinstance(target_event, types.CallbackQuery):
             try:
@@ -78,27 +78,25 @@ async def send_main_menu(target_event: Union[types.Message,
                 pass
         return
 
-
     _ = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs)
 
     show_trial_button_in_menu = await should_show_trial_button(
-        settings, subscription_service, session, user_id)
+        settings, subscription_service, session, user_id
+    )
 
     text = _(key="main_menu_greeting", user_name=user_full_name)
-    reply_markup = get_main_menu_inline_keyboard(current_lang, i18n, settings,
-                                                 show_trial_button_in_menu)
+    reply_markup = get_main_menu_inline_keyboard(
+        current_lang, i18n, settings, show_trial_button_in_menu
+    )
 
     target_message_obj: Optional[types.Message] = None
     if isinstance(target_event, types.Message):
         target_message_obj = target_event
-    elif isinstance(target_event,
-                    types.CallbackQuery) and target_event.message:
+    elif isinstance(target_event, types.CallbackQuery) and target_event.message:
         target_message_obj = target_event.message
 
     if not target_message_obj:
-        logging.error(
-            f"send_main_menu: target_message_obj is None for event from user {user_id}."
-        )
+        logging.error(f"send_main_menu: target_message_obj is None for event from user {user_id}.")
         if isinstance(target_event, types.CallbackQuery):
             await safe_answer_callback(
                 target_event,
@@ -134,12 +132,13 @@ async def send_main_menu(target_event: Union[types.Message,
 
 
 async def send_bot_interface_menu(
-        target_event: Union[types.Message, types.CallbackQuery],
-        settings: Settings,
-        i18n_data: dict,
-        subscription_service: SubscriptionService,
-        session: AsyncSession,
-        is_edit: bool = False):
+    target_event: Union[types.Message, types.CallbackQuery],
+    settings: Settings,
+    i18n_data: dict,
+    subscription_service: SubscriptionService,
+    session: AsyncSession,
+    is_edit: bool = False,
+):
     current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
     i18n: Optional[JsonI18n] = i18n_data.get("i18n_instance")
 
@@ -149,16 +148,15 @@ async def send_bot_interface_menu(
 
     user_id = target_event.from_user.id
     show_trial_button_in_menu = await should_show_trial_button(
-        settings, subscription_service, session, user_id)
+        settings, subscription_service, session, user_id
+    )
 
     text = i18n.gettext(current_lang, "bot_interface_menu_title")
     if settings.SUBSCRIPTION_MINI_APP_URL:
-        text = (
-            f"{text}\n\n"
-            f"{i18n.gettext(current_lang, 'bot_interface_menu_webapp_hint')}"
-        )
+        text = f"{text}\n\n{i18n.gettext(current_lang, 'bot_interface_menu_webapp_hint')}"
     reply_markup = get_bot_interface_inline_keyboard(
-        current_lang, i18n, settings, show_trial_button_in_menu)
+        current_lang, i18n, settings, show_trial_button_in_menu
+    )
 
     target_message_obj: Optional[types.Message] = None
     if isinstance(target_event, types.Message):
@@ -201,12 +199,13 @@ async def send_bot_interface_menu(
 
 
 async def ensure_required_channel_subscription(
-        event: Union[types.Message, types.CallbackQuery],
-        settings: Settings,
-        i18n: Optional[JsonI18n],
-        current_lang: str,
-        session: AsyncSession,
-        db_user: Optional[User] = None) -> bool:
+    event: Union[types.Message, types.CallbackQuery],
+    settings: Settings,
+    i18n: Optional[JsonI18n],
+    current_lang: str,
+    session: AsyncSession,
+    db_user: Optional[User] = None,
+) -> bool:
     """
     Verify that the user is a member of the required channel (if configured).
     Returns True when access can proceed, False when user must subscribe first.
@@ -227,9 +226,7 @@ async def ensure_required_channel_subscription(
         message_obj = event
 
     if bot_instance is None:
-        logging.error(
-            "Channel subscription check: bot instance missing for user %s.", user_id
-        )
+        logging.error("Channel subscription check: bot instance missing for user %s.", user_id)
         return False
 
     if user_id in settings.ADMIN_IDS:
@@ -254,9 +251,10 @@ async def ensure_required_channel_subscription(
         )
         return True
 
-    if (db_user.channel_subscription_verified
-            and db_user.channel_subscription_verified_for
-            == required_channel_id):
+    if (
+        db_user.channel_subscription_verified
+        and db_user.channel_subscription_verified_for == required_channel_id
+    ):
         return True
 
     def translate(key: str, **kwargs) -> str:
@@ -346,10 +344,11 @@ async def ensure_required_channel_subscription(
         )
         return True
 
-    keyboard = (get_channel_subscription_keyboard(
-        current_lang, i18n, settings.REQUIRED_CHANNEL_LINK
+    keyboard = (
+        get_channel_subscription_keyboard(current_lang, i18n, settings.REQUIRED_CHANNEL_LINK)
+        if i18n
+        else None
     )
-               if i18n else None)
 
     prompt_text = translate("channel_subscription_required")
 
@@ -379,28 +378,41 @@ async def ensure_required_channel_subscription(
 
 
 @router.message(CommandStart())
-@router.message(CommandStart(magic=F.args.regexp(r"^ref_((?:[uU][A-Za-z0-9]{9})|(?:[A-Za-z0-9]{9})|\d+)$").as_("ref_match")))
+@router.message(
+    CommandStart(
+        magic=F.args.regexp(r"^ref_((?:[uU][A-Za-z0-9]{9})|(?:[A-Za-z0-9]{9})|\d+)$").as_(
+            "ref_match"
+        )
+    )
+)
 @router.message(CommandStart(magic=F.args.regexp(r"^promo_(\w+)$").as_("promo_match")))
 @router.message(CommandStart(magic=F.args.regexp(r"^admin_user_(\d+)$").as_("admin_user_match")))
 @router.message(CommandStart(magic=F.args.regexp(r"^page_ref$").as_("page_ref_match")))
-@router.message(CommandStart(magic=F.args.regexp(r"^(?!ref_|promo_|admin_user_|page_ref$|webapp_auth_)([A-Za-z0-9_\-]{2,64})$").as_("ad_param_match")))
-async def start_command_handler(message: types.Message,
-                                state: FSMContext,
-                                settings: Settings,
-                                i18n_data: dict,
-                                subscription_service: SubscriptionService,
-                                referral_service: ReferralService,
-                                session: AsyncSession,
-                                ref_match: Optional[re.Match] = None,
-                                promo_match: Optional[re.Match] = None,
-                                page_ref_match: Optional[re.Match] = None,
-                                ad_param_match: Optional[re.Match] = None,
-                                admin_user_match: Optional[re.Match] = None):
+@router.message(
+    CommandStart(
+        magic=F.args.regexp(
+            r"^(?!ref_|promo_|admin_user_|page_ref$|webapp_auth_)([A-Za-z0-9_\-]{2,64})$"
+        ).as_("ad_param_match")
+    )
+)
+async def start_command_handler(
+    message: types.Message,
+    state: FSMContext,
+    settings: Settings,
+    i18n_data: dict,
+    subscription_service: SubscriptionService,
+    referral_service: ReferralService,
+    session: AsyncSession,
+    ref_match: Optional[re.Match] = None,
+    promo_match: Optional[re.Match] = None,
+    page_ref_match: Optional[re.Match] = None,
+    ad_param_match: Optional[re.Match] = None,
+    admin_user_match: Optional[re.Match] = None,
+):
     await state.clear()
     current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
     i18n: Optional[JsonI18n] = i18n_data.get("i18n_instance")
-    _ = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs
-                                           ) if i18n else key
+    _ = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs) if i18n else key
 
     user = message.from_user
     user_id = user.id
@@ -409,21 +421,17 @@ async def start_command_handler(message: types.Message,
         target_user_id = int(admin_user_match.group(1))
         target_user = await user_dal.get_user_by_id(session, target_user_id)
         if not target_user:
-            await message.answer(
-                _("admin_user_not_found", input=hd.quote(str(target_user_id)))
-            )
+            await message.answer(_("admin_user_not_found", input=hd.quote(str(target_user_id))))
             return
 
         try:
             from bot.handlers.admin.user_management import (
+                _send_with_profile_link_fallback,
                 format_user_card,
                 get_user_card_keyboard,
-                _send_with_profile_link_fallback,
             )
 
-            referral_service = ReferralService(
-                settings, subscription_service, message.bot, i18n
-            )
+            referral_service = ReferralService(settings, subscription_service, message.bot, i18n)
             user_card_text = await format_user_card(
                 target_user,
                 session,
@@ -468,7 +476,8 @@ async def start_command_handler(message: types.Message,
             if settings.LEGACY_REFS:
                 potential_referrer_id = int(raw_ref_value)
                 if potential_referrer_id != user_id and await user_dal.get_user_by_id(
-                        session, potential_referrer_id):
+                    session, potential_referrer_id
+                ):
                     referred_by_user_id = potential_referrer_id
         else:
             normalized_code = raw_ref_value.strip()
@@ -476,8 +485,7 @@ async def start_command_handler(message: types.Message,
                 normalized_code = normalized_code[1:]
             ref_user = None
             if normalized_code:
-                ref_user = await user_dal.get_user_by_referral_code(
-                    session, normalized_code)
+                ref_user = await user_dal.get_user_by_referral_code(session, normalized_code)
             if ref_user and ref_user.user_id != user_id:
                 referred_by_user_id = ref_user.user_id
     elif promo_match:
@@ -504,7 +512,7 @@ async def start_command_handler(message: types.Message,
             "last_name": sanitized_last_name,
             "language_code": current_lang,
             "referred_by_id": referred_by_user_id,
-            "registration_date": datetime.now(timezone.utc)
+            "registration_date": datetime.now(timezone.utc),
         }
         try:
             db_user, created = await user_dal.create_user(session, user_data_to_create)
@@ -531,11 +539,13 @@ async def start_command_handler(message: types.Message,
                 )
                 if referred_by_user_id and referral_welcome_days > 0:
                     try:
-                        referral_bonus_end_date = await subscription_service.extend_active_subscription_days(
-                            session,
-                            user_id,
-                            referral_welcome_days,
-                            reason="referral_welcome_bonus",
+                        referral_bonus_end_date = (
+                            await subscription_service.extend_active_subscription_days(
+                                session,
+                                user_id,
+                                referral_welcome_days,
+                                reason="referral_welcome_bonus",
+                            )
                         )
                         if referral_bonus_end_date:
                             await session.commit()
@@ -572,20 +582,18 @@ async def start_command_handler(message: types.Message,
                 # Send notification about new user registration
                 try:
                     from bot.services.notification_service import NotificationService
+
                     notification_service = NotificationService(message.bot, settings, i18n)
                     await notification_service.notify_new_user_registration(
                         user_id=user_id,
                         username=sanitized_username,
                         first_name=sanitized_first_name,
-                        referred_by_id=referred_by_user_id
+                        referred_by_id=referred_by_user_id,
                     )
                 except Exception as e:
                     logging.error(f"Failed to send new user notification: {e}")
         except Exception as e_create:
-
-            logging.error(
-                f"Failed to add new user {user_id} to session: {e_create}",
-                exc_info=True)
+            logging.error(f"Failed to add new user {user_id} to session: {e_create}", exc_info=True)
             await message.answer(_("error_occurred_processing_request"))
             return
     else:
@@ -612,22 +620,23 @@ async def start_command_handler(message: types.Message,
             try:
                 await user_dal.update_user(session, user_id, update_payload)
 
-                logging.info(
-                    f"Updated existing user {user_id} in session: {update_payload}"
-                )
+                logging.info(f"Updated existing user {user_id} in session: {update_payload}")
             except Exception as e_update:
-
                 logging.error(
                     f"Failed to update existing user {user_id} in session: {e_update}",
-                    exc_info=True)
+                    exc_info=True,
+                )
 
     # Attribute user to ad campaign if start param provided
     if ad_start_param:
         try:
             from db.dal import ad_dal as _ad_dal
+
             campaign = await _ad_dal.get_campaign_by_start_param(session, ad_start_param)
             if campaign and campaign.is_active:
-                await _ad_dal.ensure_attribution(session, user_id=user_id, campaign_id=campaign.ad_campaign_id)
+                await _ad_dal.ensure_attribution(
+                    session, user_id=user_id, campaign_id=campaign.ad_campaign_id
+                )
                 await session.commit()
         except Exception as e_attr:
             logging.error(f"Failed to attribute user {user_id} to ad '{ad_start_param}': {e_attr}")
@@ -636,14 +645,12 @@ async def start_command_handler(message: types.Message,
             except Exception:
                 pass
 
-    if not await ensure_required_channel_subscription(message, settings, i18n,
-                                                      current_lang, session,
-                                                      db_user):
+    if not await ensure_required_channel_subscription(
+        message, settings, i18n, current_lang, session, db_user
+    ):
         return
 
-    open_referral_page_for_existing_user = (
-        should_open_referral_from_start and is_existing_user
-    )
+    open_referral_page_for_existing_user = should_open_referral_from_start and is_existing_user
 
     # Send welcome message if not disabled
     if not settings.DISABLE_WELCOME_MESSAGE and not open_referral_page_for_existing_user:
@@ -653,6 +660,7 @@ async def start_command_handler(message: types.Message,
     if promo_code_to_apply:
         try:
             from bot.services.promo_code_service import PromoCodeService
+
             promo_code_service = PromoCodeService(settings, subscription_service, message.bot, i18n)
 
             success, result = await promo_code_service.apply_promo_code(
@@ -664,7 +672,9 @@ async def start_command_handler(message: types.Message,
                 logging.info(f"Auto-applied promo code '{promo_code_to_apply}' for user {user_id}")
 
                 # Get updated subscription details
-                active = await subscription_service.get_active_subscription_details(session, user_id)
+                active = await subscription_service.get_active_subscription_details(
+                    session, user_id
+                )
                 config_link_display = active.get("config_link") if active else None
                 connect_button_url = active.get("connect_button_url") if active else None
                 config_link_text = config_link_display or _("config_link_not_available")
@@ -673,11 +683,14 @@ async def start_command_handler(message: types.Message,
 
                 promo_success_text = _(
                     "promo_code_applied_success_full",
-                    end_date=(new_end_date.strftime("%d.%m.%Y %H:%M:%S") if new_end_date else "N/A"),
+                    end_date=(
+                        new_end_date.strftime("%d.%m.%Y %H:%M:%S") if new_end_date else "N/A"
+                    ),
                     config_link=config_link_text,
                 )
 
                 from bot.keyboards.inline.user_keyboards import get_connect_and_main_keyboard
+
                 await message.answer(
                     promo_success_text,
                     reply_markup=get_connect_and_main_keyboard(
@@ -687,75 +700,76 @@ async def start_command_handler(message: types.Message,
                         config_link_display,
                         connect_button_url=connect_button_url,
                     ),
-                    parse_mode="HTML"
+                    parse_mode="HTML",
                 )
 
                 # Don't show main menu if promo was successfully applied
                 return
             else:
                 await session.commit()
-                logging.warning(f"Failed to auto-apply promo code '{promo_code_to_apply}' for user {user_id}: {result}")
+                logging.warning(
+                    f"Failed to auto-apply promo code '{promo_code_to_apply}' for user {user_id}: {result}"
+                )
                 await message.answer(str(result), parse_mode="HTML")
                 # Continue to show main menu if promo failed
 
         except Exception as e:
-            logging.error(f"Error auto-applying promo code '{promo_code_to_apply}' for user {user_id}: {e}")
+            logging.error(
+                f"Error auto-applying promo code '{promo_code_to_apply}' for user {user_id}: {e}"
+            )
             await session.rollback()
 
     if open_referral_page_for_existing_user:
         from . import referral as user_referral_handlers
+
         await user_referral_handlers.referral_command_handler(
             message, settings, i18n_data, referral_service, message.bot, session
         )
         return
 
-    await send_main_menu(message,
-                         settings,
-                         i18n_data,
-                         subscription_service,
-                         session,
-                         is_edit=False)
+    await send_main_menu(message, settings, i18n_data, subscription_service, session, is_edit=False)
 
 
 @router.message(Command("tg"))
-async def tg_interface_command_handler(message: types.Message,
-                                       state: FSMContext,
-                                       settings: Settings,
-                                       i18n_data: dict,
-                                       subscription_service: SubscriptionService,
-                                       session: AsyncSession):
+async def tg_interface_command_handler(
+    message: types.Message,
+    state: FSMContext,
+    settings: Settings,
+    i18n_data: dict,
+    subscription_service: SubscriptionService,
+    session: AsyncSession,
+):
     await state.clear()
 
     current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
     i18n: Optional[JsonI18n] = i18n_data.get("i18n_instance")
     db_user = await user_dal.get_user_by_id(session, message.from_user.id)
-    if not await ensure_required_channel_subscription(message, settings, i18n,
-                                                      current_lang, session,
-                                                      db_user):
+    if not await ensure_required_channel_subscription(
+        message, settings, i18n, current_lang, session, db_user
+    ):
         return
 
-    await send_bot_interface_menu(message,
-                                  settings,
-                                  i18n_data,
-                                  subscription_service,
-                                  session,
-                                  is_edit=False)
+    await send_bot_interface_menu(
+        message, settings, i18n_data, subscription_service, session, is_edit=False
+    )
 
 
 @router.callback_query(F.data == "channel_subscription:verify")
 async def verify_channel_subscription_callback(
-        callback: types.CallbackQuery,
-        settings: Settings,
-        i18n_data: dict,
-        subscription_service: SubscriptionService,
-        session: AsyncSession):
+    callback: types.CallbackQuery,
+    settings: Settings,
+    i18n_data: dict,
+    subscription_service: SubscriptionService,
+    session: AsyncSession,
+):
     current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
     i18n: Optional[JsonI18n] = i18n_data.get("i18n_instance")
 
     db_user = await user_dal.get_user_by_id(session, callback.from_user.id)
 
     verified = await ensure_required_channel_subscription(
-        callback, settings, i18n, current_lang, session, db_user)
+        callback, settings, i18n, current_lang, session, db_user
+    )
     if not verified:
         return
 
@@ -769,15 +783,13 @@ async def verify_channel_subscription_callback(
         _ = lambda key, **kwargs: key
 
     if not settings.DISABLE_WELCOME_MESSAGE:
-        welcome_text = _(key="welcome",
-                         user_name=hd.quote(callback.from_user.full_name))
+        welcome_text = _(key="welcome", user_name=hd.quote(callback.from_user.full_name))
         if callback.message:
             await callback.message.answer(welcome_text)
         else:
             fallback_bot: Optional[Bot] = getattr(callback, "bot", None)
             if fallback_bot:
-                await fallback_bot.send_message(callback.from_user.id,
-                                                welcome_text)
+                await fallback_bot.send_message(callback.from_user.id, welcome_text)
 
     try:
         await safe_answer_callback(
@@ -788,12 +800,9 @@ async def verify_channel_subscription_callback(
     except Exception:
         pass
 
-    await send_main_menu(callback,
-                         settings,
-                         i18n_data,
-                         subscription_service,
-                         session,
-                         is_edit=bool(callback.message))
+    await send_main_menu(
+        callback, settings, i18n_data, subscription_service, session, is_edit=bool(callback.message)
+    )
 
 
 @router.message(Command("language"))
@@ -806,8 +815,7 @@ async def language_command_handler(
 ):
     current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
     i18n: Optional[JsonI18n] = i18n_data.get("i18n_instance")
-    _ = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs
-                                           ) if i18n else key
+    _ = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs) if i18n else key
 
     text_to_send = _(key="choose_language")
     reply_markup = get_language_selection_keyboard(
@@ -816,8 +824,7 @@ async def language_command_handler(
         back_callback=back_callback,
     )
 
-    target_message_obj = event.message if isinstance(
-        event, types.CallbackQuery) else event
+    target_message_obj = event.message if isinstance(event, types.CallbackQuery) else event
     if not target_message_obj:
         if isinstance(event, types.CallbackQuery):
             await safe_answer_callback(
@@ -830,21 +837,22 @@ async def language_command_handler(
     if isinstance(event, types.CallbackQuery):
         if event.message:
             try:
-                await event.message.edit_text(text_to_send,
-                                              reply_markup=reply_markup)
+                await event.message.edit_text(text_to_send, reply_markup=reply_markup)
             except Exception:
-                await target_message_obj.answer(text_to_send,
-                                                reply_markup=reply_markup)
+                await target_message_obj.answer(text_to_send, reply_markup=reply_markup)
         await safe_answer_callback(event)
     else:
-        await target_message_obj.answer(text_to_send,
-                                        reply_markup=reply_markup)
+        await target_message_obj.answer(text_to_send, reply_markup=reply_markup)
 
 
 @router.callback_query(F.data.startswith("set_lang_"))
 async def select_language_callback_handler(
-        callback: types.CallbackQuery, i18n_data: dict, settings: Settings,
-        subscription_service: SubscriptionService, session: AsyncSession):
+    callback: types.CallbackQuery,
+    i18n_data: dict,
+    settings: Settings,
+    subscription_service: SubscriptionService,
+    session: AsyncSession,
+):
     i18n: Optional[JsonI18n] = i18n_data.get("i18n_instance")
     if not i18n or not callback.message:
         await safe_answer_callback(
@@ -867,15 +875,12 @@ async def select_language_callback_handler(
 
     user_id = callback.from_user.id
     try:
-        updated = await user_dal.update_user_language(session, user_id,
-                                                      lang_code)
+        updated = await user_dal.update_user_language(session, user_id, lang_code)
         if updated:
-
             i18n_data["current_language"] = lang_code
             _ = lambda key, **kwargs: i18n.gettext(lang_code, key, **kwargs)
             await safe_answer_callback(callback, _(key="language_set_alert"))
-            logging.info(
-                f"User {user_id} language updated to {lang_code} in session.")
+            logging.info(f"User {user_id} language updated to {lang_code} in session.")
         else:
             await safe_answer_callback(
                 callback,
@@ -884,43 +889,41 @@ async def select_language_callback_handler(
             )
             return
     except Exception as e_lang_update:
-
-        logging.error(
-            f"Error updating lang for user {user_id}: {e_lang_update}",
-            exc_info=True)
+        logging.error(f"Error updating lang for user {user_id}: {e_lang_update}", exc_info=True)
         await safe_answer_callback(callback, "Error setting language.", show_alert=True)
         return
     if return_target == "bot":
-        await send_bot_interface_menu(callback,
-                                      settings,
-                                      i18n_data,
-                                      subscription_service,
-                                      session,
-                                      is_edit=True)
+        await send_bot_interface_menu(
+            callback, settings, i18n_data, subscription_service, session, is_edit=True
+        )
     else:
-        await send_main_menu(callback,
-                             settings,
-                             i18n_data,
-                             subscription_service,
-                             session,
-                             is_edit=True)
+        await send_main_menu(
+            callback, settings, i18n_data, subscription_service, session, is_edit=True
+        )
 
 
 @router.callback_query(F.data.startswith("main_action:"))
 async def main_action_callback_handler(
-        callback: types.CallbackQuery, state: FSMContext, settings: Settings,
-        i18n_data: dict, bot: Bot, subscription_service: SubscriptionService,
-        referral_service: ReferralService, panel_service: PanelApiService,
-        promo_code_service: PromoCodeService, session: AsyncSession):
+    callback: types.CallbackQuery,
+    state: FSMContext,
+    settings: Settings,
+    i18n_data: dict,
+    bot: Bot,
+    subscription_service: SubscriptionService,
+    referral_service: ReferralService,
+    panel_service: PanelApiService,
+    promo_code_service: PromoCodeService,
+    session: AsyncSession,
+):
     action = callback.data.split(":")[1]
     user_id = callback.from_user.id
 
     if action in {"back_to_main", "back_to_main_keep", "bot_interface"}:
         await state.clear()
 
-    from . import subscription as user_subscription_handlers
-    from . import referral as user_referral_handlers
     from . import promo_user as user_promo_handlers
+    from . import referral as user_referral_handlers
+    from . import subscription as user_subscription_handlers
     from . import trial_handler as user_trial_handlers
 
     if not callback.message:
@@ -933,7 +936,8 @@ async def main_action_callback_handler(
 
     if action == "subscribe":
         await user_subscription_handlers.display_subscription_options(
-            callback, i18n_data, settings, session)
+            callback, i18n_data, settings, session
+        )
     elif action == "bot_subscribe":
         await user_subscription_handlers.display_subscription_options(
             callback,
@@ -944,8 +948,8 @@ async def main_action_callback_handler(
         )
     elif action == "my_subscription":
         await user_subscription_handlers.my_subscription_command_handler(
-            callback, i18n_data, settings, panel_service, subscription_service,
-            session, bot)
+            callback, i18n_data, settings, panel_service, subscription_service, session, bot
+        )
     elif action == "bot_my_subscription":
         await user_subscription_handlers.my_subscription_command_handler(
             callback,
@@ -959,11 +963,12 @@ async def main_action_callback_handler(
         )
     elif action == "my_devices":
         await user_subscription_handlers.my_devices_command_handler(
-            callback, i18n_data, settings, panel_service, subscription_service,
-            session, bot)
+            callback, i18n_data, settings, panel_service, subscription_service, session, bot
+        )
     elif action == "referral":
         await user_referral_handlers.referral_command_handler(
-            callback, settings, i18n_data, referral_service, bot, session)
+            callback, settings, i18n_data, referral_service, bot, session
+        )
     elif action == "bot_referral":
         await user_referral_handlers.referral_command_handler(
             callback,
@@ -976,7 +981,8 @@ async def main_action_callback_handler(
         )
     elif action == "apply_promo":
         await user_promo_handlers.prompt_promo_code_input(
-            callback, state, i18n_data, settings, session)
+            callback, state, i18n_data, settings, session
+        )
     elif action == "bot_apply_promo":
         await user_promo_handlers.prompt_promo_code_input(
             callback,
@@ -988,9 +994,9 @@ async def main_action_callback_handler(
         )
     elif action == "request_trial":
         await user_trial_handlers.request_trial_confirmation_handler(
-            callback, settings, i18n_data, subscription_service, session)
+            callback, settings, i18n_data, subscription_service, session
+        )
     elif action == "language":
-
         await language_command_handler(callback, i18n_data, settings)
     elif action == "bot_language":
         await language_command_handler(
@@ -1000,16 +1006,12 @@ async def main_action_callback_handler(
             back_callback="main_action:bot_interface",
         )
     elif action == "bot_interface":
-        await send_bot_interface_menu(callback,
-                                      settings,
-                                      i18n_data,
-                                      subscription_service,
-                                      session,
-                                      is_edit=True)
+        await send_bot_interface_menu(
+            callback, settings, i18n_data, subscription_service, session, is_edit=True
+        )
     elif action in {"info", "bot_info"}:
         i18n: Optional[JsonI18n] = i18n_data.get("i18n_instance")
-        current_lang = i18n_data.get("current_language",
-                                     settings.DEFAULT_LANGUAGE)
+        current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
         if not i18n:
             await safe_answer_callback(
                 callback,
@@ -1017,8 +1019,7 @@ async def main_action_callback_handler(
                 show_alert=True,
             )
             return
-        _ = lambda key, **kwargs: i18n.gettext(
-            current_lang, key, **kwargs) if i18n else key
+        _ = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs) if i18n else key
 
         privacy_url = settings.PRIVACY_POLICY_URL
         user_agreement_url = settings.USER_AGREEMENT_URL or settings.TERMS_OF_SERVICE_URL
@@ -1043,30 +1044,23 @@ async def main_action_callback_handler(
             ),
         )
         try:
-            await callback.message.edit_text(_(key="info_links_message"),
-                                             reply_markup=reply_markup)
+            await callback.message.edit_text(_(key="info_links_message"), reply_markup=reply_markup)
         except Exception:
-            await callback.message.answer(_(key="info_links_message"),
-                                          reply_markup=reply_markup)
+            await callback.message.answer(_(key="info_links_message"), reply_markup=reply_markup)
         await safe_answer_callback(callback)
     elif action == "back_to_main":
-        await send_main_menu(callback,
-                             settings,
-                             i18n_data,
-                             subscription_service,
-                             session,
-                             is_edit=True)
+        await send_main_menu(
+            callback, settings, i18n_data, subscription_service, session, is_edit=True
+        )
     elif action == "back_to_main_keep":
-        await send_main_menu(callback,
-                             settings,
-                             i18n_data,
-                             subscription_service,
-                             session,
-                             is_edit=False)
+        await send_main_menu(
+            callback, settings, i18n_data, subscription_service, session, is_edit=False
+        )
     else:
         i18n: Optional[JsonI18n] = i18n_data.get("i18n_instance")
-        _ = lambda key, **kwargs: i18n.gettext(
-            i18n_data.get("current_language"), key, **kwargs) if i18n else key
+        _ = lambda key, **kwargs: (
+            i18n.gettext(i18n_data.get("current_language"), key, **kwargs) if i18n else key
+        )
         await safe_answer_callback(
             callback,
             _("main_menu_unknown_action"),