bitunix-automated-crypto-trading 3.3.2__py3-none-any.whl → 3.3.5__py3-none-any.whl

bitunix_automated_crypto_trading/BitunixApi.py

@@ -4,6 +4,7 @@ import time
 import json
 import hashlib
 import asyncio 
+import re
 import requests
 from urllib.parse import urlencode
 from typing import Dict, Any
@@ -33,17 +34,19 @@ class BitunixApi:
         self.depth_Url='https://fapi.bitunix.com/api/v1/futures/market/depth'
         self.placeOrder_Url="https://fapi.bitunix.com/api/v1/futures/trade/place_order"
         self.flashClose_Url="https://fapi.bitunix.com/api/v1/futures/trade/flash_close_position"
+        self.get_order_url="https://fapi.bitunix.com/api/v1/futures/trade/get_order_detail"
         self.pending_order_url="https://fapi.bitunix.com/api/v1/futures/trade/get_pending_orders"
         self.cancelOrder_Url="https://fapi.bitunix.com/api/v1/futures/trade/cancel_orders"
+        self.pending_tpsl_order_url="https://fapi.bitunix.com/api/v1/futures/tpsl/get_pending_orders"
+        self.place_tpsl_order_url="https://fapi.bitunix.com/api/v1/futures/tpsl/place_order"
+        self.modify_tpsl_order_url="https://fapi.bitunix.com/api/v1/futures/tpsl/modify_order"
+        self.cancel_tpsl_Order_Url="https://fapi.bitunix.com/api/v1/futures/tpsl/cancel_order"
         self.Trade_history_Url="https://fapi.bitunix.com/api/v1/futures/trade/get_history_trades"
         self.position_history_Url="https://fapi.bitunix.com/api/v1/futures/position/get_history_positions"
  
     async def update_settings(self, settings):
         self.settings = settings
        
-    async def create_timestamp(self):
-        return str(int(time.time()*1000))
-
     async def is_near_high_of_day(self, current_value, high_of_day, threshold_percentage=5):
         # Calculate the difference as a percentage of the high of the day
         difference_percentage = ((high_of_day - current_value) / high_of_day) * 100
@@ -56,70 +59,80 @@ class BitunixApi:
         # Check if the difference is within the threshold
         return difference_percentage <= threshold_percentage
 
+    #signature generation related methods
+    async def _create_timestamp(self):
+        return str(int(time.time()*1000))
 
     async def _generate_nonce(self) -> str:
         random_bytes = secrets.token_bytes(32)
         return base64.b64encode(random_bytes).decode('utf-8')
 
+    async def _generate_sign_api(self, nonce, timestamp, api_key, secret_key, method, data):
+        query_params = ""
+        body = ""
+        if data:
+            if method.lower() == "get":
+                data = {k: v for k, v in data.items() if v is not None}
+                query_params = '&'.join([f"{k}={v}" for k, v in sorted(data.items())])
+                query_params = re.sub(r'[^a-zA-Z0-9]', '', query_params)
+            if method.lower() == "post":
+                # body = str(data).replace(" ", "")
+                body = str(data)
 
-    async def sign_request(self, nonce: str, timestamp: str, 
-                     query_params: str = None, 
-                     body: str = None) -> str:
-        query_string = query_params if query_params else ""
-        body_string = body if body else ""
-        message = f"{nonce}{timestamp}{self.api_key}{query_string}{body_string}"
-
-        # First SHA256 encryption
-        digest = hashlib.sha256(message.encode()).hexdigest()
-
-        # Second SHA256 encryption
-        sign = hashlib.sha256((digest + self.secret_key).encode()).hexdigest()
-
-        return sign
-        
-    async def _get(self, endpoint: str, params: Dict[str, Any] = None) -> Dict[str, Any]:
-            response = self.session.get(endpoint, params=params)
-            response.raise_for_status()
-            return response.json()    
+        digest_input = nonce + timestamp + api_key + query_params + body
+        # print(f"digest_input={digest_input}")
+        digest = hashlib.sha256((digest_input).encode()).hexdigest()
+        # print(f"digest={digest}")
+        sign_input = digest + secret_key
+        # print(f"sign_input={sign_input}")
+        sign = hashlib.sha256((sign_input).encode()).hexdigest()
 
+        return sign        
+    
     async def _get_authenticated(self, endpoint: str, params: Dict[str, Any] = None) -> Dict[str, Any]:
-        timestamp = await self.create_timestamp()
+        timestamp = await self._create_timestamp()
         nonce = await self._generate_nonce()
         
+        signature = await self._generate_sign_api(nonce, timestamp, self.api_key, self.secret_key, "get", params)  
+        
         headers = {
             "api-key": self.api_key,  
+            "nonce": nonce,
             "timestamp": timestamp,   
-            "nonce": nonce,           
+            "sign": signature,  # Placeholder for signature   
+            "language": "en-US",
+            "Content-Type": "application/json"  
         }
