app/bybit/open_positions.py

@@ -54,12 +54,6 @@ async def start_trading_cycle(
             tg_id=tg_id,
             symbol=symbol,
             mode=0)
-        await set_margin_mode(tg_id=tg_id, margin_mode=margin_type)
-        await set_leverage(
-            tg_id=tg_id,
-            symbol=symbol,
-            leverage=leverage,
-        )
 
         await rq.set_user_deal(
             tg_id=tg_id,
@@ -316,7 +310,12 @@ async def open_positions(
     try:
         client = await get_bybit_client(tg_id=tg_id)
         get_ticker = await get_tickers(tg_id, symbol=symbol)
-        price_symbol = safe_float(get_ticker.get("lastPrice")) or 0
+
+        if get_ticker is None:
+            price_symbol = 0
+        else:
+            price_symbol = safe_float(get_ticker.get("lastPrice"))
+
         instruments_info = await get_instruments_info(tg_id=tg_id, symbol=symbol)
         qty_step_str = instruments_info.get("lotSizeFilter").get("qtyStep")
         qty_step = safe_float(qty_step_str)

app/bybit/set_functions/set_tp_sl.py

@@ -25,11 +25,13 @@ async def set_tp_sl_for_position(
     """
     try:
         client = await get_bybit_client(tg_id)
+        take_profit = round(take_profit_price, 6) if take_profit_price is not None else None
+        stop_loss = round(stop_loss_price, 6) if stop_loss_price is not None else None
         resp = client.set_trading_stop(
             category="linear",
             symbol=symbol,
-            takeProfit=str(round(take_profit_price, 5)),
+            takeProfit=str(take_profit) if take_profit is not None else None,
-            stopLoss=str(round(stop_loss_price, 5)),
+            stopLoss=str(stop_loss) if stop_loss is not None else None,
             positionIdx=position_idx,
             tpslMode="Full",
         )

app/bybit/telegram_message_handler.py

@@ -1,9 +1,10 @@
 import logging.config
 import math
-
+# import json
 import app.telegram.keyboards.inline as kbi
 import database.request as rq
 from app.bybit.get_functions.get_instruments_info import get_instruments_info
+from app.bybit.get_functions.get_positions import get_active_positions_by_symbol
 from app.bybit.logger_bybit.logger_bybit import LOGGING_CONFIG
 from app.bybit.open_positions import trading_cycle, trading_cycle_profit
 from app.bybit.set_functions.set_tp_sl import set_tp_sl_for_position
@@ -56,7 +57,10 @@ class TelegramMessageHandler:
 
     async def format_execution_update(self, message, tg_id):
         try:
+            # logger.info("Execution update: %s", json.dumps(message))
             execution = message.get("data", [{}])[0]
+            exec_type = format_value(execution.get("execType"))
+            if exec_type == "Trade" or exec_type == "BustTrade":
                 closed_size = format_value(execution.get("closedSize"))
                 symbol = format_value(execution.get("symbol"))
                 exec_price = format_value(execution.get("execPrice"))
@@ -89,7 +93,11 @@ class TelegramMessageHandler:
                         tg_id=tg_id, symbol=symbol, fee=safe_float(exec_fee)
                     )
 
+                get_total_fee = 0
+
+                if user_auto_trading is not None:
                     get_total_fee = user_auto_trading.total_fee
+
                 total_fee = safe_float(exec_fee) + safe_float(get_total_fee)
 
                 exec_pnl = format_value(execution.get("execPnl"))
@@ -103,8 +111,14 @@ class TelegramMessageHandler:
                 user_deals_data = await rq.get_user_deal_by_symbol(
                     tg_id=tg_id, symbol=symbol
                 )
+                if user_deals_data is None:
+                    commission_fee = "Yes_commission_fee"
+                    commission_place = "Commission_for_qty"
+
+                else:
                     commission_fee = user_deals_data.commission_fee or "Yes_commission_fee"
                     commission_place = user_deals_data.commission_place or "Commission_for_qty"
+
                 current_series = user_deals_data.current_series
                 current_step = user_deals_data.current_step
                 order_quantity = user_deals_data.order_quantity
@@ -182,12 +196,27 @@ class TelegramMessageHandler:
                                                         position_idx=0)
                     if ress:
                         take_profit_truncated = await truncate_float(take_profit_price, 6)
-                    stop_loss_truncated = await truncate_float(stop_loss_price, 6)
-
                         text += (f"Движение: {side_rus}\n"
                                  f"Тейк-профит: {take_profit_truncated}\n"
-                             f"Стоп-лосс: {stop_loss_truncated}\n"
                                  )
+                        if stop_loss_price is not None:
+                            stop_loss_truncated = await truncate_float(stop_loss_price, 6)
+                        else:
+                            stop_loss_truncated = None
+
+                        if stop_loss_truncated is not None:
+                            text += f"Стоп-лосс: {stop_loss_truncated}\n"
+                        else:
+                            deals = await get_active_positions_by_symbol(
+                                tg_id=tg_id, symbol=symbol
+                            )
+                            position = next((d for d in deals if d.get("symbol") == symbol), None)
+
+                            if position:
+                                liq_price = position.get("liqPrice", 0)
+                                text += f"Цена ликвидации: {liq_price}\n"
+
+
                     else:
                         text += (f"Движение: {side_rus}\n"
                                  "Не удалось установить ТП и СЛ\n")

app/bybit/web_socket.py

@@ -25,7 +25,6 @@ class WebSocketBot:
         self.user_keys = {}
         self.loop = None
         self.message_handler = TelegramMessageHandler(telegram_bot)
-        self.last_execution_seq = {}
 
     async def run_user_check_loop(self):
         """Run a loop to check for users and connect them to the WebSocket."""
@@ -106,17 +105,7 @@ class WebSocketBot:
         await self.message_handler.format_order_update(message, tg_id)
 
     async def handle_execution_update(self, message, tg_id):
-        """Handle execution updates."""
+        """Handle execution updates without duplicate processing."""
-        data_items = message.get('data', [])
-        if not data_items:
-            return
-        for exec_data in data_items:
-            seq = exec_data.get('seq')
-            if tg_id not in self.last_execution_seq:
-                self.last_execution_seq[tg_id] = -1
-            if seq <= self.last_execution_seq[tg_id]:
-                continue
-            self.last_execution_seq[tg_id] = seq
         await self.message_handler.format_execution_update(message, tg_id)
 
     @staticmethod