chore: run lint and prettifier

bot/handlers/user/subscription/__init__.py

@@ -1,8 +1,6 @@
 from aiogram import Router
 
-from . import core
-from . import payments
-from . import payment_methods
+from . import core, payment_methods, payments
 
 router = Router(name="user_subscription_router")
 
@@ -12,6 +10,8 @@ router.include_router(payments.router)
 router.include_router(payment_methods.router)
 
 # Re-export commonly used entrypoints for backward compatibility
-from .core import display_subscription_options, my_subscription_command_handler, my_devices_command_handler  # noqa: E402,F401
-
-
+from .core import (  # noqa: E402,F401
+    display_subscription_options,
+    my_devices_command_handler,
+    my_subscription_command_handler,
+)

bot/handlers/user/subscription/core.py

@@ -1,29 +1,29 @@
 import hashlib
 import html
 import logging
-from aiogram import Router, F, types, Bot
+from datetime import datetime
+from typing import Optional, Union
+
+from aiogram import Bot, F, Router, types
 from aiogram.filters import Command
 from aiogram.types import InlineKeyboardButton, InlineKeyboardMarkup, WebAppInfo
 from aiogram.utils.keyboard import InlineKeyboardBuilder
-from typing import Optional, Union
-from datetime import datetime
 from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy.future import select
 
-from config.settings import Settings
 from bot.keyboards.inline.user_keyboards import (
-    get_subscription_options_keyboard,
-    get_back_to_main_menu_markup,
     get_autorenew_confirm_keyboard,
-    get_tariff_catalog_keyboard,
-    get_tariff_periods_keyboard,
-    get_tariff_packages_keyboard,
-    get_payment_method_keyboard,
+    get_back_to_main_menu_markup,
     get_hwid_device_packages_keyboard,
+    get_payment_method_keyboard,
+    get_subscription_options_keyboard,
+    get_tariff_catalog_keyboard,
+    get_tariff_packages_keyboard,
+    get_tariff_periods_keyboard,
 )
-from bot.services.subscription_service import SubscriptionService
-from bot.services.panel_api_service import PanelApiService
 from bot.middlewares.i18n import JsonI18n
+from bot.services.panel_api_service import PanelApiService
+from bot.services.subscription_service import SubscriptionService
+from config.settings import Settings
 from db.dal import subscription_dal, user_billing_dal
 from db.models import Subscription
 
@@ -55,7 +55,9 @@ def _has_multiple_enabled_tariffs(settings: Settings) -> bool:
     return len(_enabled_tariffs(settings)) > 1
 
 
-def _tariff_purchase_markup(tariff, current_lang: str, i18n: JsonI18n, settings: Settings) -> InlineKeyboardMarkup:
+def _tariff_purchase_markup(
+    tariff, current_lang: str, i18n: JsonI18n, settings: Settings
+) -> InlineKeyboardMarkup:
     if tariff.billing_model == "period":
         return get_tariff_periods_keyboard(tariff, current_lang, i18n, settings)
     return get_tariff_packages_keyboard(tariff, tariff.traffic_packages.rub, current_lang, i18n)
