Added documentation, added event_loop for tasks, added WebSocket

.gitignore

@@ -7,3 +7,5 @@ __pycache__/
 env/
 venv/
 .venv/
+.idea
+/.idea

BybitBot_API.py

@@ -1,11 +1,9 @@
 import asyncio
 import logging.config
 from aiogram import Bot, Dispatcher
-from aiogram.filters import Command, CommandStart
-from aiogram.types import Message
-
+import app.services.Bybit.functions.bybit_ws as bybit_ws
+import app.telegram.database.requests as rq
 from app.telegram.database.models import async_main
-
 from app.telegram.handlers.handlers import router
 from app.telegram.functions.main_settings.settings import router_main_settings
 from app.telegram.functions.risk_management_settings.settings import router_risk_management_settings
@@ -14,7 +12,7 @@ from app.services.Bybit.functions.Add_Bybit_API import router_register_bybit_api
 from app.services.Bybit.functions.functions import router_functions_bybit_trade
 
 from logger_helper.logger_helper import LOGGING_CONFIG
-from config import TOKEN_TG_BOT_1, TOKEN_TG_BOT_2, TOKEN_TG_BOT_3
+from config import TOKEN_TG_BOT_1
 
 logging.config.dictConfig(LOGGING_CONFIG)
 logger = logging.getLogger("main")
@@ -22,7 +20,39 @@ logger = logging.getLogger("main")
 bot = Bot(token=TOKEN_TG_BOT_1)
 dp = Dispatcher()
 
-async def main():
+
+def get_or_create_event_loop() -> asyncio.AbstractEventLoop:
+    """
+    Возвращает текущий активный цикл событий asyncio или создает новый, если его нет.
+    """
+    try:
+        return asyncio.get_running_loop()
+    except RuntimeError:
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        return loop
+
+
+loop = get_or_create_event_loop()
+bybit_ws.set_event_loop(loop)
+
+
+async def run_ws_for_user(tg_id, message) -> None:
+    """
+    Запускает WebSocket Bybit для пользователя с указанным tg_id.
+    """
+
+    api_key = await rq.get_bybit_api_key(tg_id)
+    api_secret = await rq.get_bybit_secret_key(tg_id)
+
+    await bybit_ws.start_execution_ws(api_key, api_secret, message)
+
+
+async def main() -> None:
+    """
+    Основная асинхронная функция запуска бота:
+    """
+
     await async_main()
 
     dp.include_router(router)
@@ -34,6 +64,7 @@ async def main():
 
     await dp.start_polling(bot)
 
+
 if __name__ == '__main__':
     try:
         logger.info("Bot is on")

README.md

@@ -1,20 +1,74 @@
-# Чат-робот STCS
-__
+Crypto Trading Telegram Bot
 
-**Функционал:**
-+ **Настройки**
-  + Основные параметры *(Настроен, работает)*
-    + Режим торговли Лонг/Шорт *(настроены)*, Switch/Smart *(не настроены)*
-    + Тип маржи: Изолированная / Кросс *(настроено)*
-    + Размер кредитного плеча: от x1 до x100 *(настроено)*
-    + Начальная ставка: числовое значение *(настроено)*
-    + Коэффициент мартингейла: число *(настроено)*
-    + Максимальное количество ставок в серии: число *(настроено)*
-  + Риск-менеджмент (Настроен, работает)
-    + Процент изменения цены для фиксации прибыли (TP%): число *(настроено)*
-    + Процент изменения цены для фиксации убытков (SL%): число (пример: 1%) *(настроено)*
-    + Максимальный риск на сделку (в % от баланса): число (опционально) *(настроено)*
-   + Условия запуска *(Не настроен)*
-   + Дополнительные параметры *(Не настроен)*
-   + Подключение Bybit *(настроено)*
-    + Информация о правильном получении и сохранении Bybit-API keys *(настроено)*
+Этот бот — автоматизированный торговый помощник для работы с криптовалютной биржей Bybit на основе стратегии мартингейла. Он позволяет торговать бессрочными контрактами с управлением рисками, тейк-профитами, стоп-лоссами и кредитным плечом.
+
+##Основные возможности
+
+- Поддержка работы с биржей Bybit через официальный API.
+
+- Открытие и закрытие позиций по выбранным торговым парам.
+
+- Поддержка рыночных и лимитных ордеров.
+
+- Установка уровней тейк-профита (TP) и стоп-лосса (SL).
+
+- Управление кредитным плечом (leverage).
+
+- Реализация стратегии мартингейла с настройками шага, коэффициента и лимитов.
+
+- Контроль максимального риска на сделку по балансу пользователя.
+
+- Обработка ошибок API, логирование событий и информирование пользователя.
+
+- Таймеры для отложенного открытия и закрытия сделок.
+
+- Интерактивное меню и ввод настроек через Telegram.
+
+- Хранение пользовательских настроек и статистики в базе данных.
+
+
+##Установка и запуск
+
+1. Клонируйте репозиторий:
+
+
+git clone <URL_репозитория>
+
+
+2. Установите зависимости:
+
+pip install -r requirements.txt
+
+
+3. Создайте файл .env и настройте переменные окружения.
+
+
+4. Запустите бота:
+
+python BybitBot_API.py
+
+
+##Настройки пользователя
+
+- Кредитное плечо (например, 15x)
+
+- Торговая пара (например, DOGEUSDT, BTCUSDT)
+
+- Начальное количество для сделок
+
+- Тип ордера (Market или Limit)
+
+- Уровни Take Profit и Stop Loss (в процентах или цене)
+
+- Коэффициент мартингейла и максимальное количество шагов
+
+- Максимально допустимый риск на одну сделку (% от баланса)
+
+- Таймеры для старта и закрытия сделок
+
+
+##Безопасность и риски
+
+- Бот требует аккуратной настройки параметров риска.
+
+- Храните API ключи в безопасности, избегайте публикации.

app/services/Bybit/functions/Add_Bybit_API.py

@@ -7,8 +7,7 @@ import app.telegram.Keyboards.reply_keyboards as reply_markup
 import app.telegram.database.requests as rq
 from aiogram.types import Message, CallbackQuery
 
-# FSM - Механизм состояния
-from aiogram.fsm.state import State, StatesGroup
+from app.states.States import state_reg_bybit_api
 from aiogram.fsm.context import FSMContext
 
 logging.config.dictConfig(LOGGING_CONFIG)
@@ -16,12 +15,13 @@ logger = logging.getLogger("add_bybit_api")
 
 router_register_bybit_api = Router()
 
-class state_reg_bybit_api(StatesGroup):
-    api_key = State()
-    secret_key = State()
 
 @router_register_bybit_api.callback_query(F.data == 'clb_new_user_connect_bybit_api_message')
-async def info_for_bybit_api_message(callback: CallbackQuery):
+async def info_for_bybit_api_message(callback: CallbackQuery) -> None:
+    """
+    Отвечает пользователю подробной инструкцией по подключению аккаунта Bybit.
+    Показывает как создать API ключ и передать его чат-боту.
+    """
     text = '''<b>Подключение Bybit аккаунта</b>
     
 <b>1. Зарегистрируйтесь или войдите в свой аккаунт на Bybit (https://www.bybit.com/).</b>
@@ -43,17 +43,27 @@ async def info_for_bybit_api_message(callback: CallbackQuery):
 
     await callback.answer()
 
+
 @router_register_bybit_api.callback_query(F.data == 'clb_new_user_connect_bybit_api')
-async def add_api_key_message(callback: CallbackQuery, state: FSMContext):   
+async def add_api_key_message(callback: CallbackQuery, state: FSMContext) -> None:
+    """
+    Инициирует процесс добавления API ключа.
+    Переводит пользователя в состояние ожидания ввода API Key.
+    """
     await state.set_state(state_reg_bybit_api.api_key)
 
     text = 'Отправьте KEY_API ниже: '
 
     await callback.message.answer(text=text)
 
+
 @router_register_bybit_api.message(state_reg_bybit_api.api_key)
-async def add_api_key_and_message_for_secret_key(message: Message, state: FSMContext):
-    await state.update_data(api_key = message.text)
+async def add_api_key_and_message_for_secret_key(message: Message, state: FSMContext) -> None:
+    """
+    Сохраняет API Key во временное состояние FSM,
+    затем запрашивает у пользователя ввод Secret Key.
+    """
+    await state.update_data(api_key=message.text)
 
     text = 'Отправьте SECRET_KEY ниже'
 
@@ -61,9 +71,14 @@ async def add_api_key_and_message_for_secret_key(message: Message, state: FSMCon
 
     await state.set_state(state_reg_bybit_api.secret_key)
 
+
 @router_register_bybit_api.message(state_reg_bybit_api.secret_key)
-async def add_secret_key(message: Message, state: FSMContext):
-    await state.update_data(secret_key = message.text)
+async def add_secret_key(message: Message, state: FSMContext) -> None:
+    """
+    Сохраняет Secret Key и финализирует регистрацию,
+    обновляет базу данных, устанавливает символ пользователя и очищает состояние.
+    """
+    await state.update_data(secret_key=message.text)
 
     data = await state.get_data()
 
@@ -73,6 +88,5 @@ async def add_secret_key(message: Message, state: FSMContext):
 
     await state.clear()
 
-    await message.answer('Данные добавлены, нажмите на профиль и начните торговлю!', reply_markup=reply_markup.base_buttons_markup)
-
-    
+    await message.answer('Данные добавлены, нажмите на профиль и начните торговлю!',
+                         reply_markup=reply_markup.base_buttons_markup)

app/services/Bybit/functions/Futures.py

@@ -1,5 +1,7 @@
 import asyncio
+import json
 import time
+
 import logging.config
 from pybit import exceptions
 from pybit.unified_trading import HTTP
@@ -7,46 +9,174 @@ from logger_helper.logger_helper import LOGGING_CONFIG
 import app.services.Bybit.functions.price_symbol as price_symbol
 import app.services.Bybit.functions.balance as balance_g
 import app.telegram.database.requests as rq
+import app.telegram.Keyboards.inline_keyboards as inline_markup
 
 logging.config.dictConfig(LOGGING_CONFIG)
 logger = logging.getLogger("futures")
 
-async def info_access_open_deal(message, symbol, trade_mode, margin_mode, leverage, qty):
-    human_margin_mode = 'Isolated' if margin_mode == 'ISOLATED_MARGIN' else 'Cross'
-    text = f'''Позиция была успешна открыта!
-Торговая пара: {symbol}
-Движение: {trade_mode}
-Тип-маржи: {human_margin_mode}
-Кредитное плечо: {leverage}
-Количество: {qty}
-'''
-    await message.answer(text=text, parse_mode='html')
 
-
-async def error_max_step(message):
-    await message.answer('Сделка не была совершена, превышен лимит максимального количества ставок в серии.')
-
-
-async def error_max_risk(message):
-    await message.answer('Сделка не была совершена, риск убытка превышает допустимый лимит.')
-
-
-async def open_position(tg_id, message, side: str, margin_mode: str):
+def safe_float(val) -> float:
     """
-    Открытие позиции (торговля с мартингейлом и управлением рисками)
-
-    :param tg_id: Telegram ID пользователя
-    :param message: объект сообщения Telegram для ответов
-    :param side: 'Buy' для Long, 'Sell' для Short
-    :param margin_mode: 'Isolated' или 'Cross'
+    Безопасное преобразование значения в float.
+    Возвращает 0.0, если значение None, пустое или некорректное.
     """
+    try:
+        if val is None or val == '':
+            return 0.0
+        return float(val)
+    except (ValueError, TypeError):
+        logger.error("Некорректное значение для преобразования в float")
+        return 0.0
 
+
+def format_trade_details_position(data, commission_fee):
+    """
+    Форматирует информацию о сделке в виде строки.
+    """
+    msg = data.get('data', [{}])[0]
+
+    closed_size = float(msg.get('closedSize', 0))
+    symbol = msg.get('symbol', 'N/A')
+    entry_price = float(msg.get('execPrice', 0))
+    qty = float(msg.get('execQty', 0))
+    order_type = msg.get('orderType', 'N/A')
+    side = msg.get('side', '')
+    commission = float(msg.get('execFee', 0))
+    pnl = float(msg.get('execPnl', 0))
+
+    if commission_fee == "Да":
+        if pnl >= 0:
+            pnl -= commission
+        else:
+            pnl -= commission
+
+    movement = ''
+    if side.lower() == 'buy':
+        movement = 'Покупка'
+    elif side.lower() == 'sell':
+        movement = 'Продажа'
+    else:
+        movement = side
+
+    if closed_size > 0:
+        return (
+            f"Сделка закрыта:\n"
+            f"Торговая пара: {symbol}\n"
+            f"Цена исполнения: {entry_price:.6f}\n"
+            f"Количество: {qty}\n"
+            f"Закрыто позиций: {closed_size}\n"
+            f"Тип ордера: {order_type}\n"
+            f"Движение: {movement}\n"
+            f"Комиссия за сделку: {commission:.6f}\n"
+            f"Реализованная прибыль: {pnl:.6f} USDT"
+        )
+    else:
+        return (
+            f"Сделка открыта:\n"
+            f"Торговая пара: {symbol}\n"
+            f"Цена исполнения: {entry_price:.6f}\n"
+            f"Количество: {qty}\n"
+            f"Тип ордера: {order_type}\n"
+            f"Движение: {movement}\n"
+            f"Комиссия за сделку: {commission:.6f}"
+        )
+
+
+def parse_pnl_from_msg(msg) -> float:
+    """
+    Извлекает реализованную прибыль/убыток из сообщения.
+    """
+    try:
+        return float(msg.get('realisedPnl', 0))
+    except Exception as e:
+        logger.error(f"Ошибка при извлечении реализованной прибыли: {e}")
+        return 0.0
+
+
+async def handle_execution_message(message, msg: dict) -> None:
+    """
+    Обработчик сообщений об исполнении сделки.
+    Логирует событие и проверяет условия для мартингейла и TP.
+    """
+    logger.info(f"Исполнена сделка:\n{json.dumps(msg, indent=4, ensure_ascii=False)}")
+
+    pnl = parse_pnl_from_msg(msg)
+    tg_id = message.from_user.id
+
+    data_main_stgs = await rq.get_user_main_settings(tg_id)
+    data_main_risk_stgs = await rq.get_user_risk_management_settings(tg_id)
+    take_profit_percent = safe_float(data_main_stgs.get('take_profit_percent', 2))
+    commission_fee = data_main_risk_stgs.get('commission_fee', "ДА")
+    symbol = await rq.get_symbol(tg_id)
+    api_key = await rq.get_bybit_api_key(tg_id)
+    api_secret = await rq.get_bybit_secret_key(tg_id)
+    client = HTTP(api_key=api_key, api_secret=api_secret)
+    positions_resp = client.get_positions(category='linear', symbol=symbol)
+    positions_list = positions_resp.get('result', {}).get('list', [])
+    position = positions_list[0] if positions_list else None
+
+    trade_info = format_trade_details_position(msg, commission_fee=commission_fee)
+    await message.answer(f"{trade_info}", reply_markup=inline_markup.back_to_main)
+
+    liquidation_threshold = -100
+
+    if pnl <= liquidation_threshold:
+        current_step = int(await rq.get_martingale_step(tg_id))
+        current_step += 1
+        await rq.update_martingale_step(tg_id, current_step)
+
+        side = 'Buy' if position and position.get('side', '').lower() == 'long' else 'Sell'
+        margin_mode = data_main_stgs.get('margin_type', 'Isolated')
+        await open_position(tg_id, message, side=side, margin_mode=margin_mode)
+
+    elif position:
+        entry_price = safe_float(position.get('avgPrice'))
+        side = position.get('side', '')
+        current_price = float(position.get('markPrice', 0))
+
+        if side.lower() == 'long':
+            take_profit_trigger_price = entry_price * (1 + take_profit_percent / 100)
+            if current_price >= take_profit_trigger_price:
+                await close_user_trade(tg_id, symbol, message)
+                await rq.update_martingale_step(tg_id, 0)
+        elif side.lower() == 'short':
+            take_profit_trigger_price = entry_price * (1 - take_profit_percent / 100)
+            if current_price <= take_profit_trigger_price:
+                await close_user_trade(tg_id, symbol, message)
+                await rq.update_martingale_step(tg_id, 0)
+
+
+async def error_max_step(message) -> None:
+    """
+    Сообщение об ошибке превышения максимального количества шагов мартингейла.
+    """
+    logger.error('Сделка не была совершена, превышен лимит максимального количества ставок в серии.')
+    await message.answer('Сделка не была совершена, превышен лимит максимального количества ставок в серии.',
+                         reply_markup=inline_markup.back_to_main)
+
+
+async def error_max_risk(message) -> None:
+    """
+    Сообщение об ошибке превышения риск-лимита сделки.
+    """
+    logger.error('Сделка не была совершена, риск убытка превышает допустимый лимит.')
+    await message.answer('Сделка не была совершена, риск убытка превышает допустимый лимит.',
+                         reply_markup=inline_markup.back_to_main)
+
+
+async def open_position(tg_id, message, side: str, margin_mode: str, tpsl_mode='Full'):
+    """
+    Открывает позицию на Bybit с учётом настроек пользователя, маржи, размера лота, платформы и риска.
+
+    Возвращает True при успехе, False при ошибках открытия ордера, None при исключениях.
+    """
     api_key = await rq.get_bybit_api_key(tg_id)
     secret_key = await rq.get_bybit_secret_key(tg_id)
     symbol = await rq.get_symbol(tg_id)
 
     data_main_stgs = await rq.get_user_main_settings(tg_id)
-    order_type = data_main_stgs.get('entry_order_type', 'Market')
+    order_type = data_main_stgs.get('entry_order_type')
+
     limit_price = None
     if order_type == 'Limit':
         limit_price = await rq.get_limit_price(tg_id)
@@ -55,192 +185,485 @@ async def open_position(tg_id, message, side: str, margin_mode: str):
     bybit_margin_mode = 'ISOLATED_MARGIN' if margin_mode == 'Isolated' else 'REGULAR_MARGIN'
 
     client = HTTP(api_key=api_key, api_secret=secret_key)
+    try:
+        client.set_tp_sl_mode(symbol=symbol, category='linear', tpSlMode='Full')
+    except exceptions.InvalidRequestError as e:
+        if 'same tp sl mode' in str(e):
+            logger.info("Режим TP/SL уже установлен - пропускаем")
+        else:
+            raise
 
     try:
         balance = await balance_g.get_balance(tg_id, message)
         price = await price_symbol.get_price(tg_id)
 
-        # Установка маржинального режима
         client.set_margin_mode(setMarginMode=bybit_margin_mode)
 
-        martingale_factor = float(data_main_stgs['martingale_factor'])
-        max_martingale_steps = int(data_main_stgs['maximal_quantity'])
-        starting_quantity = float(data_main_stgs['starting_quantity'])
-        max_risk_percent = float(data_risk_stgs['max_risk_deal'])
-        loss_profit = float(data_risk_stgs['price_loss'])
-        takeprofit = float(data_risk_stgs['price_profit'])
-        commission_fee = float(data_risk_stgs.get('commission_fee', 0))
+        martingale_factor = safe_float(data_main_stgs.get('martingale_factor'))
+        max_martingale_steps = int(data_main_stgs.get('maximal_quantity', 0))
+        starting_quantity = safe_float(data_main_stgs.get('starting_quantity'))
 
-        takeProfit = max(takeprofit - commission_fee, 0)
+        max_risk_percent = safe_float(data_risk_stgs.get('max_risk_deal'))
+        loss_profit = safe_float(data_risk_stgs.get('price_loss'))
+        take_profit = safe_float(data_risk_stgs.get('price_profit'))
+        positions_resp = client.get_positions(category='linear', symbol=symbol)
+        positions_list = positions_resp.get('result', {}).get('list', [])
+
+        if positions_list:
+            position = positions_list[0]
+            size = safe_float(position.get('size', 0))
+            side_pos = position.get('side', '')
+            if size > 0 and side_pos:
+                entry_price = safe_float(position.get('avgPrice', price))
+            else:
+                entry_price = price
+        else:
+            entry_price = price
+
+        if order_type == 'Market':
+            base_price = entry_price
+        else:
+            base_price = limit_price
+
+        if side.lower() == 'buy':
+            take_profit_price = base_price * (1 + take_profit / 100)
+            stop_loss_price = base_price * (1 - loss_profit / 100)
+        else:
+            take_profit_price = base_price * (1 - take_profit / 100)
+            stop_loss_price = base_price * (1 + loss_profit / 100)
+
+        take_profit_price = max(take_profit_price, 0)
+        stop_loss_price = max(stop_loss_price, 0)
 
         current_martingale_step = 0
         next_quantity = starting_quantity
-        last_quantity = starting_quantity
         realised_pnl = 0.0
 
-        # Получаем текущие открытые позиции по символу
-        positions_resp = client.get_positions(category='linear', symbol=symbol)
-        positions_list = positions_resp.get('result', {}).get('list', [])
-        current_martingale_step = await rq.get_martingale_step(tg_id)
+        current_martingale = await rq.get_martingale_step(tg_id)
+        current_martingale_step = int(current_martingale)
+
         if positions_list:
-            position = positions_list[0]
-            realised_pnl = float(position.get('unrealisedPnl', 0.0))
-
-
             if realised_pnl > 0:
                 current_martingale_step = 0
                 next_quantity = starting_quantity
-
             else:
                 current_martingale_step += 1
                 if current_martingale_step > max_martingale_steps:
                     await error_max_step(message)
                     return
-                next_quantity = starting_quantity * (martingale_factor ** current_martingale_step)
+                next_quantity = float(starting_quantity) * (float(martingale_factor) ** current_martingale_step)
         else:
-            # Позиция не открыта — начинаем с начальной ставки
             next_quantity = starting_quantity
             current_martingale_step = 0
 
-        # Проверяем риск убытка
-        potential_loss = next_quantity * price * (loss_profit / 100)
-        allowed_loss = balance * (max_risk_percent / 100)
+        potential_loss = safe_float(next_quantity) * safe_float(price) * (loss_profit / 100)
+        allowed_loss = safe_float(balance) * (max_risk_percent / 100)
 
         if potential_loss > allowed_loss:
             await error_max_risk(message)
             return
 
-        # Отправляем запрос на открытие ордера
+        instruments_resp = client.get_instruments_info(category='linear', symbol=symbol)
+
+        if instruments_resp.get('retCode') == 0:
+            instrument_info = instruments_resp.get('result', {}).get('list', [])
+            if instrument_info:
+                instrument = instrument_info[0]
+                min_order_qty = float(instrument.get('minOrderQty', 0))
+                min_order_value_api = float(instrument.get('minOrderValue', 0))
+
+                if min_order_value_api == 0:
+                    min_order_value_api = 5.0
+                # Рассчитываем по формуле:
+                min_order_value_calc = min_order_qty * price if min_order_qty > 0 else 0
+                # Минимальное значение из значений параметров на бирже
+                min_order_value = max(min_order_value_calc, min_order_value_api)
+            else:
+                min_order_value = 5.0
+
+        order_value = float(next_quantity) * float(price)
+
+        if order_value < min_order_value:
+            await message.answer(
+                f"Сумма ордера слишком мала: {order_value:.2f} USDT. "
+                f"Минимум для торговли — {min_order_value} USDT. "
+                f"Пожалуйста, увеличьте количество позиций.", reply_markup=inline_markup.back_to_main)
+            return False
+
+        leverage = int(data_main_stgs.get('size_leverage', 1))
+        try:
+            resp = client.set_leverage(
+                category='linear',
+                symbol=symbol,
+                buyLeverage=str(leverage),
+                sellLeverage=str(leverage)
+            )
+        except exceptions.InvalidRequestError as e:
+            if "110043" in str(e):
+                logger.info(f"Leverage already set to {leverage} for {symbol}")
+            else:
+                raise e
+
+        if tpsl_mode == 'Full':
+            tp_order_type = 'Market'
+            sl_order_type = 'Market'
+            tp_limit_price = None
+            sl_limit_price = None
+        else:  # Partial
+            tp_order_type = 'Limit'
+            sl_order_type = 'Limit'
+            tp_limit_price = take_profit_price
+            sl_limit_price = stop_loss_price
+
         response = client.place_order(
             category='linear',
             symbol=symbol,
             side=side,
             orderType=order_type,
-            qty=next_quantity,
-            leverage=int(data_main_stgs['size_leverage']),
-            price=limit_price if order_type == 'Limit' else None,
-            takeProfit=takeProfit,
-            stopLoss=loss_profit,
+            qty=str(next_quantity),
+            price=str(limit_price) if order_type == 'Limit' and limit_price else None,
+            takeProfit=str(take_profit_price),
+            tpOrderType=tp_order_type,
+            tpLimitPrice=str(tp_limit_price) if tp_limit_price else None,
+            stopLoss=str(stop_loss_price),
+            slOrderType=sl_order_type,
+            slLimitPrice=str(sl_limit_price) if sl_limit_price else None,
+            tpslMode=tpsl_mode,
+            timeInForce='GTC',
             orderLinkId=f"deal_{symbol}_{int(time.time())}"
         )
 
-        if response.get('ret_code', -1) == 0:
-            await info_access_open_deal(message, symbol, data_main_stgs['trading_mode'], bybit_margin_mode,
-                                       data_main_stgs['size_leverage'], next_quantity)
+        if response.get('retCode', -1) == 0:
             await rq.update_martingale_step(tg_id, current_martingale_step)
+            return True
         else:
-            await message.answer(f"Ошибка открытия ордера: {response.get('ret_msg', 'неизвестная ошибка')}")
+            logger.error(f"Ошибка открытия ордера: {response}")
+            await message.answer(f"Ошибка открытия ордера", reply_markup=inline_markup.back_to_main)
+            return False
 
     except exceptions.InvalidRequestError as e:
         logger.error(f"InvalidRequestError: {e}")
-        await message.answer('Ошибка: неверно указана торговая пара или параметры.')
+        await message.answer('Недостаточно средств для размещения нового ордера с заданным количеством и плечом.',
+                             reply_markup=inline_markup.back_to_main)
     except Exception as e:
         logger.error(f"Ошибка при совершении сделки: {e}")
-
+        await message.answer('Возникла ошибка при попытке открыть позицию.', reply_markup=inline_markup.back_to_main)
 
 
 async def trading_cycle(tg_id, message):
-    start_time = time.time()
-    timer_min = await rq.get_user_timer(tg_id)
-    timer_sec = timer_min * 60 if timer_min else 0
+    """
+    Цикл торговой логики с учётом таймера пользователя.
+    """
+    try:
+        timer_data = await rq.get_user_timer(tg_id)
+        timer_min = 0
+        if isinstance(timer_data, dict):
+            timer_min = timer_data.get('timer_minutes') or timer_data.get('timer') or 0
+        else:
+            timer_min = timer_data or 0
 
-    while True:
-        elapsed = time.time() - start_time
-        if timer_sec > 0 and elapsed > timer_sec:
-            await message.answer("Время работы по таймеру истекло. Торговля остановлена.")
-            await rq.update_martingale_step(tg_id, 0)
-            break
+        timer_sec = timer_min * 60
+
+        if timer_sec > 0:
+            await asyncio.sleep(timer_sec)
 
-        # Проверяем позиции
         data_main_stgs = await rq.get_user_main_settings(tg_id)
-        side = 'Buy' if data_main_stgs['trading_mode'] == 'Long' else 'Sell'
+        side = 'Buy' if data_main_stgs.get('trading_mode', '') == 'Long' else 'Sell'
         margin_mode = data_main_stgs.get('margin_type', 'Isolated')
 
-        # Можно добавлять логику по PNL, стоп-лоссам, тейк-профитам
-
         await open_position(tg_id, message, side=side, margin_mode=margin_mode)
-
-        await asyncio.sleep(10)
+    except asyncio.CancelledError:
+        logger.info(f"Торговый цикл для пользователя {tg_id} был отменён.")
 
 
+async def set_take_profit_stop_loss(tg_id: int, message, take_profit_price: float, stop_loss_price: float,
+                                    tpsl_mode='Full'):
+    """
+    Устанавливает уровни Take Profit и Stop Loss для открытой позиции.
+    """
+    api_key = await rq.get_bybit_api_key(tg_id)
+    secret_key = await rq.get_bybit_secret_key(tg_id)
+    symbol = await rq.get_symbol(tg_id)
 
-async def get_active_positions(message, api_key, secret_key, symbol):
+    data_main_stgs = await rq.get_user_main_settings(tg_id)
+    order_type = data_main_stgs.get('entry_order_type')
+    starting_quantity = safe_float(data_main_stgs.get('starting_quantity'))
 
-    client = HTTP(
-        api_key=api_key,
-        api_secret=secret_key
-    )
-    instruments_resp = client.get_instruments_info(category='linear')
-    if instruments_resp.get('ret_code') != 0:
-        return []
-    symbols = [item['symbol'] for item in instruments_resp.get('result', {}).get('list', [])]
+    limit_price = None
+    if order_type == 'Limit':
+        limit_price = await rq.get_limit_price(tg_id)
 
-    active_positions = []
+    data_risk_stgs = await rq.get_user_risk_management_settings(tg_id)
+    trading_mode = data_main_stgs.get('trading_mode')
+
+    side = None
+    if trading_mode == 'Long':
+        side = 'Buy'
+    elif trading_mode == 'Short':
+        side = 'Sell'
+
+    if side is None:
+        await message.answer("Не удалось определить сторону сделки.")
+        return
+
+    client = HTTP(api_key=api_key, api_secret=secret_key)
+    await cancel_all_tp_sl_orders(tg_id, symbol)
 
-    async def fetch_positions(symbol):
     try:
-            resp = client.get_positions(category='linear', symbol=symbol)
-            if resp.get('ret_code') == 0:
-                positions = resp.get('result', {}).get('list', [])
-                for pos in positions:
-                    if pos.get('size') and float(pos['size']) > 0:
-                        active_positions.append(pos)
+        try:
+            client.set_tp_sl_mode(symbol=symbol, category='linear', tpSlMode=tpsl_mode)
+        except exceptions.InvalidRequestError as e:
+            if 'same tp sl mode' in str(e).lower():
+                logger.info(f"Режим TP/SL уже установлен для {symbol}")
+            else:
+                raise
+
+        positions_resp = client.get_positions(category='linear', symbol=symbol)
+        positions = positions_resp.get('result', {}).get('list', [])
+
+        if not positions or abs(float(positions[0].get('size', 0))) == 0:
+            params = dict(
+                category='linear',
+                symbol=symbol,
+                side=side,
+                orderType=order_type,
+                qty=str(starting_quantity),
+                timeInForce='GTC',
+                orderLinkId=f"deal_{symbol}_{int(time.time())}",
+                takeProfit=str(take_profit_price),
+                stopLoss=str(stop_loss_price),
+                tpOrderType='Limit' if tpsl_mode == 'Partial' else 'Market',
+                slOrderType='Limit' if tpsl_mode == 'Partial' else 'Market',
+                tpslMode=tpsl_mode
+            )
+            if order_type == 'Limit' and limit_price is not None:
+                params['price'] = str(limit_price)
+
+            if tpsl_mode == 'Partial':
+                params['tpLimitPrice'] = str(take_profit_price)
+                params['slLimitPrice'] = str(stop_loss_price)
+
+            response = client.place_order(**params)
+            if response.get('retCode') != 0:
+                await message.answer(f"Ошибка создания ордера с TP/SL: {response.get('retMsg')}",
+                                     reply_markup=inline_markup.back_to_main)
+                return
+
+        else:
+            resp = client.set_trading_stop(
+                category='linear',
+                symbol=symbol,
+                takeProfit=str(round(take_profit_price, 5)),
+                stopLoss=str(round(stop_loss_price, 5)),
+                tpTriggerBy='LastPrice',
+                slTriggerBy='LastPrice',
+                reduceOnly=False
+            )
+
+            if resp.get('retCode') != 0:
+                await message.answer(f"Ошибка обновления TP/SL: {resp.get('retMsg')}",
+                                     reply_markup=inline_markup.back_to_main)
+                return
+
+        await message.answer(
+            f"ТП и СЛ успешно установлены:\nТейк-профит: {take_profit_price:.5f}\nСтоп-лосс: {stop_loss_price:.5f}",
+            reply_markup=inline_markup.back_to_main)
     except Exception as e:
-            logger.error(f"Ошибка при получении позиций: {e}")
-            await message.answer('⚠️ Ошибка при получении позиций')
-
-    for sym in symbols:
-        await fetch_positions(sym)
-
-    return active_positions
+        logger.error(f"Ошибка установки TP/SL для {symbol}: {e}", exc_info=True)
+        await message.answer("Произошла ошибка при установке TP и SL.", reply_markup=inline_markup.back_to_main)
 
 
-async def close_user_trade(tg_id: int, symbol: str) -> bool:
+async def cancel_all_tp_sl_orders(tg_id, symbol):
+    """
+    Отменяет все открытые ордера TP/SL для указанного символа.
+    """
     api_key = await rq.get_bybit_api_key(tg_id)
     secret_key = await rq.get_bybit_secret_key(tg_id)
     client = HTTP(api_key=api_key, api_secret=secret_key)
+    last_response = None
+    try:
+        orders_resp = client.get_open_orders(category='linear', symbol=symbol)
+        orders = orders_resp.get('result', {}).get('list', [])
+
+        for order in orders:
+            order_id = order.get('orderId')
+            cancel_resp = client.cancel_order(category='linear', symbol=symbol, orderId=order_id)
+            last_response = cancel_resp
+            if cancel_resp.get('retCode') != 0:
+                logger.warning(f"Не удалось отменить ордер {order_id}: {cancel_resp.get('retMsg')}")
+    except Exception as e:
+        logger.error(f"Ошибка при отмене ордеров TP/SL: {e}")
+
+    return last_response
+
+
+async def get_active_positions_by_symbol(tg_id, message):
+    """
+    Показывает активные позиции пользователя по символу.
+    """
+    api_key = await rq.get_bybit_api_key(tg_id)
+    secret_key = await rq.get_bybit_secret_key(tg_id)
+    client = HTTP(api_key=api_key, api_secret=secret_key)
+    symbol = await rq.get_symbol(tg_id)
+
+    active_positions = client.get_positions(category='linear', symbol=symbol)
+    positions = active_positions.get('result', {}).get('list', [])
+    pos = positions[0] if positions else None
+
+    if float(pos.get('size', 0)) == 0:
+        await message.answer("❗️ У вас нет активных позиций.", reply_markup=inline_markup.back_to_main)
+        return
+
+    text = (
+        f"Торговая пара: {pos.get('symbol')}\n"
+        f"Цена входа: {pos.get('avgPrice')}\n"
+        f"Движение: {pos.get('side')}\n"
+        f"Кредитное плечо: {pos.get('leverage')}x\n"
+        f"Количество: {pos.get('size')}\n"
+        f"Тейк-профит: {pos.get('takeProfit')}\n"
+        f"Стоп-лосс: {pos.get('stopLoss')}\n"
+    )
+
+    await message.answer(text, reply_markup=inline_markup.create_close_deal_markup(symbol))
+
+
+async def get_active_orders_by_symbol(tg_id, message):
+    """
+    Показывает активные лимитные ордера пользователя по символу.
+    """
+    api_key = await rq.get_bybit_api_key(tg_id)
+    secret_key = await rq.get_bybit_secret_key(tg_id)
+    symbol = await rq.get_symbol(tg_id)
+    client = HTTP(api_key=api_key, api_secret=secret_key)
+
+    active_orders = client.get_open_orders(category='linear', symbol=symbol)
+    limit_orders = [
+        order for order in active_orders.get('result', {}).get('list', [])
+        if order.get('orderType') == 'Limit'
+    ]
+
+    if not limit_orders:
+        await message.answer("Нет активных лимитных ордеров по данной торговой паре.",
+                             reply_markup=inline_markup.back_to_main)
+        return
+
+    texts = []
+    for order in limit_orders:
+        text = (
+            f"Торговая пара: {order.get('symbol')}\n"
+            f"Тип ордера: {order.get('orderType')}\n"
+            f"Сторона: {order.get('side')}\n"
+            f"Цена: {order.get('price')}\n"
+            f"Количество: {order.get('qty')}\n"
+            f"Тейк-профит: {order.get('takeProfit')}\n"
+            f"Стоп-лосс: {order.get('stopLoss')}\n"
+            f"Кредитное плечо: {order.get('leverage')}\n"
+        )
+        texts.append(text)
+
+    await message.answer("\n\n".join(texts), reply_markup=inline_markup.create_close_deal_markup(symbol))
+
+
+async def close_user_trade(tg_id: int, symbol: str, message):
+    """
+    Закрывает открытые позиции пользователя по символу рыночным ордером.
+    Возвращает True при успехе, False при ошибках.
+    """
+    try:
+        api_key = await rq.get_bybit_api_key(tg_id)
+        secret_key = await rq.get_bybit_secret_key(tg_id)
+        data_risk_stgs = await rq.get_user_risk_management_settings(tg_id)
+
+        limit_price = await rq.get_limit_price(tg_id)
+        include_fee = data_risk_stgs.get('commission_fee', 'Нет') == 'Да'
+        client = HTTP(api_key=api_key, api_secret=secret_key)
 
-    # Получаем текущие открытые позиции по символу (пример для linear фьючерсов)
         positions_resp = client.get_positions(category="linear", symbol=symbol)
 
-    ret_code = positions_resp.get('ret_code')
-    result = positions_resp.get('result')
-
-    if ret_code != 0 or not result or not result.get('list'):
+        if positions_resp.get('retCode') != 0:
             return False
-
-    positions_list = result['list']
+        positions_list = positions_resp.get('result', {}).get('list', [])
         if not positions_list:
             return False
 
         position = positions_list[0]
-    qty = abs(float(position['size']))
-    side = position['side']
-
+        qty = abs(safe_float(position.get('size')))
+        side = position.get('side')
+        entry_price = safe_float(position.get('avgPrice'))
         if qty == 0:
             return False
 
-    # Определяем сторону закрытия — противоположная открытой позиции
+        orders = client.get_open_orders(category='linear', symbol=symbol)
+        cancel_resp = await cancel_all_tp_sl_orders(tg_id, symbol)
+        open_orders_list = orders.get('result', {}).get('list', [])
+        order_id = open_orders_list[0].get('orderId') if open_orders_list else None
         close_side = "Sell" if side == "Buy" else "Buy"
+        ticker_resp = client.get_tickers(category="linear", symbol=symbol)
+        current_price = 0.0
+        if ticker_resp.get('retCode') == 0:
+            result = ticker_resp.get('result', {})
+            ticker_list = []
+            if isinstance(result, dict):
+                ticker_list = result.get('list', [])
+            elif isinstance(result, list):
+                ticker_list = result
+            if ticker_list:
+                current_price = float(ticker_list[0].get('lastPrice', 0.0))
 
-    try:
-        response = client.place_order(
+            place_resp = client.place_order(
                 category="linear",
                 symbol=symbol,
                 side=close_side,
                 orderType="Market",
                 qty=str(qty),
-            timeInForce="GoodTillCancel",
+                timeInForce="GTC",
                 reduceOnly=True
             )
-        return response['ret_code'] == 0
-    except Exception as e:
-        logger.error(f"Ошибка закрытия сделки {symbol} для пользователя {tg_id}: {e}")
 
+            if place_resp.get('retCode', -1) == 0:
+                trade_fee = 0
+                try:
+                    trades_resp = client.get_closed_pnl(category="linear", symbol=symbol)
+                    if trades_resp.get('retCode') == 0:
+                        trades = trades_resp.get('result', {}).get('list', [])
+                        for trade in trades:
+                            if trade.get('orderId') == order_id:
+                                trade_fee += float(trade.get('execFee', 0))
+                except Exception as e:
+                    logger.error(f"Ошибка при получении сделок: {e}")
+                    trade_fee = 0
+
+                pnl = (current_price - entry_price) * qty if side == "Buy" else (entry_price - current_price) * qty
+
+                if include_fee:
+                    pnl -= trade_fee
+                pnl_percent = (pnl / (entry_price * qty)) * 100 if entry_price * qty > 0 else 0
+                return True
+            else:
+                if message:
+                    await message.answer(f"Ошибка закрытия сделки {symbol}.",
+                                         reply_markup=inline_markup.back_to_main)
+                return False
+
+    except Exception as e:
+        logger.error(f"Ошибка закрытия сделки {symbol} для пользователя {tg_id}: {e}", exc_info=True)
+        if message:
+            await message.answer("Произошла ошибка при закрытии сделки.", reply_markup=inline_markup.back_to_main)
         return False
 
 
-def get_positive_percent(negative_percent: float, manual_positive_percent: float | None) -> float:
-    if manual_positive_percent and manual_positive_percent > 0:
-        return manual_positive_percent
-    return abs(negative_percent)
+async def close_trade_after_delay(tg_id: int, message, symbol: str, delay_sec: int):
+    """
+    Закрывает сделку пользователя после задержки delay_sec секунд.
+    """
+    try:
+        await asyncio.sleep(delay_sec)
+        result = await close_user_trade(tg_id, symbol, message)
+        if result:
+            await message.answer(f"Сделка {symbol} успешно закрыта по таймеру.",
+                                 reply_markup=inline_markup.back_to_main)
+        else:
+            await message.answer(f"Не удалось закрыть сделку {symbol} по таймеру.",
+                                 reply_markup=inline_markup.back_to_main)
+    except asyncio.CancelledError:
+        await message.answer(f"Закрытие сделки {symbol} по таймеру отменено.", reply_markup=inline_markup.back_to_main)

app/services/Bybit/functions/bybit_ws.py

@@ -0,0 +1,47 @@
+import asyncio
+import logging.config
+from pybit.unified_trading import WebSocket
+from websocket import WebSocketConnectionClosedException
+from logger_helper.logger_helper import LOGGING_CONFIG
+
+logging.config.dictConfig(LOGGING_CONFIG)
+logger = logging.getLogger("bybit_ws")
+
+event_loop = None  # Сюда нужно будет установить event loop из основного приложения
+
+
+def set_event_loop(loop: asyncio.AbstractEventLoop):
+    global event_loop
+    event_loop = loop
+
+
+def on_execution_callback(message, msg):
+    """
+    Callback на событие исполнения сделки.
+    Безопасно запускает асинхронный обработчик из sync callback.
+    """
+    if event_loop is not None:
+        from app.services.Bybit.functions.Futures import handle_execution_message  # Импорт внутри, чтобы избежать циклических импортов
+        asyncio.run_coroutine_threadsafe(handle_execution_message(message, msg), event_loop)
+    else:
+        logger.error("Event loop не установлен, callback пропущен.")
+
+
+async def start_execution_ws(api_key: str, api_secret: str, message):
+    """
+    Запускает и поддерживает WebSocket подключение для исполнения сделок.
+    Реконнект при потерях соединения.
+    """
+    reconnect_delay = 5
+    while True:
+        try:
+            ws = WebSocket(api_key=api_key, api_secret=api_secret, testnet=False, channel_type="private")
+            ws.execution_stream(lambda msg: on_execution_callback(message, msg))
+            while True:
+                await asyncio.sleep(1)  # Поддержание активности
+        except WebSocketConnectionClosedException:
+            logger.warning("WebSocket закрыт, переподключение через 5 секунд...")
+            await asyncio.sleep(reconnect_delay)
+        except Exception as e:
+            logger.error(f"Ошибка WebSocket: {e}")
+            await asyncio.sleep(reconnect_delay)

app/services/Bybit/functions/functions.py

@@ -1,18 +1,22 @@
-import asyncio
-import logging.config
+import logging.config
 from aiogram import F, Router
+
+from app.tasks.tasks import handle_stop_close_trade, handle_start_close_trade, handle_stop_trading, handle_start_trading
 from logger_helper.logger_helper import LOGGING_CONFIG
-from app.services.Bybit.functions import Futures, min_qty
-from app.services.Bybit.functions.Futures import open_position, close_user_trade, get_active_positions, trading_cycle
+
+from app.services.Bybit.functions.Futures import (close_user_trade, open_position, set_take_profit_stop_loss, \
+                                                  get_active_positions_by_symbol, get_active_orders_by_symbol,
+                                                  )
 from app.services.Bybit.functions.balance import get_balance
 import app.telegram.Keyboards.inline_keyboards as inline_markup
-import app.telegram.Keyboards.reply_keyboards as reply_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
 
-# FSM - Механизм состояния
-from aiogram.fsm.state import State, StatesGroup
+from app.states.States import (state_update_entry_type, state_update_symbol, state_limit_price,
+                               SetTP_SL_State, CloseTradeTimerState)
 from aiogram.fsm.context import FSMContext
 
 from app.services.Bybit.functions.get_valid_symbol import get_valid_symbols
@@ -23,71 +27,62 @@ logger = logging.getLogger("functions")
 router_functions_bybit_trade = Router()
 
 
-class state_update_symbol(StatesGroup):
-    symbol = State()
-
-
-class state_update_entry_type(StatesGroup):
-    entry_type = State()
-
-
-class TradeSetup(StatesGroup):
-    waiting_for_timer = State()
-    waiting_for_positive_percent = State()
-
-class state_limit_price(StatesGroup):
-    price = State()
-
-
-
 @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, state: FSMContext):
-    api = await rq.get_bybit_api_key(callback.from_user.id)
-    secret = await rq.get_bybit_secret_key(callback.from_user.id)
-    balance = await get_balance(callback.from_user.id, callback.message)
+async def clb_start_bybit_trade_message(callback: CallbackQuery) -> None:
+    """
+    Обработка нажатия кнопок запуска торговли или возврата в главное меню.
+    Отправляет информацию о балансе, символе, цене и инструкциях по торговле.
+    """
+    user_id = callback.from_user.id
+    balance = await get_balance(user_id, callback.message)
+    price = await get_price(user_id)
 
     if balance:
-        symbol = await rq.get_symbol(callback.from_user.id)
+        symbol = await rq.get_symbol(user_id)
 
-        text = f'''💎 Торговля на Bybit
-                
-⚖️ Ваш баланс (USDT): {balance}  
-📊 Текущая торговая пара: {symbol}
-
-Как начать торговлю?
-
-1️⃣ Проверьте и тщательно настройте все параметры в вашем профиле.  
-2️⃣ Нажмите ниже кнопку 'Указать торговую пару' и введите торговую пару, без лишних символов (например: BTCUSDT). 
-3️⃣ Нажмите кнопку 'Выбрать тип входа' и после нажмите начать торговлю. 
-'''
+        text = (
+            f"💎 Торговля на Bybit\n\n"
+            f"⚖️ Ваш баланс (USDT): {float(balance):.2f}\n"
+            f"📊 Текущая торговая пара: {symbol}\n"
+            f"$$$ Цена: {price}\n\n"
+            "Как начать торговлю?\n\n"
+            "1️⃣ Проверьте и тщательно настройте все параметры в вашем профиле.\n"
+            "2️⃣ Нажмите ниже кнопку 'Указать торговую пару' и введите торговую пару, без лишних символов (например: BTCUSDT).\n"
+            "3️⃣ Нажмите кнопку 'Выбрать тип входа' и после нажмите начать торговлю.\n"
+        )
         await callback.message.edit_text(text=text, parse_mode='html', reply_markup=inline_markup.trading_markup)
 
 
-async def start_bybit_trade_message(message, state):
-    api = await rq.get_bybit_api_key(message.from_user.id)
-    secret = await rq.get_bybit_secret_key(message.from_user.id)
+async def start_bybit_trade_message(message: Message) -> None:
+    """
+    Отправляет пользователю информацию о балансе, символе и текущей цене,
+    вместе с инструкциями по началу торговли.
+    """
     balance = await get_balance(message.from_user.id, message)
+    price = await get_price(message.from_user.id)
 
     if balance:
         symbol = await rq.get_symbol(message.from_user.id)
 
-        text = f'''💎 Торговля на Bybit
-                
-⚖️ Ваш баланс (USDT): {balance}  
-📊 Текущая торговая пара: {symbol}
-
-Как начать торговлю?
-
-1️⃣ Проверьте и тщательно настройте все параметры в вашем профиле.  
-2️⃣ Нажмите ниже кнопку 'Указать торговую пару' и введите торговую пару, без лишних символов (например: BTCUSDT).
-3️⃣ Нажмите кнопку 'Выбрать тип входа' и после нажмите начать торговлю.  
-'''
+        text = (
+            f"💎 Торговля на Bybit\n\n"
+            f"⚖️ Ваш баланс (USDT): {balance}\n"
+            f"📊 Текущая торговая пара: {symbol}\n"
+            f"$$$ Цена: {price}\n\n"
+            "Как начать торговлю?\n\n"
+            "1️⃣ Проверьте и тщательно настройте все параметры в вашем профиле.\n"
+            "2️⃣ Нажмите ниже кнопку 'Указать торговую пару' и введите торговую пару, без лишних символов (например: BTCUSDT).\n"
+            "3️⃣ Нажмите кнопку 'Выбрать тип входа' и после нажмите начать торговлю.\n"
+        )
 
         await message.answer(text=text, parse_mode='html', reply_markup=inline_markup.trading_markup)
 
 
 @router_functions_bybit_trade.callback_query(F.data == 'clb_update_trading_pair')
-async def update_symbol_for_trade_message(callback: CallbackQuery, state: FSMContext):
+async def update_symbol_for_trade_message(callback: CallbackQuery, state: FSMContext) -> None:
+    """
+    Начинает процедуру обновления торговой пары, переводит пользователя в состояние ожидания пары.
+    """
     await state.set_state(state_update_symbol.symbol)
 
     await callback.message.answer(
@@ -96,7 +91,11 @@ async def update_symbol_for_trade_message(callback: CallbackQuery, state: FSMCon
 
 
 @router_functions_bybit_trade.message(state_update_symbol.symbol)
-async def update_symbol_for_trade(message: Message, state: FSMContext):
+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)
@@ -108,20 +107,28 @@ async def update_symbol_for_trade(message: Message, state: FSMContext):
     await state.update_data(symbol=message.text)
     await message.answer('Пара была успешно обновлена')
     await rq.update_symbol(message.from_user.id, user_input)
-    await start_bybit_trade_message(message, state)
+    await start_bybit_trade_message(message)
 
     await state.clear()
 
 
 @router_functions_bybit_trade.callback_query(F.data == 'clb_update_entry_type')
-async def update_entry_type_message(callback: CallbackQuery, state: FSMContext):
+async def update_entry_type_message(callback: CallbackQuery, state: FSMContext) -> None:
+    """
+    Запрашивает у пользователя тип входа в позицию (Market или Limit).
+    """
     await state.set_state(state_update_entry_type.entry_type)
     await callback.message.answer("Выберите тип входа в позицию:", reply_markup=inline_markup.entry_order_type_markup)
     await callback.answer()
 
 
 @router_functions_bybit_trade.callback_query(lambda c: c.data and c.data.startswith('entry_order_type:'))
-async def entry_order_type_callback(callback: CallbackQuery, state: FSMContext):
+async def entry_order_type_callback(callback: CallbackQuery, state: FSMContext) -> None:
+    """
+    Обработка выбора типа входа в позицию.
+    Если Limit, запрашивает цену лимитного ордера.
+    Если Market — обновляет настройки.
+    """
     order_type = callback.data.split(':')[1]
 
     if order_type not in ['Market', 'Limit']:
@@ -148,18 +155,21 @@ async def entry_order_type_callback(callback: CallbackQuery, state: FSMContext):
 
 
 @router_functions_bybit_trade.message(state_limit_price.price)
-async def set_limit_price(message: Message, state: FSMContext):
+async def set_limit_price(message: Message, state: FSMContext) -> None:
+    """
+    Обрабатывает ввод цены лимитного ордера, проверяет формат и сохраняет настройки.
+    """
     try:
         price = float(message.text)
         if price <= 0:
-            await message.answer("Цена должна быть положительным числом. Попробуйте снова.", reply_markup=inline_markup.cancel)
+            await message.answer("Цена должна быть положительным числом. Попробуйте снова.",
+                                 reply_markup=inline_markup.cancel)
             return
     except ValueError:
         await message.answer("Некорректный формат цены. Введите число.", reply_markup=inline_markup.cancel)
         return
 
     await state.update_data(entry_order_type='Limit', limit_price=price)
-    data = await state.get_data()
 
     await rq.update_entry_order_type(message.from_user.id, 'Limit')
     await rq.update_limit_price(message.from_user.id, price)
@@ -168,86 +178,16 @@ async def set_limit_price(message: Message, state: FSMContext):
     await state.clear()
 
 
-
-@router_functions_bybit_trade.callback_query(F.data == "clb_my_deals")
-async def show_my_trades_callback(callback: CallbackQuery):
-    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)
-    symbol = await rq.get_symbol(tg_id)
-
-    trades = await get_active_positions(callback.message, api_key, secret_key, symbol)
-
-    if not trades:
-        await callback.message.answer("Нет активных позиций.")
-        await callback.answer()
-        return
-
-    keyboard = inline_markup.create_trades_inline_keyboard(trades)
-
-    await callback.message.answer(
-        "Выберите сделку из списка:",
-        reply_markup=keyboard
-    )
-    await callback.answer()
-
-
-@router_functions_bybit_trade.callback_query(lambda c: c.data and c.data.startswith('select_trade:'))
-async def on_trade_selected(callback: CallbackQuery):
-    symbol = callback.data.split(':')[1]
-
-    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)
-
-    positions = await get_active_positions(callback.message, api_key, secret_key, symbol)
-
-    # Если несколько позиций по символу, можно выбрать нужную или взять первую
-    if not positions:
-        await callback.message.answer("Позиция не найдена")
-        await callback.answer()
-        return
-
-    pos = positions[0]
-    symbol = pos.get('symbol')
-    side = pos.get('side')
-    entry_price = pos.get('entryPrice')  # Цена открытия позиции
-    current_price = pos.get('price')  # Текущая цена (если есть)
-
-    text = (f"Информация по позиции:\n"
-            f"Название: {symbol}\n"
-            f"Направление: {side}\n"
-            f"Цена покупки: {entry_price}\n"
-            f"Текущая цена: {current_price if current_price else 'N/A'}")
-
-    keyboard = inline_markup.create_close_deal_markup(symbol)
-
-    await callback.message.answer(text, reply_markup=keyboard)
-    await callback.answer()
-
-
-@router_functions_bybit_trade.callback_query(lambda c: c.data and c.data.startswith("close_deal:"))
-async def close_trade_callback(callback: CallbackQuery):
-    symbol = callback.data.split(':')[1]
-    tg_id = callback.from_user.id
-
-    result = await close_user_trade(tg_id, symbol)
-
-    if result:
-        await callback.message.answer(f"Сделка {symbol} успешно закрыта.")
-    else:
-        await callback.message.answer(f"Не удалось закрыть сделку {symbol}.")
-
-    await callback.answer()
-
-
 @router_functions_bybit_trade.callback_query(F.data == "clb_start_chatbot_trading")
-async def start_trading_process(callback: CallbackQuery, state: FSMContext):
+async def start_trading_process(callback: CallbackQuery) -> None:
+    """
+    Запускает торговый цикл в выбранном режиме Long/Short.
+    Проверяет API-ключи, режим торговли, маржинальный режим и открытые позиции,
+    затем запускает торговый цикл с задержкой или без неё.
+    """
     tg_id = callback.from_user.id
     message = callback.message
 
-    # Получаем настройки пользователя
     data_main_stgs = await rq.get_user_main_settings(tg_id)
     api_key = await rq.get_bybit_api_key(tg_id)
     secret_key = await rq.get_bybit_secret_key(tg_id)
@@ -255,24 +195,21 @@ async def start_trading_process(callback: CallbackQuery, state: FSMContext):
     margin_mode = data_main_stgs.get('margin_type', 'Isolated')
     trading_mode = data_main_stgs.get('trading_mode')
 
-    # Проверка API ключей
     if not api_key or not secret_key:
         await message.answer("❗️ У вас не настроены API ключи для Bybit.")
         await callback.answer()
         return
 
-    # Проверка режима торговли
     if trading_mode not in ['Long', 'Short', 'Smart', 'Switch']:
         await message.answer(f"❗️ Некорректный торговый режим: {trading_mode}")
         await callback.answer()
         return
 
-    # Проверка допустимости маржинального режима
     if margin_mode not in ['Isolated', 'Cross']:
         margin_mode = 'Isolated'
 
-    # Проверяем открытые позиции и маржинальный режим
     client = HTTP(api_key=api_key, api_secret=secret_key)
+
     try:
         positions_resp = client.get_positions(category='linear', symbol=symbol)
         positions = positions_resp.get('result', {}).get('list', [])
@@ -289,44 +226,228 @@ async def start_trading_process(callback: CallbackQuery, state: FSMContext):
                 f"(текущий режим: {existing_margin_mode})", show_alert=True)
             return
 
-    # Определяем сторону для открытия позиции
     if trading_mode == 'Long':
         side = 'Buy'
     elif trading_mode == 'Short':
         side = 'Sell'
     else:
-        await message.answer(f"Режим торговли '{trading_mode}' пока не поддерживается.")
+        await message.answer(f"Режим торговли '{trading_mode}' пока не поддерживается.",
+                             reply_markup=inline_markup.back_to_main)
         await callback.answer()
         return
 
-    # Сообщаем о начале торговли
     await message.answer("Начинаю торговлю с использованием текущих настроек...")
 
-    # Открываем позицию (вызывает Futures.open_position)
-    success = await open_position(tg_id, message, side=side, margin_mode=margin_mode)
-    if not success:
-        await message.answer('⚠️ Ошибка при совершении сделки', reply_markup=inline_markup.back_to_main)
-        return
-
-
-    # Проверяем таймер и информируем пользователя
 
     timer_data = await rq.get_user_timer(tg_id)
-    timer_minutes = timer_data.get('timer') if isinstance(timer_data, dict) else timer_data
-    if timer_minutes and timer_minutes > 0:
-        await message.answer(f"Торговля будет работать по таймеру: {timer_minutes} мин.")
-        asyncio.create_task(trading_cycle(tg_id, message))
+    if isinstance(timer_data, dict):
+        timer_minute = timer_data.get('timer_minutes', 0)
     else:
-        await message.answer(
-            "Торговля начата без ограничения по времени. Для остановки нажмите кнопку 'Закрыть сделку'.",
-            reply_markup=inline_markup.create_close_deal_markup(symbol)
-        )
+        timer_minute = timer_data or 0
+
+    if timer_minute > 0:
+        await handle_start_trading(tg_id, message)
+        await message.answer(f"Торговля начнётся через {timer_minute} мин. Для отмены нажмите кнопку ниже.",
+                             reply_markup=inline_markup.cancel_start_markup)
+        await rq.update_user_timer(tg_id, minutes=0)
+    else:
+        await open_position(tg_id, message, side=side, margin_mode=margin_mode)
 
     await callback.answer()
 
 
+@router_functions_bybit_trade.callback_query(F.data == "clb_my_deals")
+async def show_my_trades(callback: CallbackQuery) -> None:
+    """
+    Отображает пользователю выбор типа сделки по текущей торговой паре.
+    """
+    await callback.answer()
+    try:
+        symbol = await rq.get_symbol(callback.from_user.id)
+        await callback.message.answer(f"Выберите тип сделки для пары {symbol}:",
+                                      reply_markup=inline_markup.my_deals_select_markup)
+    except Exception as e:
+        logger.error(f"Произошла ошибка при выборе типа сделки: {e}")
+
+
+@router_functions_bybit_trade.callback_query(F.data == "clb_open_deals")
+async def show_my_trades_callback(callback: CallbackQuery):
+    """
+    Показывает открытые позиции пользователя по символу.
+    """
+    await callback.answer()
+
+    try:
+        await get_active_positions_by_symbol(callback.from_user.id, message=callback.message)
+    except Exception as e:
+        logger.error(f"Произошла ошибка при выборе сделки: {e}")
+        await callback.message.answer("Произошла ошибка при выборе сделки", reply_markup=inline_markup.back_to_main)
+
+
+@router_functions_bybit_trade.callback_query(F.data == "clb_open_orders")
+async def show_my_orders_callback(callback: CallbackQuery) -> None:
+    """
+    Показывает открытые позиции пользователя по символу.
+    """
+    await callback.answer()
+
+    try:
+        await get_active_orders_by_symbol(callback.from_user.id, message=callback.message)
+    except Exception as e:
+        logger.error(f"Произошла ошибка при выборе ордера: {e}")
+        await callback.message.answer("Произошла ошибка при выборе ордера", reply_markup=inline_markup.back_to_main)
+
+
+@router_functions_bybit_trade.callback_query(F.data == "clb_set_tp_sl")
+async def set_tp_sl(callback: CallbackQuery, state: FSMContext) -> None:
+    """
+    Показывает активные ордера пользователя.
+    """
+    await callback.answer()
+    await state.set_state(SetTP_SL_State.waiting_for_take_profit)
+    await callback.message.answer("Введите значение Take Profit (в цене, например 26000.5):",
+                                  reply_markup=inline_markup.cancel)
+
+
+@router_functions_bybit_trade.message(SetTP_SL_State.waiting_for_take_profit)
+async def process_take_profit(message: Message, state: FSMContext) -> None:
+    """
+    Обрабатывает ввод значения Take Profit и запрашивает Stop Loss.
+    """
+    try:
+        tp = float(message.text.strip())
+        if tp <= 0:
+            await message.answer("Значение Take Profit должно быть положительным числом. Попробуйте снова.",
+                                 reply_markup=inline_markup.cancel)
+            return
+    except ValueError:
+        await message.answer("Некорректный ввод. Пожалуйста, введите число для Take Profit.",
+                             reply_markup=inline_markup.cancel)
+        return
+
+    await state.update_data(take_profit=tp)
+    await state.set_state(SetTP_SL_State.waiting_for_stop_loss)
+    await message.answer("Введите значение Stop Loss (в цене, например 24500.3):", reply_markup=inline_markup.cancel)
+
+
+@router_functions_bybit_trade.message(SetTP_SL_State.waiting_for_stop_loss)
+async def process_stop_loss(message: Message, state: FSMContext) -> None:
+    """
+    Обрабатывает ввод значения Stop Loss и завершает процесс установки TP/SL.
+    """
+    try:
+        sl = float(message.text.strip())
+        if sl <= 0:
+            await message.answer("Значение Stop Loss должно быть положительным числом. Попробуйте снова.",
+                                 reply_markup=inline_markup.cancel)
+            return
+    except ValueError:
+        await message.answer("Некорректный ввод. Пожалуйста, введите число для Stop Loss.",
+                             reply_markup=inline_markup.cancel)
+        return
+
+    data = await state.get_data()
+    tp = data.get("take_profit")
+
+    if tp is None:
+        await message.answer("Ошибка, не найдено значение Take Profit. Попробуйте снова.")
+        await state.clear()
+        return
+
+    tg_id = message.from_user.id
+
+    await set_take_profit_stop_loss(tg_id, message, take_profit_price=tp, stop_loss_price=sl)
+
+    await state.clear()
+
+
+@router_functions_bybit_trade.callback_query(F.data == "clb_stop_timer")
+async def cancel_start_callback(callback: CallbackQuery) -> None:
+    """
+    Отменяет задачу старта торговли по таймеру, если она активна.
+    """
+    tg_id = callback.from_user.id
+    await handle_stop_close_trade(tg_id)
+
+    await callback.message.answer("Торговля по таймеру отменена.", reply_markup=inline_markup.back_to_main)
+    await callback.answer()
+
+
+@router_functions_bybit_trade.callback_query(lambda c: c.data and c.data.startswith("close_deal:"))
+async def close_trade_callback(callback: CallbackQuery) -> None:
+    """
+    Закрывает сделку пользователя по символу.
+    """
+    symbol = callback.data.split(':')[1]
+    tg_id = callback.from_user.id
+
+    result = await close_user_trade(tg_id, symbol, message=callback.message)
+
+    if result:
+        await handle_stop_trading(tg_id)
+        logger.info(f"Сделка {symbol} успешно закрыта.")
+    else:
+        logger.error(f"Не удалось закрыть сделку {symbol}.")
+        await callback.message.answer(f"Не удалось закрыть сделку {symbol}.")
+
+    await callback.answer()
+
+
+@router_functions_bybit_trade.callback_query(lambda c: c.data and c.data.startswith("close_deal_by_timer:"))
+async def ask_close_delay(callback: CallbackQuery, state: FSMContext) -> None:
+    """
+    Запускает диалог с пользователем для задания задержки перед закрытием сделки.
+    """
+    symbol = callback.data.split(":")[1]
+    await state.update_data(symbol=symbol)
+    await state.set_state(CloseTradeTimerState.waiting_for_delay)
+    await callback.message.answer("Введите задержку в минутах до закрытия сделки (например, 60):",
+                                  reply_markup=inline_markup.cancel)
+    await callback.answer()
+
+
+@router_functions_bybit_trade.message(CloseTradeTimerState.waiting_for_delay)
+async def process_close_delay(message: Message, state: FSMContext) -> None:
+    """
+    Обрабатывает ввод задержки и запускает задачу закрытия сделки с задержкой.
+    """
+    try:
+        delay_minutes = int(message.text.strip())
+        if delay_minutes <= 0:
+            await message.answer("Введите положительное число.")
+            return
+    except ValueError:
+        await message.answer("Некорректный ввод. Введите число в минутах.")
+        return
+
+    data = await state.get_data()
+    symbol = data.get("symbol")
+    tg_id = message.from_user.id
+
+    delay = delay_minutes * 60
+
+    await handle_start_close_trade(tg_id, message, symbol, delay)
+
+    await message.answer(f"Закрытие сделки {symbol} запланировано через {delay} секунд.",
+                         reply_markup=inline_markup.cancel_start_markup)
+    await state.clear()
+
+
+@router_functions_bybit_trade.callback_query(F.data == "clb_change_martingale_reset")
+async def reset_martingale(callback: CallbackQuery) -> None:
+    """
+    Сбрасывает шаги мартингейла пользователя.
+    """
+    tg_id = callback.from_user.id
+    await rq.update_martingale_step(tg_id, 0)
+    await callback.answer("Сброс шагов выполнен.")
+
+
 @router_functions_bybit_trade.callback_query(F.data == "clb_cancel")
-async def cancel(callback: CallbackQuery, state: FSMContext):
+async def cancel(callback: CallbackQuery, state: FSMContext) -> None:
+    """
+    Отменяет текущее состояние FSM и сообщает пользователю об отмене.
+    """
     await state.clear()
     await callback.message.answer("Отменено!", reply_markup=inline_markup.back_to_main)
     await callback.answer()

app/states/States.py

@@ -0,0 +1,47 @@
+from aiogram.fsm.state import State, StatesGroup
+
+
+class state_update_symbol(StatesGroup):
+    """FSM состояние для обновления торгового символа."""
+    symbol = State()
+
+
+class state_update_entry_type(StatesGroup):
+    """FSM состояние для обновления типа входа."""
+    entry_type = State()
+
+
+class TradeSetup(StatesGroup):
+    """FSM состояния для настройки торговли с таймером и процентом."""
+    waiting_for_timer = State()
+    waiting_for_positive_percent = State()
+
+
+class state_limit_price(StatesGroup):
+    """FSM состояние для установки лимита."""
+    price = State()
+
+
+class CloseTradeTimerState(StatesGroup):
+    """FSM состояние ожидания задержки перед закрытием сделки."""
+    waiting_for_delay = State()
+
+
+class SetTP_SL_State(StatesGroup):
+    """FSM состояние для установки TP и SL."""
+    waiting_for_take_profit = State()
+    waiting_for_stop_loss = State()
+
+
+class update_risk_management_settings(StatesGroup):
+    """FSM состояние для обновления настроек управления рисками."""
+    price_profit = State()
+    price_loss = State()
+    max_risk_deal = State()
+    commission_fee = State()
+
+
+class state_reg_bybit_api(StatesGroup):
+    """FSM состояние для регистрации API Bybit."""
+    api_key = State()
+    secret_key = State()

app/tasks/tasks.py

@@ -0,0 +1,98 @@
+import asyncio
+import logging.config
+from typing import Optional
+from app.services.Bybit.functions.Futures import close_trade_after_delay, trading_cycle
+from logger_helper.logger_helper import LOGGING_CONFIG
+
+logging.config.dictConfig(LOGGING_CONFIG)
+logger = logging.getLogger("tasks")
+
+active_start_tasks = {}
+active_close_tasks = {}
+
+lock_start_tasks = asyncio.Lock()
+lock_close_tasks = asyncio.Lock()
+
+
+def start_trading_cycle(tg_id, message) -> None:
+    """
+    Запускает асинхронную задачу торгового цикла для пользователя с указанным tg_id.
+    """
+    task = asyncio.create_task(trading_cycle(tg_id, message))
+    active_start_tasks[tg_id] = task
+
+
+def stop_trading_cycle(tg_id) -> None:
+    """
+    Останавливает (отменяет) задачу торгового цикла для пользователя с указанным tg_id.
+    """
+    task: Optional[asyncio.Task] = active_start_tasks.pop(tg_id, None)
+    if task:
+        task.cancel()
+
+
+def start_close_trade_task(tg_id, message, symbol, delay_sec) -> None:
+    """
+    Запускает асинхронную задачу автоматического закрытия сделки после задержки.
+    """
+    task = asyncio.create_task(close_trade_after_delay(tg_id, message, symbol, delay_sec))
+    active_close_tasks[tg_id] = task
+
+
+def stop_close_trade_task(tg_id) -> None:
+    """
+    Останавливает (отменяет) задачу автоматического закрытия сделки для пользователя.
+    """
+    task: Optional[asyncio.Task] = active_close_tasks.pop(tg_id, None)
+    if task:
+        task.cancel()
+
+
+async def handle_start_trading(tg_id: int, message):
+    """
+    Запускает торговый цикл. Если уже есть запущенная задача, отменяет её.
+    """
+    async with lock_start_tasks:
+        old_task = active_start_tasks.get(tg_id)
+        if old_task and not old_task.done():
+            old_task.cancel()
+            try:
+                await old_task
+            except asyncio.CancelledError:
+                logger.info(f"Старая задача торговли для пользователя {tg_id} отменена")
+        start_trading_cycle(tg_id, message)
+        logger.info(f"Новая задача торговли запущена для пользователя {tg_id}")
+
+
+async def handle_stop_trading(tg_id: int):
+    """
+    Останавливает торговую задачу пользователя, если она активна.
+    """
+    async with lock_start_tasks:
+        stop_trading_cycle(tg_id)
+        logger.info(f"Задача торговли остановлена для пользователя {tg_id}")
+
+
+async def handle_start_close_trade(tg_id: int, message, symbol: str, delay_sec: int):
+    """
+    Запускает задачу закрытия сделки с задержкой. Отменяет старую задачу, если есть.
+    """
+    async with lock_close_tasks:
+        old_task = active_close_tasks.get(tg_id)
+        if old_task and not old_task.done():
+            old_task.cancel()
+            try:
+                await old_task
+            except asyncio.CancelledError:
+                logger.info(f"Старая задача закрытия сделки пользователя {tg_id} отменена")
+        start_close_trade_task(tg_id, message, symbol, delay_sec)
+        logger.info(f"Задача закрытия сделки для {symbol} запущена с задержкой {delay_sec}s для пользователя {tg_id}")
+
+
+async def handle_stop_close_trade(tg_id: int):
+    """
+    Отменяет задачу закрытия сделки пользователя, если она есть.
+    """
+    async with lock_close_tasks:
+        stop_close_trade_task(tg_id)
+        logger.info(f"Задача закрытия сделки отменена для пользователя {tg_id}")

app/telegram/Keyboards/inline_keyboards.py

@@ -1,4 +1,5 @@
 from aiogram.types import InlineKeyboardButton, InlineKeyboardMarkup
+from aiogram.utils.keyboard import InlineKeyboardBuilder
 
 start_markup = InlineKeyboardMarkup(inline_keyboard=[
     [InlineKeyboardButton(text="🔥 Начать торговлю", callback_data="clb_start_chatbot_message")]
@@ -37,6 +38,7 @@ 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")],
 
 ])
 
@@ -71,7 +73,8 @@ main_settings_markup = InlineKeyboardMarkup(inline_keyboard=[
      InlineKeyboardButton(text='Начальная ставка', callback_data='clb_change_starting_quantity')],
 
     [InlineKeyboardButton(text='Коэффициент Мартингейла', callback_data='clb_change_martingale_factor'),
-     InlineKeyboardButton(text='Максимальное кол-во ставок', callback_data='clb_change_maximum_quantity')],
+     InlineKeyboardButton(text='Сбросить шаги Мартингейла', callback_data='clb_change_martingale_reset')],
+     [InlineKeyboardButton(text='Максимальное кол-во ставок', callback_data='clb_change_maximum_quantity')],
 
     back_btn_list_settings,
     back_btn_to_main
@@ -82,7 +85,7 @@ risk_management_settings_markup = InlineKeyboardMarkup(inline_keyboard=[
      InlineKeyboardButton(text='Изм. цены убытков', callback_data='clb_change_price_loss')],
 
     [InlineKeyboardButton(text='Макс. риск на сделку', callback_data='clb_change_max_risk_deal')],
-    [InlineKeyboardButton(text='Комиссия биржи', callback_data='commission_fee')],
+    [InlineKeyboardButton(text='Учитывать комиссию биржи (Да/Нет)', callback_data='commission_fee')],
 
     back_btn_list_settings,
     back_btn_to_main
@@ -139,9 +142,9 @@ trigger_markup = InlineKeyboardMarkup(inline_keyboard=[  # ИЗМЕНИТЬ НА
     [InlineKeyboardButton(text="Автоматический", callback_data="clb_trigger_auto")]
 ])
 
-buttons_yes_no_markup = InlineKeyboardMarkup(inline_keyboard=[  # ИЗМЕНИТЬ НА INLINE
+buttons_yes_no_markup = InlineKeyboardMarkup(inline_keyboard=[
     [InlineKeyboardButton(text='Да', callback_data="clb_yes"),
-     InlineKeyboardButton(text='Нет', callback_data="clb_yes")]
+     InlineKeyboardButton(text='Нет', callback_data="clb_no")],
 ])
 
 buttons_on_off_markup = InlineKeyboardMarkup(inline_keyboard=[  # ИЗМЕНИТЬ НА INLINE
@@ -149,26 +152,35 @@ buttons_on_off_markup = InlineKeyboardMarkup(inline_keyboard=[  # ИЗМЕНИТ
      InlineKeyboardButton(text='Выключить', callback_data="clb_off")]
 ])
 
+my_deals_select_markup = InlineKeyboardMarkup(inline_keyboard=[
+    [InlineKeyboardButton(text='Открытые сделки', callback_data="clb_open_deals"),
+     InlineKeyboardButton(text='Открытые ордера', callback_data="clb_open_orders")],
+    back_btn_to_main
+])
 
 def create_trades_inline_keyboard(trades):
-    buttons = []
+    builder = InlineKeyboardBuilder()
     for trade in trades:
         symbol = trade['symbol'] if isinstance(trade, dict) else trade.symbol
-        buttons.append([
-            InlineKeyboardButton(text=f"{symbol}", callback_data=f"show_deal_{symbol}")
-        ])
-    return InlineKeyboardMarkup(inline_keyboard=buttons)
+        builder.button(text=symbol, callback_data=f"show_deal_{symbol}")
+    builder.adjust(2)
+    return builder.as_markup()
 
 
 def create_close_deal_markup(symbol: str) -> InlineKeyboardMarkup:
     return InlineKeyboardMarkup(inline_keyboard=[
         [InlineKeyboardButton(text="Закрыть сделку", callback_data=f"close_deal:{symbol}")],
+        [InlineKeyboardButton(text="Закрыть по таймеру", callback_data=f"close_deal_by_timer:{symbol}")],
+        [InlineKeyboardButton(text="Установить TP/SL", callback_data="clb_set_tp_sl")],
         back_btn_to_main
     ])
 
 
 timer_markup = InlineKeyboardMarkup(inline_keyboard=[
     [InlineKeyboardButton(text="Установить таймер", callback_data="clb_set_timer")],
-    [InlineKeyboardButton(text="Остановить таймер", callback_data="clb_stop_timer")],
     back_btn_to_main
 ])
+
+cancel_start_markup = InlineKeyboardMarkup(inline_keyboard=[
+    [InlineKeyboardButton(text="Отменить таймер", callback_data="clb_stop_timer")]
+])

app/telegram/Keyboards/reply_keyboards.py

@@ -3,4 +3,4 @@
 base_buttons_markup = ReplyKeyboardMarkup(keyboard=[
     [KeyboardButton(text="👤 Профиль")],    
     # [KeyboardButton(text="Настройки")]         
-], resize_keyboard=True)
+], resize_keyboard=True, one_time_keyboard=False)

app/telegram/database/models.py

@@ -1,31 +1,55 @@
-import logging
-from datetime import datetime
-
+from datetime import datetime
+import logging.config
 from sqlalchemy.sql.sqltypes import DateTime
 
-logger = logging.getLogger(__name__)
-
 from sqlalchemy import BigInteger, Boolean, Integer, String, ForeignKey
 from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
 from sqlalchemy.ext.asyncio import AsyncAttrs, async_sessionmaker, create_async_engine
-
+from logger_helper.logger_helper import LOGGING_CONFIG
 from sqlalchemy import select, insert
 
+logging.config.dictConfig(LOGGING_CONFIG)
+logger = logging.getLogger("models")
+
 engine = create_async_engine(url='sqlite+aiosqlite:///db.sqlite3')
 
 async_session = async_sessionmaker(engine)
 
+
 class Base(AsyncAttrs, DeclarativeBase):
+    """Базовый класс для declarative моделей SQLAlchemy с поддержкой async."""
     pass
 
+
 class User_Telegram_Id(Base):
+    """
+    Модель таблицы user_telegram_id.
+
+    Хранит идентификаторы Telegram пользователей.
+
+    Атрибуты:
+        id (int): Внутренний первичный ключ записи.
+        tg_id (int): Уникальный идентификатор пользователя Telegram.
+    """
     __tablename__ = 'user_telegram_id'
 
     id: Mapped[int] = mapped_column(primary_key=True)
 
     tg_id = mapped_column(BigInteger)
 
+
 class User_Bybit_API(Base):
+    """
+    Модель таблицы user_bybit_api.
+
+    Хранит API ключи и секреты Bybit для каждого Telegram пользователя.
+
+    Атрибуты:
+        id (int): Внутренний первичный ключ записи.
+        tg_id (int): Внешний ключ на Telegram пользователя (user_telegram_id.tg_id).
+        api_key (str): API ключ Bybit (уникальный для пользователя).
+        secret_key (str): Секретный ключ Bybit (уникальный для пользователя).
+    """
     __tablename__ = 'user_bybit_api'
 
     id: Mapped[int] = mapped_column(primary_key=True)
@@ -35,7 +59,26 @@ class User_Bybit_API(Base):
     api_key = mapped_column(String(18), default='None')
     secret_key = mapped_column(String(36), default='None')
 
+
 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)
@@ -44,28 +87,69 @@ class User_Symbol(Base):
 
     symbol = mapped_column(String(18), default='PENGUUSDT')
 
+
 class Trading_Mode(Base):
+    """
+    Справочник доступных режимов торговли.
+
+    Атрибуты:
+        id (int): Первичный ключ.
+        mode (str): Уникальный режим (например, 'Long', 'Short').
+    """
     __tablename__ = 'trading_modes'
 
     id: Mapped[int] = mapped_column(primary_key=True)
 
     mode = mapped_column(String(10), unique=True)
 
+
 class Margin_type(Base):
+    """
+    Справочник типов маржинальной торговли.
+
+    Атрибуты:
+        id (int): Первичный ключ.
+        type (str): Тип маржи (например, 'Isolated', 'Cross').
+    """
     __tablename__ = 'margin_types'
 
     id: Mapped[int] = mapped_column(primary_key=True)
 
     type = mapped_column(String(15), unique=True)
 
+
 class Trigger(Base):
+    """
+    Справочник видов триггеров для сделок.
+
+    Атрибуты:
+        id (int): Первичный ключ.
+        trigger (str): Название триггера (например, 'Ручной', 'Автоматический').
+    """
     __tablename__ = 'triggers'
 
     id: Mapped[int] = mapped_column(primary_key=True)
 
     trigger = mapped_column(String(15), unique=True)
 
+
 class User_Main_Settings(Base):
+    """
+    Основные настройки пользователя для торговли.
+
+    Атрибуты:
+        id (int): Первичный ключ.
+        tg_id (int): Внешний ключ на Telegram пользователя.
+        trading_mode (str): Режим торговли, FK на trading_modes.mode.
+        margin_type (str): Тип маржи, FK на 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 (Optional[str]): Цена лимитного ордера, если есть.
+    """
     __tablename__ = 'user_main_settings'
 
     id: Mapped[int] = mapped_column(primary_key=True)
@@ -84,6 +168,17 @@ class User_Main_Settings(Base):
 
 
 class User_Risk_Management_Settings(Base):
+    """
+    Настройки управления рисками пользователя.
+
+    Атрибуты:
+        id (int): Первичный ключ.
+        tg_id (int): Внешний ключ на Telegram пользователя.
+        price_profit (int): Процент прибыли для трейда.
+        price_loss (int): Процент убытка для трейда.
+        max_risk_deal (int): Максимально допустимый риск по сделке в процентах.
+        commission_fee (str): Учитывать ли комиссию в расчетах ("Да"/"Нет").
+    """
     __tablename__ = 'user_risk_management_settings'
 
     id: Mapped[int] = mapped_column(primary_key=True)
@@ -93,9 +188,24 @@ class User_Risk_Management_Settings(Base):
     price_profit = mapped_column(Integer(), default=1)
     price_loss = mapped_column(Integer(), default=1)
     max_risk_deal = mapped_column(Integer(), default=100)
-    commission_fee = mapped_column(Integer(), default=0)
+    commission_fee = mapped_column(String(), default="Да")
+
 
 class User_Condition_Settings(Base):
+    """
+    Дополнительные пользовательские условия для торговли.
+
+    Атрибуты:
+        id (int): Первичный ключ.
+        tg_id (int): Внешний ключ на Telegram пользователя.
+        trigger (str): Тип триггера, FK на triggers.trigger.
+        filter_time (str): Временной фильтр.
+        filter_volatility (bool): Фильтр по волатильности.
+        external_cues (bool): Внешние сигналы.
+        tradingview_cues (bool): Сигналы TradingView.
+        webhook (str): URL webhook.
+        ai_analytics (bool): Использование AI для аналитики.
+    """
     __tablename__ = 'user_condition_settings'
 
     id: Mapped[int] = mapped_column(primary_key=True)
@@ -110,7 +220,18 @@ class User_Condition_Settings(Base):
     webhook = mapped_column(String(40), default='')
     ai_analytics = mapped_column(Boolean, default=False)
 
+
 class User_Additional_Settings(Base):
+    """
+    Прочие дополнительные настройки пользователя.
+
+    Атрибуты:
+        id (int): Первичный ключ.
+        tg_id (int): Внешний ключ на Telegram пользователя.
+        pattern_save (bool): Сохранять ли шаблоны.
+        autostart (bool): Автоматический запуск.
+        notifications (bool): Получение уведомлений.
+    """
     __tablename__ = 'user_additional_settings'
 
     id: Mapped[int] = mapped_column(primary_key=True)
@@ -121,7 +242,55 @@ class User_Additional_Settings(Base):
     autostart = mapped_column(Boolean, default=False)
     notifications = mapped_column(Boolean, default=False)
 
+
+class USER_DEALS(Base):
+    """
+    Таблица сделок пользователя.
+
+    Атрибуты:
+        id (int): Первичный ключ.
+        tg_id (int): Внешний ключ на Telegram пользователя.
+        symbol (str): Торговая пара.
+        side (str): Направление сделки (Buy/Sell).
+        open_price (int): Цена открытия.
+        positive_percent (int): Процент доходности.
+    """
+    __tablename__ = 'user_deals'
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+
+    tg_id = mapped_column(ForeignKey("user_telegram_id.tg_id"))
+
+    symbol = mapped_column(String(18), default='PENGUUSDT')
+    side = mapped_column(String(10), nullable=False)
+    open_price = mapped_column(Integer(), nullable=False)
+    positive_percent = mapped_column(Integer(), nullable=False)
+
+
+class UserTimer(Base):
+    """
+    Таймер пользователя для отсроченного запуска сделок.
+
+    Атрибуты:
+        id (int): Первичный ключ.
+        tg_id (int): Внешний ключ на Telegram пользователя.
+        timer_minutes (int): Количество минут таймера.
+        timer_start (datetime): Время начала таймера.
+        timer_end (Optional[datetime]): Время окончания таймера (если установлено).
+    """
+    __tablename__ = 'user_timers'
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    tg_id = mapped_column(ForeignKey("user_telegram_id.tg_id"))
+    timer_minutes = mapped_column(Integer, nullable=False, default=0)
+    timer_start = mapped_column(DateTime, default=datetime.utcnow)
+    timer_end = mapped_column(DateTime, nullable=True)
+
+
 async def async_main():
+    """
+    Асинхронное создание всех таблиц и заполнение справочников начальными данными.
+    """
     async with engine.begin() as conn:
         await conn.run_sync(Base.metadata.create_all)
 
@@ -146,26 +315,3 @@ async def async_main():
             if not result.first():
                 logger.info("Заполение таблицы триггеров")
                 await conn.execute(Trigger.__table__.insert().values(trigger=trigger))
-
-
-class USER_DEALS(Base):
-    __tablename__ = 'user_deals'
-
-    id: Mapped[int] = mapped_column(primary_key=True)
-
-    tg_id = mapped_column(ForeignKey("user_telegram_id.tg_id"))
-
-    symbol = mapped_column(String(18), default='PENGUUSDT')
-    side = mapped_column(String(10), nullable=False)
-    open_price = mapped_column(Integer(), nullable=False)
-    positive_percent = mapped_column(Integer(), nullable=False)
-
-
-class UserTimer(Base):
-    __tablename__ = 'user_timers'
-
-    id: Mapped[int] = mapped_column(primary_key=True)
-    tg_id = mapped_column(ForeignKey("user_telegram_id.tg_id"))
-    timer_minutes = mapped_column(Integer, nullable=False, default=0)
-    timer_start = mapped_column(DateTime, default=datetime.utcnow)
-    timer_end = mapped_column(DateTime, nullable=True)

app/telegram/database/requests.py

@@ -3,29 +3,37 @@ from logger_helper.logger_helper import LOGGING_CONFIG
 from datetime import datetime, timedelta
 from typing import Any
 
+from app.telegram.database.models import (
+    async_session,
+    User_Telegram_Id as UTi,
+    User_Main_Settings as UMS,
+    User_Bybit_API as UBA,
+    User_Symbol,
+    User_Risk_Management_Settings as URMS,
+    User_Condition_Settings as UCS,
+    User_Additional_Settings as UAS,
+    Trading_Mode,
+    Margin_type,
+    Trigger,
+    USER_DEALS,
+    UserTimer,
+)
+
+from sqlalchemy import select, update
+
 logging.config.dictConfig(LOGGING_CONFIG)
 logger = logging.getLogger("requests")
 
-from app.telegram.database.models import async_session
-from app.telegram.database.models import User_Telegram_Id as UTi
-from app.telegram.database.models import User_Main_Settings as UMS
-from app.telegram.database.models import User_Bybit_API as UBA
-from app.telegram.database.models import User_Symbol
-from app.telegram.database.models import User_Risk_Management_Settings as URMS
-from app.telegram.database.models import User_Condition_Settings as UCS
-from app.telegram.database.models import User_Additional_Settings as UAS
-from app.telegram.database.models import Trading_Mode
-from app.telegram.database.models import Margin_type
-from app.telegram.database.models import Trigger
-from app.telegram.database.models import USER_DEALS, UserTimer
 
-import app.telegram.functions.functions as func  # functions
+# --- Функции сохранения в БД ---
 
-from sqlalchemy import select, delete, update
+async def save_tg_id_new_user(tg_id) -> None:
+    """
+    Сохраняет Telegram ID нового пользователя в базу, если такого ещё нет.
 
-
-# SET_DB
-async def save_tg_id_new_user(tg_id):
+    Args:
+        tg_id (int): Telegram ID пользователя.
+    """
     async with async_session() as session:
         user = await session.scalar(select(UTi).where(UTi.tg_id == tg_id))
 
@@ -37,26 +45,33 @@ async def save_tg_id_new_user(tg_id):
         await session.commit()
 
 
-async def set_new_user_bybit_api(tg_id):
+async def set_new_user_bybit_api(tg_id) -> None:
+    """
+    Создаёт запись API пользователя Bybit, если её ещё нет.
+
+    Args:
+        tg_id (int): Telegram ID пользователя.
+    """
     async with async_session() as session:
         user = await session.scalar(select(UBA).where(UBA.tg_id == tg_id))
 
         if not user:
-            session.add(UBA(
-                tg_id=tg_id,
-            ))
-
+            session.add(UBA(tg_id=tg_id))
         await session.commit()
 
 
-async def set_new_user_symbol(tg_id):
+async def set_new_user_symbol(tg_id) -> None:
+    """
+    Создаёт запись торгового символа пользователя, если её нет.
+
+    Args:
+        tg_id (int): Telegram ID пользователя.
+    """
     async with async_session() as session:
         user = await session.scalar(select(User_Symbol).where(User_Symbol.tg_id == tg_id))
 
         if not user:
-            session.add(User_Symbol(
-                tg_id=tg_id
-            ))
+            session.add(User_Symbol(tg_id=tg_id))
 
             logger.info(f"Symbol был успешно добавлен %s", tg_id)
 
@@ -64,6 +79,14 @@ async def set_new_user_symbol(tg_id):
 
 
 async def set_new_user_default_main_settings(tg_id, trading_mode, margin_type) -> None:
+    """
+    Создаёт основные настройки пользователя по умолчанию.
+
+    Args:
+        tg_id (int): Telegram ID пользователя.
+        trading_mode (str): Режим торговли.
+        margin_type (str): Тип маржи.
+    """
     async with async_session() as session:
         settings = await session.scalar(select(UMS).where(UMS.tg_id == tg_id))
 
@@ -80,6 +103,12 @@ async def set_new_user_default_main_settings(tg_id, trading_mode, margin_type) -
 
 
 async def set_new_user_default_risk_management_settings(tg_id) -> None:
+    """
+    Создаёт настройки риск-менеджмента по умолчанию.
+
+    Args:
+        tg_id (int): Telegram ID пользователя.
+    """
     async with async_session() as session:
         settings = await session.scalar(select(URMS).where(URMS.tg_id == tg_id))
 
@@ -94,6 +123,13 @@ async def set_new_user_default_risk_management_settings(tg_id) -> None:
 
 
 async def set_new_user_default_condition_settings(tg_id, trigger) -> None:
+    """
+    Создаёт условные настройки по умолчанию.
+
+    Args:
+        tg_id (int): Telegram ID пользователя.
+        trigger (Any): Значение триггера по умолчанию.
+    """
     async with async_session() as session:
         settings = await session.scalar(select(UCS).where(UCS.tg_id == tg_id))
 
@@ -109,6 +145,12 @@ async def set_new_user_default_condition_settings(tg_id, trigger) -> None:
 
 
 async def set_new_user_default_additional_settings(tg_id) -> None:
+    """
+    Создаёт дополнительные настройки по умолчанию.
+
+    Args:
+        tg_id (int): Telegram ID пользователя.
+    """
     async with async_session() as session:
         settings = await session.scalar(select(UAS).where(UAS.tg_id == tg_id))
 
@@ -122,32 +164,46 @@ async def set_new_user_default_additional_settings(tg_id) -> None:
         await session.commit()
 
 
-# GET_DB
+# --- Функции получения данных из БД ---
+
 async def check_user(tg_id):
+    """
+    Проверяет наличие пользователя в базе.
+
+    Args:
+        tg_id (int): Telegram ID пользователя.
+
+    Returns:
+        Optional[UTi]: Пользователь или None.
+    """
     async with async_session() as session:
         user = await session.scalar(select(UTi).where(UTi.tg_id == tg_id))
         return user
 
 
 async def get_bybit_api_key(tg_id):
+    """Получить API ключ Bybit пользователя."""
     async with async_session() as session:
         api_key = await session.scalar(select(UBA.api_key).where(UBA.tg_id == tg_id))
         return api_key
 
 
 async def get_bybit_secret_key(tg_id):
+    """Получить секретный ключ Bybit пользователя."""
     async with async_session() as session:
         secret_key = await session.scalar(select(UBA.secret_key).where(UBA.tg_id == tg_id))
         return secret_key
 
 
 async def get_symbol(tg_id):
+    """Получить символ пользователя."""
     async with async_session() as session:
         symbol = await session.scalar(select(User_Symbol.symbol).where(User_Symbol.tg_id == tg_id))
         return symbol
 
 
 async def get_user_trades(tg_id):
+    """Получить сделки пользователя."""
     async with async_session() as session:
         query = select(USER_DEALS.symbol, USER_DEALS.side).where(USER_DEALS.tg_id == tg_id)
         result = await session.execute(query)
@@ -155,14 +211,63 @@ async def get_user_trades(tg_id):
         return trades
 
 
+async def get_entry_order_type(tg_id: object) -> str | None | Any:
+    """Получить тип входного ордера пользователя."""
+    async with async_session() as session:
+        order_type = await session.scalar(
+            select(UMS.entry_order_type).where(UMS.tg_id == tg_id)
+        )
+        # Если в базе не установлен тип — возвращаем значение по умолчанию
+        return order_type or 'Market'
+
+
+# --- Функции обновления данных ---
+
 async def update_user_trades(tg_id, **kwargs):
+    """Обновить сделки пользователя."""
     async with async_session() as session:
         query = update(USER_DEALS).where(USER_DEALS.tg_id == tg_id).values(**kwargs)
         await session.execute(query)
         await session.commit()
 
 
+async def update_symbol(tg_id: int, symbol: str) -> None:
+    """Обновить торговый символ пользователя."""
+    async with async_session() as session:
+        await session.execute(update(User_Symbol).where(User_Symbol.tg_id == tg_id).values(symbol=symbol))
+        await session.commit()
+
+
+async def update_api_key(tg_id: int, api: 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))
+        await session.commit()
+
+
+# --- Более мелкие обновления и запросы по настройкам ---
+
+async def update_trade_mode_user(tg_id, trading_mode) -> None:
+    """Обновить режим торговли пользователя."""
+    async with async_session() as session:
+        mode = await session.scalar(select(Trading_Mode.mode).where(Trading_Mode.mode == trading_mode))
+
+        if mode:
+            logger.info("Изменён торговый режим для пользователя %s", tg_id)
+            await session.execute(update(UMS).where(UMS.tg_id == tg_id).values(trading_mode=mode))
+
+            await session.commit()
+
+
 async def delete_user_trade(tg_id: int, symbol: str):
+    """Удалить сделку пользователя."""
     async with async_session() as session:
         await session.execute(
             USER_DEALS.__table__.delete().where(
@@ -173,24 +278,28 @@ async def delete_user_trade(tg_id: int, symbol: str):
 
 
 async def get_for_registration_trading_mode():
+    """Получить режим торговли по умолчанию."""
     async with async_session() as session:
         mode = await session.scalar(select(Trading_Mode.mode).where(Trading_Mode.id == 1))
         return mode
 
 
 async def get_for_registration_margin_type():
+    """Получить тип маржи по умолчанию."""
     async with async_session() as session:
         type = await session.scalar(select(Margin_type.type).where(Margin_type.id == 1))
         return type
 
 
 async def get_for_registration_trigger():
+    """Получить триггер по умолчанию."""
     async with async_session() as session:
         trigger = await session.scalar(select(Trigger.trigger).where(Trigger.id == 1))
         return trigger
 
 
 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))
 
@@ -203,6 +312,9 @@ async def get_user_main_settings(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,
@@ -210,13 +322,17 @@ async def get_user_main_settings(tg_id):
                 'size_leverage': size_leverage,
                 'starting_quantity': starting_quantity,
                 'martingale_factor': martingale_factor,
-                'maximal_quantity': maximal_quantity
+                'maximal_quantity': maximal_quantity,
+                'entry_order_type': entry_order_type,
+                'limit_order_price': limit_order_price,
+                'martingale_step': martingale_step,
             }
 
             return data
 
 
 async def get_user_risk_management_settings(tg_id):
+    """Получить риск-менеджмента настройки пользователя."""
     async with async_session() as session:
         user = await session.scalar(select(URMS).where(URMS.tg_id == tg_id))
 
@@ -238,41 +354,8 @@ async def get_user_risk_management_settings(tg_id):
             return data
 
 
-# UPDATE_SYMBOL
-async def update_symbol(tg_id, symbol) -> None:
-    async with async_session() as session:
-        await session.execute(update(User_Symbol).where(User_Symbol.tg_id == tg_id).values(symbol=symbol))
-
-        await session.commit()
-
-
-async def update_api_key(tg_id, api):
-    async with async_session() as session:
-        api_key = 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, api):
-    async with async_session() as session:
-        secret_key = await session.execute(update(UBA).where(UBA.tg_id == tg_id).values(secret_key=api))
-
-        await session.commit()
-
-
-# UPDATE_MAIN_SETTINGS_DB
-async def update_trade_mode_user(tg_id, trading_mode) -> None:
-    async with async_session() as session:
-        mode = await session.scalar(select(Trading_Mode.mode).where(Trading_Mode.mode == trading_mode))
-
-        if mode:
-            logger.info("Изменен трейд мод %s", tg_id)
-            await session.execute(update(UMS).where(UMS.tg_id == tg_id).values(trading_mode=mode))
-
-            await session.commit()
-
-
 async def update_margin_type(tg_id, margin_type) -> None:
+    """Обновить тип маржи пользователя."""
     async with async_session() as session:
         type = await session.scalar(select(Margin_type.type).where(Margin_type.type == margin_type))
 
@@ -284,6 +367,7 @@ async def update_margin_type(tg_id, margin_type) -> None:
 
 
 async def update_size_leverange(tg_id, num):
+    """Обновить размер левеража пользователя."""
     async with async_session() as session:
         await session.execute(update(UMS).where(UMS.tg_id == tg_id).values(size_leverage=num))
 
@@ -291,6 +375,7 @@ async def update_size_leverange(tg_id, num):
 
 
 async def update_starting_quantity(tg_id, num):
+    """Обновить размер левеража пользователя."""
     async with async_session() as session:
         await session.execute(update(UMS).where(UMS.tg_id == tg_id).values(starting_quantity=num))
 
@@ -298,6 +383,7 @@ async def update_starting_quantity(tg_id, num):
 
 
 async def update_martingale_factor(tg_id, num):
+    """Обновить размер левеража пользователя."""
     async with async_session() as session:
         await session.execute(update(UMS).where(UMS.tg_id == tg_id).values(martingale_factor=num))
 
@@ -305,15 +391,17 @@ async def update_martingale_factor(tg_id, num):
 
 
 async def update_maximal_quantity(tg_id, num):
+    """Обновить размер левеража пользователя."""
     async with async_session() as session:
         await session.execute(update(UMS).where(UMS.tg_id == tg_id).values(maximal_quantity=num))
 
         await session.commit()
 
 
-# UPDATE_RISK_MANAGEMENT_SETTINGS_DB
+# ОБНОВЛЕНИЕ НАСТРОЕК РИСК-МЕНЕДЖМЕНТА
 
 async def update_price_profit(tg_id, num):
+    """Обновить цену тейк-профита (прибыль) пользователя."""
     async with async_session() as session:
         await session.execute(update(URMS).where(URMS.tg_id == tg_id).values(price_profit=num))
 
@@ -321,6 +409,7 @@ async def update_price_profit(tg_id, num):
 
 
 async def update_price_loss(tg_id, num):
+    """Обновить цену тейк-лосса (убыток) пользователя."""
     async with async_session() as session:
         await session.execute(update(URMS).where(URMS.tg_id == tg_id).values(price_loss=num))
 
@@ -328,6 +417,7 @@ async def update_price_loss(tg_id, num):
 
 
 async def update_max_risk_deal(tg_id, num):
+    """Обновить максимальную сумму риска пользователя."""
     async with async_session() as session:
         await session.execute(update(URMS).where(URMS.tg_id == tg_id).values(max_risk_deal=num))
 
@@ -335,6 +425,7 @@ async def update_max_risk_deal(tg_id, num):
 
 
 async def update_entry_order_type(tg_id, order_type):
+    """Обновить тип входного ордера пользователя."""
     async with async_session() as session:
         await session.execute(
             update(UMS)
@@ -344,16 +435,8 @@ async def update_entry_order_type(tg_id, order_type):
         await session.commit()
 
 
-async def get_entry_order_type(tg_id: object) -> str | None | Any:
-    async with async_session() as session:
-        order_type = await session.scalar(
-            select(UMS.entry_order_type).where(UMS.tg_id == tg_id)
-        )
-        # Если в базе не установлен тип — возвращаем значение по умолчанию
-        return order_type or 'Market'
-
-
 async def get_limit_price(tg_id):
+    """Получить лимитную цену пользователя как float, либо None."""
     async with async_session() as session:
         result = await session.execute(
             select(UMS.limit_order_price)
@@ -369,6 +452,7 @@ async def get_limit_price(tg_id):
 
 
 async def update_limit_price(tg_id, price):
+    """Обновить лимитную цену пользователя."""
     async with async_session() as session:
         await session.execute(
             update(UMS)
@@ -379,6 +463,7 @@ async def update_limit_price(tg_id, price):
 
 
 async def update_commission_fee(tg_id, num):
+    """Обновить комиссию пользователя."""
     async with async_session() as session:
         await session.execute(update(URMS).where(URMS.tg_id == tg_id).values(commission_fee=num))
 
@@ -386,6 +471,7 @@ async def update_commission_fee(tg_id, num):
 
 
 async def get_user_timer(tg_id):
+    """Получить данные о таймере пользователя."""
     async with async_session() as session:
         result = await session.execute(select(UserTimer).where(UserTimer.tg_id == tg_id))
         user_timer = result.scalars().first()
@@ -416,9 +502,9 @@ async def get_user_timer(tg_id):
 
 
 async def update_user_timer(tg_id, minutes: int):
+    """Обновить данные о таймере пользователя."""
     async with async_session() as session:
         try:
-            async with async_session() as session:
             timer_start = None
             timer_end = None
 
@@ -448,6 +534,7 @@ async def update_user_timer(tg_id, minutes: int):
 
 
 async def get_martingale_step(tg_id):
+    """Получить шаг мартингейла пользователя."""
     async with async_session() as session:
         result = await session.execute(select(UMS).where(UMS.tg_id == tg_id))
         user_settings = result.scalars().first()
@@ -455,6 +542,7 @@ async def get_martingale_step(tg_id):
 
 
 async def update_martingale_step(tg_id, step):
+    """Обновить шаг мартингейла пользователя."""
     async with async_session() as session:
         await session.execute(update(UMS).where(UMS.tg_id == tg_id).values(martingale_step=step))
 

app/telegram/functions/condition_settings/settings.py

@@ -1,10 +1,19 @@
-import app.telegram.Keyboards.inline_keyboards as inline_markup
+import asyncio
+import logging.config
+import app.telegram.Keyboards.inline_keyboards as inline_markup
 from aiogram import Router, F
 from aiogram.types import Message, CallbackQuery
 from aiogram.fsm.context import FSMContext
 import app.telegram.database.requests as rq
 from aiogram.fsm.state import State, StatesGroup
 
+from app.services.Bybit.functions.Futures import trading_cycle
+
+from logger_helper.logger_helper import LOGGING_CONFIG
+
+logging.config.dictConfig(LOGGING_CONFIG)
+logger = logging.getLogger("condition_settings")
+
 condition_settings_router = Router()
 
 
@@ -47,7 +56,7 @@ async def trigger_message(message, state):
     await message.answer(text=text, parse_mode='html', reply_markup=inline_markup.trigger_markup)
 
 
-async def timer_message(id,message: Message, state: FSMContext):
+async def timer_message(id, message: Message, state: FSMContext):
     await state.set_state(condition_settings.timer)
 
     timer_info = await rq.get_user_timer(id)
@@ -56,8 +65,7 @@ async def timer_message(id,message: Message, state: FSMContext):
         return
 
     await message.answer(
-        f"Таймер: {timer_info['timer_minutes']} мин\n"
-        f"Осталось: {timer_info['remaining_minutes']} мин\n",
+        f"Таймер: {timer_info['timer_minutes']} мин\n",
         reply_markup=inline_markup.timer_markup
     )
 
@@ -77,21 +85,15 @@ async def process_timer_input(message: Message, state: FSMContext):
             await message.reply("Введите число больше нуля.")
             return
 
-        # Сохраняем в базу или память время таймера для пользователя
         await rq.update_user_timer(message.from_user.id, minutes)
+        await message.answer(f"Таймер установлен на {minutes} минут.\nНажмите кнопку 'Начать торговлю' для запуска.",
+                             reply_markup=inline_markup.start_trading_markup)
 
-        await message.answer(f"Таймер установлен на {minutes} минут.", reply_markup=inline_markup.back_to_main)
         await state.clear()
     except ValueError:
         await message.reply("Пожалуйста, введите корректное число.")
 
 
-@condition_settings_router.callback_query(F.data == "clb_stop_timer")
-async def stop_timer_callback(callback: CallbackQuery):
-    await rq.update_user_timer(callback.from_user.id, 0)  # обнуляем таймер
-    await callback.message.answer("Таймер остановлен.", reply_markup=inline_markup.back_to_main)
-    await callback.answer()
-
 
 async def filter_volatility_message(message, state):
     text = '''Фильтр волатильности