-        
-        query_string = urlencode(sorted(params.items())).replace('=','').replace('&','')  if params else ""
-        signature = await self.sign_request(nonce, timestamp, query_params=query_string)
-        headers["sign"] = signature  
 
         response = self.session.get(endpoint, params=params, headers=headers)
         response.raise_for_status()
         return response.json()
 
     async def _post_authenticated(self, endpoint: str, data: Dict[str, Any]) -> Dict[str, Any]:
-        timestamp = await self.create_timestamp()
+        timestamp = await self._create_timestamp()
         nonce = await self._generate_nonce()
         
+        body_string = json.dumps(data, separators=(',',':'))
+        signature = await self._generate_sign_api(nonce, timestamp, self.api_key, self.secret_key, "post", body_string)
+
         headers = {
             "api-key": self.api_key,
             "timestamp": timestamp,
             "nonce": nonce,
+            "sign": signature,
             "Content-Type": "application/json"
         }
-        
-        body_string = json.dumps(data, separators=(',', ':'))
-        signature = await self.sign_request(nonce, timestamp, body=body_string)
-        headers["sign"] = signature
 
         response = self.session.post(endpoint, data=body_string, headers=headers)
         self.logger.info(f"Response: {body_string} {response.json()}")
         response.raise_for_status()
         return response.json()
 
+    async def _get(self, endpoint: str, params: Dict[str, Any] = None) -> Dict[str, Any]:
+            response = self.session.get(endpoint, params=params)
+            response.raise_for_status()
+            return response.json()    
+
     async def PlaceOrder(self, ticker, qty, price, side, positionId=0, tradeSide="OPEN",reduceOnly=False, tpPrice=0, tpOrderPrice=0, slPrice=0, slOrderPrice=0):
         datajs = None
         if tpPrice == 0 and slPrice == 0:
@@ -143,8 +156,8 @@ class BitunixApi:
                 "symbol": ticker,
                 "tradeSide":tradeSide,
                 "slPrice": slPrice,
-                "slStopType": self.settings.STOP_LOSS_PRICE_TYPE,
-                "slOrderType": self.settings.STOP_LOSS_ORDER_TYPE,
+                "slStopType": self.settings.SL_STOP_TYPE,
+                "slOrderType": self.settings.SL_ORDER_TYPE,
                 "slOrderPrice": slOrderPrice,
                 "positionId":positionId
             }
@@ -158,8 +171,8 @@ class BitunixApi:
                 "symbol": ticker,
                 "tradeSide":tradeSide,
                 "tpPrice": tpPrice,
-                "tpStopType": self.settings.TAKE_PROFIT_PRICE_TYPE,
-                "tpOrderType": self.settings.TAKE_PROFIT_ORDER_TYPE,
+                "tpStopType": self.settings.TP_STOP_TYPE,
+                "tpOrderType": self.settings.TP_ORDER_TYPE,
                 "tpOrderPrice":tpOrderPrice,
                 "positionId":positionId
             }
@@ -173,12 +186,12 @@ class BitunixApi:
                 "symbol": ticker,
                 "tradeSide":tradeSide,
                 "tpPrice": tpPrice,
-                "tpStopType": self.settings.TAKE_PROFIT_PRICE_TYPE,
-                "tpOrderType": self.settings.TAKE_PROFIT_ORDER_TYPE,
+                "tpStopType": self.settings.TP_STOP_TYPE,
+                "tpOrderType": self.settings.TP_ORDER_TYPE,
                 "tpOrderPrice":tpOrderPrice,
                 "slPrice": slPrice,
-                "slStopType": self.settings.STOP_LOSS_PRICE_TYPE,
-                "slOrderType": self.settings.STOP_LOSS_ORDER_TYPE,
+                "slStopType": self.settings.SL_STOP_TYPE,
+                "slOrderType": self.settings.SL_ORDER_TYPE,
                 "slOrderPrice": slOrderPrice,
                 "positionId":positionId
             }
@@ -201,13 +214,20 @@ class BitunixApi:
         datajs = await self._post_authenticated(self.cancelOrder_Url,data)
         return datajs
 
-    async def GetTradeHistoryData(self):
-        tradeHistory=await self._get_authenticated(self.Trade_history_Url)
+    async def GetTradeHistoryData(self, dictparm={}):
+        tradeHistory=await self._get_authenticated(self.Trade_history_Url, dictparm)
         if tradeHistory['code']==0:
             return tradeHistory['data']
         else:
             self.logger.info(tradeHistory['msg'])
 
+    async def GetOrderData(self, dictparm={}):
+        orders=await self._get_authenticated(self.get_order_url, dictparm)
+        if orders['code']==0:
+            return orders['data']
+        else:
+            self.logger.info(orders['msg'])
+
     async def GetPendingOrderData(self,dictparm={}):
         orders=await self._get_authenticated(self.pending_order_url, dictparm)
         if orders['code']==0:
@@ -215,6 +235,35 @@ class BitunixApi:
         else:
             self.logger.info(orders['msg'])
 
