bitunix-automated-crypto-trading 3.3.5__tar.gz → 3.3.7__tar.gz

{bitunix_automated_crypto_trading-3.3.5 → bitunix_automated_crypto_trading-3.3.7}/PKG-INFO

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

{bitunix_automated_crypto_trading-3.3.5 → bitunix_automated_crypto_trading-3.3.7}/README.md

@@ -63,8 +63,10 @@ The platform can be configured through the `config.py` file or `config.txt`. Key
   - `LOSS_PERCENTAGE`: Maximum loss ROI percentage
   - `BOT_CONTROLS_TP_SL`: 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_TP_SL`: 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.
+  - `BOT_TRAIL_TP`
+      if set to True then bot will trail the TP in the direction of profit    
+  - `BOT_TRAIL_SL`
+      if set to True then bot will trail the SL in the direction of profit
   - `PROFIT_LOSS_PRICE_TYPE`: "MARK_PRICE" or "LAST_PRICE"
   - `PROFIT_LOSS_ORDER_TYPE`: "MARKET" or "LIMIT" 
   - `OPTION_MOVING_AVERAGE`: Moving average period (1h, 1d, 15m, 5m, 1m)
@@ -83,6 +85,7 @@ The platform can be configured through the `config.py` file or `config.txt`. Key
     - `MACD_SHORT`: MACD short period
     - `MACD_LONG`: MACD long period
     - `ADX_PERIOD`: ADX period
+    - `MINIMUM_CONSECUTIVE_CANDLES`: Minimum number of consecutive candles to consider for a signal.
     
   - `Study Parameters`:
     - `EMA_STUDY`: Enable EMA study

{bitunix_automated_crypto_trading-3.3.5 → bitunix_automated_crypto_trading-3.3.7}/bitunix_automated_crypto_trading/BitunixSignal.py

@@ -643,27 +643,21 @@ class BitunixSignal:
         del inuse1, inuse2, inuseTickers
         gc.collect()
 
-    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)
-    
+   
     async def get_duration(self,datetime_str):
         """Calculates the duration in minutes from a given datetime string to the current time."""
         # Convert input datetime string to a datetime object
         trade_time = datetime.strptime(datetime_str, "%Y-%m-%d %H:%M:%S")
-        
-        # Convert datetime object to Unix timestamp
+        # Convert datetime object to Unix timestamp)
         trade_time_unix = int(trade_time.timestamp())
-
+        #print(f"trade_time_unix: {trade_time_unix}, trade_time: {trade_time}")
         # Get current Unix timestamp
         current_time_unix = int(time.time())
-
+        #print(f"current_time_unix: {current_time_unix}, time: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
         # Calculate duration in minutes
         duration_minutes = (current_time_unix - trade_time_unix) / 60
+        #print(f"diff: {current_time_unix - trade_time_unix}")
+        #print(f"duration_minutes: {duration_minutes}")
         
         return round(duration_minutes)
 
@@ -735,6 +729,7 @@ class BitunixSignal:
                         self.logger.info(f"row.symbol: {row.symbol} , duration_minutes: {duration_minutes}, last trade time: {mtime if duration_minutes is not None else 'N/A'}")
                         if duration_minutes is None or duration_minutes > self.settings.DELAY_IN_MINUTES_FOR_SAME_TICKER_TRADES:
                             side = "BUY" if row[f'{period}_barcolor'] == self.green and row[f'{period}_trend'] == "BUY"  else "SELL" if row[f'{period}_barcolor'] == self.red and row[f'{period}_trend'] == "SELL" else ""
+                            #self.logger.info(f"row.symbol: {row.symbol} , ok to {side}, {row[f'{period}_barcolor']} , {row[f'{period}_trend']} ")
                             if side != "":
                                 select = True
                                 self.pendingPositions = await self.bitunixApi.GetPendingPositionData({'symbol': row.symbol})
@@ -798,6 +793,7 @@ class BitunixSignal:
                                     count=count+1
                         else:
                             self.logger.info(f"Skipping {row.symbol} as it has been opened for less than {self.settings.DELAY_IN_MINUTES_FOR_SAME_TICKER_TRADES} minutes")
+                            
                         if count >= int(self.settings.MAX_AUTO_TRADES):
                             break
                         await asyncio.sleep(0)
@@ -812,7 +808,7 @@ class BitunixSignal:
             current_time = time.time() * 1000
             df=self.orderdf.copy(deep=False)
             for index, row in df.iterrows():
-                if current_time - int(row.ctime) > 6000000000:
+                if current_time - int(row.ctime) > 60000:
                     self.notifications.add_notification(
                         f'{colors.LBLUE} Canceling order {row.orderId}, {row.symbol} {row.qty} created at {row.rtime} '
                     )
@@ -829,8 +825,8 @@ class BitunixSignal:
 
                     # Calculate the duration in minutes since the position was opened
                     ctime = row['ctime']
-                    duration_minutes = await self.get_duration(ctime)
-                    no_of_candles_since_current_open = await self.calculate_candles(period, duration_minutes)
+                    #duration_minutes = await self.get_duration(ctime)
+                    #no_of_candles_since_current_open = await self.calculate_candles(period, duration_minutes)
                     
                     requiredCols=[f'{period}_open', f'{period}_close', f'{period}_high', f'{period}_low', f'{period}_ema_open', f"{period}_ema_close", f'{period}_macd', f'{period}_bbm', f'{period}_rsi', f'{period}_trendline', f'{period}_candle_trend', f'{period}_trend', f'{period}_cb', f'{period}_barcolor']    
                     required_cols = set(requiredCols)
@@ -846,7 +842,7 @@ class BitunixSignal:
                             
                         if select and int(self.settings.MAX_AUTO_TRADES)!=0:
                             
-                            if self.settings.BOT_TRAIL_TP_SL and self.settings.PROFIT_PERCENTAGE > 0 and self.settings.LOSS_PERCENTAGE > 0:
+                            if 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)                                
@@ -861,13 +857,17 @@ class BitunixSignal:
                                 old_tpPrice = None
                                 tpStopType = self.settings.SL_STOP_TYPE
                                 tpOrderType = self.settings.SL_ORDER_TYPE
+                                tpOrderPrice = None
 
                                 slPrice = None 
                                 slorderId = None
                                 old_slPrice = None
                                 slStopType = self.settings.SL_STOP_TYPE
                                 slOrderType = self.settings.SL_ORDER_TYPE
+                                slOrderPrice = None
 
+                                roi = round((row['unrealizedPNL'] / (row['qty'] * row['avgOpenPrice'])) * 100 * self.settings.LEVERAGE,2)
+                                
                                 datajs = await self.bitunixApi.GetPendingTpSlOrderData({'symbol': symbol})
                                 if datajs:
                                     for order in datajs:
@@ -885,33 +885,60 @@ class BitunixSignal:
                                             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":
+                                tp_midpoint = None
+                                sl_midpoint = None
+                                if self.settings.BOT_TRAIL_TP:
+                                    if old_tpPrice is not None:
+                                        tp_midpoint =  old_tpPrice / (1 + self.settings.PROFIT_PERCENTAGE/100/self.settings.LEVERAGE) if side == "BUY" else old_tpPrice / (1 - self.settings.PROFIT_PERCENTAGE/100/self.settings.LEVERAGE) if tpPrice is not None else None
+                                    if tp_midpoint is not None and (price > tp_midpoint and side == "BUY" or price < tp_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))
+                                        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))
+                                            
+                                if self.settings.BOT_TRAIL_SL:
+                                    if old_slPrice is not None:
+                                       sl_midpoint =  old_slPrice / (1 - self.settings.LOSS_PERCENTAGE/100/self.settings.LEVERAGE) if side == "BUY" else old_slPrice / (1 + self.settings.LOSS_PERCENTAGE/100/self.settings.LEVERAGE) if tpPrice is not None else None
+                                       if roi > self.settings.PROFIT_PERCENTAGE:
+                                           sl_midpoint = tp_midpoint                                       
+                                       
+                                    if sl_midpoint is not None and (price > sl_midpoint and side == "BUY" or price < sl_midpoint and side == "SELL"):
+                                        if roi > self.settings.PROFIT_PERCENTAGE and self.settings.PROFIT_PERCENTAGE < self.settings.LOSS_PERCENTAGE:
+                                            slPrice = 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)
+                                        else:
+                                            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))
 
+                                if (self.settings.BOT_TRAIL_TP and tpOrderPrice is not None) or (self.settings.BOT_TRAIL_SL and slOrderPrice is not None):
                                     self.notifications.add_notification(
-                                        f'{colors.CYAN} {row.symbol} TP/SL midpoint is at {midpoint}'
+                                        f'{colors.CYAN} {row.symbol} avgOpenPrice: {avgOpenPrice}, current price: {price}, ROI: {roi}%, TP: {old_tpPrice}, TP midpoint: {tp_midpoint}, new TP: {tpPrice}, SL: {old_slPrice}, SL midpoint: {sl_midpoint}, new SL: {slPrice}'
                                     )
-                                    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_TRAIL_TP and tpPrice is not None and tpOrderPrice is not None:
+                                        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_TRAIL_SL and slPrice is not None and slOrderPrice is not None:
+                                        datajs3 = await self.bitunixApi.ModifyTpSlOrder({'orderId':slorderId,'slPrice':str(slPrice),'slQty':str(qty),'slStopType':slStopType,'slOrderType':slOrderType})
+                                        if datajs3 is not None:
+                                            if roi > self.settings.PROFIT_PERCENTAGE and self.settings.PROFIT_PERCENTAGE < self.settings.LOSS_PERCENTAGE:
+                                                self.notifications.add_notification(
+                                                    f'{colors.CYAN} Stop Loss order for {row.symbol} moved from {old_slPrice} to breakeven {slPrice}'
+                                                )
+                                            else:
+                                                self.notifications.add_notification(
+                                                    f'{colors.CYAN} Stop Loss order for {row.symbol} moved from {old_slPrice} to {slPrice}'
+                                                )
+
+                                                                          
 
                             if self.settings.BOT_CONTROLS_TP_SL:
                                 # check take profit amount or accept loss amount

{bitunix_automated_crypto_trading-3.3.5 → bitunix_automated_crypto_trading-3.3.7}/bitunix_automated_crypto_trading/TickerManager.py

@@ -750,13 +750,13 @@ class Tickers:
                 trending_conditions = [
                     (
                         (df[f'{period}_trend']=='BUY') &
-                        (df[f'{period}_cb']>1) 
+                        (df[f'{period}_cb']>= self.settings.MINIMUM_CONSECUTIVE_CANDLES) 
                         #&
                         #(df[f'{period}_barcolor']==self.green) 
                     ),
                     (
                         (df[f'{period}_trend']=='SELL') &
-                        (df[f'{period}_cb']>1) 
+                        (df[f'{period}_cb']>= self.settings.MINIMUM_CONSECUTIVE_CANDLES) 
                         #&
                         #(df[f'{period}_barcolor']==self.red) 
                     )

{bitunix_automated_crypto_trading-3.3.5 → bitunix_automated_crypto_trading-3.3.7}/bitunix_automated_crypto_trading/config.py

@@ -22,7 +22,8 @@ class Settings(BaseSettings):
     PROFIT_AMOUNT: float = Field(default=0, ge=0.0)
     LOSS_AMOUNT: float = Field(default=5.0, ge=0.0)
     BOT_CONTROLS_TP_SL: bool = Field(default=False)
-    BOT_TRAIL_TP_SL: bool = Field(default=False)
+    BOT_TRAIL_TP: bool = Field(default=False)
+    BOT_TRAIL_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")
@@ -43,6 +44,7 @@ class Settings(BaseSettings):
     MACD_SHORT: int = Field(default=12, ge=1)
     MACD_LONG: int = Field(default=26, ge=1)
     ADX_PERIOD: int = Field(default=14, ge=1)
+    MINIMUM_CONSECUTIVE_CANDLES: int = Field(default=2, ge=1)
 
     # Technical Indicators
     OPEN_ON_ANY_SIGNAL: bool = Field(default=True)

bitunix_automated_crypto_trading-3.3.7/bitunix_automated_crypto_trading/version.py

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

{bitunix_automated_crypto_trading-3.3.5 → bitunix_automated_crypto_trading-3.3.7}/bitunix_automated_crypto_trading.egg-info/PKG-INFO

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

bitunix_automated_crypto_trading-3.3.5/bitunix_automated_crypto_trading/version.py

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