app/telegram/functions/functions.py

@@ -10,10 +10,9 @@ async def start_message(message):
         username = message.from_user.first_name
     else:
         username = f'{message.from_user.first_name} {message.from_user.last_name}'
-    await message.answer(f""" Привет <b>{username}</b>! 👋
-
-Добро пожаловать в чат-робот для автоматизации трейдинга — вашего надежного помощника для анализа рынка и принятия взвешенных решений. 
-""", parse_mode='html', reply_markup=inline_markup.start_markup)
+    await message.answer(f""" Привет <b>{username}</b>! 👋""", parse_mode='html', reply_markup=reply_markup.base_buttons_markup)
+    await message.answer("Добро пожаловать в чат-робот для автоматизации трейдинга — вашего надежного помощника для анализа рынка и принятия взвешенных решений.",
+                         parse_mode='html', reply_markup=inline_markup.start_markup)
 
 async def profile_message(username, message):
     await message.answer(f""" <b>@{username}</b>

app/telegram/functions/main_settings/settings.py

@@ -38,6 +38,7 @@ async def main_settings_message(id, message, state):
 <b>- Размер кредитного плеча:</b> х{data['size_leverage']}
 <b>- Начальная ставка:</b> {data['starting_quantity']}
 <b>- Коэффициент мартингейла:</b> {data['martingale_factor']}
+<b>- Количество ставок в серии:</b> {data['martingale_step']}
 <b>- Максимальное количество ставок в серии:</b> {data['maximal_quantity']}    
 """, parse_mode='html', reply_markup=inline_markup.main_settings_markup)
 

