bitunix-automated-crypto-trading 3.3.2__tar.gz → 3.3.4__tar.gz

{bitunix_automated_crypto_trading-3.3.2 → bitunix_automated_crypto_trading-3.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bitunix_automated_crypto_trading
-Version: 3.3.2
+Version: 3.3.4
 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 → bitunix_automated_crypto_trading-3.3.4}/README.md

@@ -57,12 +57,16 @@ The platform can be configured through the `config.py` file or `config.txt`. Key
   - `MIN_VOLUME`: Ticker selection based on Minimum trading volume
   - `ORDER_AMOUNT_PERCENTAGE`: Order size as percentage of portfolio
   - `MAX_AUTO_TRADES`: Maximum number of automated trades
+  - `PROFIT_AMOUNT`: Target profit amount
+  - `LOSS_AMOUNT`: Maximum loss amount
   - `PROFIT_PERCENTAGE`: Target profit ROI percentage
   - `LOSS_PERCENTAGE`: Maximum loss ROI percentage
+  - `BOT_TAKE_PROFIT_STOP_LOSS`: True or False
+      if false then take profit and stop loss will be placed by the bot when TP or SL is reached, if true then take profit and stop loss will be placed when the trade is opened
+  - `BOT_TRAIL_STOP_LOSS`: True or False
+      if set to True then bot will move the stop loss to breakeven when the trade is reaches 50% of the target profit and then move the stop loss to the 50% of the target profit when the trade reaches 90% of the target profit.
   - `PROFIT_LOSS_PRICE_TYPE`: "MARK_PRICE" or "LAST_PRICE"
   - `PROFIT_LOSS_ORDER_TYPE`: "MARKET" or "LIMIT" 
-  - `PROFIT_AMOUNT`: Target profit amount
-  - `LOSS_AMOUNT`: Maximum loss amount
   - `OPTION_MOVING_AVERAGE`: Moving average period (1h, 1d, 15m, 5m, 1m)
   - `DELAY_IN_MINUTES_FOR_SAME_TICKER_TRADES`: Delay in minutes to prohibit trading the same ticker again
   - `BARS`: Number of bars to use for study and charting
@@ -177,6 +181,7 @@ The platform can be configured through the `config.py` file or `config.txt`. Key
     - You can control the study like Moving Average, MACD, Bollinger Band, RSI or close proximity to high or low of the candle using the env file
     - You can control the trading strategy using the CalculateStudy function in TickerManager.py and AutoTradeProcess function in BitunixSignal.py
     - Changes are activated by unchecking and checking the AutoTrade checkbox
+    - Trailing TP and SL in the direction of profit, if BOT_TRAIL_STOP_LOSS to True and BOT_TAKE_PROFIT_STOP_LOSS to False in the config file
 
 ## Auto Trading
 
@@ -228,7 +233,7 @@ The platform can be configured through the `config.py` file or `config.txt`. Key
   - check python version should be 3.13 or above
     - python3 --version
     - python -m pip install --upgrade pip
-    - pip install https://github.com/cgohlke/talib-build/releases/download/v0.6.3/ta_lib-0.6.3-cp313-cp313-win_amd64.whl
+    - ta-lib, install it from https://ta-lib.org/install/#executable-installer-recommended
   - change the tags/3.1.8 to the latest version in the script below and run it
     - wget https://github.com/tcj2001/bitunix-automated-crypto-trading/archive/refs/tags/3.1.8.zip
     - unzip zip file and copy the content inside C:\bitunix\Ver1.0.zip\bitunix-automated-crypto-trading-Ver1.0 to c:\bitunix

{bitunix_automated_crypto_trading-3.3.2 → bitunix_automated_crypto_trading-3.3.4}/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-3.3.2 → bitunix_automated_crypto_trading-3.3.4}/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
@@ -838,6 +845,74 @@ class BitunixSignal:
                             select = False
                             
                         if select and int(self.settings.MAX_AUTO_TRADES)!=0:
+                            
+                            if self.settings.BOT_TRAIL_STOP_LOSS 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_TAKE_PROFIT_STOP_LOSS:
                                 # check take profit amount or accept loss amount
                                 if float(self.settings.LOSS_AMOUNT) > 0 and total_pnl < -float(self.settings.LOSS_AMOUNT):

{bitunix_automated_crypto_trading-3.3.2 → bitunix_automated_crypto_trading-3.3.4}/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-3.3.2 → bitunix_automated_crypto_trading-3.3.4}/bitunix_automated_crypto_trading/config.py

@@ -22,10 +22,11 @@ class Settings(BaseSettings):
     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_TRAIL_STOP_LOSS: 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-3.3.4/bitunix_automated_crypto_trading/version.py

@@ -0,0 +1 @@
+__version__ = "3.3.4"

{bitunix_automated_crypto_trading-3.3.2 → bitunix_automated_crypto_trading-3.3.4}/bitunix_automated_crypto_trading.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bitunix_automated_crypto_trading
-Version: 3.3.2
+Version: 3.3.4
 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/bitunix_automated_crypto_trading/version.py

@@ -1 +0,0 @@
-__version__ = "3.3.2"