+    async def GetPendingTpSlOrderData(self,dictparm={}):
+        orders=await self._get_authenticated(self.pending_tpsl_order_url, dictparm)
+        if orders['code']==0:
+            return orders['data']
+        else:
+            self.logger.info(orders['msg'])
+
+    async def PlaceTpSlOrder(self,dictparm={}):
+        orders=await self._post_authenticated(self.place_tpsl_order_url, dictparm)
+        if orders['code']==0:
+            return orders['data']
+        else:
+            self.logger.info(orders['msg'])
+
+    async def ModifyTpSlOrder(self,dictparm={}):
+        orders=await self._post_authenticated(self.modify_tpsl_order_url, dictparm)
+        if orders['code']==0:
+            return orders['data']
+        else:
+            self.logger.info(orders['msg'])
+
+    async def CancelTpSlOrder(self, symbol, orderId):
+        data = {
+            "symbol": symbol,
+            "orderId":orderId
+        }
+        datajs = await self._post_authenticated(self.cancel_tpsl_Order_Url,data)
+        return datajs
+
     async def GetPendingPositionData(self, dictparm={}):
         positions=await self._get_authenticated(self.pending_positions_URL, dictparm)
         if positions['code']==0:

bitunix_automated_crypto_trading/BitunixSignal.py

@@ -646,6 +646,7 @@ class BitunixSignal:
     async def get_duration_minutes_unixtime(self, trade_time_unix):
         """Calculates the duration in minutes from trade time to current time."""
         current_time_unix = int(time.time())  # Get current Unix timestamp
+        print(f"Current time (Unix): {current_time_unix}, Trade time (Unix): {trade_time_unix}")
         duration_seconds = current_time_unix - trade_time_unix
         duration_minutes = duration_seconds / 60  # Convert seconds to minutes
         return round(duration_minutes)
@@ -678,6 +679,12 @@ class BitunixSignal:
         increment = Decimal(f'1e-{decimal_places}')
         return float(value + increment)
 
+    async def decrement_by_last_decimal(self, value_str):
+        value = Decimal(value_str)
+        # Count number of decimal places
+        decimal_places = abs(value.as_tuple().exponent)
+        decrement = Decimal(f'1e-{decimal_places}')
+        return float(value - decrement)
 
     async def calculate_candles(self, timeframe, duration_minutes):
         
@@ -752,12 +759,12 @@ class BitunixSignal:
                                         tpPrice = price + float(self.settings.PROFIT_AMOUNT)/qty if side == "BUY" else price - float(self.settings.PROFIT_AMOUNT)/qty
                                         tpPrice = Decimal(await self.str_precision(tpPrice))
                                         tpPrice =float(str(tpPrice.quantize(Decimal(f'1e-{decimal_places}'))))
-                                        tpOrderPrice = await self.increment_by_last_decimal(str(tpPrice))
+                                        tpOrderPrice = await self.decrement_by_last_decimal(str(tpPrice))
                                     if self.settings.PROFIT_PERCENTAGE > 0 or self.settings.PROFIT_AMOUNT > 0:
                                         tpPrice = price * (1 + float(self.settings.PROFIT_PERCENTAGE) / 100 / self.settings.LEVERAGE) if side == "BUY" else price * (1 - float(self.settings.PROFIT_PERCENTAGE) / 100 / self.settings.LEVERAGE)
                                         tpPrice = Decimal(await self.str_precision(tpPrice))
                                         tpPrice = float(str(tpPrice.quantize(Decimal(f'1e-{decimal_places}'))))
-                                        tpOrderPrice = await self.increment_by_last_decimal(await self.str_precision(tpPrice))
+                                        tpOrderPrice = await self.decrement_by_last_decimal(await self.str_precision(tpPrice))
 
                                     slPrice=0
                                     slOrderPrice=0
@@ -777,7 +784,7 @@ class BitunixSignal:
                                         f'{colors.YELLOW} Opening {"long" if side=="BUY" else "short"} position for {row.symbol} with {qty} qty @ {price})'
                                     )
                                     datajs = None
-                                    if self.settings.BOT_TAKE_PROFIT_STOP_LOSS:
+                                    if self.settings.BOT_CONTROLS_TP_SL:
                                         datajs = await self.bitunixApi.PlaceOrder(row.symbol, qty, price, side)
                                     else:
                                         if tpPrice == 0 and slPrice == 0:
@@ -838,7 +845,75 @@ class BitunixSignal:
                             select = False
                             
                         if select and int(self.settings.MAX_AUTO_TRADES)!=0:
-                            if self.settings.BOT_TAKE_PROFIT_STOP_LOSS:
+                            
+                            if self.settings.BOT_TRAIL_TP_SL and self.settings.PROFIT_PERCENTAGE > 0 and self.settings.LOSS_PERCENTAGE > 0:
+                                last, bid, ask, mtv = await self.GetTickerBidLastAsk(row.symbol)
+                                price = (bid if side == "BUY" else ask if side == "SELL" else last) if bid<=last<=ask else last
+                                decimal_places = abs(Decimal(str(price)).as_tuple().exponent)                                
+
+                                symbol = row['symbol']
+                                positionId = row['positionId']
+                                avgOpenPrice = float(row['avgOpenPrice'])
+                                qty = float(row['qty'])
+                              
+                                tpPrice = None 
+                                tporderId = None
+                                old_tpPrice = None
+                                tpStopType = self.settings.SL_STOP_TYPE
+                                tpOrderType = self.settings.SL_ORDER_TYPE
+
+                                slPrice = None 
+                                slorderId = None
+                                old_slPrice = None
+                                slStopType = self.settings.SL_STOP_TYPE
+                                slOrderType = self.settings.SL_ORDER_TYPE
+
+                                datajs = await self.bitunixApi.GetPendingTpSlOrderData({'symbol': symbol})
+                                if datajs:
+                                    for order in datajs:
+                                        if order['tpPrice'] is not None:
+                                            tporderId = order['id']
+                                            tpStopType = order['tpStopType']
+                                            tpOrderType = order['tpOrderType']
+                                            tpPrice = float(order['tpPrice'])
+                                            old_tpPrice = tpPrice
+                                        if order['slPrice'] is not None:
+                                            slorderId = order['id']
+                                            slStopType = order['slStopType']
+                                            slOrderType = order['slOrderType']
+                                            slPrice = float(order['slPrice'])
+                                            old_slPrice = slPrice
+
+                                # move TP and SL in the direction of profit
+                                midpoint =  tpPrice / (1 + self.settings.PROFIT_PERCENTAGE/100/self.settings.LEVERAGE) if side == "BUY" else tpPrice / (1 - self.settings.PROFIT_PERCENTAGE/100/self.settings.LEVERAGE) if tpPrice is not None else None
+                                if price > midpoint and side == "BUY" or price < midpoint and side == "SELL":
+
+                                    tpPrice = price * (1 + float(self.settings.PROFIT_PERCENTAGE) / 100 / self.settings.LEVERAGE) if side == "BUY" else price * (1 - float(self.settings.PROFIT_PERCENTAGE) / 100 / self.settings.LEVERAGE)
+                                    tpPrice = Decimal(await self.str_precision(tpPrice))
+                                    tpPrice =float(str(tpPrice.quantize(Decimal(f'1e-{decimal_places}'))))
+                                    tpOrderPrice = await self.decrement_by_last_decimal(str(tpPrice))
+
+                                    slPrice = price * (1 - float(self.settings.LOSS_PERCENTAGE) / 100 / self.settings.LEVERAGE) if side == "BUY" else price * (1 + float(self.settings.LOSS_PERCENTAGE) / 100 / self.settings.LEVERAGE)
+                                    slPrice = Decimal(await self.str_precision(slPrice))
+                                    slPrice = float(str(slPrice.quantize(Decimal(f'1e-{decimal_places}'))))
+                                    slOrderPrice = await self.increment_by_last_decimal(await self.str_precision(slPrice))
+
+                                    self.notifications.add_notification(
+                                        f'{colors.CYAN} {row.symbol} TP/SL midpoint is at {midpoint}'
+                                    )
+                                    datajs3 = await self.bitunixApi.ModifyTpSlOrder({'orderId':slorderId,'slPrice':str(slPrice),'slQty':str(qty),'slStopType':slStopType,'slOrderType':slOrderType})
+                                    if datajs3 is not None:
+                                        self.notifications.add_notification(
+                                            f'{colors.CYAN} Stop Loss order for {row.symbol} moved from {old_slPrice} to {slPrice}'
+                                        )
+                                    datajs2 = await self.bitunixApi.ModifyTpSlOrder({'orderId':tporderId,'tpPrice':str(tpPrice), 'tpOrderPrice':str(tpOrderPrice), 'tpQty':str(qty),'tpStopType':tpStopType,'tpOrderType':tpOrderType})
+                                    if datajs2 is not None:
+                                        self.notifications.add_notification(
+                                            f'{colors.CYAN} Take Profit order for {row.symbol} moved from {old_tpPrice} to {tpPrice}'
+                                        )
+                                            
+
+                            if self.settings.BOT_CONTROLS_TP_SL:
                                 # check take profit amount or accept loss amount
                                 if float(self.settings.LOSS_AMOUNT) > 0 and total_pnl < -float(self.settings.LOSS_AMOUNT):
                                     last, bid, ask, mtv = await self.GetTickerBidLastAsk(row.symbol)

bitunix_automated_crypto_trading/TickerManager.py

@@ -319,20 +319,16 @@ class Interval:
                 df.replace([np.inf, -np.inf], 0, inplace=True)
                 
                 if self.settings.OPEN_ON_ANY_SIGNAL:
-                    # If EMA is enabled and crossing or MACD is enabled and crossing or BBM is enabled and crossing or RSI is enbabled and crossing
-                    # and 
-                    # ADX is enabled and strong and candle trend is enabled and bullish
-                    # then BUY or SELL
 
                     # Check for BUY signal