app/telegram/functions/risk_management_settings/settings.py

@@ -1,27 +1,21 @@
 from aiogram import Router
 import app.telegram.Keyboards.inline_keyboards as inline_markup
-import app.telegram.Keyboards.reply_keyboards as reply_markup
 
 import app.telegram.database.requests as rq
 from aiogram.types import Message, CallbackQuery
 
-# FSM - Механизм состояния
-from aiogram.fsm.state import State, StatesGroup
+from app.states.States import update_risk_management_settings
 
 router_risk_management_settings = Router()
 
-class update_risk_management_settings(StatesGroup):
-    price_profit = State()
-    price_loss = State()
-    max_risk_deal = State()
-    commission_fee = State()
 
 async def reg_new_user_default_risk_management_settings(id, message):
     tg_id = id
 
     await rq.set_new_user_default_risk_management_settings(tg_id)
 
-async def main_settings_message(id, message, state):
+
+async def main_settings_message(id, message):
     data = await rq.get_user_risk_management_settings(id)
 
     text = f"""<b>Риск менеджмент</b>,
@@ -29,10 +23,11 @@ async def main_settings_message(id, message, state):
     <b>- Процент изменения цены для фиксации прибыли:</b> {data.get('price_profit', 0)}%
     <b>- Процент изменения цены для фиксации убытков:</b> {data.get('price_loss', 0)}%
     <b>- Максимальный риск на сделку (в % от баланса):</b> {data.get('max_risk_deal', 0)}%
-    <b>- Комиссия биржи для расчета процента фиксации прибыли:</b> {data.get('commission_fee', 0)}%
+    <b>- Комиссия биржи для расчета прибыли:</b> {data.get('commission_fee', "Да")}
     """
     await message.answer(text=text, parse_mode='html', reply_markup=inline_markup.risk_management_settings_markup)
 
+
 async def price_profit_message(message, state):
     await state.set_state(update_risk_management_settings.price_profit)
 
@@ -40,9 +35,10 @@ async def price_profit_message(message, state):
 
     await message.answer(text=text, parse_mode='html', reply_markup=None)
 
+
 @router_risk_management_settings.message(update_risk_management_settings.price_profit)
 async def state_price_profit(message: Message, state):
-    await state.update_data(price_profit = message.text)
+    await state.update_data(price_profit=message.text)
 
     data = await state.get_data()
     data_settings = await rq.get_user_risk_management_settings(message.from_user.id)
@@ -51,13 +47,15 @@ async def state_price_profit(message: Message, state):
         await message.answer(f"✅ Изменено: {data_settings['price_profit']}% → {data['price_profit']}%")
 
         await rq.update_price_profit(message.from_user.id, data['price_profit'])
-        await main_settings_message(message.from_user.id, message, state)
+        await main_settings_message(message.from_user.id, message)
 
         await state.clear()
     else:
-        await message.answer(f'⛔️ Ошибка: ваше значение ({data['price_profit']}%) или выше лимита (100) или вы вводите неверные символы')
+        await message.answer(
+            f'⛔️ Ошибка: ваше значение ({data['price_profit']}%) или выше лимита (100) или вы вводите неверные символы')
+
+        await main_settings_message(message.from_user.id, message)
 
