bitunix-automated-crypto-trading 3.2.5__tar.gz → 3.2.7__tar.gz

{bitunix_automated_crypto_trading-3.2.5 → bitunix_automated_crypto_trading-3.2.7}/PKG-INFO

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

{bitunix_automated_crypto_trading-3.2.5 → bitunix_automated_crypto_trading-3.2.7}/README.md

@@ -59,9 +59,12 @@ The platform can be configured through the `config.py` file or `config.txt`. Key
   - `MAX_AUTO_TRADES`: Maximum number of automated trades
   - `PROFIT_PERCENTAGE`: Target profit ROI percentage
   - `LOSS_PERCENTAGE`: Maximum loss ROI percentage
+  - `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
     
   - `Technical Indicators Parameters`:

{bitunix_automated_crypto_trading-3.2.5 → bitunix_automated_crypto_trading-3.2.7}/bitunix_automated_crypto_trading/BitunixApi.py

@@ -9,6 +9,7 @@ from urllib.parse import urlencode
 from typing import Dict, Any
 import traceback
 from logger import Logger
+#import ccxt
 
 
 class BitunixApi:
@@ -17,6 +18,7 @@ class BitunixApi:
         self.api_key = api_key
         self.secret_key = secret_key
         self.logger = logger
+        self.settings = settings
         self.session = requests.Session()
         self.session.headers.update({
             'Content-Type': 'application/json',
@@ -118,18 +120,70 @@ class BitunixApi:
         response.raise_for_status()
         return response.json()
 
-    async def PlaceOrder(self, ticker, qty, price, side, positionId=0, tradeSide="OPEN",reduceOnly=False):
-        data = {
-            "side": side,
-            "orderType":"LIMIT",
-            "qty":  qty,
-            "price": price,
-            "symbol": ticker,
-            "tradeSide":tradeSide,
-            "reduceOnly":reduceOnly,
-            "positionId":positionId
-        }
-        datajs = await self._post_authenticated(self.placeOrder_Url,data)
+    async def PlaceOrder(self, ticker, qty, price, side, positionId=0, tradeSide="OPEN",reduceOnly=False, takeProfitPrice=0, stopLossPrice=0):
+        datajs = None
+        if takeProfitPrice == 0 or stopLossPrice == 0:
+            data = {
+                "side": side,
+                "orderType":"LIMIT",
+                "qty":  qty,
+                "price": price,
+                "symbol": ticker,
+                "tradeSide":tradeSide,
+                "reduceOnly":reduceOnly,
+                "positionId":positionId
+            }
+            datajs = await self._post_authenticated(self.placeOrder_Url,data)
+        elif takeProfitPrice == 0:
+            data = {
+                "side": side,
+                "orderType":"LIMIT",
+                "qty":  qty,
+                "price": price,
+                "symbol": ticker,
+                "tradeSide":tradeSide,
+                "slPrice": stopLossPrice,
+                "slStopType":'MARK_PRICE',
+                "slStopType": self.settings.PROFIT_LOSS_PRICE_TYPE,
+                "slpOrderType": self.settings.PROFIT_LOSS_ORDER_TYPE,
+                "positionId":positionId
+            }
+            datajs = await self._post_authenticated(self.placeOrder_Url,data)
+        elif stopLossPrice == 0:
+            data = {
+                "side": side,
+                "orderType":"LIMIT",
+                "qty":  qty,
+                "price": price,
+                "symbol": ticker,
+                "tradeSide":tradeSide,
+                "tpPrice": takeProfitPrice,
+                "tpStopType": self.settings.PROFIT_LOSS_PRICE_TYPE,
+                "tppOrderType": self.settings.PROFIT_LOSS_ORDER_TYPE,
+                "tpOrderPrice":takeProfitPrice,
+                "positionId":positionId
+            }
+            datajs = await self._post_authenticated(self.placeOrder_Url,data)
+        else:
+            data = {
+                "side": side,
+                "orderType":"LIMIT",
+                "qty":  qty,
+                "price": price,
+                "symbol": ticker,
+                "tradeSide":tradeSide,
+                "tpPrice": takeProfitPrice,
+                "tpStopType": self.settings.PROFIT_LOSS_PRICE_TYPE,
+                "tppOrderType": self.settings.PROFIT_LOSS_ORDER_TYPE,
+                "tpOrderPrice":takeProfitPrice,
+                "slPrice": stopLossPrice,
+                "slStopType": self.settings.PROFIT_LOSS_PRICE_TYPE,
+                "slpOrderType": self.settings.PROFIT_LOSS_ORDER_TYPE,
+                "slOrderPrice": stopLossPrice,
+                "positionId":positionId
+            }
+            datajs = await self._post_authenticated(self.placeOrder_Url,data)
+            
         return datajs
 
     async def FlashClose(self, positionId):
@@ -193,7 +247,7 @@ class BitunixApi:
         except Exception as e:
             stack = traceback.extract_stack()
             function_name = stack[-2].name
-            logger.error(f"Function: {function_name}, {e}, {e.args}, {type(e).__name__}")
+            self.logger.error(f"Function: {function_name}, {e}, {e.args}, {type(e).__name__}")
 
     async def GetTickersPair(self, tickersStr):
         try:
@@ -204,7 +258,7 @@ class BitunixApi:
         except Exception as e:
             stack = traceback.extract_stack()
             function_name = stack[-2].name
-            logger.error(f"Function: {function_name}, {e}, {e.args}, {type(e).__name__}")
+            self.logger.error(f"Function: {function_name}, {e}, {e.args}, {type(e).__name__}")
 
     async def GetTickerList(self, threshold, volume):
         symbols=[]

{bitunix_automated_crypto_trading-3.2.5 → bitunix_automated_crypto_trading-3.2.7}/bitunix_automated_crypto_trading/BitunixSignal.py

@@ -111,7 +111,10 @@ class BitunixSignal:
                 olist = [entry['symbol'] for entry in self.pendingOrders['orderList']]
             newlist=olist+plist+list(set(symbols))
             self.tickerList=newlist[:300]
-            self.tickerList.remove("STMXUSDT")
+            if "STMXUSDT" in self.tickerList:
+                self.tickerList.remove("STMXUSDT")
+            if "AMBUSDT" in self.tickerList:
+                self.tickerList.remove("AMBUSDT")
             #self.tickerList=['POLUSDT']
         else:
             self.tickerList = self.settings.TICKERS.split(",")
@@ -615,7 +618,6 @@ class BitunixSignal:
                     self.signaldf['sell'] = self.signaldf.apply(self.add_sell_button, axis=1)
                 else:
                     self.signaldf = pd.DataFrame()
-                self.signaldfStyle= self.signaldfrenderer.render_html(self.signaldf)
 
                 #if not self.settings.USE_PUBLIC_WEBSOCKET:                    
                 #get bid las ask using api for max_auto_trades rows
@@ -629,6 +631,9 @@ class BitunixSignal:
                                 for index, row in self.signaldf[:m].iterrows()
                             ]
                         )  
+            else:
+                self.signaldf = pd.DataFrame()                        
+            self.signaldfStyle= self.signaldfrenderer.render_html(self.signaldf)
 
         except Exception as e:
             self.logger.info(f"Function: BuySellList, {e}, {e.args}, {type(e).__name__}")
@@ -636,6 +641,39 @@ 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
+        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
+        trade_time_unix = int(trade_time.timestamp())
+
+        # Get current Unix timestamp
+        current_time_unix = int(time.time())
+
+        # Calculate duration in minutes
+        duration_minutes = (current_time_unix - trade_time_unix) / 60
+        
+        return round(duration_minutes)
+
+    
+
+    async def calculate_candles(self, timeframe, duration_minutes):
+        
+        timeframe_dict = {"5m": 5, "15m": 15, "1h": 60, "1d": 1440}  # 1 day = 1440 minutes
+        if timeframe in timeframe_dict:
+            return duration_minutes // timeframe_dict[timeframe]
+        else:
+            return np.nan
+
     async def AutoTradeProcess(self):
         if self.settings.VERBOSE_LOGGING:
             self.logger.info(f"AutoTradeProcess started")
@@ -665,26 +703,57 @@ class BitunixSignal:
                     #open position upto a max of max_auto_trades from the signal list
                     df=self.signaldf.copy(deep=False)
                     for index, row in df.iterrows():
-                        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 ""
-                        if side != "":
-                            select = True
-                            self.pendingPositions = await self.bitunixApi.GetPendingPositionData({'symbol': row.symbol})
-                            if self.pendingPositions and len(self.pendingPositions) == 1:
-                                select = False
-                            self.pendingOrders = await self.bitunixApi.GetPendingOrderData({'symbol': row.symbol})
-                            if self.pendingOrders and len(self.pendingOrders['orderList']) == 1:
-                                select = False
-                            if select:
-                                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
-                                balance = float(self.portfoliodf["available"].iloc[0]) + float(self.portfoliodf["crossUnrealizedPNL"].iloc[0])
-                                qty= str(max(balance * (float(self.settings.ORDER_AMOUNT_PERCENTAGE) / 100) / price * int(self.settings.LEVERAGE),mtv))
-
-                                self.notifications.add_notification(
-                                    f'{colors.YELLOW} Opening {"long" if side=="BUY" else "short"} position for {row.symbol} with {qty} qty @ {price})'
-                                )
-                                datajs = await self.bitunixApi.PlaceOrder(row.symbol, qty, price, side)
-                                count=count+1
+                        
+                        # Calculate the duration in minutes since the position was opened
+                        data = await self.bitunixApi.GetPositionHistoryData({'symbol': row['symbol']})
+                        xtime = float(data['positionList'][0]['mtime'])
+                        mtime = pd.to_datetime(xtime, unit='ms').tz_localize('UTC').tz_convert(cst).strftime('%Y-%m-%d %H:%M:%S')
+                        duration_minutes = await self.get_duration(mtime)
+                        if 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 ""
+                            if side != "":
+                                select = True
+                                self.pendingPositions = await self.bitunixApi.GetPendingPositionData({'symbol': row.symbol})
+                                if self.pendingPositions and len(self.pendingPositions) == 1:
+                                    select = False
+                                self.pendingOrders = await self.bitunixApi.GetPendingOrderData({'symbol': row.symbol})
+                                if self.pendingOrders and len(self.pendingOrders['orderList']) == 1:
+                                    select = False
+                                if select:
+                                    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
+
+                                    tp_price=0
+                                    if self.settings.PROFIT_AMOUNT > 0:
+                                        tp_price = price * (1 + float(self.settings.PROFIT_AMOUNT)) if side == "BUY" else price * (1 - float(self.settings.PROFIT_AMOUNT))
+                                    if self.settings.PROFIT_PERCENTAGE > 0 or self.settings.PROFIT_AMOUNT > 0:
+                                        tp_price = 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)
+
+                                    lp_price=0
+                                    if self.settings.LOSS_AMOUNT > 0:
+                                        lp_price = price * (1 - float(self.settings.LOSS_AMOUNT)) if side == "BUY" else price * (1 + float(self.settings.LOSS_AMOUNT))
+                                    if self.settings.LOSS_PERCENTAGE > 0 or self.settings.LOSS_AMOUNT > 0:
+                                        lp_price = 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)
+                                        
+                                    balance = float(self.portfoliodf["available"].iloc[0]) + float(self.portfoliodf["crossUnrealizedPNL"].iloc[0])
+                                    qty= str(max(balance * (float(self.settings.ORDER_AMOUNT_PERCENTAGE) / 100 ) / price * int(self.settings.LEVERAGE),mtv))
+
+                                    self.notifications.add_notification(
+                                        f'{colors.YELLOW} Opening {"long" if side=="BUY" else "short"} position for {row.symbol} with {qty} qty @ {price})'
+                                    )
+                                    datajs = None
+                                    if tp_price == 0 and lp_price == 0:
+                                        datajs = await self.bitunixApi.PlaceOrder(row.symbol, qty, price, side)
+                                    elif tp_price == 0:
+                                        datajs = await self.bitunixApi.PlaceOrder(row.symbol, qty, price, side, stopLossPrice=lp_price)
+                                    elif lp_price == 0:
+                                        datajs = await self.bitunixApi.PlaceOrder(row.symbol, qty, price, side, takeProfitPrice=tp_price)
+                                    else:   
+                                        datajs = await self.bitunixApi.PlaceOrder(row.symbol, qty, price, side, takeProfitPrice=tp_price, stopLossPrice=lp_price)
+                                    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)
@@ -699,7 +768,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) > 60000:
+                if current_time - int(row.ctime) > 6000000000:
                     self.notifications.add_notification(
                         f'{colors.LBLUE} Canceling order {row.orderId}, {row.symbol} {row.qty} created at {row.rtime} '
                     )
@@ -714,6 +783,11 @@ class BitunixSignal:
                     total_pnl = unrealized_pnl + realized_pnl
                     side=row['side']
 
+                    # 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)
+                    
                     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)
 
@@ -728,76 +802,6 @@ class BitunixSignal:
                             
                         if select and int(self.settings.MAX_AUTO_TRADES)!=0:
                         
-                            # 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)
-                                price = (ask if row['side'] == "BUY" else bid if row['side'] == "SELL" else last) if bid<=last<=ask else last
-
-                                self.notifications.add_notification(
-                                    f'{colors.CYAN} Closing {"long" if side=="BUY" else "short"} position due to stop loss amount for {row.symbol} with {row.qty} qty @ {price})'
-                                )
-                                datajs = await self.bitunixApi.PlaceOrder(
-                                    positionId=row.positionId,
-                                    ticker=row.symbol,
-                                    qty=row.qty,
-                                    price=price,
-                                    side=row.side,
-                                    tradeSide="CLOSE"
-                                )
-                                continue
-
-                            if float(self.settings.PROFIT_AMOUNT) > 0 and total_pnl > float(self.settings.PROFIT_AMOUNT):
-                                last, bid, ask, mtv = await self.GetTickerBidLastAsk(row.symbol)
-                                price = (ask if row['side'] == "BUY" else bid if row['side'] == "SELL" else last) if bid<=last<=ask else last
-
-                                self.notifications.add_notification(
-                                    f'{colors.CYAN} Closing {"long" if side=="BUY" else "short"} position  due to take profit amount for {row.symbol} with {row.qty} qty @ {price})'
-                                )
-                                datajs = await self.bitunixApi.PlaceOrder(
-                                    positionId=row.positionId,
-                                    ticker=row.symbol,
-                                    qty=row.qty,
-                                    price=price,
-                                    side=row.side,
-                                    tradeSide="CLOSE"
-                                )
-                                continue
-
-                            # check take profit percentage or accept loss percentage
-                            if float(self.settings.LOSS_PERCENTAGE) > 0 and row['ROI'] < -float(self.settings.LOSS_PERCENTAGE):
-                                last, bid, ask, mtv = await self.GetTickerBidLastAsk(row.symbol)
-                                price = (ask if row['side'] == "BUY" else bid if row['side'] == "SELL" else last) if bid<=last<=ask else last
-
-                                self.notifications.add_notification(
-                                    f'{colors.CYAN} Closing {"long" if side=="BUY" else "short"} position due to stop loss percentage for {row.symbol} with {row.qty} qty @ {price})'
-                                )
-                                datajs = await self.bitunixApi.PlaceOrder(
-                                    positionId=row.positionId,
-                                    ticker=row.symbol,
-                                    qty=row.qty,
-                                    price=price,
-                                    side=row.side,
-                                    tradeSide="CLOSE"
-                                )
-                                continue
-
-                            if float(self.settings.PROFIT_PERCENTAGE) > 0 and row['ROI'] > float(self.settings.PROFIT_PERCENTAGE):
-                                last, bid, ask, mtv = await self.GetTickerBidLastAsk(row.symbol)
-                                price = (ask if row['side'] == "BUY" else bid if row['side'] == "SELL" else last) if bid<=last<=ask else last
-
-                                self.notifications.add_notification(
-                                    f'{colors.CYAN} Closing {"long" if side=="BUY" else "short"} position  due to take profit percentage for {row.symbol} with {row.qty} qty @ {price})'
-                                )
-                                datajs = await self.bitunixApi.PlaceOrder(
-                                    positionId=row.positionId,
-                                    ticker=row.symbol,
-                                    qty=row.qty,
-                                    price=price,
-                                    side=row.side,
-                                    tradeSide="CLOSE"
-                                )
-                                continue
-
                             # Moving average comparison between fast and medium or medium and slow
                             if self.settings.EMA_STUDY and self.settings.EMA_CHECK_ON_CLOSE: 
                                 if row.side == 'BUY' and self.signaldf_full.at[row.symbol, f'{period}_ema_close'] == "SELL":

{bitunix_automated_crypto_trading-3.2.5 → bitunix_automated_crypto_trading-3.2.7}/bitunix_automated_crypto_trading/TickerManager.py

@@ -268,16 +268,16 @@ class Interval:
                         
                         if df is not None and len(df) >= 2:
                             if self.settings.TRENDLINE_BREAKOUT:
-                                if df['close'].iloc[-1] > df['trend_resistance_line'].iloc[-1]:     
+                                if df['close'].iloc[-1] > df['trend_resistance_line'].iloc[-1] and df['trend_resistance_line'].iloc[-1] > df['trend_support_line'].iloc[-1]:     
                                         self.trendline_signal = "BUY"
-                                elif df['close'].iloc[-1] < df['trend_support_line'].iloc[-1]:     
+                                elif df['close'].iloc[-1] < df['trend_support_line'].iloc[-1] and df['trend_resistance_line'].iloc[-1] > df['trend_support_line'].iloc[-1]:     
                                         self.trendline_signal = "SELL"
                                 else:
                                     self.trendline_signal = "HOLD"
                             else:
-                                if df['close'].iloc[-1] < df['trend_resistance_line'].iloc[-1]  and df['close'].iloc[-2] < df['open'].iloc[-2] and df['close'].iloc[-1] < df['open'].iloc[-1]:
+                                if df['close'].iloc[-1] < df['trend_resistance_line'].iloc[-1]  and df['close'].iloc[-2] < df['open'].iloc[-2] and df['close'].iloc[-1] < df['open'].iloc[-1]  and df['trend_resistance_line'].iloc[-1] > df['trend_support_line'].iloc[-1]:
                                     self.trendline_signal = "SELL"
-                                elif df['close'].iloc[-1] > df['trend_support_line'].iloc[-1] and df['close'].iloc[-2] > df['open'].iloc[-2] and df['close'].iloc[-1] > df['open'].iloc[-1]:
+                                elif df['close'].iloc[-1] > df['trend_support_line'].iloc[-1] and df['close'].iloc[-2] > df['open'].iloc[-2] and df['close'].iloc[-1] > df['open'].iloc[-1]  and df['trend_resistance_line'].iloc[-1] > df['trend_support_line'].iloc[-1]:
                                     self.trendline_signal = "BUY"
                                 else:
                                     self.trendline_signal = "HOLD"
@@ -334,10 +334,11 @@ class Interval:
                         (self.settings.TRENDLINE_STUDY and self.settings.TRENDLINE_CHECK_ON_OPEN and self.trendline_signal == "BUY")
                     )
                     additional_buy_conditions = (
-                        (not self.settings.ADX_STUDY or not self.settings.ADX_CHECK_ON_OPEN or self.adx_signal == "STRONG") or
+                        (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
@@ -348,7 +349,7 @@ class Interval:
                         (self.settings.TRENDLINE_STUDY and self.settings.TRENDLINE_CHECK_ON_OPEN and self.trendline_signal == "SELL")
                     )
                     additional_sell_conditions = (
-                        (self.settings.ADX_STUDY and self.settings.ADX_CHECK_ON_OPEN and self.adx_signal == "STRONG") or
+                        (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")
                     )
 

{bitunix_automated_crypto_trading-3.2.5 → bitunix_automated_crypto_trading-3.2.7}/bitunix_automated_crypto_trading/bitunix.py

@@ -616,7 +616,7 @@ async def stream_log_file(websocket: WebSocket):
             lines = log_file.readlines()
             # Determine starting point: offset_from_end
             start_index = max(len(lines) - 100, 0)
-            for line in lines[start_index:]:  # Yield existing lines from offset
+            for line in  reversed(lines[start_index:]):  # Yield existing lines from offset
                 await websocket.send_text(line)
             # Stream new lines added to the file
             log_file.seek(0, 2)  # Go to the end of the file

{bitunix_automated_crypto_trading-3.2.5 → bitunix_automated_crypto_trading-3.2.7}/bitunix_automated_crypto_trading/config.py

@@ -10,18 +10,21 @@ class Settings(BaseSettings):
     
     #Ticker list
     TICKERS:str = Field(default="")
-    THRESHOLD: float = Field(default=5.0, ge=0.0)
-    MIN_VOLUME: int = Field(default=10_000_000, ge=0)
+    THRESHOLD: float = Field(default=100.0, ge=0.0)
+    MIN_VOLUME: int = Field(default=500000000, ge=0)
 
     # Trading Parameters
     LEVERAGE: int = Field(default=20, ge=1, le=100)
-    ORDER_AMOUNT_PERCENTAGE: float = Field(default=0.01, ge=0.0, le=100)
+    ORDER_AMOUNT_PERCENTAGE: float = Field(default=10, ge=0.0, le=100)
     MAX_AUTO_TRADES: int = Field(default=10, ge=0)
-    PROFIT_PERCENTAGE: float = Field(default=25, ge=0.0)
-    LOSS_PERCENTAGE: float = Field(default=50, ge=0.0)
-    PROFIT_AMOUNT: float = Field(default=0.25, ge=0.0)
+    PROFIT_PERCENTAGE: float = Field(default=10, ge=0.0)
+    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)
+    PROFIT_LOSS_PRICE_TYPE: str = Field(default="MARK_PRICE", pattern=r"^(MARK_PRICE|LAST_PRICE)$")
+    PROFIT_LOSS_ORDER_TYPE: str = Field(default="LIMIT", pattern=r"^(MARKET|LIMIT)$")
     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)
 
     # Technical Indicators Parameters
@@ -40,50 +43,50 @@ class Settings(BaseSettings):
     # Technical Indicators
     OPEN_ON_ANY_SIGNAL: bool = Field(default=True)
 
-    BOS_PERIOD: int = Field(default=20, ge=1)
-    BOS_STUDY: bool = Field(default=True)
-    BOS_CHART: bool = Field(default=True)
-    BOS_CHECK_ON_OPEN: bool = Field(default=False)
-    BOS_CHECK_ON_CLOSE: bool = Field(default=False)
-
     EMA_CHART: bool = Field(default=True)
     EMA_STUDY: bool = Field(default=True)
     EMA_CROSSING: bool = Field(default=False)
     EMA_CHECK_ON_OPEN: bool = Field(default=True)
     EMA_CHECK_ON_CLOSE: bool = Field(default=True)
-    EMA_CLOSE_ON_FAST_MEDIUM: bool = Field(default=True)
+    EMA_CLOSE_ON_FAST_MEDIUM: bool = Field(default=False)
 
-    MACD_CHART: bool = Field(default=False)
+    MACD_CHART: bool = Field(default=True)
     MACD_STUDY: bool = Field(default=True)
-    MACD_CROSSING: bool = Field(default=False)
-    MACD_CHECK_ON_OPEN: bool = Field(default=False)
+    MACD_CROSSING: bool = Field(default=True)
+    MACD_CHECK_ON_OPEN: bool = Field(default=True)
     MACD_CHECK_ON_CLOSE: bool = Field(default=False)
 
-    BBM_CHART: bool = Field(default=False)
+    BBM_CHART: bool = Field(default=True)
     BBM_STUDY: bool = Field(default=True)
-    BBM_CROSSING: bool = Field(default=False)
-    BBM_CHECK_ON_OPEN: bool = Field(default=False)
+    BBM_CROSSING: bool = Field(default=True)
+    BBM_CHECK_ON_OPEN: bool = Field(default=True)
     BBM_CHECK_ON_CLOSE: bool = Field(default=False)
 
-    RSI_CHART: bool = Field(default=False)
+    RSI_CHART: bool = Field(default=True)
     RSI_STUDY: bool = Field(default=True)
-    RSI_CROSSING: bool = Field(default=False)
-    RSI_CHECK_ON_OPEN: bool = Field(default=False)
+    RSI_CROSSING: bool = Field(default=True)
+    RSI_CHECK_ON_OPEN: bool = Field(default=True)
     RSI_CHECK_ON_CLOSE: bool = Field(default=False)
 
-    TRENDLINE_PEAK_DISTANCE: int = Field(default=1, ge=0, le=30)
+    BOS_PERIOD: int = Field(default=24, ge=1)
+    BOS_STUDY: bool = Field(default=True)
+    BOS_CHART: bool = Field(default=True)
+    BOS_CHECK_ON_OPEN: bool = Field(default=True)
+    BOS_CHECK_ON_CLOSE: bool = Field(default=False)
+
+    TRENDLINE_PEAK_DISTANCE: int = Field(default=3, ge=0, le=30)
     TRENDLINE_CHART: bool = Field(default=True)
     TRENDLINE_STUDY: bool = Field(default=True)
-    TRENDLINE_BREAKOUT: bool = Field(default=False)
-    TRENDLINE_CHECK_ON_OPEN: bool = Field(default=False)
+    TRENDLINE_BREAKOUT: bool = Field(default=True)
+    TRENDLINE_CHECK_ON_OPEN: bool = Field(default=True)
     TRENDLINE_CHECK_ON_CLOSE: bool = Field(default=False)
 
     ADX_STUDY: bool = Field(default=True)
-    ADX_CHECK_ON_OPEN: bool = Field(default=False)
+    ADX_CHECK_ON_OPEN: bool = Field(default=True)
     ADX_CHECK_ON_CLOSE: bool = Field(default=False)
 
     CANDLE_TREND_STUDY: bool = Field(default=True)
-    CANDLE_TREND_CHECK_ON_OPEN: bool = Field(default=False)
+    CANDLE_TREND_CHECK_ON_OPEN: bool = Field(default=True)
     CANDLE_TREND_REVERSAL_CHECK_ON_CLOSE: bool = Field(default=False)
 
     # Time Intervals

bitunix_automated_crypto_trading-3.2.7/bitunix_automated_crypto_trading/version.py

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

{bitunix_automated_crypto_trading-3.2.5 → bitunix_automated_crypto_trading-3.2.7}/bitunix_automated_crypto_trading.egg-info/PKG-INFO

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

bitunix_automated_crypto_trading-3.2.5/bitunix_automated_crypto_trading/version.py

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