Merge pull request 'develop' (#4) from Alex/stcs:develop into stable

Reviewed-on: #4
2025-09-12 09:28:08 +07:00
parent 15e248d7d7 07666fa984
commit 688fc7a8ab
15 changed files with 798 additions and 472 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -9,3 +9,5 @@ venv/
 .venv/
 .idea
 /.idea
+/myenv
+myenv
--- a/BybitBot_API.py
+++ b/BybitBot_API.py
@@ -1,7 +1,7 @@
 import asyncio
 import logging.config
 from aiogram import Bot, Dispatcher
-
+from aiogram.fsm.storage.redis import RedisStorage
 from app.services.Bybit.functions.bybit_ws import get_or_create_event_loop, set_event_loop
 from app.telegram.database.models import async_main
 from app.telegram.handlers.handlers import router
@@ -17,8 +17,9 @@ from config import TOKEN_TG_BOT_1
 logging.config.dictConfig(LOGGING_CONFIG)
 logger = logging.getLogger("main")

+storage = RedisStorage.from_url("redis://localhost:6379/0")
 bot = Bot(token=TOKEN_TG_BOT_1)
-dp = Dispatcher()
+dp = Dispatcher(storage=storage)


 async def main() -> None:
@@ -37,7 +38,10 @@ async def main() -> None:
    dp.include_router(router_register_bybit_api)
    dp.include_router(router_functions_bybit_trade)

+    try:
        await dp.start_polling(bot)
+    except asyncio.CancelledError:
+        logger.info("Bot is off")


 if __name__ == '__main__':
--- a/app/services/Bybit/functions/Add_Bybit_API.py
+++ b/app/services/Bybit/functions/Add_Bybit_API.py
@@ -1,9 +1,16 @@
 from aiogram import F, Router
 import logging.config
+
+from app.services.Bybit.functions.functions import start_bybit_trade_message
 from logger_helper.logger_helper import LOGGING_CONFIG
 import app.telegram.Keyboards.inline_keyboards as inline_markup
 import app.telegram.Keyboards.reply_keyboards as reply_markup

+import app.telegram.functions.main_settings.settings as func_main_settings
+import app.telegram.functions.risk_management_settings.settings as func_rmanagement_settings
+import app.telegram.functions.condition_settings.settings as func_condition_settings
+import app.telegram.functions.additional_settings.settings as func_additional_settings
+
 import app.telegram.database.requests as rq
 from aiogram.types import Message, CallbackQuery

@@ -81,12 +88,24 @@ async def add_secret_key(message: Message, state: FSMContext) -> None:
    await state.update_data(secret_key=message.text)

    data = await state.get_data()
+    user = await rq.check_user(message.from_user.id)

-    await rq.update_api_key(message.from_user.id, data['api_key'])
-    await rq.update_secret_key(message.from_user.id, data['secret_key'])
+    await rq.upsert_api_keys(message.from_user.id, data['api_key'], data['secret_key'])
    await rq.set_new_user_symbol(message.from_user.id)

    await state.clear()

-    await message.answer('Данные добавлены, нажмите на профиль и начните торговлю!',
+    await message.answer('Данные добавлены.',
                         reply_markup=reply_markup.base_buttons_markup)
+
+    if user:
+        await start_bybit_trade_message(message)
+    else:
+        await rq.save_tg_id_new_user(message.from_user.id)
+
+        await func_main_settings.reg_new_user_default_main_settings(message.from_user.id, message)
+        await func_rmanagement_settings.reg_new_user_default_risk_management_settings(message.from_user.id,
+                                                                                      message)
+        await func_condition_settings.reg_new_user_default_condition_settings(message.from_user.id)
+        await func_additional_settings.reg_new_user_default_additional_settings(message.from_user.id, message)
+        await start_bybit_trade_message(message)
--- a/app/services/Bybit/functions/Futures.py
+++ b/app/services/Bybit/functions/Futures.py
--- a/app/services/Bybit/functions/balance.py
+++ b/app/services/Bybit/functions/balance.py
@@ -32,7 +32,7 @@ async def get_balance(tg_id: int, message) -> float:
        api_secret=secret_key
    )

-    if api_key == 'None' or secret_key == 'None':
+    if api_key is None or secret_key is None:
        await message.answer('⚠️ Подключите платформу для торговли',
                             reply_markup=inline_markup.connect_bybit_api_message)
        return 0
@@ -48,5 +48,5 @@ async def get_balance(tg_id: int, message) -> float:
            return 0
    except Exception as e:
        logger.error(f"Ошибка при получении общего баланса: {e}")
-        await message.answer('⚠️ Ошибка при получении баланса')
+        await message.answer('Ошибка при подключении, повторите попытку', reply_markup=inline_markup.connect_bybit_api_message)
        return 0
--- a/app/services/Bybit/functions/bybit_ws.py
+++ b/app/services/Bybit/functions/bybit_ws.py
@@ -1,5 +1,6 @@
 import asyncio
 import logging.config
+
 from pybit.unified_trading import WebSocket
 from websocket import WebSocketConnectionClosedException
 from logger_helper.logger_helper import LOGGING_CONFIG
@@ -11,6 +12,30 @@ logger = logging.getLogger("bybit_ws")
 event_loop = None  # Сюда нужно будет установить event loop из основного приложения
 active_ws_tasks = {}

+
+def on_ws_error(ws, error):
+    logger.error(f"WebSocket internal error: {error}")
+    # Запланировать переподключение через event loop
+    if event_loop:
+        asyncio.run_coroutine_threadsafe(reconnect_ws(ws), event_loop)
+
+
+def on_ws_close(ws, close_status_code, close_msg):
+    logger.warning(f"WebSocket closed: {close_status_code} - {close_msg}")
+    # Запланировать переподключение через event loop
+    if event_loop:
+        asyncio.run_coroutine_threadsafe(reconnect_ws(ws), event_loop)
+
+
+async def reconnect_ws(ws):
+    logger.info("Запускаем переподключение WebSocket...")
+    await asyncio.sleep(5)
+    try:
+        await ws.run_forever()
+    except WebSocketConnectionClosedException:
+        logger.info("WebSocket переподключение успешно завершено.")
+
+
 def get_or_create_event_loop() -> asyncio.AbstractEventLoop:
    """
    Возвращает текущий активный цикл событий asyncio или создает новый, если его нет.
@@ -46,6 +71,7 @@ def on_order_callback(message, msg):
    if event_loop is not None:
        from app.services.Bybit.functions.Futures import handle_order_message
        asyncio.run_coroutine_threadsafe(handle_order_message(message, msg), event_loop)
+        logger.info("Callback выполнен.")
    else:
        logger.error("Event loop не установлен, callback пропущен.")

@@ -54,6 +80,7 @@ def on_execution_callback(message, ws_msg):
    if event_loop is not None:
        from app.services.Bybit.functions.Futures import handle_execution_message
        asyncio.run_coroutine_threadsafe(handle_execution_message(message, ws_msg), event_loop)
+        logger.info("Callback выполнен.")
    else:
        logger.error("Event loop не установлен, callback пропущен.")

@@ -72,8 +99,12 @@ async def start_execution_ws(api_key: str, api_secret: str, message):
                continue
            ws = WebSocket(api_key=api_key, api_secret=api_secret, testnet=False, channel_type="private")

+            ws.on_error = on_ws_error
+            ws.on_close = on_ws_close
+
            ws.subscribe("order", lambda ws_msg: on_order_callback(message, ws_msg))
            ws.subscribe("execution", lambda ws_msg: on_execution_callback(message, ws_msg))
+
            while True:
                await asyncio.sleep(1)  # Поддержание активности
        except WebSocketConnectionClosedException:
--- a/app/services/Bybit/functions/functions.py
+++ b/app/services/Bybit/functions/functions.py
@@ -2,13 +2,14 @@
 import logging.config
 from aiogram import F, Router

+from app.services.Bybit.functions.bybit_ws import run_ws_for_user
 from app.telegram.functions.main_settings.settings import main_settings_message
 from logger_helper.logger_helper import LOGGING_CONFIG

 from app.services.Bybit.functions.Futures import (close_user_trade, set_take_profit_stop_loss, \
                                                  get_active_positions_by_symbol, get_active_orders_by_symbol,
                                                  get_active_positions, get_active_orders, cancel_all_tp_sl_orders,
-                                                  trading_cycle, open_position, close_trade_after_delay, safe_float,
+                                                  open_position, close_trade_after_delay, safe_float,
                                                  )
 from app.services.Bybit.functions.balance import get_balance
 import app.telegram.Keyboards.inline_keyboards as inline_markup
@@ -28,6 +29,8 @@ logger = logging.getLogger("functions")

 router_functions_bybit_trade = Router()

+user_trade_tasks = {}
+

@router_functions_bybit_trade.callback_query(F.data.in_(['clb_start_trading', 'clb_back_to_main', 'back_to_main']))
 async def clb_start_bybit_trade_message(callback: CallbackQuery) -> None:
@@ -61,8 +64,10 @@ async def start_bybit_trade_message(message: Message) -> None:
    вместе с инструкциями по началу торговли.
    """
    balance = await get_balance(message.from_user.id, message)
+    tg_id = message.from_user.id

    if balance:
+        await run_ws_for_user(tg_id, message)
        symbol = await rq.get_symbol(message.from_user.id)
        price = await get_price(message.from_user.id, symbol=symbol)

@@ -86,6 +91,7 @@ async def update_symbol_for_trade_message(callback: CallbackQuery, state: FSMCon
    Начинает процедуру обновления торговой пары, переводит пользователя в состояние ожидания пары.
    """
    await state.set_state(state_update_symbol.symbol)
+    await callback.answer()

    await callback.message.answer(
        text='Укажите торговую пару заглавными буквами без пробелов и лишних символов (пример: BTCUSDT): ',
@@ -99,7 +105,6 @@ async def update_symbol_for_trade(message: Message, state: FSMContext) -> None:
    При успешном обновлении сохранит пару и отправит обновлённую информацию.
    """
    user_input = message.text.strip().upper()
-
    exists = await get_valid_symbols(message.from_user.id, user_input)

    if not exists:
@@ -187,20 +192,25 @@ async def start_trading_process(callback: CallbackQuery) -> None:
    Проверяет API-ключи, режим торговли, маржинальный режим и открытые позиции,
    затем запускает торговый цикл с задержкой или без неё.
    """
+    await callback.answer()
    tg_id = callback.from_user.id
    message = callback.message
-
    data_main_stgs = await rq.get_user_main_settings(tg_id)
    symbol = await rq.get_symbol(tg_id)
    margin_mode = data_main_stgs.get('margin_type', 'Isolated')
    trading_mode = data_main_stgs.get('trading_mode')
-    switch_mode = data_main_stgs.get('switch_mode_enabled')
    starting_quantity = safe_float(data_main_stgs.get('starting_quantity'))
+    switch_state = data_main_stgs.get("switch_state", "По направлению")

-    side = None
-    if switch_mode == 'Включено':
-        switch_state = data_main_stgs.get('switch_state', 'Long')
-        side = 'Buy' if switch_state == 'Long' else 'Sell'
+    if trading_mode == 'Switch':
+        if switch_state == "По направлению":
+            side = data_main_stgs.get("last_side")
+        else:
+            side = data_main_stgs.get("last_side")
+            if side.lower() == "buy":
+                side = "Sell"
+            else:
+                side = "Buy"
    else:
        if trading_mode == 'Long':
            side = 'Buy'
@@ -209,7 +219,6 @@ async def start_trading_process(callback: CallbackQuery) -> None:
        else:
            await message.answer(f"Режим торговли '{trading_mode}' пока не поддерживается.",
                                 reply_markup=inline_markup.back_to_main)
-            await callback.answer()
            return

    await message.answer("Начинаю торговлю с использованием текущих настроек...")
@@ -221,14 +230,39 @@ async def start_trading_process(callback: CallbackQuery) -> None:
        timer_minute = timer_data or 0

    if timer_minute > 0:
-        await trading_cycle(tg_id, message, side=side, margin_mode=margin_mode, symbol=symbol,
-                            starting_quantity=starting_quantity)
-        await message.answer(f"Торговля начнётся через {timer_minute} мин.")
+        await message.answer(f"Торговля начнётся через {timer_minute} мин.", reply_markup=inline_markup.cancel_start)
+
+        async def delay_start():
+            try:
+                await asyncio.sleep(timer_minute * 60)
+                await open_position(tg_id, message, side, margin_mode, symbol=symbol, quantity=starting_quantity)
                await rq.update_user_timer(tg_id, minutes=0)
+            except asyncio.exceptions.CancelledError:
+                logger.exception(f"Торговый цикл для пользователя {tg_id} был отменён.")
+                raise
+
+        task = asyncio.create_task(delay_start())
+        user_trade_tasks[tg_id] = task
    else:
        await open_position(tg_id, message, side, margin_mode, symbol=symbol, quantity=starting_quantity)

-    await callback.answer()
+
+@router_functions_bybit_trade.callback_query(F.data == "clb_cancel_start")
+async def cancel_start_trading(callback: CallbackQuery):
+    tg_id = callback.from_user.id
+    task = user_trade_tasks.get(tg_id)
+    if task and not task.done():
+        task.cancel()
+        try:
+            await task
+        except asyncio.CancelledError:
+            pass
+        user_trade_tasks.pop(tg_id, None)
+        await rq.update_user_timer(tg_id, minutes=0)
+        await callback.message.answer("Запуск торговли отменён.", reply_markup=inline_markup.back_to_main)
+        await callback.message.edit_reply_markup(reply_markup=None)
+    else:
+        await callback.answer("Нет запланированной задачи запуска.", show_alert=True)


@router_functions_bybit_trade.callback_query(F.data == "clb_my_deals")
@@ -437,7 +471,8 @@ async def process_close_delay(message: Message, state: FSMContext) -> None:
    symbol = data.get("symbol")

    delay = delay_minutes * 60
-    await message.answer(f"Закрытие сделки {symbol} запланировано через {delay_minutes} мин.")
+    await message.answer(f"Закрытие сделки {symbol} запланировано через {delay_minutes} мин.",
+                         reply_markup=inline_markup.back_to_main)
    await close_trade_after_delay(message.from_user.id, message, symbol, delay)
    await state.clear()

@@ -448,7 +483,7 @@ async def reset_martingale(callback: CallbackQuery) -> None:
    Сбрасывает шаги мартингейла пользователя.
    """
    tg_id = callback.from_user.id
-    await rq.update_martingale_step(tg_id, 0)
+    await rq.update_martingale_step(tg_id, 1)
    await callback.answer("Сброс шагов выполнен.")
    await main_settings_message(tg_id, callback.message)

@@ -479,11 +514,11 @@ async def stop_immediately(callback: CallbackQuery):
@router_functions_bybit_trade.callback_query(F.data == "stop_with_timer")
 async def stop_with_timer_start(callback: CallbackQuery, state: FSMContext):
    """
-    Запускает диалог с пользователем для задания задержки перед остановкой торговли.
+    Запускает диалог с пользователем для задания задержки до остановки торговли.
    """

    await state.set_state(CloseTradeTimerState.waiting_for_trade)
-    await callback.message.answer("Введите задержку в минутах перед остановкой торговли:",
+    await callback.message.answer("Введите задержку в минутах до остановки торговли:",
                                  reply_markup=inline_markup.cancel)
    await callback.answer()

@@ -505,7 +540,8 @@ async def process_stop_delay(message: Message, state: FSMContext):
    tg_id = message.from_user.id
    delay_seconds = delay_minutes * 60

-    await message.answer(f"Торговля будет остановлена через {delay_minutes} минут.")
+    await message.answer(f"Торговля будет остановлена через {delay_minutes} минут.",
+                         reply_markup=inline_markup.back_to_main)
    await asyncio.sleep(delay_seconds)
    await rq.update_trigger(tg_id, "Ручной")
    await message.answer("Автоматическая торговля остановлена.", reply_markup=inline_markup.back_to_main)
--- a/app/telegram/Keyboards/inline_keyboards.py
+++ b/app/telegram/Keyboards/inline_keyboards.py
@@ -9,6 +9,10 @@ settings_markup = InlineKeyboardMarkup(inline_keyboard=[
    [InlineKeyboardButton(text="Запуск", callback_data='clb_start_trading')]
 ])

+cancel_start = InlineKeyboardMarkup(inline_keyboard=[
+    [InlineKeyboardButton(text="Отменить запуск", callback_data="clb_cancel_start")]
+])
+
 back_btn_list_settings = [InlineKeyboardButton(text="Назад",
                                               callback_data='clb_back_to_special_settings_message')]  # Кнопка для возврата к списку каталога настроек
 back_btn_list_settings_markup = InlineKeyboardMarkup(inline_keyboard=[[InlineKeyboardButton(text="Назад",
@@ -25,8 +29,8 @@ special_settings_markup = InlineKeyboardMarkup(inline_keyboard=[
    [InlineKeyboardButton(text="Основные настройки", callback_data='clb_change_main_settings'),
     InlineKeyboardButton(text="Риск-менеджмент", callback_data='clb_change_risk_management_settings')],

-    [InlineKeyboardButton(text="Условия запуска", callback_data='clb_change_condition_settings'),
-     InlineKeyboardButton(text="Дополнительные параметры", callback_data='clb_change_additional_settings')],
+    [InlineKeyboardButton(text="Условия запуска", callback_data='clb_change_condition_settings')],
+     # InlineKeyboardButton(text="Дополнительные параметры", callback_data='clb_change_additional_settings')],
    [InlineKeyboardButton(text="Подключить Bybit", callback_data='clb_new_user_connect_bybit_api_message')],
    back_btn_to_main
 ])
@@ -46,10 +50,8 @@ trading_markup = InlineKeyboardMarkup(inline_keyboard=[
 ])

 start_trading_markup = InlineKeyboardMarkup(inline_keyboard=[
-    [InlineKeyboardButton(text="На главную", callback_data='back_to_main')],
    [InlineKeyboardButton(text="Начать торговлю", callback_data="clb_start_chatbot_trading")],
-    [InlineKeyboardButton(text="Установить таймер", callback_data="clb_set_timer")],
-
+    [InlineKeyboardButton(text="На главную", callback_data='back_to_main')],
 ])

 cancel = InlineKeyboardMarkup(inline_keyboard=[
@@ -73,7 +75,7 @@ back_to_main = InlineKeyboardMarkup(inline_keyboard=[

 main_settings_markup = InlineKeyboardMarkup(inline_keyboard=[
    [InlineKeyboardButton(text='Режим торговли', callback_data='clb_change_trading_mode'),
-     InlineKeyboardButton(text='Режим свитч', callback_data='clb_change_switch_mode'),
+     InlineKeyboardButton(text='Состояние свитча', callback_data='clb_change_switch_state'),
     InlineKeyboardButton(text='Тип маржи', callback_data='clb_change_margin_type')],

    [InlineKeyboardButton(text='Размер кредитного плеча', callback_data='clb_change_size_leverage'),
@@ -101,14 +103,14 @@ risk_management_settings_markup = InlineKeyboardMarkup(inline_keyboard=[
 condition_settings_markup = InlineKeyboardMarkup(inline_keyboard=[
    [InlineKeyboardButton(text='Режим торговли', callback_data='clb_change_mode'),
     InlineKeyboardButton(text='Таймер', callback_data='clb_change_timer')],
-
-    [InlineKeyboardButton(text='Фильтр волатильности', callback_data='clb_change_filter_volatility'),
-     InlineKeyboardButton(text='Внешние сигналы', callback_data='clb_change_external_cues')],
-
-    [InlineKeyboardButton(text='Сигналы TradingView', callback_data='clb_change_tradingview_cues'),
-     InlineKeyboardButton(text='Webhook URL', callback_data='clb_change_webhook')],
-
-    [InlineKeyboardButton(text='AI - аналитика', callback_data='clb_change_ai_analytics')],
+    #
+    # [InlineKeyboardButton(text='Фильтр волатильности', callback_data='clb_change_filter_volatility'),
+    #  InlineKeyboardButton(text='Внешние сигналы', callback_data='clb_change_external_cues')],
+    #
+    # [InlineKeyboardButton(text='Сигналы TradingView', callback_data='clb_change_tradingview_cues'),
+    #  InlineKeyboardButton(text='Webhook URL', callback_data='clb_change_webhook')],
+    #
+    # [InlineKeyboardButton(text='AI - аналитика', callback_data='clb_change_ai_analytics')],

    back_btn_list_settings,
    back_btn_to_main
@@ -127,7 +129,8 @@ additional_settings_markup = InlineKeyboardMarkup(inline_keyboard=[
 trading_mode_markup = InlineKeyboardMarkup(inline_keyboard=[
    [InlineKeyboardButton(text="Лонг", callback_data="trade_mode_long"),
     InlineKeyboardButton(text="Шорт", callback_data="trade_mode_short"),
-     InlineKeyboardButton(text="Смарт", callback_data="trade_mode_smart")],
+     InlineKeyboardButton(text="Свитч", callback_data="trade_mode_switch")],
+     # InlineKeyboardButton(text="Смарт", callback_data="trade_mode_smart")],

    back_btn_list_settings,
    back_btn_to_main
@@ -137,8 +140,7 @@ margin_type_markup = InlineKeyboardMarkup(inline_keyboard=[
    [InlineKeyboardButton(text="Изолированный", callback_data="margin_type_isolated"),
     InlineKeyboardButton(text="Кросс", callback_data="margin_type_cross")],

-    back_btn_list_settings,
-    back_btn_to_main
+    back_btn_list_settings
 ])

 trigger_markup = InlineKeyboardMarkup(inline_keyboard=[  # ИЗМЕНИТЬ НА INLINE
@@ -196,6 +198,7 @@ def create_close_limit_markup(symbol: str) -> InlineKeyboardMarkup:

 timer_markup = InlineKeyboardMarkup(inline_keyboard=[
    [InlineKeyboardButton(text="Установить таймер", callback_data="clb_set_timer")],
+    [InlineKeyboardButton(text="Удалить таймер", callback_data="clb_delete_timer")],
    back_btn_to_main
 ])

@@ -208,14 +211,7 @@ stop_choice_markup = InlineKeyboardMarkup(
    ]
 )

-buttons_on_off_markup_for_switch = InlineKeyboardMarkup(inline_keyboard=[  # ИЗМЕНИТЬ НА INLINE
-    [InlineKeyboardButton(text='Включить', callback_data="clb_on_switch"),
-     InlineKeyboardButton(text='Выключить', callback_data="clb_off_switch")],
-    [InlineKeyboardButton(text="Изменить состояние", callback_data="clb_switch_state")],
-    back_btn_to_main
-])
-
 switch_state_markup = InlineKeyboardMarkup(inline_keyboard=[
-    [InlineKeyboardButton(text='Long', callback_data="clb_long_switch"),
-     InlineKeyboardButton(text='Short', callback_data="clb_short_switch")],
+    [InlineKeyboardButton(text='По направлению', callback_data="clb_long_switch"),
+     InlineKeyboardButton(text='Против направления', callback_data="clb_short_switch")],
 ])
--- a/app/telegram/database/models.py
+++ b/app/telegram/database/models.py
@@ -54,10 +54,10 @@ class User_Bybit_API(Base):

    id: Mapped[int] = mapped_column(primary_key=True)

-    tg_id = mapped_column(ForeignKey("user_telegram_id.tg_id"))
+    tg_id = mapped_column(ForeignKey("user_telegram_id.tg_id"), unique=True, nullable=True)

-    api_key = mapped_column(String(18), default='None')
-    secret_key = mapped_column(String(36), default='None')
+    api_key = mapped_column(String(18), unique=True, nullable=True)
+    secret_key = mapped_column(String(36), unique=True, nullable=True)


 class User_Symbol(Base):
@@ -65,25 +65,12 @@ class User_Symbol(Base):
    Модель таблицы user_main_settings.

    Хранит основные настройки торговли для пользователя.
-
-    Атрибуты:
-        id (int): Внутренний первичный ключ записи.
-        tg_id (int): Внешний ключ на Telegram пользователя.
-        trading_mode (str): Режим торговли (ForeignKey на trading_modes.mode).
-        margin_type (str): Тип маржи (ForeignKey на margin_types.type).
-        size_leverage (int): Кредитное плечо.
-        starting_quantity (int): Начальный объём позиции.
-        martingale_factor (int): Коэффициент мартингейла.
-        martingale_step (int): Текущий шаг мартингейла.
-        maximal_quantity (int): Максимальное количество шагов мартингейла.
-        entry_order_type (str): Тип входа (Market или Limit).
-        limit_order_price (str, optional): Цена лимитного ордера, если используется.
    """
    __tablename__ = 'user_symbols'

    id: Mapped[int] = mapped_column(primary_key=True)

-    tg_id = mapped_column(ForeignKey("user_telegram_id.tg_id"))
+    tg_id = mapped_column(ForeignKey("user_telegram_id.tg_id"), unique=True, nullable=True)

    symbol = mapped_column(String(18), default='PENGUUSDT')

@@ -94,7 +81,7 @@ class Trading_Mode(Base):

    Атрибуты:
        id (int): Первичный ключ.
-        mode (str): Уникальный режим (например, 'Long', 'Short').
+        mode (str): Уникальный режим (например, 'Long', 'Short', 'Switch).
    """
    __tablename__ = 'trading_modes'

@@ -123,7 +110,7 @@ class Trigger(Base):
    Справочник триггеров для сделок.

    Атрибуты:
-        id (int): Первичный ключ..
+        id (int): Первичный ключ.
    """
    __tablename__ = 'triggers'

@@ -148,24 +135,25 @@ class User_Main_Settings(Base):
        maximal_quantity (int): Максимальное число шагов мартингейла.
        entry_order_type (str): Тип ордера входа (Market/Limit).
        limit_order_price (Optional[str]): Цена лимитного ордера, если есть.
+        last_side (str): Последняя сторона ордера.
    """
    __tablename__ = 'user_main_settings'

    id: Mapped[int] = mapped_column(primary_key=True)

-    tg_id = mapped_column(ForeignKey("user_telegram_id.tg_id"))
+    tg_id = mapped_column(ForeignKey("user_telegram_id.tg_id"), unique=True, nullable=True)

    trading_mode = mapped_column(ForeignKey("trading_modes.mode"))
    margin_type = mapped_column(ForeignKey("margin_types.type"))
-    switch_mode_enabled = mapped_column(String(15), default="Выключен")
-    switch_state = mapped_column(String(10), default='Long')
+    switch_state = mapped_column(String(10), default='По направлению')
    size_leverage = mapped_column(Integer(), default=1)
    starting_quantity = mapped_column(Integer(), default=1)
    martingale_factor = mapped_column(Integer(), default=1)
-    martingale_step = mapped_column(Integer(), default=0)
+    martingale_step = mapped_column(Integer(), default=1)
    maximal_quantity = mapped_column(Integer(), default=10)
    entry_order_type = mapped_column(String(10), default='Market')
    limit_order_price = mapped_column(Numeric(18, 15), nullable=True)
+    last_side = mapped_column(String(10), default='Buy')


 class User_Risk_Management_Settings(Base):
@@ -184,7 +172,7 @@ class User_Risk_Management_Settings(Base):

    id: Mapped[int] = mapped_column(primary_key=True)

-    tg_id = mapped_column(ForeignKey("user_telegram_id.tg_id"))
+    tg_id = mapped_column(ForeignKey("user_telegram_id.tg_id"), unique=True, nullable=True)

    price_profit = mapped_column(Integer(), default=1)
    price_loss = mapped_column(Integer(), default=1)
@@ -211,9 +199,9 @@ class User_Condition_Settings(Base):

    id: Mapped[int] = mapped_column(primary_key=True)

-    tg_id = mapped_column(ForeignKey("user_telegram_id.tg_id"))
+    tg_id = mapped_column(ForeignKey("user_telegram_id.tg_id"), unique=True, nullable=True)

-    trigger = mapped_column(String(15), default='Ручной')
+    trigger = mapped_column(String(15), default='Автоматический')
    filter_time = mapped_column(String(25), default='???')
    filter_volatility = mapped_column(Boolean, default=False)
    external_cues = mapped_column(Boolean, default=False)
@@ -237,7 +225,7 @@ class User_Additional_Settings(Base):

    id: Mapped[int] = mapped_column(primary_key=True)

-    tg_id = mapped_column(ForeignKey("user_telegram_id.tg_id"))
+    tg_id = mapped_column(ForeignKey("user_telegram_id.tg_id"), unique=True, nullable=True)

    pattern_save = mapped_column(Boolean, default=False)
    autostart = mapped_column(Boolean, default=False)
@@ -260,7 +248,7 @@ class USER_DEALS(Base):

    id: Mapped[int] = mapped_column(primary_key=True)

-    tg_id = mapped_column(ForeignKey("user_telegram_id.tg_id"))
+    tg_id = mapped_column(ForeignKey("user_telegram_id.tg_id"), unique=True, nullable=True)

    symbol = mapped_column(String(18), default='PENGUUSDT')
    side = mapped_column(String(10), nullable=False)
@@ -282,7 +270,7 @@ class UserTimer(Base):
    __tablename__ = 'user_timers'

    id: Mapped[int] = mapped_column(primary_key=True)
-    tg_id = mapped_column(ForeignKey("user_telegram_id.tg_id"))
+    tg_id = mapped_column(ForeignKey("user_telegram_id.tg_id"), unique=True, nullable=True)
    timer_minutes = mapped_column(Integer, nullable=False, default=0)
    timer_start = mapped_column(DateTime, default=datetime.utcnow)
    timer_end = mapped_column(DateTime, nullable=True)
@@ -296,7 +284,7 @@ async def async_main():
        await conn.run_sync(Base.metadata.create_all)

        # Заполнение таблиц
-        modes = ['Long', 'Short', 'Smart']
+        modes = ['Long', 'Short', 'Switch', 'Smart']
        for mode in modes:
            result = await conn.execute(select(Trading_Mode).where(Trading_Mode.mode == mode))
            if not result.first():
@@ -309,3 +297,10 @@ async def async_main():
            if not result.first():
                logger.info("Заполение таблицы типов маржи")
                await conn.execute(Margin_type.__table__.insert().values(type=type))
+
+        last_side = ['Buy', 'Sell']
+        for side in last_side:
+            result = await conn.execute(select(User_Main_Settings).where(User_Main_Settings.last_side == side))
+            if not result.first():
+                logger.info("Заполение таблицы последнего направления")
+                await conn.execute(User_Main_Settings.__table__.insert().values(last_side=side))
--- a/app/telegram/database/requests.py
+++ b/app/telegram/database/requests.py
@@ -239,17 +239,21 @@ async def update_symbol(tg_id: int, symbol: str) -> None:
        await session.commit()


-async def update_api_key(tg_id: int, api: str) -> None:
+async def upsert_api_keys(tg_id: int, api_key: str, secret_key: str) -> None:
    """Обновить API ключ пользователя."""
    async with async_session() as session:
-        await session.execute(update(UBA).where(UBA.tg_id == tg_id).values(api_key=api))
-        await session.commit()
-
-
-async def update_secret_key(tg_id: int, api: str) -> None:
-    """Обновить секретный ключ пользователя."""
-    async with async_session() as session:
-        await session.execute(update(UBA).where(UBA.tg_id == tg_id).values(secret_key=api))
+        result = await session.execute(select(UBA).where(UBA.tg_id == tg_id))
+        user = result.scalars().first()
+        if user:
+            if api_key is not None:
+                user.api_key = api_key
+            if secret_key is not None:
+                user.secret_key = secret_key
+            logger.info(f"Обновлены ключи для пользователя {tg_id}")
+        else:
+            new_user = UBA(tg_id=tg_id, api_key=api_key, secret_key=secret_key)
+            session.add(new_user)
+            logger.info(f"Добавлен новый пользователь {tg_id} с ключами")
        await session.commit()


@@ -303,36 +307,20 @@ async def get_user_main_settings(tg_id):
    """Получить основные настройки пользователя."""
    async with async_session() as session:
        user = await session.scalar(select(UMS).where(UMS.tg_id == tg_id))
-
        if user:
-            logger.info("Получение основных настроек пользователя %s", tg_id)
-
-            trading_mode = await session.scalar(select(UMS.trading_mode).where(UMS.tg_id == tg_id))
-            margin_mode = await session.scalar(select(UMS.margin_type).where(UMS.tg_id == tg_id))
-            switch_mode_enabled = await session.scalar(select(UMS.switch_mode_enabled).where(UMS.tg_id == tg_id))
-            switch_state = await session.scalar(select(UMS.switch_state).where(UMS.tg_id == tg_id))
-            size_leverage = await session.scalar(select(UMS.size_leverage).where(UMS.tg_id == tg_id))
-            starting_quantity = await session.scalar(select(UMS.starting_quantity).where(UMS.tg_id == tg_id))
-            martingale_factor = await session.scalar(select(UMS.martingale_factor).where(UMS.tg_id == tg_id))
-            maximal_quantity = await session.scalar(select(UMS.maximal_quantity).where(UMS.tg_id == tg_id))
-            entry_order_type = await session.scalar(select(UMS.entry_order_type).where(UMS.tg_id == tg_id))
-            limit_order_price = await session.scalar(select(UMS.limit_order_price).where(UMS.tg_id == tg_id))
-            martingale_step = await session.scalar(select(UMS.martingale_step).where(UMS.tg_id == tg_id))
-
            data = {
-                'trading_mode': trading_mode,
-                'margin_type': margin_mode,
-                'switch_mode_enabled': switch_mode_enabled,
-                'switch_state': switch_state,
-                'size_leverage': size_leverage,
-                'starting_quantity': starting_quantity,
-                'martingale_factor': martingale_factor,
-                'maximal_quantity': maximal_quantity,
-                'entry_order_type': entry_order_type,
-                'limit_order_price': limit_order_price,
-                'martingale_step': martingale_step,
+                'trading_mode': user.trading_mode,
+                'margin_type': user.margin_type,
+                'switch_state': user.switch_state,
+                'size_leverage': user.size_leverage,
+                'starting_quantity': user.starting_quantity,
+                'martingale_factor': user.martingale_factor,
+                'maximal_quantity': user.maximal_quantity,
+                'entry_order_type': user.entry_order_type,
+                'limit_order_price': user.limit_order_price,
+                'martingale_step': user.martingale_step,
+                'last_side': user.last_side,
            }
-
            return data


@@ -576,3 +564,22 @@ async def update_trigger(tg_id, trigger):
        await session.execute(update(UCS).where(UCS.tg_id == tg_id).values(trigger=trigger))

        await session.commit()
+
+
+async def set_last_series_info(tg_id: int, last_side: str):
+    async with async_session() as session:
+        async with session.begin():
+            # Обновляем запись
+            result = await session.execute(
+                update(UMS)
+                .where(UMS.tg_id == tg_id)
+                .values(last_side=last_side)
+            )
+            if result.rowcount == 0:
+                # Если запись не существует, создаём новую
+                new_entry = UMS(
+                    tg_id=tg_id,
+                    last_side=last_side,
+                )
+                session.add(new_entry)
+        await session.commit()
--- a/app/telegram/functions/condition_settings/settings.py
+++ b/app/telegram/functions/condition_settings/settings.py
@@ -29,12 +29,7 @@ async def main_settings_message(id, message):
    text = f""" <b>Условия запуска</b>

 <b>- Режим торговли:</b>  {trigger}
-<b>- Таймер: </b> установить таймер / остановить таймер  
-<b>- Фильтр волатильности / объёма: </b> включить/отключить  
-<b>- Интеграции и внешние сигналы: </b>
-<b>- Использовать сигналы TradingView:</b> да / нет
-<b>- Использовать AI-аналитику от ChatGPT:</b> да / не
-<b>- Webhook URL для сигналов (если используется TradingView): </b>
+<b>- Таймер: </b> установить таймер / удалить таймер
 """
    await message.answer(text=text, parse_mode='html', reply_markup=inline_markup.condition_settings_markup)

@@ -42,7 +37,7 @@ async def main_settings_message(id, message):
 async def trigger_message(id, message, state: FSMContext):
    await state.set_state(condition_settings.trigger)
    text = '''
-<b>- Автоматический:</b> торговля будет продолжаться до условии остановки.
+<b>- Автоматический:</b> торговля будет происходить в рамках серии ставок.
 <b>- Ручной:</b> торговля будет происходить только в ручном режиме.
 <em>- Выберите тип триггера:</em>'''

@@ -73,7 +68,7 @@ async def timer_message(id, message: Message, state: FSMContext):
        return

    await message.answer(
-        f"Таймер: {timer_info['timer_minutes']} мин\n",
+        f"Таймер установлен на: {timer_info['timer_minutes']} мин\n",
        reply_markup=inline_markup.timer_markup
    )

@@ -81,7 +76,7 @@ async def timer_message(id, message: Message, state: FSMContext):
@condition_settings_router.callback_query(F.data == "clb_set_timer")
 async def set_timer_callback(callback: CallbackQuery, state: FSMContext):
    await state.set_state(condition_settings.timer)  # состояние для ввода времени
-    await callback.message.answer("Введите время работы в минутах (например, 60):")
+    await callback.message.answer("Введите время работы в минутах (например, 60):", reply_markup=inline_markup.cancel)
    await callback.answer()


@@ -94,14 +89,21 @@ async def process_timer_input(message: Message, state: FSMContext):
            return

        await rq.update_user_timer(message.from_user.id, minutes)
-        await message.answer(f"Таймер установлен на {minutes} минут.\nНажмите кнопку 'Начать торговлю' для запуска.",
-                             reply_markup=inline_markup.start_trading_markup)
-
+        logger.info("Timer set for user %s: %s minutes", message.from_user.id, minutes)
+        await timer_message(message.from_user.id, message, state)
        await state.clear()
    except ValueError:
        await message.reply("Пожалуйста, введите корректное число.")


+@condition_settings_router.callback_query(F.data == "clb_delete_timer")
+async def delete_timer_callback(callback: CallbackQuery, state: FSMContext):
+    await state.clear()
+    await rq.update_user_timer(callback.from_user.id, 0)
+    logger.info("Timer deleted for user %s", callback.from_user.id)
+    await timer_message(callback.from_user.id, callback.message, state)
+    await callback.answer()
+

 async def filter_volatility_message(message, state):
    text = '''Фильтр волатильности
--- a/app/telegram/functions/main_settings/settings.py
+++ b/app/telegram/functions/main_settings/settings.py
@@ -5,6 +5,9 @@ import app.telegram.Keyboards.inline_keyboards as inline_markup
 from pybit.unified_trading import HTTP
 import app.telegram.database.requests as rq
 from aiogram.types import Message, CallbackQuery
+
+from app.services.Bybit.functions.price_symbol import get_price
+from app.services.Bybit.functions.Futures import safe_float, calculate_total_budget, get_bybit_client
 from app.states.States import update_main_settings
 from logger_helper.logger_helper import LOGGING_CONFIG

@@ -24,20 +27,54 @@ async def reg_new_user_default_main_settings(id, message):


 async def main_settings_message(id, message):
+    try:
        data = await rq.get_user_main_settings(id)
+        tg_id = id
+
+        data_main_stgs = await rq.get_user_main_settings(id)
+        data_risk_stgs = await rq.get_user_risk_management_settings(id)
+        client = await get_bybit_client(tg_id)
+        symbol = await rq.get_symbol(tg_id)
+        max_martingale_steps = (data_main_stgs or {}).get('maximal_quantity', 0)
+        commission_fee = (data_risk_stgs or {}).get('commission_fee')
+        starting_quantity = safe_float((data_main_stgs or {}).get('starting_quantity'))
+        martingale_factor = safe_float((data_main_stgs or {}).get('martingale_factor'))
+        fee_info = client.get_fee_rates(category='linear', symbol=symbol)
+        leverage = safe_float((data_main_stgs or {}).get('size_leverage'))
+        price = await get_price(tg_id, symbol=symbol)
+        entry_price = safe_float(price)
+
+        if commission_fee == "Да":
+            commission_fee_percent = safe_float(fee_info['result']['list'][0]['takerFeeRate'])
+        else:
+            commission_fee_percent = 0.0
+
+        total_budget = await calculate_total_budget(
+            starting_quantity=starting_quantity,
+            martingale_factor=martingale_factor,
+            max_steps=max_martingale_steps,
+            commission_fee_percent=commission_fee_percent,
+            leverage=leverage,
+            current_price=entry_price,
+        )

        await message.answer(f"""<b>Основные настройки</b>
         
    <b>- Режим торговли:</b> {data['trading_mode']}
-<b>- Режим свитч:</b> {data['switch_mode_enabled']}
    <b>- Состояние свитча:</b> {data['switch_state']}
+    <b>- Направление последней сделки:</b> {data['last_side']}
    <b>- Тип маржи:</b> {data['margin_type']}
    <b>- Размер кредитного плеча:</b> х{data['size_leverage']}
    <b>- Начальная ставка:</b> {data['starting_quantity']}
    <b>- Коэффициент мартингейла:</b> {data['martingale_factor']}
-<b>- Количество ставок в серии:</b> {data['martingale_step']}
+    <b>- Текущий шаг:</b> {data['martingale_step']}
    <b>- Максимальное количество ставок в серии:</b> {data['maximal_quantity']}   
+    
+    <b>- Требуемый бюджет:</b> {total_budget:.2f} USDT
    """, parse_mode='html', reply_markup=inline_markup.main_settings_markup)
+    except PermissionError as e:
+        logger.error("Authenticated endpoints require keys: %s", e)
+        await message.answer("Вы не авторизованы.", reply_markup=inline_markup.connect_bybit_api_message)


 async def trading_mode_message(message, state):
@@ -49,7 +86,7 @@ async def trading_mode_message(message, state):

 <b>Шорт</b> — метод продажи активов, взятых в кредит, чтобы получить прибыль от снижения цены.

-<b>Смарт</b> — автоматизированный режим, который подбирает оптимальную стратегию в зависимости от текущих рыночных условий.
+<b>Свитч</b> — динамическое переключение между торговыми режимами для максимизации эффективности.
    
 <em>Выберите ниже для изменений:</em>    
 """, parse_mode='html', reply_markup=inline_markup.trading_mode_markup)
@@ -77,6 +114,13 @@ async def state_trading_mode(callback: CallbackQuery, state):

                await state.clear()

+            case 'trade_mode_switch':
+                await callback.message.answer(f"✅ Изменено: {data_settings['trading_mode']} → Switch")
+                await rq.update_trade_mode_user(id, 'Switch')
+                await main_settings_message(id, callback.message)
+
+                await state.clear()
+
            case 'trade_mode_smart':
                await callback.message.answer(f"✅ Изменено: {data_settings['trading_mode']} → Smart")
                await rq.update_trade_mode_user(id, 'Smart')
@@ -91,45 +135,27 @@ async def switch_mode_enabled_message(message, state):
    await state.set_state(update_main_settings.switch_mode_enabled)

    await message.edit_text(
-        """<b>Свитч</b> — динамическое переключение между торговыми режимами для максимизации эффективности.
+        f"""<b> Состояние свитча</b>
        
+        <b>По направлению</b> - по направлению последней сделки предыдущей серии
+        <b>Против направления</b> - против направления последней сделки предыдущей серии
+        
+        <em>По умолчанию при первом запуске бота, направление сделки установлено на "Buy".</em>
        <em>Выберите ниже для изменений:</em>""", parse_mode='html',
-        reply_markup=inline_markup.buttons_on_off_markup_for_switch)
-
-
-@router_main_settings.callback_query(lambda c: c.data in ["clb_on_switch", "clb_off_switch"])
-async def state_switch_mode_enabled(callback: CallbackQuery, state):
-    await callback.answer()
-    tg_id = callback.from_user.id
-    val = "Включить" if callback.data == "clb_on_switch" else "Выключить"
-    if val == "Включить":
-        await rq.update_switch_mode_enabled(tg_id, "Включено")
-        await callback.answer(f"Включено")
-        await main_settings_message(tg_id, callback.message)
-    else:
-        await rq.update_switch_mode_enabled(tg_id, "Выключено")
-        await callback.answer(f"Выключено")
-        await main_settings_message(tg_id, callback.message)
-    await state.clear()
-
-
-@router_main_settings.callback_query(lambda c: c.data in ["clb_switch_state"])
-async def state_switch_mode_enabled(callback: CallbackQuery):
-    await callback.answer()
-    await callback.message.answer("Выберите состояние свитча:", reply_markup=inline_markup.switch_state_markup)
+        reply_markup=inline_markup.switch_state_markup)


@router_main_settings.callback_query(lambda c: c.data in ["clb_long_switch", "clb_short_switch"])
 async def state_switch_mode_enabled(callback: CallbackQuery, state):
    await callback.answer()
    tg_id = callback.from_user.id
-    val = "Long" if callback.data == "clb_long_switch" else "Short"
-    if val == "Long":
-        await rq.update_switch_state(tg_id, "Long")
+    val = "По направлению" if callback.data == "clb_long_switch" else "Против направления"
+    if val == "По направлению":
+        await rq.update_switch_state(tg_id, "По направлению")
        await callback.message.answer(f"Состояние свитча: {val}")
        await main_settings_message(tg_id, callback.message)
    else:
-        await rq.update_switch_state(tg_id, "Short")
+        await rq.update_switch_state(tg_id, "Против направления")
        await callback.message.answer(f"Состояние свитча: {val}")
        await main_settings_message(tg_id, callback.message)
    await state.clear()
@@ -144,23 +170,47 @@ async def size_leverage_message(message, state):

@router_main_settings.message(update_main_settings.size_leverage)
 async def state_size_leverage(message: Message, state):
+    try:
+        leverage = float(message.text)
+        if leverage <= 0:
+            raise ValueError("Неверное значение")
+    except ValueError:
+        await message.answer(
+            "Ошибка: пожалуйста, введите положительное число для кредитного плеча."
+            "\nПопробуйте снова."
+        )
+        return
+
    await state.update_data(size_leverage=message.text)

    data = await state.get_data()
-    data_settings = await rq.get_user_main_settings(message.from_user.id)
+    tg_id = message.from_user.id
+    symbol = await rq.get_symbol(tg_id)
+    leverage = data['size_leverage']
+    client = await get_bybit_client(tg_id)

-    if data['size_leverage'].isdigit() and int(data['size_leverage']) <= 100:
-        await message.answer(f"✅ Изменено: {data_settings['size_leverage']} → {data['size_leverage']}")
+    instruments_resp = client.get_instruments_info(category="linear", symbol=symbol)
+    info = instruments_resp.get("result", {}).get("list", [])

-        await rq.update_size_leverange(message.from_user.id, data['size_leverage'])
+    max_leverage = safe_float(info[0].get("leverageFilter", {}).get("maxLeverage", 0))
+
+    if safe_float(leverage) > max_leverage:
+        await message.answer(
+            f"Запрошенное кредитное плечо {leverage} превышает максимальное {max_leverage} для {symbol}. "
+            f"Устанавливаю максимальное.",
+            reply_markup=inline_markup.back_to_main,
+        )
+        logger.info(
+            f"Запрошенное кредитное плечо {leverage} превышает максимальное {max_leverage} для {symbol}. Устанавливаю максимальное.")
+
+        await rq.update_size_leverange(message.from_user.id, max_leverage)
        await main_settings_message(message.from_user.id, message)
-
        await state.clear()
    else:
-        await message.answer(
-            f'⛔️ Ошибка: ваше значение ({data['size_leverage']}) или выше лимита (100) или вы вводите неверные символы')
-
+        await message.answer(f"✅ Изменено: {leverage}")
+        await rq.update_size_leverange(message.from_user.id, safe_float(leverage))
        await main_settings_message(message.from_user.id, message)
+        await state.clear()


 async def martingale_factor_message(message, state):
@@ -213,13 +263,16 @@ async def margin_type_message(message, state):

@router_main_settings.callback_query(update_main_settings.margin_type)
 async def state_margin_type(callback: CallbackQuery, state):
+    callback_data = callback.data
+    if callback_data in ['margin_type_isolated', 'margin_type_cross']:
        tg_id = callback.from_user.id
        api_key = await rq.get_bybit_api_key(tg_id)
        secret_key = await rq.get_bybit_secret_key(tg_id)
        data_settings = await rq.get_user_main_settings(tg_id)
+        symbol = await rq.get_symbol(tg_id)
        client = HTTP(api_key=api_key, api_secret=secret_key)
        try:
-        active_positions = client.get_positions(category='linear', settleCoin='USDT')
+            active_positions = client.get_positions(category='linear', settleCoin="USDT")

            positions = active_positions.get('result', {}).get('list', [])
        except Exception as e:
@@ -230,13 +283,14 @@ async def state_margin_type(callback: CallbackQuery, state):
            size = pos.get('size')
            if float(size) > 0:
                await callback.answer(
-                "⚠️ Маржинальный режим нельзя менять при открытой позиции",
-                show_alert=True
+                    "⚠️ Маржинальный режим нельзя менять при открытой позиции"
                )
                return
+
        try:
            match callback.data:
                case 'margin_type_isolated':
+                    await callback.answer()
                    await callback.message.answer(f"✅ Изменено: {data_settings['margin_type']} → Isolated")

                    await rq.update_margin_type(tg_id, 'Isolated')
@@ -244,6 +298,7 @@ async def state_margin_type(callback: CallbackQuery, state):

                    await state.clear()
                case 'margin_type_cross':
+                    await callback.answer()
                    await callback.message.answer(f"✅ Изменено: {data_settings['margin_type']} → Cross")

                    await rq.update_margin_type(tg_id, 'Cross')
@@ -252,6 +307,11 @@ async def state_margin_type(callback: CallbackQuery, state):
                    await state.clear()
        except Exception as e:
            logger.error(f"error: {e}")
+    else:
+        await callback.answer()
+        await main_settings_message(callback.from_user.id, callback.message)
+
+        await state.clear()


 async def starting_quantity_message(message, state):
--- a/app/telegram/handlers/handlers.py
+++ b/app/telegram/handlers/handlers.py
@@ -1,7 +1,7 @@
 import logging.config

 from aiogram import F, Router
-from aiogram.filters import CommandStart
+from aiogram.filters import CommandStart, Command
 from aiogram.types import Message, CallbackQuery
 from aiogram.fsm.context import FSMContext

@@ -23,7 +23,7 @@ logger = logging.getLogger("handlers")

 router = Router()

-
+@router.message(Command("start"))
@router.message(CommandStart())
 async def start_message(message: Message) -> None:
    """
@@ -37,6 +37,7 @@ async def start_message(message: Message) -> None:
    await func.start_message(message)


+@router.message(Command("profile"))
@router.message(F.text == "👤 Профиль")
 async def profile_message(message: Message) -> None:
    """
@@ -52,6 +53,12 @@ async def profile_message(message: Message) -> None:
    if user and balance:
        await run_ws_for_user(tg_id, message)
        await func.profile_message(message.from_user.username, message)
+    else:
+        await rq.save_tg_id_new_user(message.from_user.id)
+        await func_main_settings.reg_new_user_default_main_settings(message.from_user.id, message)
+        await func_rmanagement_settings.reg_new_user_default_risk_management_settings(message.from_user.id, message)
+        await func_condition_settings.reg_new_user_default_condition_settings(message.from_user.id)
+        await func_additional_settings.reg_new_user_default_additional_settings(message.from_user.id, message)


@router.callback_query(F.data == "clb_start_chatbot_message")
@@ -64,6 +71,8 @@ async def clb_profile_msg(callback: CallbackQuery) -> None:
    Args:
        callback (CallbackQuery): Полученный колбэк.
    """
+    tg_id = callback.from_user.id
+    message = callback.message
    user = await rq.check_user(callback.from_user.id)
    balance = await get_balance(callback.from_user.id, callback.message)
    first_name = callback.from_user.first_name or ""
@@ -71,6 +80,7 @@ async def clb_profile_msg(callback: CallbackQuery) -> None:
    username = f"{first_name} {last_name}".strip() or callback.from_user.username or "Пользователь"

    if user and balance:
+        await run_ws_for_user(tg_id, message)
        await func.profile_message(callback.from_user.username, callback.message)
    else:
        await rq.save_tg_id_new_user(callback.from_user.id)
@@ -164,7 +174,7 @@ async def clb_change_additional_message(callback: CallbackQuery) -> None:

 # Конкретные настройки каталогов
 list_main_settings = ['clb_change_trading_mode',
-                      'clb_change_switch_mode',
+                      'clb_change_switch_state',
                      'clb_change_margin_type',
                      'clb_change_size_leverage',
                      'clb_change_starting_quantity',
@@ -188,7 +198,7 @@ async def clb_main_settings_msg(callback: CallbackQuery, state: FSMContext) -> N
        match callback.data:
            case 'clb_change_trading_mode':
                await func_main_settings.trading_mode_message(callback.message, state)
-            case 'clb_change_switch_mode':
+            case 'clb_change_switch_state':
                await func_main_settings.switch_mode_enabled_message(callback.message, state)
            case 'clb_change_margin_type':
                await func_main_settings.margin_type_message(callback.message, state)
--- a/logger_helper/logger_helper.py
+++ b/logger_helper/logger_helper.py
@@ -80,7 +80,7 @@ LOGGING_CONFIG = {
            "level": "DEBUG",
            "propagate": False,
        },
-        "conditions_settings": {
+        "condition_settings": {
            "handlers": ["console", "timed_rotating_file"],
            "level": "DEBUG",
            "propagate": False,
--- a/requirements.txt
+++ b/requirements.txt
@@ -6,22 +6,40 @@ aiosignal==1.4.0
 aiosqlite==0.21.0
 annotated-types==0.7.0
 attrs==25.3.0
+black==25.1.0
 certifi==2025.8.3
 charset-normalizer==3.4.3
+click==8.2.1
+colorama==0.4.6
 dotenv==0.9.9
+flake8==7.3.0
+flake8-bugbear==24.12.12
+flake8-pie==0.16.0
 frozenlist==1.7.0
 greenlet==3.2.4
 idna==3.10
+isort==6.0.1
 magic-filter==1.0.12
+mando==0.7.1
+mccabe==0.7.0
 multidict==6.6.4
+mypy_extensions==1.1.0
 nest-asyncio==1.6.0
+packaging==25.0
+pathspec==0.12.1
+platformdirs==4.4.0
 propcache==0.3.2
 pybit==5.11.0
+pycodestyle==2.14.0
 pycryptodome==3.23.0
 pydantic==2.11.7
 pydantic_core==2.33.2
+pyflakes==3.4.0
 python-dotenv==1.1.1
+radon==6.0.1
+redis==6.4.0
 requests==2.32.5
+six==1.17.0
 SQLAlchemy==2.0.43
 typing-inspection==0.4.1
 typing_extensions==4.14.1