-        await main_settings_message(message.from_user.id, message, state) 
 
 async def price_loss_message(message, state):
     await state.set_state(update_risk_management_settings.price_loss)
@@ -66,9 +64,10 @@ async def price_loss_message(message, state):
 
     await message.answer(text=text, parse_mode='html', reply_markup=None)
 
+
 @router_risk_management_settings.message(update_risk_management_settings.price_loss)
 async def state_price_loss(message: Message, state):
-    await state.update_data(price_loss = message.text)
+    await state.update_data(price_loss=message.text)
 
     data = await state.get_data()
     data_settings = await rq.get_user_risk_management_settings(message.from_user.id)
@@ -99,12 +98,13 @@ async def state_price_loss(message: Message, state):
         else:
             await message.answer(f"✅ Стоп-лосс изменён: {old_price_loss}% → {new_price_loss}%")
 
-        await main_settings_message(message.from_user.id, message, state)
+        await main_settings_message(message.from_user.id, message)
         await state.clear()
     else:
         await message.answer(
             f'⛔️ Ошибка: ваше значение ({data["price_loss"]}%) выше лимита (100) или содержит неверные символы')
-        await main_settings_message(message.from_user.id, message, state)
+        await main_settings_message(message.from_user.id, message)
+
 
 async def max_risk_deal_message(message, state):
     await state.set_state(update_risk_management_settings.max_risk_deal)