@@ -130,7 +132,11 @@ async def display_subscription_options(
         options = settings.subscription_options
 
     if options:
-        text_content = get_text("select_traffic_package") if traffic_mode else get_text("select_subscription_period")
+        text_content = (
+            get_text("select_traffic_package")
+            if traffic_mode
+            else get_text("select_subscription_period")
+        )
         reply_markup = get_subscription_options_keyboard(
             options,
             currency_symbol_val,
@@ -170,12 +176,16 @@ async def display_subscription_options(
 
 
 @router.callback_query(F.data == "main_action:subscribe")
-async def reshow_subscription_options_callback(callback: types.CallbackQuery, i18n_data: dict, settings: Settings, session: AsyncSession):
+async def reshow_subscription_options_callback(
+    callback: types.CallbackQuery, i18n_data: dict, settings: Settings, session: AsyncSession
+):
     await display_subscription_options(callback, i18n_data, settings, session)
 
 
 @router.callback_query(F.data.startswith("tariff:select:"))
-async def select_tariff_callback(callback: types.CallbackQuery, i18n_data: dict, settings: Settings, session: AsyncSession):
+async def select_tariff_callback(
+    callback: types.CallbackQuery, i18n_data: dict, settings: Settings, session: AsyncSession
+):
     current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
     i18n: JsonI18n = i18n_data.get("i18n_instance")
     get_text = lambda key, **kw: i18n.gettext(current_lang, key, **kw)
@@ -196,7 +206,9 @@ async def select_tariff_callback(callback: types.CallbackQuery, i18n_data: dict,
 
 
 @router.callback_query(F.data.startswith("tariff:period:"))
-async def select_tariff_period_callback(callback: types.CallbackQuery, i18n_data: dict, settings: Settings, session: AsyncSession):
+async def select_tariff_period_callback(
+    callback: types.CallbackQuery, i18n_data: dict, settings: Settings, session: AsyncSession
+):
     current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
     i18n: JsonI18n = i18n_data.get("i18n_instance")
     get_text = lambda key, **kw: i18n.gettext(current_lang, key, **kw)
@@ -227,7 +239,9 @@ async def select_tariff_period_callback(callback: types.CallbackQuery, i18n_data
 
 
 @router.callback_query(F.data.startswith("tariff:package:"))
-async def select_tariff_package_callback(callback: types.CallbackQuery, i18n_data: dict, settings: Settings, session: AsyncSession):
+async def select_tariff_package_callback(
+    callback: types.CallbackQuery, i18n_data: dict, settings: Settings, session: AsyncSession
+):
     current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
     i18n: JsonI18n = i18n_data.get("i18n_instance")
     get_text = lambda key, **kw: i18n.gettext(current_lang, key, **kw)
@@ -238,12 +252,18 @@ async def select_tariff_package_callback(callback: types.CallbackQuery, i18n_dat
     _, _, tariff_key, gb_raw = callback.data.split(":", 3)
     tariff = config.require(tariff_key)
     gb = float(gb_raw)
-    packages = tariff.traffic_packages.rub if tariff.billing_model == "traffic" else (config.topup_packages_for(tariff).rub if config.topup_packages_for(tariff) else [])
+    packages = (
+        tariff.traffic_packages.rub
+        if tariff.billing_model == "traffic"
+        else (config.topup_packages_for(tariff).rub if config.topup_packages_for(tariff) else [])
+    )
     package = next((pkg for pkg in packages if float(pkg.gb) == gb), None)
     if not package:
         await callback.answer(get_text("error_try_again"), show_alert=True)
         return
-    sale_mode = f"{'traffic_package' if tariff.billing_model == 'traffic' else 'topup'}@{tariff.key}"
+    sale_mode = (
+        f"{'traffic_package' if tariff.billing_model == 'traffic' else 'topup'}@{tariff.key}"
+    )
     markup = get_payment_method_keyboard(
         gb,
         package.price,
@@ -259,12 +279,20 @@ async def select_tariff_package_callback(callback: types.CallbackQuery, i18n_dat
 
 
 @router.callback_query(F.data == "tariff_topup:list")
-async def tariff_topup_list_callback(callback: types.CallbackQuery, i18n_data: dict, settings: Settings, subscription_service: SubscriptionService, session: AsyncSession):
+async def tariff_topup_list_callback(
+    callback: types.CallbackQuery,
+    i18n_data: dict,
+    settings: Settings,
+    subscription_service: SubscriptionService,
+    session: AsyncSession,
+):
     current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
     i18n: JsonI18n = i18n_data.get("i18n_instance")
     get_text = lambda key, **kw: i18n.gettext(current_lang, key, **kw)
     config = settings.tariffs_config
-    active = await subscription_service.get_active_subscription_details(session, callback.from_user.id)
+    active = await subscription_service.get_active_subscription_details(
+        session, callback.from_user.id
+    )
     if not config or not active or not active.get("tariff_key") or not callback.message:
         await callback.answer(get_text("error_try_again"), show_alert=True)
         return
@@ -291,14 +319,24 @@ async def tariff_topup_list_callback(callback: types.CallbackQuery, i18n_data: d
                 callback_data=f"tariff:premium_package:{tariff.key}:{package.gb:g}",
             )
         )
-    builder.row(InlineKeyboardButton(text=get_text("back_to_main_menu_button"), callback_data="main_action:my_subscription"))
+    builder.row(
+        InlineKeyboardButton(
+            text=get_text("back_to_main_menu_button"), callback_data="main_action:my_subscription"
+        )
+    )
 
     premium_lines = []
     carryover_lines = []
     if rub_packages or premium_packages:
-        carryover_lines.append("Докупленный трафик не сгорает: сначала расходуется месячный лимит, затем докупленный остаток.")
+        carryover_lines.append(
+            "Докупленный трафик не сгорает: сначала расходуется месячный лимит, затем докупленный остаток."
+        )
     if int(active.get("premium_limit_bytes") or 0) > 0:
-        premium_left = max(0, int(active.get("premium_limit_bytes") or 0) - int(active.get("premium_used_bytes") or 0))
+        premium_left = max(
+            0,
+            int(active.get("premium_limit_bytes") or 0)
+            - int(active.get("premium_used_bytes") or 0),
+        )
         labels = active.get("premium_node_labels") or active.get("premium_squad_labels") or []
         if labels:
             visible = [str(label) for label in labels[:8]]
@@ -319,7 +357,9 @@ async def tariff_topup_list_callback(callback: types.CallbackQuery, i18n_data: d
 
 
 @router.callback_query(F.data.startswith("tariff:premium_package:"))
-async def select_tariff_premium_package_callback(callback: types.CallbackQuery, i18n_data: dict, settings: Settings, session: AsyncSession):
+async def select_tariff_premium_package_callback(
+    callback: types.CallbackQuery, i18n_data: dict, settings: Settings, session: AsyncSession
+):
     current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
     i18n: JsonI18n = i18n_data.get("i18n_instance")
     get_text = lambda key, **kw: i18n.gettext(current_lang, key, **kw)
@@ -350,12 +390,20 @@ async def select_tariff_premium_package_callback(callback: types.CallbackQuery,
 
 
 @router.callback_query(F.data == "hwid_devices:list")
-async def hwid_devices_list_callback(callback: types.CallbackQuery, i18n_data: dict, settings: Settings, subscription_service: SubscriptionService, session: AsyncSession):
+async def hwid_devices_list_callback(
+    callback: types.CallbackQuery,
+    i18n_data: dict,
+    settings: Settings,
+    subscription_service: SubscriptionService,
+    session: AsyncSession,
+):
     current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
     i18n: JsonI18n = i18n_data.get("i18n_instance")
     get_text = lambda key, **kw: i18n.gettext(current_lang, key, **kw)
     config = settings.tariffs_config
-    active = await subscription_service.get_active_subscription_details(session, callback.from_user.id)
+    active = await subscription_service.get_active_subscription_details(
+        session, callback.from_user.id
+    )
     if not config or not active or not active.get("tariff_key") or not callback.message:
         await callback.answer(get_text("error_try_again"), show_alert=True)
         return
@@ -381,7 +429,9 @@ async def hwid_devices_list_callback(callback: types.CallbackQuery, i18n_data: d
 
 
 @router.callback_query(F.data.startswith("hwid_devices:package:"))
-async def hwid_devices_package_callback(callback: types.CallbackQuery, i18n_data: dict, settings: Settings, session: AsyncSession):
+async def hwid_devices_package_callback(
+    callback: types.CallbackQuery, i18n_data: dict, settings: Settings, session: AsyncSession
+):
     current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
     i18n: JsonI18n = i18n_data.get("i18n_instance")
     get_text = lambda key, **kw: i18n.gettext(current_lang, key, **kw)
@@ -393,7 +443,11 @@ async def hwid_devices_package_callback(callback: types.CallbackQuery, i18n_data
     tariff = config.require(tariff_key)
     count = int(count_raw)
     package = next(
-        (pkg for pkg in (tariff.hwid_device_packages.rub if tariff.hwid_device_packages else []) if int(pkg.count) == count),
+        (
+            pkg
+            for pkg in (tariff.hwid_device_packages.rub if tariff.hwid_device_packages else [])
+            if int(pkg.count) == count
+        ),
         None,
     )
     if not package:
@@ -409,34 +463,68 @@ async def hwid_devices_package_callback(callback: types.CallbackQuery, i18n_data
         settings,
         sale_mode=f"hwid_devices@{tariff.key}",
     )
-    await callback.message.edit_text(get_text("choose_payment_method_hwid_devices"), reply_markup=markup)
+    await callback.message.edit_text(
+        get_text("choose_payment_method_hwid_devices"), reply_markup=markup
+    )
     await callback.answer()
 
 
 @router.callback_query(F.data == "tariff_change:list")
-async def tariff_change_list_callback(callback: types.CallbackQuery, i18n_data: dict, settings: Settings, subscription_service: SubscriptionService, session: AsyncSession):
+async def tariff_change_list_callback(
+    callback: types.CallbackQuery,
+    i18n_data: dict,
+    settings: Settings,
+    subscription_service: SubscriptionService,
+    session: AsyncSession,
+):
     current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
     i18n: JsonI18n = i18n_data.get("i18n_instance")
     config = settings.tariffs_config
-    active = await subscription_service.get_active_subscription_details(session, callback.from_user.id)
+    active = await subscription_service.get_active_subscription_details(
+        session, callback.from_user.id
+    )
     if not config or not active or not callback.message:
         await callback.answer("Error", show_alert=True)
         return
     if len(config.enabled_tariffs) <= 1:
-        await callback.answer("Смена тарифа недоступна: сейчас включен только один тариф.", show_alert=True)
+        await callback.answer(
+            "Смена тарифа недоступна: сейчас включен только один тариф.", show_alert=True
+        )
         return
     rows = []
     for tariff in config.enabled_tariffs:
         if tariff.key == active.get("tariff_key"):
             continue
-        rows.append([InlineKeyboardButton(text=tariff.name(current_lang), callback_data=f"tariff_change:select:{tariff.key}")])
-    rows.append([InlineKeyboardButton(text=i18n.gettext(current_lang, "back_to_main_menu_button"), callback_data="main_action:my_subscription")])
-    await callback.message.edit_text("Выберите тариф", reply_markup=InlineKeyboardMarkup(inline_keyboard=rows))
+        rows.append(
+            [
+                InlineKeyboardButton(
+                    text=tariff.name(current_lang),
+                    callback_data=f"tariff_change:select:{tariff.key}",
+                )
+            ]
+        )
+    rows.append(
+        [
+            InlineKeyboardButton(
+                text=i18n.gettext(current_lang, "back_to_main_menu_button"),
+                callback_data="main_action:my_subscription",
+            )
+        ]
+    )
+    await callback.message.edit_text(
+        "Выберите тариф", reply_markup=InlineKeyboardMarkup(inline_keyboard=rows)
+    )
     await callback.answer()
 
 
 @router.callback_query(F.data.startswith("tariff_change:select:"))
-async def tariff_change_select_callback(callback: types.CallbackQuery, i18n_data: dict, settings: Settings, subscription_service: SubscriptionService, session: AsyncSession):
+async def tariff_change_select_callback(
+    callback: types.CallbackQuery,
+    i18n_data: dict,
+    settings: Settings,
+    subscription_service: SubscriptionService,
+    session: AsyncSession,
+):
     current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
     i18n: JsonI18n = i18n_data.get("i18n_instance")
     config = settings.tariffs_config
@@ -445,32 +533,85 @@ async def tariff_change_select_callback(callback: types.CallbackQuery, i18n_data
         return
     tariff_key = callback.data.split(":", 2)[2]
     target = config.require(tariff_key)
-    db_sub = await subscription_dal.get_active_subscription_by_user_id(session, callback.from_user.id)
+    db_sub = await subscription_dal.get_active_subscription_by_user_id(
+        session, callback.from_user.id
+    )
     if not db_sub:
         await callback.answer("Error", show_alert=True)
         return
     options = subscription_service.calculate_tariff_switch_options(db_sub, target)
     rows = []
     if options["mode"] == "period_to_period":
-        rows.append([InlineKeyboardButton(text=f"Без доплаты, дней станет {options['recalc_days']}", callback_data=f"tariff_change:confirm_apply:{target.key}:recalc_days")])
+        rows.append(
+            [
+                InlineKeyboardButton(
+                    text=f"Без доплаты, дней станет {options['recalc_days']}",
+                    callback_data=f"tariff_change:confirm_apply:{target.key}:recalc_days",
+                )
+            ]
+        )
         if options.get("paid_diff_rub", 0) > 0:
-            rows.append([InlineKeyboardButton(text=f"Доплатить {options['paid_diff_rub']} RUB", callback_data=f"tariff_change:confirm_pay:{target.key}:{options['paid_diff_rub']}")])
+            rows.append(
+                [
+                    InlineKeyboardButton(
+                        text=f"Доплатить {options['paid_diff_rub']} RUB",
+                        callback_data=f"tariff_change:confirm_pay:{target.key}:{options['paid_diff_rub']}",
+                    )
+                ]
+            )
     elif options["mode"] == "period_to_traffic":
-        rows.append([InlineKeyboardButton(text=f"Перейти без доплаты, получить {options['converted_gb']} GB", callback_data=f"tariff_change:confirm_apply:{target.key}:convert_days_to_gb")])
+        rows.append(
+            [
+                InlineKeyboardButton(
+                    text=f"Перейти без доплаты, получить {options['converted_gb']} GB",
+                    callback_data=f"tariff_change:confirm_apply:{target.key}:convert_days_to_gb",
+                )
+            ]
+        )
         for package in target.traffic_packages.rub:
-            rows.append([InlineKeyboardButton(text=f"+ {package.gb:g} GB за {package.price:g} RUB", callback_data=f"tariff:package:{target.key}:{package.gb:g}")])
+            rows.append(
+                [
+                    InlineKeyboardButton(
+                        text=f"+ {package.gb:g} GB за {package.price:g} RUB",
+                        callback_data=f"tariff:package:{target.key}:{package.gb:g}",
+                    )
+                ]
+            )
     else:
         for months in target.enabled_periods:
             price = target.period_price(months, "rub")
             if price:
-                rows.append([InlineKeyboardButton(text=f"{months} мес. за {price:g} RUB", callback_data=f"tariff:period:{target.key}:{months}")])
-    rows.append([InlineKeyboardButton(text=i18n.gettext(current_lang, "back_to_main_menu_button"), callback_data="tariff_change:list")])
-    await callback.message.edit_text(f"{target.name(current_lang)}\n{target.description(current_lang)}".strip(), reply_markup=InlineKeyboardMarkup(inline_keyboard=rows))
+                rows.append(
+                    [
+                        InlineKeyboardButton(
+                            text=f"{months} мес. за {price:g} RUB",
+                            callback_data=f"tariff:period:{target.key}:{months}",
+                        )
+                    ]
+                )
+    rows.append(
+        [
+            InlineKeyboardButton(
+                text=i18n.gettext(current_lang, "back_to_main_menu_button"),
+                callback_data="tariff_change:list",
+            )
+        ]
+    )
+    await callback.message.edit_text(
+        f"{target.name(current_lang)}\n{target.description(current_lang)}".strip(),
+        reply_markup=InlineKeyboardMarkup(inline_keyboard=rows),
+    )
     await callback.answer()
 
 
 @router.callback_query(F.data.startswith("tariff_change:confirm_apply:"))
-async def tariff_change_confirm_apply_callback(callback: types.CallbackQuery, i18n_data: dict, settings: Settings, subscription_service: SubscriptionService, session: AsyncSession):
+async def tariff_change_confirm_apply_callback(
+    callback: types.CallbackQuery,
+    i18n_data: dict,
+    settings: Settings,
+    subscription_service: SubscriptionService,
+    session: AsyncSession,
+):
     current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
     i18n: JsonI18n = i18n_data.get("i18n_instance")
     config = settings.tariffs_config
@@ -479,7 +620,9 @@ async def tariff_change_confirm_apply_callback(callback: types.CallbackQuery, i1
         return
     _, _, tariff_key, mode = callback.data.split(":", 3)
     target = config.require(tariff_key)
-    db_sub = await subscription_dal.get_active_subscription_by_user_id(session, callback.from_user.id)
+    db_sub = await subscription_dal.get_active_subscription_by_user_id(
+        session, callback.from_user.id
+    )
     if not db_sub:
         await callback.answer("Error", show_alert=True)
         return
@@ -491,8 +634,17 @@ async def tariff_change_confirm_apply_callback(callback: types.CallbackQuery, i1
     else:
         action_text = "тариф будет изменен без доплаты"
     rows = [
-        [InlineKeyboardButton(text="✅ Подтвердить", callback_data=f"tariff_change:apply:{target.key}:{mode}")],
-        [InlineKeyboardButton(text=i18n.gettext(current_lang, "back_to_main_menu_button"), callback_data=f"tariff_change:select:{target.key}")],
+        [
+            InlineKeyboardButton(
+                text="✅ Подтвердить", callback_data=f"tariff_change:apply:{target.key}:{mode}"
+            )
+        ],
+        [
+            InlineKeyboardButton(
+                text=i18n.gettext(current_lang, "back_to_main_menu_button"),
+                callback_data=f"tariff_change:select:{target.key}",
+            )
+        ],
     ]
     await callback.message.edit_text(
         f"Подтвердите смену тарифа\n\nНовый тариф: {target.name(current_lang)}\nИзменение: {action_text}",
@@ -502,7 +654,9 @@ async def tariff_change_confirm_apply_callback(callback: types.CallbackQuery, i1
 
 
 @router.callback_query(F.data.startswith("tariff_change:confirm_pay:"))
-async def tariff_change_confirm_pay_callback(callback: types.CallbackQuery, i18n_data: dict, settings: Settings):
+async def tariff_change_confirm_pay_callback(
+    callback: types.CallbackQuery, i18n_data: dict, settings: Settings
+):
     current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
     i18n: JsonI18n = i18n_data.get("i18n_instance")
     config = settings.tariffs_config
@@ -512,8 +666,18 @@ async def tariff_change_confirm_pay_callback(callback: types.CallbackQuery, i18n
     _, _, tariff_key, amount_raw = callback.data.split(":", 3)
     target = config.require(tariff_key)
     rows = [
-        [InlineKeyboardButton(text="✅ Подтвердить и оплатить", callback_data=f"tariff_change:pay:{target.key}:{amount_raw}")],
-        [InlineKeyboardButton(text=i18n.gettext(current_lang, "back_to_main_menu_button"), callback_data=f"tariff_change:select:{target.key}")],
+        [
+            InlineKeyboardButton(
+                text="✅ Подтвердить и оплатить",
+                callback_data=f"tariff_change:pay:{target.key}:{amount_raw}",
+            )
+        ],
+        [
+            InlineKeyboardButton(
+                text=i18n.gettext(current_lang, "back_to_main_menu_button"),
+                callback_data=f"tariff_change:select:{target.key}",
+            )
+        ],
     ]
     await callback.message.edit_text(
         f"Подтвердите смену тарифа\n\nНовый тариф: {target.name(current_lang)}\nБудет создана оплата на {amount_raw} RUB.",
@@ -523,19 +687,37 @@ async def tariff_change_confirm_pay_callback(callback: types.CallbackQuery, i18n
 
 
 @router.callback_query(F.data.startswith("tariff_change:apply:"))
-async def tariff_change_apply_callback(callback: types.CallbackQuery, i18n_data: dict, settings: Settings, subscription_service: SubscriptionService, session: AsyncSession):
+async def tariff_change_apply_callback(
+    callback: types.CallbackQuery,
+    i18n_data: dict,
+    settings: Settings,
+    subscription_service: SubscriptionService,
+    session: AsyncSession,
+):
     _, _, tariff_key, mode = callback.data.split(":", 3)
-    result = await subscription_service.switch_tariff_without_payment(session, callback.from_user.id, tariff_key, mode)
+    result = await subscription_service.switch_tariff_without_payment(
+        session, callback.from_user.id, tariff_key, mode
+    )
     if result:
         await session.commit()
         await callback.answer("Готово", show_alert=True)
-        await my_subscription_command_handler(callback, i18n_data, settings, subscription_service.panel_service, subscription_service, session, callback.bot)
+        await my_subscription_command_handler(
+            callback,
+            i18n_data,
+            settings,
+            subscription_service.panel_service,
+            subscription_service,
+            session,
+            callback.bot,
+        )
     else:
         await callback.answer("Error", show_alert=True)
 
 
 @router.callback_query(F.data.startswith("tariff_change:pay:"))
-async def tariff_change_pay_callback(callback: types.CallbackQuery, i18n_data: dict, settings: Settings, session: AsyncSession):
+async def tariff_change_pay_callback(
+    callback: types.CallbackQuery, i18n_data: dict, settings: Settings, session: AsyncSession
+):
     current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
     i18n: JsonI18n = i18n_data.get("i18n_instance")
     _, _, tariff_key, amount_raw = callback.data.split(":", 3)
@@ -613,6 +795,7 @@ async def my_subscription_command_handler(
     config_link_display = active.get("config_link")
     connect_button_url = active.get("connect_button_url")
     config_link_value = config_link_display or get_text("config_link_not_available")
+
     def _fmt_gb(val: Optional[float]) -> str:
         if val is None:
             return get_text("traffic_na")
@@ -623,6 +806,7 @@ async def my_subscription_command_handler(
         except Exception:
             pass
         return str(val)
+
     def _format_traffic_period(strategy: Optional[str]) -> Optional[str]:
         if not strategy:
             return None
@@ -639,14 +823,18 @@ async def my_subscription_command_handler(
     def _format_used_with_period(used_display: str, period_label: Optional[str]) -> str:
         if not period_label:
             return used_display
-        return get_text("traffic_used_with_period", traffic_used=used_display, traffic_period=period_label)
+        return get_text(
+            "traffic_used_with_period", traffic_used=used_display, traffic_period=period_label
+        )
 
     period_label = _format_traffic_period(active.get("traffic_limit_strategy"))
     period_label = period_label or get_text("traffic_period_unknown")
 
     if traffic_mode:
         limit_display = _fmt_gb(active.get("traffic_limit_bytes"))
-        used_display = _format_used_with_period(_fmt_gb(active.get("traffic_used_bytes")), period_label)
+        used_display = _format_used_with_period(
+            _fmt_gb(active.get("traffic_used_bytes")), period_label
+        )
         remaining_display = get_text("traffic_na")
         try:
             limit_val = active.get("traffic_limit_bytes") or 0
@@ -677,10 +865,16 @@ async def my_subscription_command_handler(
             days_left=max(0, days_left),
             status=active.get("status_from_panel", get_text("status_active")).capitalize(),
             config_link=config_link_value,
-            traffic_limit=(f"{active['traffic_limit_bytes'] / 2**30:.2f} GB" if active.get("traffic_limit_bytes") else get_text("traffic_unlimited")),
+            traffic_limit=(
+                f"{active['traffic_limit_bytes'] / 2**30:.2f} GB"
+                if active.get("traffic_limit_bytes")
+                else get_text("traffic_unlimited")
+            ),
             traffic_used=(
                 _format_used_with_period(
-                    f"{active['traffic_used_bytes'] / 2**30:.2f} GB" if active.get("traffic_used_bytes") is not None else get_text("traffic_na"),
+                    f"{active['traffic_used_bytes'] / 2**30:.2f} GB"
+                    if active.get("traffic_used_bytes") is not None
+                    else get_text("traffic_na"),
                     period_label,
                 )
             ),
@@ -721,26 +915,32 @@ async def my_subscription_command_handler(
     )
     kb = base_markup.inline_keyboard
     try:
-        local_sub = await subscription_dal.get_active_subscription_by_user_id(session, event.from_user.id)
+        local_sub = await subscription_dal.get_active_subscription_by_user_id(
+            session, event.from_user.id
+        )
         # Build rows to prepend above the base "back" markup
         prepend_rows = []
 
         # 1) Connect button: prefer the actual subscription URL; fall back to mini-app
         cfg_link_val = connect_button_url or config_link_display
         if cfg_link_val:
-            prepend_rows.append([
-                InlineKeyboardButton(
-                    text=get_text("connect_button"),
-                    url=cfg_link_val,
-                )
-            ])
+            prepend_rows.append(
+                [
+                    InlineKeyboardButton(
+                        text=get_text("connect_button"),
+                        url=cfg_link_val,
+                    )
+                ]
+            )
         elif settings.SUBSCRIPTION_MINI_APP_URL:
-            prepend_rows.append([
-                InlineKeyboardButton(
-                    text=get_text("connect_button"),
-                    web_app=WebAppInfo(url=settings.SUBSCRIPTION_MINI_APP_URL),
-                )
-            ])
+            prepend_rows.append(
+                [
+                    InlineKeyboardButton(
+                        text=get_text("connect_button"),
+                        web_app=WebAppInfo(url=settings.SUBSCRIPTION_MINI_APP_URL),
+                    )
+                ]
+            )
 
         if settings.MY_DEVICES_SECTION_ENABLED:
             max_devices_value = active.get("max_devices")
@@ -786,47 +986,69 @@ async def my_subscription_command_handler(
                 current_devices=current_devices_display,
                 max_devices=max_devices_display,
             )
-            prepend_rows.append([
-                InlineKeyboardButton(
-                    text=devices_button_text,
-                    callback_data="main_action:my_devices",
-                )
-            ])
+            prepend_rows.append(
+                [
+                    InlineKeyboardButton(
+                        text=devices_button_text,
+                        callback_data="main_action:my_devices",
+                    )
+                ]
+            )
             if settings.tariffs_config and local_sub and local_sub.tariff_key:
                 try:
                     tariff_for_devices = settings.tariffs_config.require(local_sub.tariff_key)
-                    if tariff_for_devices.hwid_device_packages and tariff_for_devices.hwid_device_packages.rub:
-                        prepend_rows.append([
-                            InlineKeyboardButton(
-                                text=get_text("buy_hwid_devices_menu_button"),
-                                callback_data="hwid_devices:list",
-                            )
-                        ])
+                    if (
+                        tariff_for_devices.hwid_device_packages
+                        and tariff_for_devices.hwid_device_packages.rub
+                    ):
+                        prepend_rows.append(
+                            [
+                                InlineKeyboardButton(
+                                    text=get_text("buy_hwid_devices_menu_button"),
+                                    callback_data="hwid_devices:list",
+                                )
+                            ]
+                        )
                 except Exception:
                     pass
 
         # 2) Auto-renew toggle (YooKassa only)
-        if not traffic_mode and local_sub and local_sub.provider == "yookassa" and settings.yookassa_autopayments_active:
+        if (
+            not traffic_mode
+            and local_sub
+            and local_sub.provider == "yookassa"
+            and settings.yookassa_autopayments_active
+        ):
             toggle_text = (
-                get_text("autorenew_disable_button") if local_sub.auto_renew_enabled else get_text("autorenew_enable_button")
+                get_text("autorenew_disable_button")
+                if local_sub.auto_renew_enabled
+                else get_text("autorenew_enable_button")
+            )
+            prepend_rows.append(
+                [
+                    InlineKeyboardButton(
+                        text=toggle_text,
+                        callback_data=f"toggle_autorenew:{local_sub.subscription_id}:{1 if not local_sub.auto_renew_enabled else 0}",
+                    )
+                ]
             )
-            prepend_rows.append([
-                InlineKeyboardButton(
-                    text=toggle_text,
-                    callback_data=f"toggle_autorenew:{local_sub.subscription_id}:{1 if not local_sub.auto_renew_enabled else 0}",
-                )
-            ])
 
         # 3) Payment methods management (when autopayments enabled)
         if not traffic_mode and settings.yookassa_autopayments_active:
-            prepend_rows.append([
-                InlineKeyboardButton(text=get_text("payment_methods_manage_button"), callback_data="pm:manage")
-            ])
+            prepend_rows.append(
+                [
+                    InlineKeyboardButton(
+                        text=get_text("payment_methods_manage_button"), callback_data="pm:manage"
+                    )
+                ]
+            )
 
         if settings.tariffs_config and local_sub and local_sub.tariff_key:
             tariff_actions = []
             if _has_multiple_enabled_tariffs(settings):
-                tariff_actions.append(InlineKeyboardButton(text="Сменить тариф", callback_data="tariff_change:list"))
+                tariff_actions.append(
+                    InlineKeyboardButton(text="Сменить тариф", callback_data="tariff_change:list")
+                )
             try:
                 tariff = settings.tariffs_config.require(local_sub.tariff_key)
                 topup_packages = settings.tariffs_config.topup_packages_for(tariff)
@@ -837,7 +1059,9 @@ async def my_subscription_command_handler(
             except Exception:
                 has_topup_packages = False
             if has_topup_packages:
-                tariff_actions.append(InlineKeyboardButton(text="Докупить трафик", callback_data="tariff_topup:list"))
+                tariff_actions.append(
+                    InlineKeyboardButton(text="Докупить трафик", callback_data="tariff_topup:list")
+                )
             if tariff_actions:
                 prepend_rows.append(tariff_actions)
 
@@ -853,7 +1077,9 @@ async def my_subscription_command_handler(
         except Exception:
             pass
         try:
-            await event.message.edit_text(text, reply_markup=markup, parse_mode="HTML", disable_web_page_preview=True)
+            await event.message.edit_text(
+                text, reply_markup=markup, parse_mode="HTML", disable_web_page_preview=True
+            )
         except Exception:
             await bot.send_message(
                 chat_id=target.chat.id,
@@ -863,7 +1089,9 @@ async def my_subscription_command_handler(
                 disable_web_page_preview=True,
             )
     else:
-        await target.answer(text, reply_markup=markup, parse_mode="HTML", disable_web_page_preview=True)
+        await target.answer(
+            text, reply_markup=markup, parse_mode="HTML", disable_web_page_preview=True
+        )
 
 
 @router.callback_query(F.data == "main_action:my_devices")
@@ -942,46 +1170,79 @@ async def my_devices_command_handler(
         devices_list = []
         current_devices = len(devices_list_raw)
         for index, device in enumerate(devices_list_raw, start=1):
-            device_model = device.get('deviceModel') or None
-            platform = device.get('platform') or None
-            user_agent = device.get('userAgent') or None
-            os_version = device.get('osVersion') or None
-            created_at = device.get('createdAt')
-            hwid = device.get('hwid')
+            device_model = device.get("deviceModel") or None
+            platform = device.get("platform") or None
+            user_agent = device.get("userAgent") or None
+            os_version = device.get("osVersion") or None
+            created_at = device.get("createdAt")
+            hwid = device.get("hwid")
             try:
-                created_at_str = datetime.fromisoformat(created_at).strftime("%d.%m.%Y %H:%M") if created_at else "-"
+                created_at_str = (
+                    datetime.fromisoformat(created_at).strftime("%d.%m.%Y %H:%M")
+                    if created_at
+                    else "-"
+                )
             except Exception:
                 created_at_str = str(created_at)
 
-            device_details = get_text("device_details", index=index, device_model=device_model, platform=platform, os_version=os_version, created_at_str=created_at_str, user_agent=user_agent, hwid=hwid)
+            device_details = get_text(
+                "device_details",
+                index=index,
+                device_model=device_model,
+                platform=platform,
+                os_version=os_version,
+                created_at_str=created_at_str,
+                user_agent=user_agent,
+                hwid=hwid,
+            )
             devices_list.append(device_details)
 
-        text = get_text("my_devices_details", devices="\n\n".join(devices_list), current_devices=current_devices, max_devices=max_devices_display)
+        text = get_text(
+            "my_devices_details",
+            devices="\n\n".join(devices_list),
+            current_devices=current_devices,
+            max_devices=max_devices_display,
+        )
 
-    base_markup = get_back_to_main_menu_markup(current_lang, i18n, callback_data="main_action:my_subscription")
+    base_markup = get_back_to_main_menu_markup(
+        current_lang, i18n, callback_data="main_action:my_subscription"
+    )
     kb = base_markup.inline_keyboard
 
     devices_kb = []
     if settings.tariffs_config and active.get("tariff_key") and max_devices_value != 0:
         try:
             tariff_for_devices = settings.tariffs_config.require(active["tariff_key"])
-            if tariff_for_devices.hwid_device_packages and tariff_for_devices.hwid_device_packages.rub:
-                devices_kb.append([
-                    InlineKeyboardButton(
-                        text=get_text("buy_hwid_devices_menu_button"),
-                        callback_data="hwid_devices:list",
-                    )
-                ])
+            if (
+                tariff_for_devices.hwid_device_packages
+                and tariff_for_devices.hwid_device_packages.rub
+            ):
+                devices_kb.append(
+                    [
+                        InlineKeyboardButton(
+                            text=get_text("buy_hwid_devices_menu_button"),
+                            callback_data="hwid_devices:list",
+                        )
+                    ]
+                )
         except Exception:
             pass
     for index, device in enumerate(devices_list_raw, start=1):
-        hwid = device.get('hwid')
+        hwid = device.get("hwid")
         if not hwid:
             continue
-        device_button_text = get_text("disconnect_device_button", hwid=_shorten_hwid_for_display(hwid), index=index)
+        device_button_text = get_text(
+            "disconnect_device_button", hwid=_shorten_hwid_for_display(hwid), index=index
+        )
         hwid_token = _hwid_callback_token(hwid)
 
-        devices_kb.append([InlineKeyboardButton(text=device_button_text, callback_data=f"disconnect_device:{hwid_token}")])
+        devices_kb.append(
+            [
+                InlineKeyboardButton(
+                    text=device_button_text, callback_data=f"disconnect_device:{hwid_token}"
+                )
+            ]
+        )
     kb = devices_kb + kb
     markup = InlineKeyboardMarkup(inline_keyboard=kb)
 
@@ -1028,7 +1289,9 @@ async def disconnect_device_handler(
             pass
         return
 
-    active = await subscription_service.get_active_subscription_details(session, callback.from_user.id)
+    active = await subscription_service.get_active_subscription_details(
+        session, callback.from_user.id
+    )
     if not active or not active.get("user_id"):
         await callback.answer(get_text("subscription_not_active"), show_alert=True)
         return
@@ -1064,7 +1327,9 @@ async def disconnect_device_handler(
         await callback.answer(get_text("device_disconnected"))
     except Exception:
         pass
-    await my_devices_command_handler(callback, i18n_data, settings, panel_service, subscription_service, session, bot)
+    await my_devices_command_handler(
+        callback, i18n_data, settings, panel_service, subscription_service, session, bot
+    )
 
 
 @router.callback_query(F.data.startswith("toggle_autorenew:"))
@@ -1101,7 +1366,9 @@ async def toggle_autorenew_handler(
         await callback.answer(get_text("error_try_again"), show_alert=True)
         return
     if enable:
-        has_saved_card = await user_billing_dal.user_has_saved_payment_method(session, callback.from_user.id)
+        has_saved_card = await user_billing_dal.user_has_saved_payment_method(
+            session, callback.from_user.id
+        )
         if not has_saved_card:
             try:
                 await callback.answer(get_text("autorenew_enable_requires_card"), show_alert=True)
@@ -1110,7 +1377,9 @@ async def toggle_autorenew_handler(
             return
 
     # Show confirmation popup and inline buttons
-    confirm_text = get_text("autorenew_confirm_enable") if enable else get_text("autorenew_confirm_disable")
+    confirm_text = (
+        get_text("autorenew_confirm_enable") if enable else get_text("autorenew_confirm_disable")
+    )
     kb = get_autorenew_confirm_keyboard(enable, sub.subscription_id, current_lang, i18n)
     try:
         await callback.message.edit_text(confirm_text, reply_markup=kb)
@@ -1159,25 +1428,33 @@ async def confirm_autorenew_handler(
         await callback.answer(get_text("error_try_again"), show_alert=True)
         return
     if enable:
-        has_saved_card = await user_billing_dal.user_has_saved_payment_method(session, callback.from_user.id)
+        has_saved_card = await user_billing_dal.user_has_saved_payment_method(
+            session, callback.from_user.id
+        )
         if not has_saved_card:
             try:
                 await callback.answer(get_text("autorenew_enable_requires_card"), show_alert=True)
             except Exception:
                 pass
             try:
-                await my_subscription_command_handler(callback, i18n_data, settings, panel_service, subscription_service, session, bot)
+                await my_subscription_command_handler(
+                    callback, i18n_data, settings, panel_service, subscription_service, session, bot
+                )
             except Exception:
                 pass
             return
 
-    await subscription_dal.update_subscription(session, sub.subscription_id, {"auto_renew_enabled": enable})
+    await subscription_dal.update_subscription(
+        session, sub.subscription_id, {"auto_renew_enabled": enable}
+    )
     await session.commit()
     try:
         await callback.answer(get_text("subscription_autorenew_updated"))
     except Exception:
         pass
-    await my_subscription_command_handler(callback, i18n_data, settings, panel_service, subscription_service, session, bot)
+    await my_subscription_command_handler(
+        callback, i18n_data, settings, panel_service, subscription_service, session, bot
+    )
 
 
 @router.callback_query(F.data == "autorenew:cancel")
@@ -1196,6 +1473,7 @@ async def autorenew_cancel_from_webhook_button(
 
     # Disable auto-renew on the active subscription
     from db.dal import subscription_dal
+
     sub = await subscription_dal.get_active_subscription_by_user_id(session, callback.from_user.id)
     if not sub:
         try:
@@ -1209,13 +1487,17 @@ async def autorenew_cancel_from_webhook_button(
         except Exception:
             pass
         return
-    await subscription_dal.update_subscription(session, sub.subscription_id, {"auto_renew_enabled": False})
+    await subscription_dal.update_subscription(
+        session, sub.subscription_id, {"auto_renew_enabled": False}
+    )
     await session.commit()
     try:
         await callback.answer(get_text("subscription_autorenew_updated"))
     except Exception:
         pass
-    await my_subscription_command_handler(callback, i18n_data, settings, panel_service, subscription_service, session, bot)
+    await my_subscription_command_handler(
+        callback, i18n_data, settings, panel_service, subscription_service, session, bot
+    )
 
 
 @router.message(Command("connect"))
@@ -1229,4 +1511,6 @@ async def connect_command_handler(
     bot: Bot,
 ):
     logging.info(f"User {message.from_user.id} used /connect command.")
-    await my_subscription_command_handler(message, i18n_data, settings, panel_service, subscription_service, session, bot)
+    await my_subscription_command_handler(
+        message, i18n_data, settings, panel_service, subscription_service, session, bot
+    )

bot/handlers/user/subscription/payment_methods.py

@@ -1,25 +1,28 @@
-from aiogram import Router, F, types
-from typing import Optional, List
+from typing import List, Optional
+
+from aiogram import F, Router, types
 from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.future import select
 
-from config.settings import Settings
 from bot.keyboards.inline.user_keyboards import (
-    get_payment_methods_list_keyboard,
+    get_bind_url_keyboard,
     get_payment_method_delete_confirm_keyboard,
     get_payment_method_details_keyboard,
-    get_bind_url_keyboard,
+    get_payment_methods_list_keyboard,
 )
-from bot.services.yookassa_service import YooKassaService
 from bot.middlewares.i18n import JsonI18n
+from bot.services.yookassa_service import YooKassaService
+from config.settings import Settings
 from db.dal import user_billing_dal
 from db.models import Payment
-from sqlalchemy.future import select
 
 router = Router(name="user_subscription_payment_methods_router")
 
 
 @router.callback_query(F.data == "pm:manage")
-async def payment_methods_manage(callback: types.CallbackQuery, settings: Settings, i18n_data: dict, session: AsyncSession):
+async def payment_methods_manage(
+    callback: types.CallbackQuery, settings: Settings, i18n_data: dict, session: AsyncSession
+):
     current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
     i18n: Optional[JsonI18n] = i18n_data.get("i18n_instance")
     if not settings.yookassa_autopayments_active:
@@ -32,6 +35,7 @@ async def payment_methods_manage(callback: types.CallbackQuery, settings: Settin
     _ = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs) if i18n else key
 
     from db.dal.user_billing_dal import list_user_payment_methods
+
     get_text = _
     methods = await list_user_payment_methods(session, callback.from_user.id)
     cards: List[tuple] = []
@@ -64,7 +68,9 @@ async def payment_methods_manage(callback: types.CallbackQuery, settings: Settin
     if not cards:
         text += "\n\n" + get_text("payment_method_none")
 
-    await callback.message.edit_text(text, reply_markup=get_payment_methods_list_keyboard(cards, 0, current_lang, i18n))
+    await callback.message.edit_text(
+        text, reply_markup=get_payment_methods_list_keyboard(cards, 0, current_lang, i18n)
+    )
     try:
         await callback.answer()
     except Exception:
@@ -72,7 +78,13 @@ async def payment_methods_manage(callback: types.CallbackQuery, settings: Settin
 
 
 @router.callback_query(F.data == "pm:bind")
-async def payment_method_bind(callback: types.CallbackQuery, settings: Settings, i18n_data: dict, session: AsyncSession, yookassa_service: YooKassaService):
+async def payment_method_bind(
+    callback: types.CallbackQuery,
+    settings: Settings,
+    i18n_data: dict,
+    session: AsyncSession,
+    yookassa_service: YooKassaService,
+):
     current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
     i18n: Optional[JsonI18n] = i18n_data.get("i18n_instance")
     if not settings.yookassa_autopayments_active:
@@ -98,7 +110,10 @@ async def payment_method_bind(callback: types.CallbackQuery, settings: Settings,
     if not resp or not resp.get("confirmation_url"):
         await callback.answer(_("error_payment_gateway"), show_alert=True)
         return
-    await callback.message.edit_text(_("payment_methods_title"), reply_markup=get_bind_url_keyboard(resp["confirmation_url"], current_lang, i18n))
+    await callback.message.edit_text(
+        _("payment_methods_title"),
+        reply_markup=get_bind_url_keyboard(resp["confirmation_url"], current_lang, i18n),
+    )
     try:
         await callback.answer()
     except Exception:
@@ -106,7 +121,9 @@ async def payment_method_bind(callback: types.CallbackQuery, settings: Settings,
 
 
 @router.callback_query(F.data.startswith("pm:delete_confirm"))
-async def payment_method_delete_confirm(callback: types.CallbackQuery, settings: Settings, i18n_data: dict):
+async def payment_method_delete_confirm(
+    callback: types.CallbackQuery, settings: Settings, i18n_data: dict
+):
     current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
     i18n: Optional[JsonI18n] = i18n_data.get("i18n_instance")
     if not settings.yookassa_autopayments_active:
@@ -119,7 +136,10 @@ async def payment_method_delete_confirm(callback: types.CallbackQuery, settings:
     _ = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs) if i18n else key
     parts = callback.data.split(":", 2)
     pm_id = parts[2] if len(parts) >= 3 else ""
-    await callback.message.edit_text(_("payment_method_delete_confirm"), reply_markup=get_payment_method_delete_confirm_keyboard(pm_id, current_lang, i18n))
+    await callback.message.edit_text(
+        _("payment_method_delete_confirm"),
+        reply_markup=get_payment_method_delete_confirm_keyboard(pm_id, current_lang, i18n),
+    )
     try:
         await callback.answer()
     except Exception:
@@ -127,7 +147,9 @@ async def payment_method_delete_confirm(callback: types.CallbackQuery, settings:
 
 
 @router.callback_query(F.data.startswith("pm:delete"))
-async def payment_method_delete(callback: types.CallbackQuery, settings: Settings, i18n_data: dict, session: AsyncSession):
+async def payment_method_delete(
+    callback: types.CallbackQuery, settings: Settings, i18n_data: dict, session: AsyncSession
+):
     current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
     i18n: Optional[JsonI18n] = i18n_data.get("i18n_instance")
     if not settings.yookassa_autopayments_active:
@@ -148,13 +170,20 @@ async def payment_method_delete(callback: types.CallbackQuery, settings: Setting
             delete_user_payment_method_by_provider_id,
             list_user_payment_methods,
         )
+
         if pm_id_raw:
             if pm_id_raw.isdigit():
-                deleted = await delete_user_payment_method(session, callback.from_user.id, int(pm_id_raw))
+                deleted = await delete_user_payment_method(
+                    session, callback.from_user.id, int(pm_id_raw)
+                )
             else:
-                deleted = await delete_user_payment_method_by_provider_id(session, callback.from_user.id, pm_id_raw)
+                deleted = await delete_user_payment_method_by_provider_id(
+                    session, callback.from_user.id, pm_id_raw
+                )
         try:
-            legacy_deleted = await user_billing_dal.delete_yk_payment_method(session, callback.from_user.id)
+            legacy_deleted = await user_billing_dal.delete_yk_payment_method(
+                session, callback.from_user.id
+            )
             deleted = deleted or legacy_deleted
         except Exception:
             pass
@@ -164,12 +193,15 @@ async def payment_method_delete(callback: types.CallbackQuery, settings: Setting
         text = _("payment_methods_title")
         cards = []
         for m in methods:
+
             def _is_yoomoney_network(network: Optional[str]) -> bool:
                 s = (network or "").lower()
                 return "yoomoney" in s or "yoo money" in s or "yoo-money" in s
+
             def _extract_last4(text: str) -> Optional[str]:
                 digits = "".join(ch for ch in text if ch.isdigit())
                 return digits[-4:] if len(digits) >= 4 else None
+
             def _format_pm_title(network: Optional[str], last4: Optional[str]) -> str:
                 if _is_yoomoney_network(network):
                     l4 = last4 or _extract_last4(network or "")
@@ -181,12 +213,16 @@ async def payment_method_delete(callback: types.CallbackQuery, settings: Setting
                     return _("payment_method_card_title", network=network_name, last4=last4)
                 network_name = network or _("payment_network_generic")
                 return _("payment_method_generic_title", network=network_name)
+
             title = _format_pm_title(m.card_network, m.card_last4)
             cards.append((str(m.method_id), title if not m.is_default else f"⭐ {title}"))
         if not cards:
             text += "\n\n" + _("payment_method_none")
         msg = _("payment_method_deleted_success") if deleted else _("error_try_again")
-        await callback.message.edit_text(f"{msg}\n\n{text}", reply_markup=get_payment_methods_list_keyboard(cards, 0, current_lang, i18n))
+        await callback.message.edit_text(
+            f"{msg}\n\n{text}",
+            reply_markup=get_payment_methods_list_keyboard(cards, 0, current_lang, i18n),
+        )
         try:
             await callback.answer()
         except Exception:
@@ -201,7 +237,9 @@ async def payment_method_delete(callback: types.CallbackQuery, settings: Setting
 
 
 @router.callback_query(F.data.startswith("pm:view"))
-async def payment_method_view(callback: types.CallbackQuery, settings: Settings, i18n_data: dict, session: AsyncSession):
+async def payment_method_view(
+    callback: types.CallbackQuery, settings: Settings, i18n_data: dict, session: AsyncSession
+):
     current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
     i18n: Optional[JsonI18n] = i18n_data.get("i18n_instance")
     if not settings.yookassa_autopayments_active:
@@ -216,13 +254,21 @@ async def payment_method_view(callback: types.CallbackQuery, settings: Settings,
     billing = await user_billing_dal.get_user_billing(session, callback.from_user.id)
     if not billing or not billing.yookassa_payment_method_id:
         from db.dal.user_billing_dal import list_user_payment_methods
+
         methods = await list_user_payment_methods(session, callback.from_user.id)
         if not methods:
             await callback.answer(_("payment_method_none"), show_alert=True)
             return
         parts = callback.data.split(":", 2)
         pm_id = parts[2] if len(parts) >= 3 else str(methods[0].method_id)
-        sel = next((m for m in methods if str(m.method_id) == pm_id or m.provider_payment_method_id == pm_id), methods[0])
+        sel = next(
+            (
+                m
+                for m in methods
+                if str(m.method_id) == pm_id or m.provider_payment_method_id == pm_id
+            ),
+            methods[0],
+        )
 
         def _is_yoomoney_network(network: Optional[str]) -> bool:
             s = (network or "").lower()
@@ -245,15 +291,15 @@ async def payment_method_view(callback: types.CallbackQuery, settings: Settings,
             return _("payment_method_generic_title", network=network_name)
 
         title = _format_pm_title(sel.card_network, sel.card_last4)
-        added_at = sel.created_at.strftime('%Y-%m-%d') if getattr(sel, 'created_at', None) else "—"
+        added_at = sel.created_at.strftime("%Y-%m-%d") if getattr(sel, "created_at", None) else "—"
         last_tx = "—"
         try:
             stmt = (
                 select(Payment)
                 .where(
                     Payment.user_id == callback.from_user.id,
-                    Payment.status == 'succeeded',
-                    Payment.provider == 'yookassa',
+                    Payment.status == "succeeded",
+                    Payment.provider == "yookassa",
                 )
                 .order_by(Payment.created_at.desc())
                 .limit(1)
@@ -261,26 +307,33 @@ async def payment_method_view(callback: types.CallbackQuery, settings: Settings,
             result = await session.execute(stmt)
             lp = result.scalar_one_or_none()
             if lp and lp.created_at:
-                last_tx = lp.created_at.strftime('%Y-%m-%d')
+                last_tx = lp.created_at.strftime("%Y-%m-%d")
         except Exception:
             pass
         details = f"{title}\n{_('payment_method_added_at', date=added_at)}\n{_('payment_method_last_tx', date=last_tx)}"
-        await callback.message.edit_text(details, reply_markup=get_payment_method_details_keyboard(str(sel.method_id), current_lang, i18n))
+        await callback.message.edit_text(
+            details,
+            reply_markup=get_payment_method_details_keyboard(
+                str(sel.method_id), current_lang, i18n
+            ),
+        )
         try:
             await callback.answer()
         except Exception:
             pass
         return
 
-    added_at = billing.created_at.strftime('%Y-%m-%d') if getattr(billing, 'created_at', None) else "—"
+    added_at = (
+        billing.created_at.strftime("%Y-%m-%d") if getattr(billing, "created_at", None) else "—"
+    )
     last_tx = "—"
     try:
         stmt = (
             select(Payment)
             .where(
                 Payment.user_id == callback.from_user.id,
-                Payment.status == 'succeeded',
-                Payment.provider == 'yookassa',
+                Payment.status == "succeeded",
+                Payment.provider == "yookassa",
             )
             .order_by(Payment.created_at.desc())
             .limit(1)
@@ -288,7 +341,7 @@ async def payment_method_view(callback: types.CallbackQuery, settings: Settings,
         result = await session.execute(stmt)
         last_payment = result.scalar_one_or_none()
         if last_payment and last_payment.created_at:
-            last_tx = last_payment.created_at.strftime('%Y-%m-%d')
+            last_tx = last_payment.created_at.strftime("%Y-%m-%d")
     except Exception:
         pass
 
@@ -314,7 +367,12 @@ async def payment_method_view(callback: types.CallbackQuery, settings: Settings,
 
     title = _format_pm_title(billing.card_network, billing.card_last4)
     details = f"{title}\n{_('payment_method_added_at', date=added_at)}\n{_('payment_method_last_tx', date=last_tx)}"
-    await callback.message.edit_text(details, reply_markup=get_payment_method_details_keyboard(billing.yookassa_payment_method_id, current_lang, i18n))
+    await callback.message.edit_text(
+        details,
+        reply_markup=get_payment_method_details_keyboard(
+            billing.yookassa_payment_method_id, current_lang, i18n
+        ),
+    )
     try:
         await callback.answer()
     except Exception:
@@ -322,7 +380,13 @@ async def payment_method_view(callback: types.CallbackQuery, settings: Settings,
 
 
 @router.callback_query(F.data.startswith("pm:history"))
-async def payment_method_history(callback: types.CallbackQuery, settings: Settings, i18n_data: dict, session: AsyncSession, yookassa_service: YooKassaService):
+async def payment_method_history(
+    callback: types.CallbackQuery,
+    settings: Settings,
+    i18n_data: dict,
+    session: AsyncSession,
+    yookassa_service: YooKassaService,
+):
     current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
     i18n: Optional[JsonI18n] = i18n_data.get("i18n_instance")
     if not settings.yookassa_autopayments_active:
@@ -335,6 +399,7 @@ async def payment_method_history(callback: types.CallbackQuery, settings: Settin
     _ = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs) if i18n else key
 
     from db.dal import payment_dal
+
     payments = await payment_dal.get_recent_payment_logs_with_user(session, limit=30, offset=0)
     user_payments = [p for p in payments if p.user_id == callback.from_user.id]
 
@@ -346,6 +411,7 @@ async def payment_method_history(callback: types.CallbackQuery, settings: Settin
             pm_filter_requested = True
             if split_pm_id.isdigit():
                 from db.dal.user_billing_dal import list_user_payment_methods
+
                 methods = await list_user_payment_methods(session, callback.from_user.id)
                 sel = next((m for m in methods if str(m.method_id) == split_pm_id), None)
                 if sel and sel.provider_payment_method_id:
@@ -362,7 +428,7 @@ async def payment_method_history(callback: types.CallbackQuery, settings: Settin
     if selected_pm_provider_id:
         filtered: List[Payment] = []
         for p in user_payments:
-            if p.provider != 'yookassa':
+            if p.provider != "yookassa":
                 continue
             if p.yookassa_payment_id and yookassa_service:
                 try:
@@ -376,7 +442,11 @@ async def payment_method_history(callback: types.CallbackQuery, settings: Settin
         user_payments = filtered
 
     if not user_payments:
-        from bot.keyboards.inline.user_keyboards import get_back_to_payment_method_details_keyboard, get_payment_methods_manage_keyboard
+        from bot.keyboards.inline.user_keyboards import (
+            get_back_to_payment_method_details_keyboard,
+            get_payment_methods_manage_keyboard,
+        )
+
         back_pm_id = ""
         try:
             split_a, split_b, back_pm_id = callback.data.split(":", 2)
@@ -395,11 +465,15 @@ async def payment_method_history(callback: types.CallbackQuery, settings: Settin
     def _format_item(p: Payment) -> str:
         if traffic_mode:
             units_val = p.subscription_duration_months or 0
-            units_display = str(int(units_val)) if float(units_val).is_integer() else f"{units_val:g}"
+            units_display = (
+                str(int(units_val)) if float(units_val).is_integer() else f"{units_val:g}"
+            )
             title = p.description or _("traffic_purchase_title", traffic_gb=units_display)
         else:
-            title = p.description or _("subscription_purchase_title", months=p.subscription_duration_months or 1)
-        date_str = p.created_at.strftime('%Y-%m-%d') if p.created_at else "N/A"
+            title = p.description or _(
+                "subscription_purchase_title", months=p.subscription_duration_months or 1
+            )
+        date_str = p.created_at.strftime("%Y-%m-%d") if p.created_at else "N/A"
         return f"{date_str} — {title} — {p.amount:.2f} {p.currency}"
 
     lines = [_format_item(p) for p in user_payments]
@@ -408,7 +482,11 @@ async def payment_method_history(callback: types.CallbackQuery, settings: Settin
         split_a, split_b, split_pm_id_for_back = callback.data.split(":", 2)
     except Exception:
         split_pm_id_for_back = ""
-    from bot.keyboards.inline.user_keyboards import get_back_to_payment_method_details_keyboard, get_payment_methods_manage_keyboard
+    from bot.keyboards.inline.user_keyboards import (
+        get_back_to_payment_method_details_keyboard,
+        get_payment_methods_manage_keyboard,
+    )
+
     back_markup = (
         get_back_to_payment_method_details_keyboard(split_pm_id_for_back, current_lang, i18n)
         if split_pm_id_for_back
@@ -418,21 +496,27 @@ async def payment_method_history(callback: types.CallbackQuery, settings: Settin
 
 
 @router.callback_query(F.data.startswith("pm:list:"))
-async def payment_methods_list(callback: types.CallbackQuery, settings: Settings, i18n_data: dict, session: AsyncSession):
+async def payment_methods_list(
+    callback: types.CallbackQuery, settings: Settings, i18n_data: dict, session: AsyncSession
+):
     current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
     i18n: Optional[JsonI18n] = i18n_data.get("i18n_instance")
     get_text = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs) if i18n else key
 
     from db.dal.user_billing_dal import list_user_payment_methods
+
     cards: List[tuple] = []
     methods = await list_user_payment_methods(session, callback.from_user.id)
     for m in methods:
+
         def _is_yoomoney_network(network: Optional[str]) -> bool:
             s = (network or "").lower()
             return "yoomoney" in s or "yoo money" in s or "yoo-money" in s
+
         def _extract_last4(text: str) -> Optional[str]:
             digits = "".join(ch for ch in text if ch.isdigit())
             return digits[-4:] if len(digits) >= 4 else None
+
         def _format_pm_title(network: Optional[str], last4: Optional[str]) -> str:
             if _is_yoomoney_network(network):
                 l4 = last4 or _extract_last4(network or "")
@@ -444,6 +528,7 @@ async def payment_methods_list(callback: types.CallbackQuery, settings: Settings
                 return get_text("payment_method_card_title", network=network_name, last4=last4)
             network_name = network or get_text("payment_network_generic")
             return get_text("payment_method_generic_title", network=network_name)
+
         title = _format_pm_title(m.card_network, m.card_last4)
         cards.append((str(m.method_id), title if not m.is_default else f"⭐ {title}"))
 
@@ -456,9 +541,10 @@ async def payment_methods_list(callback: types.CallbackQuery, settings: Settings
     text = get_text("payment_methods_title")
     if not cards:
         text += "\n\n" + get_text("payment_method_none")
-    await callback.message.edit_text(text, reply_markup=get_payment_methods_list_keyboard(cards, page, current_lang, i18n))
+    await callback.message.edit_text(
+        text, reply_markup=get_payment_methods_list_keyboard(cards, page, current_lang, i18n)
+    )
     try:
         await callback.answer()
     except Exception:
         pass
-

bot/handlers/user/subscription/payments_crypto.py

@@ -1,4 +1,4 @@
-from typing import Optional
+from typing import Optional
 
 from aiogram import F, Router, types
 from sqlalchemy.ext.asyncio import AsyncSession
@@ -21,7 +21,7 @@ async def pay_crypto_callback_handler(
 ):
     current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
     i18n: Optional[JsonI18n] = i18n_data.get("i18n_instance")
-    get_text = (lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs) if i18n else key)
+    get_text = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs) if i18n else key
 
     if not i18n or not callback.message:
         try:
@@ -30,7 +30,11 @@ async def pay_crypto_callback_handler(
             pass
         return
 
-    if not settings.CRYPTOPAY_ENABLED or not cryptopay_service or not getattr(cryptopay_service, "configured", False):
+    if (
+        not settings.CRYPTOPAY_ENABLED
+        or not cryptopay_service
+        or not getattr(cryptopay_service, "configured", False)
+    ):
         try:
             await callback.answer(get_text("payment_service_unavailable_alert"), show_alert=True)
         except Exception:
@@ -56,7 +60,11 @@ async def pay_crypto_callback_handler(
     payment_description = (
         get_text("payment_description_traffic", traffic_gb=human_value)
         if sale_base in {"traffic", "traffic_package", "topup", "premium_topup"}
-        else (get_text("payment_description_hwid_devices", count=int(months)) if sale_base in {"hwid_device", "hwid_devices"} else get_text("payment_description_subscription", months=int(months)))
+        else (
+            get_text("payment_description_hwid_devices", count=int(months))
+            if sale_base in {"hwid_device", "hwid_devices"}
+            else get_text("payment_description_subscription", months=int(months))
+        )
     )
 
     invoice_url = await cryptopay_service.create_invoice(
@@ -72,7 +80,9 @@ async def pay_crypto_callback_handler(
         try:
             await callback.message.edit_text(
                 get_text(
-                    key="payment_link_message_traffic" if sale_base in {"traffic", "traffic_package", "topup", "premium_topup"} else "payment_link_message",
+                    key="payment_link_message_traffic"
+                    if sale_base in {"traffic", "traffic_package", "topup", "premium_topup"}
+                    else "payment_link_message",
                     months=int(months),
                     traffic_gb=human_value,
                 ),
@@ -89,7 +99,9 @@ async def pay_crypto_callback_handler(
             try:
                 await callback.message.answer(
                     get_text(
-                        key="payment_link_message_traffic" if sale_base in {"traffic", "traffic_package", "topup", "premium_topup"} else "payment_link_message",
+                        key="payment_link_message_traffic"
+                        if sale_base in {"traffic", "traffic_package", "topup", "premium_topup"}
+                        else "payment_link_message",
                         months=int(months),
                         traffic_gb=human_value,
                     ),

bot/handlers/user/subscription/payments_freekassa.py

@@ -1,4 +1,4 @@
-import logging
+import logging
 from datetime import datetime
 from typing import Optional
 
@@ -65,9 +65,17 @@ async def pay_fk_callback_handler(
     payment_description = (
         get_text("payment_description_traffic", traffic_gb=human_value)
         if sale_base in {"traffic", "traffic_package", "topup", "premium_topup"}
-        else (get_text("payment_description_hwid_devices", count=int(months)) if sale_base in {"hwid_device", "hwid_devices"} else get_text("payment_description_subscription", months=int(months)))
+        else (
+            get_text("payment_description_hwid_devices", count=int(months))
+            if sale_base in {"hwid_device", "hwid_devices"}
+            else get_text("payment_description_subscription", months=int(months))
+        )
+    )
+    currency_code = (
+        getattr(freekassa_service, "default_currency", None)
+        or settings.DEFAULT_CURRENCY_SYMBOL
+        or "RUB"
     )
-    currency_code = getattr(freekassa_service, "default_currency", None) or settings.DEFAULT_CURRENCY_SYMBOL or "RUB"
 
     payment_record_payload = {
         "user_id": user_id,
@@ -79,8 +87,12 @@ async def pay_fk_callback_handler(
         "provider": "freekassa",
         "sale_mode": sale_mode,
         "tariff_key": sale_mode.split("@", 1)[1] if "@" in sale_mode else None,
-        "purchased_gb": float(months) if sale_base in {"traffic", "traffic_package", "topup", "premium_topup"} else None,
-        "purchased_hwid_devices": int(months) if sale_base in {"hwid_device", "hwid_devices"} else None,
+        "purchased_gb": float(months)
+        if sale_base in {"traffic", "traffic_package", "topup", "premium_topup"}
+        else None,
+        "purchased_hwid_devices": int(months)
+        if sale_base in {"hwid_device", "hwid_devices"}
+        else None,
     }
 
     try:
@@ -138,7 +150,9 @@ async def pay_fk_callback_handler(
                 )
 
         if location:
-            order_identifier_display = str(order_id_api or provider_identifier or payment_record.payment_id)
+            order_identifier_display = str(
+                order_id_api or provider_identifier or payment_record.payment_id
+            )
             order_info_text = get_text(
                 "free_kassa_order_info",
                 order_id=order_identifier_display,
@@ -146,8 +160,11 @@ async def pay_fk_callback_handler(
             )
             try:
                 await callback.message.edit_text(
-                    f"{order_info_text}\n\n" + get_text(
-                        key="payment_link_message_traffic" if sale_base in {"traffic", "traffic_package", "topup", "premium_topup"} else "payment_link_message",
+                    f"{order_info_text}\n\n"
+                    + get_text(
+                        key="payment_link_message_traffic"
+                        if sale_base in {"traffic", "traffic_package", "topup", "premium_topup"}
+                        else "payment_link_message",
                         months=int(months),
                         traffic_gb=human_value,
                     ),
@@ -161,11 +178,16 @@ async def pay_fk_callback_handler(
                     disable_web_page_preview=False,
                 )
             except Exception as e_edit:
-                logging.warning(f"FreeKassa: failed to display payment link ({e_edit}), sending new message.")
+                logging.warning(
+                    f"FreeKassa: failed to display payment link ({e_edit}), sending new message."
+                )
                 try:
                     await callback.message.answer(
-                        f"{order_info_text}\n\n" + get_text(
-                            key="payment_link_message_traffic" if sale_base in {"traffic", "traffic_package", "topup", "premium_topup"} else "payment_link_message",
+                        f"{order_info_text}\n\n"
+                        + get_text(
+                            key="payment_link_message_traffic"
+                            if sale_base in {"traffic", "traffic_package", "topup", "premium_topup"}
+                            else "payment_link_message",
                             months=int(months),
                             traffic_gb=human_value,
                         ),
@@ -207,7 +229,10 @@ async def pay_fk_callback_handler(
         await session.commit()
     except Exception as e_status:
         await session.rollback()
-        logging.error(f"FreeKassa: failed to mark payment {payment_record.payment_id} as failed_creation: {e_status}", exc_info=True)
+        logging.error(
+            f"FreeKassa: failed to mark payment {payment_record.payment_id} as failed_creation: {e_status}",
+            exc_info=True,
+        )
 
     try:
         await callback.message.edit_text(get_text("error_payment_gateway"))

bot/handlers/user/subscription/payments_platega.py

@@ -1,4 +1,4 @@
-import json
+import json
 import logging
 from typing import Optional
 
@@ -92,7 +92,11 @@ async def pay_platega_callback_handler(
     payment_description = (
         get_text("payment_description_traffic", traffic_gb=human_value)
         if sale_base in {"traffic", "traffic_package", "topup", "premium_topup"}
-        else (get_text("payment_description_hwid_devices", count=int(months)) if sale_base in {"hwid_device", "hwid_devices"} else get_text("payment_description_subscription", months=int(months)))
+        else (
+            get_text("payment_description_hwid_devices", count=int(months))
+            if sale_base in {"hwid_device", "hwid_devices"}
+            else get_text("payment_description_subscription", months=int(months))
+        )
     )
     currency_code = settings.DEFAULT_CURRENCY_SYMBOL or "RUB"
 
@@ -106,8 +110,12 @@ async def pay_platega_callback_handler(
         "provider": "platega",
         "sale_mode": sale_mode,
         "tariff_key": sale_mode.split("@", 1)[1] if "@" in sale_mode else None,
-        "purchased_gb": float(months) if sale_base in {"traffic", "traffic_package", "topup", "premium_topup"} else None,
-        "purchased_hwid_devices": int(months) if sale_base in {"hwid_device", "hwid_devices"} else None,
+        "purchased_gb": float(months)
+        if sale_base in {"traffic", "traffic_package", "topup", "premium_topup"}
+        else None,
+        "purchased_hwid_devices": int(months)
+        if sale_base in {"hwid_device", "hwid_devices"}
+        else None,
     }
 
     try:
@@ -178,7 +186,9 @@ async def pay_platega_callback_handler(
             try:
                 await callback.message.edit_text(
                     get_text(
-                        key="payment_link_message_traffic" if sale_base in {"traffic", "traffic_package", "topup", "premium_topup"} else "payment_link_message",
+                        key="payment_link_message_traffic"
+                        if sale_base in {"traffic", "traffic_package", "topup", "premium_topup"}
+                        else "payment_link_message",
                         months=int(months),
                         traffic_gb=human_value,
                     ),
@@ -192,11 +202,15 @@ async def pay_platega_callback_handler(
                     disable_web_page_preview=False,
                 )
             except Exception as e_edit:
-                logging.warning(f"Platega: failed to display payment link ({e_edit}), sending new message.")
+                logging.warning(
+                    f"Platega: failed to display payment link ({e_edit}), sending new message."
+                )
                 try:
                     await callback.message.answer(
                         get_text(
-                            key="payment_link_message_traffic" if sale_base in {"traffic", "traffic_package", "topup", "premium_topup"} else "payment_link_message",
+                            key="payment_link_message_traffic"
+                            if sale_base in {"traffic", "traffic_package", "topup", "premium_topup"}
+                            else "payment_link_message",
                             months=int(months),
                             traffic_gb=human_value,
                         ),
@@ -232,7 +246,10 @@ async def pay_platega_callback_handler(
         await session.commit()
     except Exception as e_status:
         await session.rollback()
-        logging.error(f"Platega: failed to mark payment {payment_record.payment_id} as failed_creation: {e_status}", exc_info=True)
+        logging.error(
+            f"Platega: failed to mark payment {payment_record.payment_id} as failed_creation: {e_status}",
+            exc_info=True,
+        )
 
     try:
         await callback.message.edit_text(get_text("error_payment_gateway"))

bot/handlers/user/subscription/payments_severpay.py

@@ -1,4 +1,4 @@
-import logging
+import logging
 from typing import Optional
 
 from aiogram import F, Router, types
@@ -64,7 +64,11 @@ async def pay_severpay_callback_handler(
     payment_description = (
         get_text("payment_description_traffic", traffic_gb=human_value)
         if sale_base in {"traffic", "traffic_package", "topup", "premium_topup"}
-        else (get_text("payment_description_hwid_devices", count=int(months)) if sale_base in {"hwid_device", "hwid_devices"} else get_text("payment_description_subscription", months=int(months)))
+        else (
+            get_text("payment_description_hwid_devices", count=int(months))
+            if sale_base in {"hwid_device", "hwid_devices"}
+            else get_text("payment_description_subscription", months=int(months))
+        )
     )
     currency_code = settings.DEFAULT_CURRENCY_SYMBOL or "RUB"
 
@@ -78,8 +82,12 @@ async def pay_severpay_callback_handler(
         "provider": "severpay",
         "sale_mode": sale_mode,
         "tariff_key": sale_mode.split("@", 1)[1] if "@" in sale_mode else None,
-        "purchased_gb": float(months) if sale_base in {"traffic", "traffic_package", "topup", "premium_topup"} else None,
-        "purchased_hwid_devices": int(months) if sale_base in {"hwid_device", "hwid_devices"} else None,
+        "purchased_gb": float(months)
+        if sale_base in {"traffic", "traffic_package", "topup", "premium_topup"}
+        else None,
+        "purchased_hwid_devices": int(months)
+        if sale_base in {"hwid_device", "hwid_devices"}
+        else None,
     }
 
     try:
@@ -138,7 +146,9 @@ async def pay_severpay_callback_handler(
             try:
                 await callback.message.edit_text(
                     get_text(
-                        key="payment_link_message_traffic" if sale_base in {"traffic", "traffic_package", "topup", "premium_topup"} else "payment_link_message",
+                        key="payment_link_message_traffic"
+                        if sale_base in {"traffic", "traffic_package", "topup", "premium_topup"}
+                        else "payment_link_message",
                         months=int(months),
                         traffic_gb=human_value,
                     ),
@@ -152,11 +162,15 @@ async def pay_severpay_callback_handler(
                     disable_web_page_preview=False,
                 )
             except Exception as e_edit:
-                logging.warning(f"SeverPay: failed to display payment link ({e_edit}), sending new message.")
+                logging.warning(
+                    f"SeverPay: failed to display payment link ({e_edit}), sending new message."
+                )
                 try:
                     await callback.message.answer(
                         get_text(
-                            key="payment_link_message_traffic" if sale_base in {"traffic", "traffic_package", "topup", "premium_topup"} else "payment_link_message",
+                            key="payment_link_message_traffic"
+                            if sale_base in {"traffic", "traffic_package", "topup", "premium_topup"}
+                            else "payment_link_message",
                             months=int(months),
                             traffic_gb=human_value,
                         ),
@@ -192,7 +206,10 @@ async def pay_severpay_callback_handler(
         await session.commit()
     except Exception as e_status:
         await session.rollback()
-        logging.error(f"SeverPay: failed to mark payment {payment_record.payment_id} as failed_creation: {e_status}", exc_info=True)
+        logging.error(
+            f"SeverPay: failed to mark payment {payment_record.payment_id} as failed_creation: {e_status}",
+            exc_info=True,
+        )
 
     try:
         await callback.message.edit_text(get_text("error_payment_gateway"))

bot/handlers/user/subscription/payments_stars.py

@@ -1,4 +1,4 @@
-import logging
+import logging
 from typing import Optional
 
 from aiogram import F, Router, types
@@ -22,7 +22,7 @@ async def pay_stars_callback_handler(
 ):
     current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
     i18n: Optional[JsonI18n] = i18n_data.get("i18n_instance")
-    get_text = (lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs) if i18n else key)
+    get_text = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs) if i18n else key
 
     if not i18n or not callback.message:
         try:
@@ -57,7 +57,11 @@ async def pay_stars_callback_handler(
     payment_description = (
         get_text("payment_description_traffic", traffic_gb=human_value)
         if sale_base in {"traffic", "traffic_package", "topup", "premium_topup"}
-        else (get_text("payment_description_hwid_devices", count=int(months)) if sale_base in {"hwid_device", "hwid_devices"} else get_text("payment_description_subscription", months=int(months)))
+        else (
+            get_text("payment_description_hwid_devices", count=int(months))
+            if sale_base in {"hwid_device", "hwid_devices"}
+            else get_text("payment_description_subscription", months=int(months))
+        )
     )
 
     payment_db_id = await stars_service.create_invoice(
@@ -73,16 +77,22 @@ async def pay_stars_callback_handler(
         try:
             await callback.message.edit_text(
                 get_text(
-                    "payment_invoice_sent_message_traffic" if sale_base in {"traffic", "traffic_package", "topup", "premium_topup"} else "payment_invoice_sent_message",
+                    "payment_invoice_sent_message_traffic"
+                    if sale_base in {"traffic", "traffic_package", "topup", "premium_topup"}
+                    else "payment_invoice_sent_message",
                     months=int(months),
                     traffic_gb=human_value,
                 ),
-                reply_markup=InlineKeyboardMarkup(inline_keyboard=[
-                    [InlineKeyboardButton(
-                        text=get_text("back_to_payment_methods_button"),
-                        callback_data=f"subscribe_period:{human_value}",
-                    )]
-                ]),
+                reply_markup=InlineKeyboardMarkup(
+                    inline_keyboard=[
+                        [
+                            InlineKeyboardButton(
+                                text=get_text("back_to_payment_methods_button"),
+                                callback_data=f"subscribe_period:{human_value}",
+                            )
+                        ]
+                    ]
+                ),
             )
         except Exception as e_edit:
             logging.warning(f"Stars payment: failed to show invoice info message ({e_edit})")
@@ -115,8 +125,9 @@ async def handle_successful_stars_payment(
     session: AsyncSession,
     stars_service: StarsService,
 ):
-    payload = (message.successful_payment.invoice_payload
-               if message and message.successful_payment else "")
+    payload = (
+        message.successful_payment.invoice_payload if message and message.successful_payment else ""
+    )
     try:
         parts = (payload or "").split(":")
         payment_db_id = int(parts[0])

bot/handlers/user/subscription/payments_subscription.py

@@ -43,7 +43,9 @@ async def select_subscription_period_callback_handler(
         return
 
     price_source = traffic_packages if traffic_mode else settings.subscription_options
-    stars_price_source = stars_traffic_packages if traffic_mode else settings.stars_subscription_options
+    stars_price_source = (
+        stars_traffic_packages if traffic_mode else settings.stars_subscription_options
+    )
 
     price_rub = price_source.get(months)
     stars_price = stars_price_source.get(months)
@@ -82,7 +84,11 @@ async def select_subscription_period_callback_handler(
                 pass
             return
 
-    text_content = get_text("choose_payment_method_traffic") if traffic_mode else get_text("choose_payment_method")
+    text_content = (
+        get_text("choose_payment_method_traffic")
+        if traffic_mode
+        else get_text("choose_payment_method")
+    )
     reply_markup = get_payment_method_keyboard(
         months,
         price_rub,

bot/handlers/user/subscription/payments_yookassa.py

@@ -1,4 +1,4 @@
-import logging
+import logging
 from typing import List, Optional, Tuple
 
 from aiogram import F, Router, types
@@ -37,7 +37,9 @@ def _sale_mode_base(sale_mode: str) -> str:
     return (sale_mode or "subscription").split("@", 1)[0].split("|", 1)[0]
 
 
-def _format_saved_payment_method_title(get_text, network: Optional[str], last4: Optional[str], is_default: bool) -> str:
+def _format_saved_payment_method_title(
+    get_text, network: Optional[str], last4: Optional[str], is_default: bool
+) -> str:
     def _is_yoomoney_network(name: Optional[str]) -> bool:
         s = (name or "").lower()
         return "yoomoney" in s or "yoo money" in s or "yoo-money" in s
@@ -85,7 +87,11 @@ async def _initiate_yk_payment(
     payment_description = (
         get_text("payment_description_traffic", traffic_gb=_format_value(months))
         if sale_base in {"traffic", "traffic_package", "topup", "premium_topup"}
-        else (get_text("payment_description_hwid_devices", count=int(months)) if sale_base in {"hwid_device", "hwid_devices"} else get_text("payment_description_subscription", months=int(months)))
+        else (
+            get_text("payment_description_hwid_devices", count=int(months))
+            if sale_base in {"hwid_device", "hwid_devices"}
+            else get_text("payment_description_subscription", months=int(months))
+        )
     )
     payment_record_data = {
         "user_id": user_id,
@@ -96,8 +102,12 @@ async def _initiate_yk_payment(
         "subscription_duration_months": int(months) if sale_base == "subscription" else None,
         "sale_mode": sale_base,
         "tariff_key": sale_mode.split("@", 1)[1] if "@" in sale_mode else None,
-        "purchased_gb": float(months) if sale_base in {"traffic", "traffic_package", "topup", "premium_topup"} else None,
-        "purchased_hwid_devices": int(months) if sale_base in {"hwid_device", "hwid_devices"} else None,
+        "purchased_gb": float(months)
+        if sale_base in {"traffic", "traffic_package", "topup", "premium_topup"}
+        else None,
+        "purchased_hwid_devices": int(months)
+        if sale_base in {"hwid_device", "hwid_devices"}
+        else None,
     }
 
     db_payment_record = None
@@ -157,7 +167,11 @@ async def _initiate_yk_payment(
                 title = pm.get("title")
                 card = pm.get("card") or {}
                 account_number = pm.get("account_number") or pm.get("account")
-                if isinstance(card, dict) and (pm_type or "").lower() in {"bank_card", "bank-card", "card"}:
+                if isinstance(card, dict) and (pm_type or "").lower() in {
+                    "bank_card",
+                    "bank-card",
+                    "card",
+                }:
                     display_network = card.get("card_type") or title or "Card"
                     display_last4 = card.get("last4")
                 elif (pm_type or "").lower() in {"yoo_money", "yoomoney", "yoo-money", "wallet"}:
@@ -206,7 +220,9 @@ async def _initiate_yk_payment(
                         session, user_id, selected_method_internal_id
                     )
                 except Exception:
-                    logging.exception("Failed to set default payment method after initiating payment")
+                    logging.exception(
+                        "Failed to set default payment method after initiating payment"
+                    )
             await session.commit()
         except Exception as e_db_update_ykid:
             await session.rollback()
@@ -223,7 +239,9 @@ async def _initiate_yk_payment(
         try:
             await callback.message.edit_text(
                 get_text(
-                    key="payment_link_message_traffic" if sale_base in {"traffic", "traffic_package", "topup", "premium_topup"} else "payment_link_message",
+                    key="payment_link_message_traffic"
+                    if sale_base in {"traffic", "traffic_package", "topup", "premium_topup"}
+                    else "payment_link_message",
                     months=int(months),
                     traffic_gb=_format_value(months),
                 ),
@@ -237,13 +255,13 @@ async def _initiate_yk_payment(
                 disable_web_page_preview=False,
             )
         except Exception as e_edit:
-            logging.warning(
-                f"Edit message for payment link failed: {e_edit}. Sending new one."
-            )
+            logging.warning(f"Edit message for payment link failed: {e_edit}. Sending new one.")
             try:
                 await callback.message.answer(
                     get_text(
-                        key="payment_link_message_traffic" if sale_base in {"traffic", "traffic_package", "topup", "premium_topup"} else "payment_link_message",
+                        key="payment_link_message_traffic"
+                        if sale_base in {"traffic", "traffic_package", "topup", "premium_topup"}
+                        else "payment_link_message",
                         months=int(months),
                         traffic_gb=_format_value(months),
                     ),
@@ -275,7 +293,9 @@ async def _initiate_yk_payment(
                         session, user_id, selected_method_internal_id
                     )
                 except Exception:
-                    logging.exception("Failed to set default payment method after saved-card payment start")
+                    logging.exception(
+                        "Failed to set default payment method after saved-card payment start"
+                    )
             await session.commit()
         except Exception as e_db_update_saved:
             await session.rollback()
@@ -328,7 +348,13 @@ async def _initiate_yk_payment(
 
 
 @router.callback_query(F.data.startswith("pay_yk:"))
-async def pay_yk_callback_handler(callback: types.CallbackQuery, settings: Settings, i18n_data: dict, yookassa_service: YooKassaService, session: AsyncSession):
+async def pay_yk_callback_handler(
+    callback: types.CallbackQuery,
+    settings: Settings,
+    i18n_data: dict,
+    yookassa_service: YooKassaService,
+    session: AsyncSession,
+):
     current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
     i18n: Optional[JsonI18n] = i18n_data.get("i18n_instance")
     get_text = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs) if i18n else key
@@ -372,9 +398,13 @@ async def pay_yk_callback_handler(callback: types.CallbackQuery, settings: Setti
     months, price_rub, sale_mode = parsed
     user_id = callback.from_user.id
     currency_code_for_yk = "RUB"
-    autopay_enabled = bool(settings.yookassa_autopayments_active and _sale_mode_base(sale_mode) == "subscription" and not settings.traffic_sale_mode)
+    autopay_enabled = bool(
+        settings.yookassa_autopayments_active
+        and _sale_mode_base(sale_mode) == "subscription"
+        and not settings.traffic_sale_mode
+    )
     autopay_require_binding = bool(
-        getattr(settings, 'YOOKASSA_AUTOPAYMENTS_REQUIRE_CARD_BINDING', True)
+        getattr(settings, "YOOKASSA_AUTOPAYMENTS_REQUIRE_CARD_BINDING", True)
     )
     saved_methods: List = []
     if autopay_enabled:
@@ -444,7 +474,13 @@ async def pay_yk_callback_handler(callback: types.CallbackQuery, settings: Setti
 
 
 @router.callback_query(F.data.startswith("pay_yk_new:"))
-async def pay_yk_new_card_handler(callback: types.CallbackQuery, settings: Settings, i18n_data: dict, yookassa_service: YooKassaService, session: AsyncSession):
+async def pay_yk_new_card_handler(
+    callback: types.CallbackQuery,
+    settings: Settings,
+    i18n_data: dict,
+    yookassa_service: YooKassaService,
+    session: AsyncSession,
+):
     current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
     i18n: Optional[JsonI18n] = i18n_data.get("i18n_instance")
     get_text = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs) if i18n else key
@@ -490,9 +526,13 @@ async def pay_yk_new_card_handler(callback: types.CallbackQuery, settings: Setti
     months, price_rub, sale_mode = parsed
     user_id = callback.from_user.id
     currency_code_for_yk = "RUB"
-    autopay_enabled = bool(settings.yookassa_autopayments_active and _sale_mode_base(sale_mode) == "subscription" and not settings.traffic_sale_mode)
+    autopay_enabled = bool(
+        settings.yookassa_autopayments_active
+        and _sale_mode_base(sale_mode) == "subscription"
+        and not settings.traffic_sale_mode
+    )
     autopay_require_binding = bool(
-        getattr(settings, 'YOOKASSA_AUTOPAYMENTS_REQUIRE_CARD_BINDING', True)
+        getattr(settings, "YOOKASSA_AUTOPAYMENTS_REQUIRE_CARD_BINDING", True)
     )
 
     await _initiate_yk_payment(
@@ -518,7 +558,13 @@ async def pay_yk_new_card_handler(callback: types.CallbackQuery, settings: Setti
 
 
 @router.callback_query(F.data.startswith("pay_yk_saved_list:"))
-async def pay_yk_saved_list_handler(callback: types.CallbackQuery, settings: Settings, i18n_data: dict, yookassa_service: YooKassaService, session: AsyncSession):
+async def pay_yk_saved_list_handler(
+    callback: types.CallbackQuery,
+    settings: Settings,
+    i18n_data: dict,
+    yookassa_service: YooKassaService,
+    session: AsyncSession,
+):
     current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
     i18n: Optional[JsonI18n] = i18n_data.get("i18n_instance")
     get_text = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs) if i18n else key
@@ -562,7 +608,11 @@ async def pay_yk_saved_list_handler(callback: types.CallbackQuery, settings: Set
             pass
         return
 
-    autopay_enabled = bool(settings.yookassa_autopayments_active and _sale_mode_base(sale_mode) == "subscription" and not settings.traffic_sale_mode)
+    autopay_enabled = bool(
+        settings.yookassa_autopayments_active
+        and _sale_mode_base(sale_mode) == "subscription"
+        and not settings.traffic_sale_mode
+    )
     if not autopay_enabled:
         try:
             await callback.answer(get_text("error_try_again"), show_alert=True)
@@ -662,7 +712,13 @@ async def pay_yk_saved_list_handler(callback: types.CallbackQuery, settings: Set
 
 
 @router.callback_query(F.data.startswith("pay_yk_use_saved:"))
-async def pay_yk_use_saved_handler(callback: types.CallbackQuery, settings: Settings, i18n_data: dict, yookassa_service: YooKassaService, session: AsyncSession):
+async def pay_yk_use_saved_handler(
+    callback: types.CallbackQuery,
+    settings: Settings,
+    i18n_data: dict,
+    yookassa_service: YooKassaService,
+    session: AsyncSession,
+):
     current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
     i18n: Optional[JsonI18n] = i18n_data.get("i18n_instance")
     get_text = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs) if i18n else key
@@ -717,7 +773,11 @@ async def pay_yk_use_saved_handler(callback: types.CallbackQuery, settings: Sett
             pass
         return
 
-    autopay_enabled = bool(settings.yookassa_autopayments_active and _sale_mode_base(sale_mode) == "subscription" and not settings.traffic_sale_mode)
+    autopay_enabled = bool(
+        settings.yookassa_autopayments_active
+        and _sale_mode_base(sale_mode) == "subscription"
+        and not settings.traffic_sale_mode
+    )
     if not autopay_enabled:
         try:
             await callback.answer(get_text("error_try_again"), show_alert=True)
@@ -747,7 +807,9 @@ async def pay_yk_use_saved_handler(callback: types.CallbackQuery, settings: Sett
             break
 
     if not selected_method:
-        logging.warning(f"Selected payment method not found for user {user_id}: {method_identifier}")
+        logging.warning(
+            f"Selected payment method not found for user {user_id}: {method_identifier}"
+        )
         try:
             await callback.answer(get_text("error_try_again"), show_alert=True)
         except Exception: