Added trade capping

Author: iilunin

API/TradeInfo.py

@@ -0,0 +1,45 @@
+from Bot.AccountBalances import Balance, AccountBalances
+from Bot.Strategy.TargetsAndStopLossStrategy import TargetsAndStopLossStrategy
+from Bot.Strategy.TradingStrategy import TradingStrategy
+
+
+class TradeInfo:
+    def __init__(self, strategy: TradingStrategy):
+        self.status = None
+        self.symbol = None
+        self.balance = 0
+
+        self.possible_strategies = []
+        self.active_strategy = None
+        self.active_target = None
+
+        self.stop_loss_traget = None
+        self.entry_target = None
+        self.exit_targets = []
+
+
+        if strategy:
+            self.extract_info(strategy)
+
+    def extract_info(self, strategy):
+        trade = strategy.trade
+        self.symbol = trade.symbol
+        self.status = trade
+        self.balance = AccountBalances().get_balance(trade.asset)
+
+        if isinstance(strategy, TargetsAndStopLossStrategy):
+            if strategy.strategy_sl:
+                sl_name = self.class_name(strategy.strategy_sl)
+                if strategy.strategy_sl.is_stoploss_order_active():
+                    self.active_strategy = sl_name
+
+                self.possible_strategies.append(sl_name)
+
+            if strategy.strategy_entry and not strategy.strategy_entry.is_completed() and trade.is_new():
+                enty_name = self.class_name(strategy.strategy_exit)
+                self.active_strategy = enty_name
+                self.possible_strategies.append(enty_name)
+
+
+    def class_name(self, obj):
+        return obj.__class__.__name__

Bot/EntryExitSettings.py