@@ -113,9 +113,10 @@ async def max_risk_deal_message(message, state):
 
     await message.answer(text=text, parse_mode='html', reply_markup=None)
 
+
 @router_risk_management_settings.message(update_risk_management_settings.max_risk_deal)
 async def state_max_risk_deal(message: Message, state):
-    await state.update_data(max_risk_deal = message.text)
+    await state.update_data(max_risk_deal=message.text)
 
     data = await state.get_data()
     data_settings = await rq.get_user_risk_management_settings(message.from_user.id)
@@ -124,34 +125,27 @@ async def state_max_risk_deal(message: Message, state):
         await message.answer(f"✅ Изменено: {data_settings['max_risk_deal']}% → {data['max_risk_deal']}%")
 
         await rq.update_max_risk_deal(message.from_user.id, data['max_risk_deal'])
-        await main_settings_message(message.from_user.id, message, state)
+        await main_settings_message(message.from_user.id, message)
 
         await state.clear()
     else:
-        await message.answer(f'⛔️ Ошибка: ваше значение ({data['max_risk_deal']}%) или выше лимита (100) или вы вводите неверные символы')
+        await message.answer(
+            f'⛔️ Ошибка: ваше значение ({data['max_risk_deal']}%) или выше лимита (100) или вы вводите неверные символы')
 
-        await main_settings_message(message.from_user.id, message, state)
+        await main_settings_message(message.from_user.id, message)
 
 
 async def commission_fee_message(message, state):
     await state.set_state(update_risk_management_settings.commission_fee)
-    await message.answer(text="Введите процент комиссии биржи (например, 0.1):", parse_mode='html', reply_markup=None)
+    await message.answer(text="Хотите учитывать комиссию биржи:", parse_mode='html',
+                         reply_markup=inline_markup.buttons_yes_no_markup)
 
-@router_risk_management_settings.message(update_risk_management_settings.commission_fee)
-async def state_commission_fee(message: Message, state):
-    await state.update_data(commission_fee=message.text)
-    data = await state.get_data()
-    data_settings = await rq.get_user_risk_management_settings(message.from_user.id)
 
-    try:
-        val = float(data['commission_fee'])
-        if val < 0 or val > 100:
-            raise ValueError()
-    except Exception:
-        await message.answer("⛔️ Ошибка: введите корректный процент комиссии от 0 до 100")
-        return await commission_fee_message(message, state)
-
-    await rq.update_commission_fee(message.from_user.id, val)
-    await message.answer(f"✅ Изменено: {data_settings['commission_fee']}% → {data['commission_fee']}%")
-    await main_settings_message(message.from_user.id, message, state)
+@router_risk_management_settings.callback_query(lambda c: c.data in ["clb_yes", "clb_no"])
+async def process_commission_fee_callback(callback: CallbackQuery, state):
+    val = "Да" if callback.data == "clb_yes" else "Нет"
+    await rq.update_commission_fee(callback.from_user.id, val)
+    await callback.message.answer(f"✅ Изменено: {val}")
+    await callback.answer()
+    await main_settings_message(callback.from_user.id, callback.message)
     await state.clear()

app/telegram/handlers/handlers.py

@@ -1,36 +1,54 @@
 import logging.config
-
+import asyncio
 from aiogram import F, Router
-from aiogram.filters import CommandStart, Command
+from aiogram.filters import CommandStart
 from aiogram.types import Message, CallbackQuery
 from aiogram.fsm.context import FSMContext
 
-import app.telegram.functions.functions as func  # functions
+import app.telegram.functions.functions as func
 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
-import app.telegram.Keyboards.inline_keyboards as inline_markup
 import app.telegram.Keyboards.reply_keyboards as reply_markup
+
 from logger_helper.logger_helper import LOGGING_CONFIG
 
 logging.config.dictConfig(LOGGING_CONFIG)
 logger = logging.getLogger("handlers")
 
-
 router = Router()
 
 
 @router.message(CommandStart())
-async def start_message(message: Message):
+async def start_message(message: Message) -> None:
+    """
+    Обработчик команды /start.
+    Запускает WebSocket для пользователя и инициализирует нового пользователя в БД.
+
+    Args:
+        message (Message): Входящее сообщение с командой /start.
+    """
+    from BybitBot_API import run_ws_for_user
+    tg_id = message.from_user.id
+    asyncio.create_task(run_ws_for_user(tg_id, message))
+    logger.info(f"Получение event loop")
+
     await rq.set_new_user_bybit_api(message.from_user.id)
     await func.start_message(message)
 
 
 @router.message(F.text == "👤 Профиль")
-async def profile_message(message: Message):
+async def profile_message(message: Message) -> None:
+    """
+    Обработчик кнопки 'Профиль'.
+    Проверяет существование пользователя и отображает профиль.
+
+    Args:
+        message (Message): Сообщение с текстом кнопки.
+    """
     user = await rq.check_user(message.from_user.id)
 
     if user:
@@ -38,7 +56,14 @@ async def profile_message(message: Message):
 
 
 @router.message(F.text == "Настройки")
-async def settings_msg(message: Message):
+async def settings_msg(message: Message) -> None:
+    """
+    Обработчик кнопки 'Настройки'.
+    Проверяет пользователя и отображает меню настроек.
+
+    Args:
+        message (Message): Сообщение с текстом кнопки.
+    """
     user = await rq.check_user(message.from_user.id)
 
     if user:
@@ -46,17 +71,20 @@ async def settings_msg(message: Message):
 
 
 @router.callback_query(F.data == "clb_start_chatbot_message")
-async def clb_profile_msg(callback: CallbackQuery):
+async def clb_profile_msg(callback: CallbackQuery) -> None:
+    """
+    Обработчик колбэка 'clb_start_chatbot_message'.
+    Если пользователь есть в БД — показывает профиль,
+    иначе регистрирует нового пользователя и инициализирует настройки.
+
+    Args:
+        callback (CallbackQuery): Полученный колбэк.
+    """
     user = await rq.check_user(callback.from_user.id)
 
-    username = ''
-
-    if callback.from_user.first_name == None:
-        username = callback.from_user.last_name
-    elif callback.from_user.last_name == None:
-        username = callback.from_user.first_name
-    else:
-        username = f'{callback.from_user.first_name} {callback.from_user.last_name}'
+    first_name = callback.from_user.first_name or ""
+    last_name = callback.from_user.last_name or ""
+    username = f"{first_name} {last_name}".strip() or callback.from_user.username or "Пользователь"
 
     if user:
         await func.profile_message(callback.from_user.username, callback.message)
@@ -76,44 +104,82 @@ async def clb_profile_msg(callback: CallbackQuery):
     await callback.answer()
 
 
-# Настройки торговли
 @router.callback_query(F.data == "clb_settings_message")
-async def clb_settings_msg(callback: CallbackQuery):
+async def clb_settings_msg(callback: CallbackQuery) -> None:
+    """
+    Показать главное меню настроек.
+
+    Args:
+        callback (CallbackQuery): полученный колбэк.
+    """
     await func.settings_message(callback.message)
 
     await callback.answer()
 
 
 @router.callback_query(F.data == "clb_back_to_special_settings_message")
-async def clb_back_to_settings_msg(callback: CallbackQuery):
+async def clb_back_to_settings_msg(callback: CallbackQuery) -> None:
+    """
+    Вернуть пользователя к меню специальных настроек.
+
+    Args:
+        callback (CallbackQuery): полученный колбэк.
+    """
     await func.settings_message(callback.message)
 
     await callback.answer()
 
 
 @router.callback_query(F.data == "clb_change_main_settings")
-async def clb_change_main_settings_message(callback: CallbackQuery, state: FSMContext):
+async def clb_change_main_settings_message(callback: CallbackQuery, state: FSMContext) -> None:
+    """
+    Открыть меню изменения главных настроек.
+
+    Args:
+        callback (CallbackQuery): полученный колбэк.
+        state (FSMContext): текущее состояние FSM.
+    """
     await func_main_settings.main_settings_message(callback.from_user.id, callback.message, state)
 
     await callback.answer()
 
 
 @router.callback_query(F.data == "clb_change_risk_management_settings")
-async def clb_change_risk_management_message(callback: CallbackQuery, state: FSMContext):
-    await func_rmanagement_settings.main_settings_message(callback.from_user.id, callback.message, state)
+async def clb_change_risk_management_message(callback: CallbackQuery) -> None:
+    """
+    Открыть меню изменения настроек управления рисками.
+
+    Args:
+        callback (CallbackQuery): полученный колбэк.
+    """
+    await func_rmanagement_settings.main_settings_message(callback.from_user.id, callback.message)
 
     await callback.answer()
 
 
 @router.callback_query(F.data == "clb_change_condition_settings")
-async def clb_change_condition_message(callback: CallbackQuery, state: FSMContext):
+async def clb_change_condition_message(callback: CallbackQuery, state: FSMContext) -> None:
+    """
+    Открыть меню изменения настроек условий.
+
+    Args:
+        callback (CallbackQuery): полученный колбэк.
+        state (FSMContext): текущее состояние FSM.
+    """
     await func_condition_settings.main_settings_message(callback.from_user.id, callback.message, state)
 
     await callback.answer()
 
 
 @router.callback_query(F.data == "clb_change_additional_settings")
-async def clb_change_additional_message(callback: CallbackQuery, state: FSMContext):
+async def clb_change_additional_message(callback: CallbackQuery, state: FSMContext) -> None:
+    """
+    Открыть меню изменения дополнительных настроек.
+
+    Args:
+        callback (CallbackQuery): полученный колбэк.
+        state (FSMContext): текущее состояние FSM.
+    """
     await func_additional_settings.main_settings_message(callback.from_user.id, callback.message, state)
 
     await callback.answer()
@@ -130,7 +196,14 @@ list_main_settings = ['clb_change_trading_mode',
 
 
 @router.callback_query(F.data.in_(list_main_settings))
-async def clb_main_settings_msg(callback: CallbackQuery, state: FSMContext):
+async def clb_main_settings_msg(callback: CallbackQuery, state: FSMContext) -> None:
+    """
+    Обработчик колбэков изменения главных настроек с dispatch через match-case.
+
+    Args:
+        callback (CallbackQuery): полученный колбэк.
+        state (FSMContext): текущее состояние FSM.
+    """
     await callback.answer()
 
     try:
@@ -159,7 +232,14 @@ list_risk_management_settings = ['clb_change_price_profit',
 
 
 @router.callback_query(F.data.in_(list_risk_management_settings))
-async def clb_risk_management_settings_msg(callback: CallbackQuery, state: FSMContext):
+async def clb_risk_management_settings_msg(callback: CallbackQuery, state: FSMContext) -> None:
+    """
+    Обработчик изменений настроек управления рисками.
+
+    Args:
+        callback (CallbackQuery): полученный колбэк.
+        state (FSMContext): текущее состояние FSM.
+    """
     await callback.answer()
 
     try:
@@ -187,7 +267,14 @@ list_condition_settings = ['clb_change_trigger',
 
 
 @router.callback_query(F.data.in_(list_condition_settings))
-async def clb_condition_settings_msg(callback: CallbackQuery, state: FSMContext):
+async def clb_condition_settings_msg(callback: CallbackQuery, state: FSMContext) -> None:
+    """
+    Обработчик изменений настроек условий трейдинга.
+
+    Args:
+        callback (CallbackQuery): полученный колбэк.
+        state (FSMContext): текущее состояние FSM.
+    """
     await callback.answer()
 
     try:
@@ -217,7 +304,14 @@ list_additional_settings = ['clb_change_save_pattern',
 
 
 @router.callback_query(F.data.in_(list_additional_settings))
-async def clb_additional_settings_msg(callback: CallbackQuery, state: FSMContext):
+async def clb_additional_settings_msg(callback: CallbackQuery, state: FSMContext) -> None:
+    """
+    Обработчик дополнительных настроек бота.
+
+    Args:
+        callback (CallbackQuery): полученный колбэк.
+        state (FSMContext): текущее состояние FSM.
+    """
     await callback.answer()
 
     try:

logger_helper/logger_helper.py

@@ -80,5 +80,25 @@ LOGGING_CONFIG = {
             "level": "DEBUG",
             "propagate": False,
         },
+        "conditions_settings": {
+            "handlers": ["console", "timed_rotating_file"],
+            "level": "DEBUG",
+            "propagate": False,
+        },
+        "models": {
+            "handlers": ["console", "timed_rotating_file"],
+            "level": "DEBUG",
+            "propagate": False,
+        },
+        "bybit_ws": {
+            "handlers": ["console", "timed_rotating_file"],
+            "level": "DEBUG",
+            "propagate": False,
+        },
+        "tasks": {
+            "handlers": ["console", "timed_rotating_file"],
+            "level": "DEBUG",
+            "propagate": False,
+        },
     },
 }

requirements.txt

@@ -14,6 +14,7 @@ greenlet==3.2.4
 idna==3.10
 magic-filter==1.0.12
 multidict==6.6.4
+nest-asyncio==1.6.0
 propcache==0.3.2
 pybit==5.11.0
 pycryptodome==3.23.0