-                    buy_conditions = (
-                        (self.settings.BOS_STUDY and self.settings.BOS_CHECK_ON_OPEN and self.bos_signal == "BUY") or
-                        (self.settings.EMA_STUDY and self.settings.EMA_CHECK_ON_OPEN and self.ema_open_signal == "BUY") or
-                        (self.settings.MACD_STUDY and self.settings.MACD_CHECK_ON_OPEN and self.macd_signal == "BUY") or
-                        (self.settings.BBM_STUDY and self.settings.BBM_CHECK_ON_OPEN and self.bbm_signal == "BUY") or
-                        (self.settings.RSI_STUDY and self.settings.RSI_CHECK_ON_OPEN and self.rsi_signal == "BUY") or
-                        (self.settings.TRENDLINE_STUDY and self.settings.TRENDLINE_CHECK_ON_OPEN and self.trendline_signal == "BUY")
-                    )
+                    ema_open = (self.settings.EMA_STUDY and self.settings.EMA_CHECK_ON_OPEN and self.ema_open_signal == "BUY")
+                    macd_open = (self.settings.MACD_STUDY and self.settings.MACD_CHECK_ON_OPEN and self.macd_signal == "BUY")
+                    bbm_open = (self.settings.BBM_STUDY and self.settings.BBM_CHECK_ON_OPEN and self.bbm_signal == "BUY")
+                    rsi_open = (self.settings.RSI_STUDY and self.settings.RSI_CHECK_ON_OPEN and self.rsi_signal == "BUY")
+                    bos_open = (self.settings.BOS_STUDY and self.settings.BOS_CHECK_ON_OPEN and self.bos_signal == "BUY")
+                    trendline_open = (self.settings.TRENDLINE_STUDY and self.settings.TRENDLINE_CHECK_ON_OPEN and self.trendline_signal == "BUY") 
+                    
+                    buy_conditions = ema_open or macd_open or bbm_open or rsi_open or bos_open or trendline_open
                     additional_buy_conditions = (
                         (not self.settings.ADX_STUDY or not self.settings.ADX_CHECK_ON_OPEN or self.adx_signal == "STRONG") and
                         (not self.settings.CANDLE_TREND_STUDY or not self.settings.CANDLE_TREND_CHECK_ON_OPEN or self.candle_trend == "BULLISH")
@@ -340,14 +336,14 @@ class Interval:
 
 
                     # Check for SELL signal
-                    sell_conditions = (
-                        (self.settings.BOS_STUDY and self.settings.BOS_CHECK_ON_OPEN and self.bos_signal == "SELL") or
-                        (self.settings.EMA_STUDY and self.settings.EMA_CHECK_ON_OPEN and self.ema_open_signal == "SELL") or
-                        (self.settings.MACD_STUDY and self.settings.MACD_CHECK_ON_OPEN and self.macd_signal == "SELL") or
-                        (self.settings.BBM_STUDY and self.settings.BBM_CHECK_ON_OPEN and self.bbm_signal == "SELL") or
-                        (self.settings.RSI_STUDY and self.settings.RSI_CHECK_ON_OPEN and self.rsi_signal == "SELL") or
-                        (self.settings.TRENDLINE_STUDY and self.settings.TRENDLINE_CHECK_ON_OPEN and self.trendline_signal == "SELL")
-                    )
+                    ema_close = (self.settings.EMA_STUDY and self.settings.EMA_CHECK_ON_CLOSE and self.ema_close_signal == "SELL")
+                    macd_close = (self.settings.MACD_STUDY and self.settings.MACD_CHECK_ON_CLOSE and self.macd_signal == "SELL")
+                    bbm_close = (self.settings.BBM_STUDY and self.settings.BBM_CHECK_ON_CLOSE and self.bbm_signal == "SELL")    
+                    rsi_close = (self.settings.RSI_STUDY and self.settings.RSI_CHECK_ON_CLOSE and self.rsi_signal == "SELL")
+                    bos_close = (self.settings.BOS_STUDY and self.settings.BOS_CHECK_ON_CLOSE and self.bos_signal == "SELL")
+                    trendline_close = (self.settings.TRENDLINE_STUDY and self.settings.TRENDLINE_CHECK_ON_CLOSE and self.trendline_signal == "SELL")    
+
+                    sell_conditions = ema_close or macd_close or bbm_close or rsi_close or bos_close or trendline_close
                     additional_sell_conditions = (
                         (self.settings.ADX_STUDY and self.settings.ADX_CHECK_ON_OPEN and self.adx_signal == "STRONG") and
                         (self.settings.CANDLE_TREND_STUDY and self.settings.CANDLE_TREND_CHECK_ON_OPEN or self.candle_trend == "BEARISH")
@@ -361,68 +357,40 @@ class Interval:
                     else:
                         self.current_signal = "HOLD"
                 else:
-                    buy_conditions = (
-                        (self.settings.BOS_STUDY and self.settings.BOS_CHECK_ON_OPEN and self.bos_signal == "BUY")
-                        or not self.settings.BOS_STUDY
-                    ) and (
-                        (self.settings.EMA_STUDY and self.settings.EMA_CHECK_ON_OPEN and self.ema_open_signal == "BUY")
-                        or not self.settings.EMA_STUDY or not self.settings.EMA_CHECK_ON_OPEN
-                    ) and (
-                        (self.settings.MACD_STUDY and self.settings.MACD_CHECK_ON_OPEN and self.macd_signal == "BUY")
-                        or not self.settings.MACD_STUDY or not self.settings.MACD_CHECK_ON_OPEN
-                    ) and (
-                        (self.settings.BBM_STUDY and self.settings.BBM_CHECK_ON_OPEN and self.bbm_signal == "BUY")
+                    ema_open =(self.settings.EMA_STUDY and self.settings.EMA_CHECK_ON_OPEN and self.ema_open_signal == "BUY") \
+                        or not self.settings.EMA_STUDY or not self.settings.EMA_CHECK_ON_OPEN 
+                    macd_open =  (self.settings.MACD_STUDY and self.settings.MACD_CHECK_ON_OPEN and self.macd_signal == "BUY") \
+                        or not self.settings.MACD_STUDY or not self.settings.MACD_CHECK_ON_OPEN   
+                    bbm_open = (self.settings.BBM_STUDY and self.settings.BBM_CHECK_ON_OPEN and self.bbm_signal == "BUY") \
                         or not self.settings.BBM_STUDY or not self.settings.BBM_CHECK_ON_OPEN
-                    ) and (
-                        (self.settings.RSI_STUDY and self.settings.RSI_CHECK_ON_OPEN and self.rsi_signal == "BUY")
+                    rsi_open = (self.settings.RSI_STUDY and self.settings.RSI_CHECK_ON_OPEN and self.rsi_signal == "BUY") \
                         or not self.settings.RSI_STUDY or not self.settings.RSI_CHECK_ON_OPEN
-                    ) and (
-                        (self.settings.TRENDLINE_STUDY and self.settings.TRENDLINE_CHECK_ON_OPEN and self.trendline_signal == "BUY")
+                    bos_open = (self.settings.BOS_STUDY and self.settings.BOS_CHECK_ON_OPEN and self.bos_signal == "BUY") \
+                          or not self.settings.BOS_STUDY or not self.settings.BOS_CHECK_ON_OPEN
+                    trendline_open = (self.settings.TRENDLINE_STUDY and self.settings.TRENDLINE_CHECK_ON_OPEN and self.trendline_signal == "BUY") \
                         or not self.settings.TRENDLINE_STUDY or not self.settings.TRENDLINE_CHECK_ON_OPEN
-                    )
-                    if not any([
-                        self.settings.EMA_STUDY, self.settings.MACD_STUDY, self.settings.BBM_STUDY,
-                        self.settings.RSI_STUDY, self.settings.TRENDLINE_STUDY
-                    ]) and not any([
-                        self.settings.EMA_CHECK_ON_OPEN, self.settings.MACD_CHECK_ON_OPEN, self.settings.BBM_CHECK_ON_OPEN,
-                        self.settings.RSI_CHECK_ON_OPEN, self.settings.TRENDLINE_CHECK_ON_OPEN
-                    ]):
-                        buy_conditions = False
 
+                    buy_conditions = ema_open and macd_open and bbm_open and rsi_open and bos_open and trendline_open
                     additional_buy_conditions = (
                         (not self.settings.ADX_STUDY or not self.settings.ADX_CHECK_ON_OPEN or self.adx_signal == "STRONG") and
                         (not self.settings.CANDLE_TREND_STUDY or not self.settings.CANDLE_TREND_CHECK_ON_OPEN or self.candle_trend == "BULLISH")
                     )
 
                     # Check for SELL signal
-                    sell_conditions = (
-                        (self.settings.BOS_STUDY and self.settings.BOS_CHECK_ON_OPEN and self.bos_signal == "SELL")
-                        or not self.settings.BOS_STUDY
-                    ) and (
-                        (self.settings.EMA_STUDY and self.settings.EMA_CHECK_ON_OPEN and self.ema_open_signal == "SELL")
-                        or not self.settings.EMA_STUDY or not self.settings.EMA_CHECK_ON_OPEN
-                    ) and (
-                        (self.settings.MACD_STUDY and self.settings.MACD_CHECK_ON_OPEN and self.macd_signal == "SELL")
-                        or not self.settings.MACD_STUDY or not self.settings.MACD_CHECK_ON_OPEN
-                    ) and (
-                        (self.settings.BBM_STUDY and self.settings.BBM_CHECK_ON_OPEN and self.bbm_signal == "SELL")
-                        or not self.settings.BBM_STUDY or not self.settings.BBM_CHECK_ON_OPEN
-                    ) and (
-                        (self.settings.RSI_STUDY and self.settings.RSI_CHECK_ON_OPEN and self.rsi_signal == "SELL")
-                        or not self.settings.RSI_STUDY or not self.settings.RSI_CHECK_ON_OPEN
-                    ) and (
-                        (self.settings.TRENDLINE_STUDY and self.settings.TRENDLINE_CHECK_ON_OPEN and self.trendline_signal == "SELL")
-                        or not self.settings.TRENDLINE_STUDY or not self.settings.TRENDLINE_CHECK_ON_OPEN
-                    )
-                    if not any([
-                        self.settings.EMA_STUDY, self.settings.MACD_STUDY, self.settings.BBM_STUDY,
-                        self.settings.RSI_STUDY, self.settings.TRENDLINE_STUDY
-                    ]) and not any([
-                        self.settings.EMA_CHECK_ON_OPEN, self.settings.MACD_CHECK_ON_OPEN, self.settings.BBM_CHECK_ON_OPEN,
-                        self.settings.RSI_CHECK_ON_OPEN, self.settings.TRENDLINE_CHECK_ON_OPEN
-                    ]):
-                        sell_conditions = False
-
+                    ema_close= (self.settings.EMA_STUDY and self.settings.EMA_CHECK_ON_CLOSE and self.ema_close_signal == "SELL") \
+                        or not self.settings.EMA_STUDY or not self.settings.EMA_CHECK_ON_CLOSE
+                    macd_close = (self.settings.MACD_STUDY and self.settings.MACD_CHECK_ON_CLOSE and self.macd_signal == "SELL") \
+                        or not self.settings.MACD_STUDY or not self.settings.MACD_CHECK_ON_CLOSE
+                    bbm_close = (self.settings.BBM_STUDY and self.settings.BBM_CHECK_ON_CLOSE and self.bbm_signal == "SELL") \
+                        or not self.settings.BBM_STUDY or not self.settings.BBM_CHECK_ON_CLOSE
+                    rsi_close = (self.settings.RSI_STUDY and self.settings.RSI_CHECK_ON_CLOSE and self.rsi_signal == "SELL") \
+                        or not self.settings.RSI_STUDY or not self.settings.RSI_CHECK_ON_CLOSE
+                    bos_close = (self.settings.BOS_STUDY and self.settings.BOS_CHECK_ON_CLOSE and self.bos_signal == "SELL") \
+                        or not self.settings.BOS_STUDY or not self.settings.BOS_CHECK_ON_CLOSE
+                    trendline_close = (self.settings.TRENDLINE_STUDY and self.settings.TRENDLINE_CHECK_ON_CLOSE and self.trendline_signal == "SELL") \
+                        or not self.settings.TRENDLINE_STUDY or not self.settings.TRENDLINE_CHECK_ON_CLOSE
+
+                    sell_conditions = ema_close and macd_close and bbm_close and rsi_close and bos_close and trendline_close    
                     additional_sell_conditions = (
                         (self.settings.ADX_STUDY and self.settings.ADX_CHECK_ON_OPEN and self.adx_signal == "STRONG") or
                         (self.settings.CANDLE_TREND_STUDY and self.settings.CANDLE_TREND_CHECK_ON_OPEN or self.candle_trend == "BEARISH")

bitunix_automated_crypto_trading/config.py

@@ -21,11 +21,12 @@ class Settings(BaseSettings):
     LOSS_PERCENTAGE: float = Field(default=10, ge=0.0)
     PROFIT_AMOUNT: float = Field(default=0, ge=0.0)
     LOSS_AMOUNT: float = Field(default=5.0, ge=0.0)
-    BOT_TAKE_PROFIT_STOP_LOSS: bool = Field(default=False)
-    TAKE_PROFIT_PRICE_TYPE: str = Field(default="MARK_PRICE")
-    TAKE_PROFIT_ORDER_TYPE: str = Field(default="LIMIT")
-    STOP_LOSS_PRICE_TYPE: str = Field(default="MARK_PRICE")
-    STOP_LOSS_ORDER_TYPE: str = Field(default="MARKET")
+    BOT_CONTROLS_TP_SL: bool = Field(default=False)
+    BOT_TRAIL_TP_SL: bool = Field(default=False)
+    TP_STOP_TYPE: str = Field(default="MARK_PRICE")
+    TP_ORDER_TYPE: str = Field(default="LIMIT")
+    SL_STOP_TYPE: str = Field(default="MARK_PRICE")
+    SL_ORDER_TYPE: str = Field(default="MARKET")
     OPTION_MOVING_AVERAGE: str = Field(default="1h")
     DELAY_IN_MINUTES_FOR_SAME_TICKER_TRADES: int = Field(default=15, ge=0)
     BARS: int = Field(default=100, ge=1)

bitunix_automated_crypto_trading/version.py

@@ -1 +1 @@
-__version__ = "3.3.2"
+__version__ = "3.3.5"

{bitunix_automated_crypto_trading-3.3.2.dist-info → bitunix_automated_crypto_trading-3.3.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bitunix_automated_crypto_trading
-Version: 3.3.2
+Version: 3.3.5
 Summary: Bitunix Futures Auto Trading Platform
 Home-page: https://github.com/tcj2001/bitunix-automated-crypto-trading
 Author: tcj2001

{bitunix_automated_crypto_trading-3.3.2.dist-info → bitunix_automated_crypto_trading-3.3.5.dist-info}/RECORD

@@ -1,19 +1,19 @@
 bitunix_automated_crypto_trading/AsyncThreadRunner.py,sha256=bNIM_1xRYQOFEsIn74EX6qVpC59-GMhhr2CeiPr_GWg,3253
-bitunix_automated_crypto_trading/BitunixApi.py,sha256=4iiqiN3uvX6-bmZ5WtG3pt1No0C6eNlqdLA5jylXRp8,13496
-bitunix_automated_crypto_trading/BitunixSignal.py,sha256=rVoVBSb3T3Zw-lJt1s4gRV-e8tZSZu4EINdbiilQgUc,82493
+bitunix_automated_crypto_trading/BitunixApi.py,sha256=5qg-K5IcsAbb6K1feP9zL7RzSz7JzdGAxoY8R_YWxWE,15666
+bitunix_automated_crypto_trading/BitunixSignal.py,sha256=ke8KNlorfmmifTWhdFPUR63Zsl__gPRdalAqcdR6zSo,88174
 bitunix_automated_crypto_trading/BitunixWebSocket.py,sha256=uiqAcis3u-ct07tjaTiC87ujzvcAtVRZ31CMiTBDW_M,11309
 bitunix_automated_crypto_trading/DataFrameHtmlRenderer.py,sha256=Pqdzhh_nfIxFEZH9L_R5QXB8moDPbgeTGT_hmBkHWMg,2899
 bitunix_automated_crypto_trading/NotificationManager.py,sha256=exs6REABBA1omTeTGuUuECzxs5dGqdyL7oI8WyxS6Xc,798
 bitunix_automated_crypto_trading/SupportResistance.py,sha256=x_to4M4OHg0h8o40DXDBa4E_5io-y2Lb5qo2VzFnu_8,5765
 bitunix_automated_crypto_trading/ThreadManager.py,sha256=Lw5_1EIT0m3AFSv5CIMpnjtA0DnNw2qQ6JtSpT34LyM,2349
-bitunix_automated_crypto_trading/TickerManager.py,sha256=E6U08wO1LKY4XctB6frtoAmlactMng3xwRrqG59qDt8,43030
+bitunix_automated_crypto_trading/TickerManager.py,sha256=CLd7pvE-qyYBPBauy--A54z7srmMMJsiaWcrY4ezFFU,41939
 bitunix_automated_crypto_trading/__init__.py,sha256=1hzk6nX8NnUCr1tsq8oFq1qGCNhNwnwldWE75641Eew,78
 bitunix_automated_crypto_trading/bitunix.py,sha256=lxwnYARxldA2oU6GdjupilXIlnUh4RX8rQLCOn7x13I,27143
-bitunix_automated_crypto_trading/config.py,sha256=OASGCVl0avfVSLqdaZC4fxFSiVIrmdMvin3wJMB3Kq0,5830
+bitunix_automated_crypto_trading/config.py,sha256=J-YIrcbS-FOlLze1QvAocelYPA53thJODVyhuZwQW5E,5838
 bitunix_automated_crypto_trading/logger.py,sha256=NHnA5JZdUFkTAhB7i-1iCAwrdf1fxhDuRvJUkbKPi9Y,2923
-bitunix_automated_crypto_trading/version.py,sha256=atqyGOnhrhSlkFH4WgeEJ48n-b00QDPSS9LvTLmvhmU,21
-bitunix_automated_crypto_trading-3.3.2.dist-info/METADATA,sha256=m_1FPUbtyZuXsTNhtwPOAZRSiKclI6kdnJ7O2HIudmo,996
-bitunix_automated_crypto_trading-3.3.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-bitunix_automated_crypto_trading-3.3.2.dist-info/entry_points.txt,sha256=UXREYHuSl2XYd_tOtLIq0zg3d1kX3lixX5SpN8yGBw4,82
-bitunix_automated_crypto_trading-3.3.2.dist-info/top_level.txt,sha256=uyFzHUCOsp8elnG2Ovor6xXcf7dxRxY-C-Txiwix64Q,33
-bitunix_automated_crypto_trading-3.3.2.dist-info/RECORD,,
+bitunix_automated_crypto_trading/version.py,sha256=tC7feJeEXvyWQbCx5glWxCoo1hKMycavaWn-uadNZ0E,21
+bitunix_automated_crypto_trading-3.3.5.dist-info/METADATA,sha256=gQpnt3MalX-CV_EokXNyadl2q679NfFj2Cw8bgtzudg,996
+bitunix_automated_crypto_trading-3.3.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+bitunix_automated_crypto_trading-3.3.5.dist-info/entry_points.txt,sha256=UXREYHuSl2XYd_tOtLIq0zg3d1kX3lixX5SpN8yGBw4,82
+bitunix_automated_crypto_trading-3.3.5.dist-info/top_level.txt,sha256=uyFzHUCOsp8elnG2Ovor6xXcf7dxRxY-C-Txiwix64Q,33
+bitunix_automated_crypto_trading-3.3.5.dist-info/RECORD,,