@@ -27,6 +27,9 @@ def __init__(self,
             if not self.sl_threshold:
                 self.sl_threshold = Value("1%")
                 self.pullback_threshold = Value("1%")
+        else:
+            if not self.sl_threshold:
+                self.sl_threshold = Value("0")
 
         self.side = Side(side.lower()) if side else None
         self.type = Entry(type.lower())

Bot/Strategy/EntryStrategy.py

@@ -1,3 +1,5 @@
+import traceback
+
 from binance.exceptions import BinanceAPIException
 
 from Bot.TradeEnums import OrderStatus, Side
@@ -67,7 +69,7 @@ def get_trade_volume(self, exchange_rate):
             # self.exchange_info.adjust_quanity(t.vol)
             return buying_currency_vol / exchange_rate
 
-        return t.vol.get_val(self.balance.avail)
+        return t.vol.get_val(self.trade.get_cap(self.balance.avail))
 
     def on_smart_buy(self, trigger_order_price, current_price):
         if not trigger_order_price:
@@ -113,12 +115,15 @@ def handle_stoploss_order(self, trigger_order_price, current_price):
             t = self.trade_target()
 
             if t.is_active():
-                status = self.fx.get_order_status(self.symbol(), t.id)
+                try:
+                    status = self.fx.get_order_status(self.symbol(), t.id)
 
-                if self.fx.cancel_order(self.symbol(), t.id):
-                    t.set_canceled()
-                    self.trigger_target_updated()
-                    self.balance.avail = float(status["origQty"]) - float(status["executedQty"])
+                    if self.fx.cancel_order(self.symbol(), t.id):
+                        t.set_canceled()
+                        self.trigger_target_updated()
+                        self.balance.avail = float(status["origQty"]) - float(status["executedQty"])
+                except BinanceAPIException:
+                    self.logError(traceback.format_exc())
 
 
             th_sl_price = self.smart_order.sl_threshold.get_val(t.price)
@@ -153,7 +158,6 @@ def handle_stoploss_order(self, trigger_order_price, current_price):
             t.set_active(order['orderId'])
             self.trigger_target_updated()
 
-
     def update_last_smart_price(self, trigger_price):
         if self.need_update_last_trigger_price(trigger_price):
             self.get_trade_section().best_price = trigger_price

Bot/Strategy/PlaceOrderStrategy.py

@@ -79,7 +79,7 @@ def validate_all_completed(self, targets):
         return all(t.status.is_completed() for t in targets)
 
     def prepare_volume_allocation(self, targets):
-        bal = self.balance.avail + (self.balance.locked if any(t.is_active() for t in targets) else 0)
+        bal = self.trade.get_cap(self.balance.avail) + (self.balance.locked if any(t.is_active() for t in targets) else 0)
 
         if bal <= 0:
             self.logWarning('Available balance is 0')

Bot/Strategy/StopLossStrategy.py

@@ -144,7 +144,7 @@ def set_stoploss_order(self):
 
                 # stop_trigger
 
-                volume = self.initial_sl().vol.get_val(self.balance.avail)
+                volume = self.initial_sl().vol.get_val(self.trade.get_cap(self.balance.avail))
 
                 try:
                     order = self.fx.create_stop_order(

Bot/Strategy/TargetsAndStopLossStrategy.py

@@ -127,6 +127,7 @@ def on_order_status_changed(self, t: Target, data):
                 # validate balance and activate trade only if there are trading targets
                 if self.strategy_exit:
                     AccountBalances().update_balances(self.fx.get_all_balances_dict())
+                    self.trade.cap = self.balance.avail
                     self.trade.set_active()
                     self.trigger_target_updated()
                 else:

Bot/Strategy/TradingStrategy.py

@@ -160,6 +160,10 @@ def get_single_price(self, price, selector=None):
 
         return price[selector]
 
+    def get_info(self):
+        # return TradeInfo(self)
+        pass
+
     def price_selector(self, side=None):
         if not side:
             side = self.trade_side()

Bot/Target.py

@@ -56,9 +56,9 @@ def is_entry_target(self):
 
     def __str__(self):
         if PriceHelper.is_float_price(self.price):
-            return '{}:{:.08f}@{}'.format('StopLoss' if self.is_stoploss_target() else 'Regular', self.price, self.vol)
+            return '{}:{:.08f}@{}'.format(self.__class__.__name__, self.price, self.vol)
         else:
-            return '{}:{}@{}'.format('StopLoss' if self.is_stoploss_target() else 'Regular', self.price, self.vol)
+            return '{}:{}@{}'.format(self.__class__.__name__, self.price, self.vol)
 
 
     def serializable_dict(self):

Bot/Trade.py

@@ -6,24 +6,26 @@
 
 
 class Trade(CustomSerializable):
-    def __init__(self, symbol, side, asset, sl_settings=None, status=None, entry=None, exit=None):
-
+    # def __init__(self, symbol, side, asset, status=None, sl_settings=None, entry=None, exit=None):
+    def __init__(self, symbol, side, asset, status=None, *args, **kvargs):
         self.side = Side(side.lower())
         self.symbol = symbol.upper()
         self.asset = asset.upper()
 
         self.entry: EntryExitSettings = None
         self.exit: EntryExitSettings = None
 
-        self._init_entry_exit(True, entry, self.side)
-        self._init_entry_exit(False, exit, self.side)
+        self._init_entry_exit(True, kvargs.get('entry'), self.side)
+        self._init_entry_exit(False, kvargs.get('exit'), self.side)
 
-        self.sl_settings = StopLossSettings(**sl_settings) if sl_settings else None
+        self.sl_settings = StopLossSettings(**kvargs.get('sl_settings')) if kvargs.get('sl_settings') else None
 
         if status:
             self.status = OrderStatus(status.lower())
         else:
-            self.status = OrderStatus.ACTIVE if not entry else OrderStatus.NEW
+            self.status = OrderStatus.ACTIVE if not kvargs.get('entry') else OrderStatus.NEW
+
+        self.cap = float(kvargs.get('cap')) if kvargs.get('cap') else None
 
     def _init_entry_exit(self, is_entry, data, side: Side):
         if data:
@@ -35,6 +37,9 @@ def _init_entry_exit(self, is_entry, data, side: Side):
             else:
                 self.exit = EntryExitSettings(is_entry=is_entry, **data)
 
+    def get_cap(self, available_balance):
+        return min(self.cap if self.cap else available_balance, available_balance)
+
     def is_sell(self):
         return self.side.is_sell()
 
@@ -63,6 +68,8 @@ def serializable_dict(self):
             d.pop('entry', None)
         if not self.exit:
             d.pop('exit', None)
+        if not self.cap:
+            d.pop('cap', None)
         return d
 
     def get_all_active_placed_targets(self) -> List[Target]: