bitunix-automated-crypto-trading 3.3.9__tar.gz → 3.4.0__tar.gz

{bitunix_automated_crypto_trading-3.3.9 → bitunix_automated_crypto_trading-3.4.0}/PKG-INFO

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

{bitunix_automated_crypto_trading-3.3.9 → bitunix_automated_crypto_trading-3.4.0}/bitunix_automated_crypto_trading/AsyncThreadRunner.py

@@ -87,8 +87,8 @@ class AsyncThreadRunner:
                     # For now, we'll just log and continue, allowing the manager to detect if the thread dies from other reasons.
                 
                 # Check stop event again before sleeping to allow immediate stopping
-                if self._stop_event.is_set():
-                    break
+                #if self._stop_event.is_set():
+                #    break
                 
                 # Use asyncio.sleep to allow graceful cancellation
                 try:

{bitunix_automated_crypto_trading-3.3.9 → bitunix_automated_crypto_trading-3.4.0}/bitunix_automated_crypto_trading/BitunixSignal.py

@@ -158,14 +158,14 @@ class BitunixSignal:
             self.StoreDepthDataTask = AsyncThreadRunner(self.bitunixPublicDepthWebSocketClient.run_websocket, self.logger, 0, self.StoreDepthData)
             self.StoreDepthDataTask.start_thread(thread_name="StoreDepthData")
             self.depth_que = asyncio.Queue()
-            self.ProcessDepthDataTask = AsyncThreadRunner(self.ProcessDepthData, self.logger, interval=0) # run only once
+            self.ProcessDepthDataTask = AsyncThreadRunner(self.ProcessDepthData, self.logger, interval=int(self.settings.TICKER_DATA_API_INTERVAL)) # run only once
             self.ProcessDepthDataTask.start_thread(thread_name="ProcessDepthData")
 
             self.bitunixPublicTickerWebSocketClient.tickerList = self.tickerList
             self.StoreTickerDataTask = AsyncThreadRunner(self.bitunixPublicTickerWebSocketClient.run_websocket, self.logger, 0, self.StoreTickerData)
             self.StoreTickerDataTask.start_thread(thread_name="StoreTickerData")
             self.ticker_que = asyncio.Queue()
-            self.ProcessTickerDataTask = AsyncThreadRunner(self.ProcessTickerData, self.logger, interval=0) # run only once
+            self.ProcessTickerDataTask = AsyncThreadRunner(self.ProcessTickerData, self.logger, interval=int(self.settings.TICKER_DATA_API_INTERVAL)) # run only once
             self.ProcessTickerDataTask.start_thread(thread_name="ProcessTickerData")
             
 
@@ -238,38 +238,39 @@ class BitunixSignal:
 
     #api data       
     async def GetTickerData(self):
-        if not self.settings.USE_PUBLIC_WEBSOCKET:
-            start=time.time()
-            # Get the current time and set the seconds and microseconds to zero
-            current_time = datetime.now()
-            current_minute = current_time.replace(second=0, microsecond=0)
-            ts = int(current_minute.timestamp())*1000
-
-            #api used insted of websocket
-            data = await self.bitunixApi.GetTickerData()
-            self.tickerdf = pd.DataFrame()
-            if data:
-                
-                # Create a DataFrame from the data
-                self.tickerdf = pd.DataFrame(data, columns=["symbol", "last"])
-                
-                #remove not required symbols
-                self.tickerdf.loc[~self.tickerdf['symbol'].isin(self.tickerObjects.symbols()), :] = None
-                self.tickerdf.dropna(inplace=True)
-                
-                self.tickerdf['ts']=ts
-                self.tickerdf["tickerObj"] = self.tickerdf["symbol"].map(self.tickerObjects.get_tickerDict())
-                self.tuples_list = list(zip(self.tickerdf["tickerObj"],  self.tickerdf["last"].astype(float), self.tickerdf["ts"]))
-                self.tickerObjects.form_candle(self.tuples_list)
+        if self.settings.VERBOSE_LOGGING:
+            self.logger.info(f"GetTickerData started")
+        start=time.time()
+        # Get the current time and set the seconds and microseconds to zero
+        current_time = datetime.now()
+        current_minute = current_time.replace(second=0, microsecond=0)
+        ts = int(current_minute.timestamp())*1000
+
+        #api used insted of websocket
+        data = await self.bitunixApi.GetTickerData()
+        self.tickerdf = pd.DataFrame()
+        if data:
+            
+            # Create a DataFrame from the data
+            self.tickerdf = pd.DataFrame(data, columns=["symbol", "last"])
+            
+            #remove not required symbols
+            self.tickerdf.loc[~self.tickerdf['symbol'].isin(self.tickerObjects.symbols()), :] = None
+            self.tickerdf.dropna(inplace=True)
+            
+            self.tickerdf['ts']=ts
+            self.tickerdf["tickerObj"] = self.tickerdf["symbol"].map(self.tickerObjects.get_tickerDict())
+            self.tuples_list = list(zip(self.tickerdf["tickerObj"],  self.tickerdf["last"].astype(float), self.tickerdf["ts"]))
+            self.tickerObjects.form_candle(self.tuples_list)
 
-            self.lastTickerDataTime = time.time()
-            if self.settings.VERBOSE_LOGGING:
-                self.logger.info(f"GetTickerData: elapsed time {time.time()-start}")
-            if self.settings.BENCHMARK:
-                self.connection = sqlite3.connect(self.settings.DATABASE) 
-                self.cursor = self.connection.cursor()
-                self.cursor.execute("INSERT INTO benchmark (process_name, time) VALUES (?, ?)", ("GetTickerData", time.time()-start))
-                self.connection.commit()
+        self.lastTickerDataTime = time.time()
+        if self.settings.VERBOSE_LOGGING:
+            self.logger.info(f"GetTickerData: elapsed time {time.time()-start}")
+        if self.settings.BENCHMARK:
+            self.connection = sqlite3.connect(self.settings.DATABASE) 
+            self.cursor = self.connection.cursor()
+            self.cursor.execute("INSERT INTO benchmark (process_name, time) VALUES (?, ?)", ("GetTickerData", time.time()-start))
+            self.connection.commit()
     
     async def drain_queue(self, queue):
         items = []
@@ -285,32 +286,34 @@ class BitunixSignal:
 
     # Function to process the last price deque
     async def ProcessTickerData(self):
-        while True:
-            try:
-                latest_data = {}
-                reversed_items = await self.drain_queue(self.ticker_que)
-                while reversed_items:
-                    message = reversed_items.popleft()
-                    data = json.loads(message)
-                    if data.get('symbol') and data.get('ch') == 'ticker':
-                        symbol = data["symbol"]
-                        ts = data["ts"]
-                        if symbol not in latest_data or ts > latest_data[symbol]['ts']:
-                            latest_data[symbol] = {'ts': ts, 'last': float(data['data']['la'])}
-                    await asyncio.sleep(0.01)
-                # Convert to DataFrame
-                self.tickerdf = pd.DataFrame.from_dict(latest_data, orient="index")
-                if not self.tickerdf.empty:
-                    self.tickerdf["tickerObj"] = self.tickerdf.index.map(self.tickerObjects.get_tickerDict())
-                    self.tuples_list = list(zip(self.tickerdf["tickerObj"],  self.tickerdf["last"].astype(float), self.tickerdf["ts"]))
-                    self.tickerObjects.form_candle(self.tuples_list)
-                    self.lastTickerDataTime = time.time()
-            except Exception as e:
-                self.logger.info(f"Function: ProcessTickerData, {e}, {e.args}, {type(e).__name__}")
-                self.logger.info(traceback.print_exc())
-            await asyncio.sleep(0.01)
-        self.logger.info(f"ProcessTickerData: exitied out of the loop, exiting app")
-        #os._exit(1)  # Exit the program 
+        if self.settings.VERBOSE_LOGGING:
+            self.logger.info(f"Started ProcessTickerData")
+        start=time.time()
+        try:
+            # Get the current time and set the seconds and microseconds to zero                    
+            latest_data = {}
+            reversed_items = await self.drain_queue(self.ticker_que)
+            while reversed_items:
+                message = reversed_items.popleft()
+                data = json.loads(message)
+                if data.get('symbol') and data.get('ch') == 'ticker':
+                    symbol = data["symbol"]
+                    ts = data["ts"]
+                    if symbol not in latest_data or ts > latest_data[symbol]['ts']:
+                        latest_data[symbol] = {'ts': ts, 'last': float(data['data']['la'])}
+                await asyncio.sleep(0.01)
+            # Convert to DataFrame
+            self.tickerdf = pd.DataFrame.from_dict(latest_data, orient="index")
+            if not self.tickerdf.empty:
+                self.tickerdf["tickerObj"] = self.tickerdf.index.map(self.tickerObjects.get_tickerDict())
+                self.tuples_list = list(zip(self.tickerdf["tickerObj"],  self.tickerdf["last"].astype(float), self.tickerdf["ts"]))
+                self.tickerObjects.form_candle(self.tuples_list)
+                self.lastTickerDataTime = time.time()
+        except Exception as e:
+            self.logger.info(f"Function: ProcessTickerData, {e}, {e.args}, {type(e).__name__}")
+            self.logger.info(traceback.print_exc())
+        if self.settings.VERBOSE_LOGGING:
+            self.logger.info(f"ProcessTickerData: elapsed time {time.time()-start}")
             
 
     #websocket data to update bid and ask
@@ -320,30 +323,31 @@ class BitunixSignal:
  
     # Function to process the bid, ask
     async def ProcessDepthData(self):
-        while True:
-            try:
-                latest_data = {}
-                reversed_items = await self.drain_queue(self.depth_que)
-                while reversed_items:
-                    message = reversed_items.popleft()
-                    data = json.loads(message)
-                    if data.get('symbol') and data.get('ch') == 'depth_book1':
-                        symbol = data["symbol"]
-                        ts = data["ts"]
-                        if symbol not in latest_data or ts > latest_data[symbol]['ts']:
-                            latest_data[symbol] = {'ts': ts, 'bid': float(data['data']['b'][0][0]), 'ask': float(data['data']['a'][0][0])}
-                    await asyncio.sleep(0.01)
-                # Convert to DataFrame
-                self.depthdf = pd.DataFrame.from_dict(latest_data, orient="index")
-                if not self.depthdf.empty:
-                    self.depthdf["tickerObj"] = self.depthdf.index.map(self.tickerObjects.get_tickerDict())
-                    self.depthdf.apply(self.apply_depth_data2, axis=1)
-            except Exception as e:
-                self.logger.info(f"Function: ProcessTickerData, {e}, {e.args}, {type(e).__name__}")
-                self.logger.info(traceback.print_exc())
-            await asyncio.sleep(0.01)
-        self.logger.info(f"ProcessDepthData: exitied out of the loop, exiting app")
-        #os._exit(1)  # Exit the program 
+        if self.settings.VERBOSE_LOGGING:
+            self.logger.info(f"Started ProcessDepthData")
+        start=time.time()
+        try:
+            latest_data = {}
+            reversed_items = await self.drain_queue(self.depth_que)
+            while reversed_items:
+                message = reversed_items.popleft()
+                data = json.loads(message)
+                if data.get('symbol') and data.get('ch') == 'depth_book1':
+                    symbol = data["symbol"]
+                    ts = data["ts"]
+                    if symbol not in latest_data or ts > latest_data[symbol]['ts']:
+                        latest_data[symbol] = {'ts': ts, 'bid': float(data['data']['b'][0][0]), 'ask': float(data['data']['a'][0][0])}
+                await asyncio.sleep(0.01)
+            # Convert to DataFrame
+            self.depthdf = pd.DataFrame.from_dict(latest_data, orient="index")
+            if not self.depthdf.empty:
+                self.depthdf["tickerObj"] = self.depthdf.index.map(self.tickerObjects.get_tickerDict())
+                self.depthdf.apply(self.apply_depth_data2, axis=1)
+        except Exception as e:
+            self.logger.info(f"Function: ProcessTickerData, {e}, {e.args}, {type(e).__name__}")
+            self.logger.info(traceback.print_exc())
+        if self.settings.VERBOSE_LOGGING:
+            self.logger.info(f"ProcessDepthData: elapsed time {time.time()-start}")
 
     def apply_depth_data2(self, row):
         row["tickerObj"].set_ask(row["ask"])
@@ -930,6 +934,8 @@ class BitunixSignal:
                                     if price > sl_midpoint and side == "BUY" or price < sl_midpoint and side == "SELL":
                                         if breakeven_calc:
                                             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)
+                                            if slPrice < avgOpenPrice and side == "BUY" or slPrice > avgOpenPrice and side == "SELL":
+                                                slPrice = avgOpenPrice
                                         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))
@@ -944,7 +950,7 @@ class BitunixSignal:
                                             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  {"break even" if breakeven_calc  else ""} {slPrice}'
+                                                    f'{colors.CYAN} Stop Loss order for {row.symbol} moved from {old_slPrice} to {"profitable" if breakeven_calc  else ""} {slPrice}'
                                                 )
                                                                           
 

{bitunix_automated_crypto_trading-3.3.9 → bitunix_automated_crypto_trading-3.4.0}/bitunix_automated_crypto_trading/TickerManager.py

@@ -330,8 +330,9 @@ class Interval:
                     
                     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")
+                        (self.settings.ADX_STUDY and self.settings.ADX_CHECK_ON_OPEN and self.adx_signal == "STRONG") if self.settings.ADX_STUDY  and self.settings.ADX_CHECK_ON_OPEN else True
+                    ) and (
+                        (self.settings.CANDLE_TREND_STUDY and self.settings.CANDLE_TREND_CHECK_ON_OPEN and self.candle_trend == "BULLISH") if self.settings.CANDLE_TREND_STUDY  and self.settings.CANDLE_TREND_CHECK_ON_OPEN else True
                     )
 
 
@@ -345,8 +346,9 @@ class Interval:
 
                     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")
+                        (self.settings.ADX_STUDY and self.settings.ADX_CHECK_ON_OPEN and self.adx_signal == "STRONG") if self.settings.ADX_STUDY  and self.settings.ADX_CHECK_ON_OPEN else True
+                    ) and (
+                        (self.settings.CANDLE_TREND_STUDY and self.settings.CANDLE_TREND_CHECK_ON_OPEN and self.candle_trend == "BEARISH") if self.settings.CANDLE_TREND_STUDY  and self.settings.CANDLE_TREND_CHECK_ON_OPEN else True
                     )
 
                     # Determine current signal
@@ -372,8 +374,9 @@ class Interval:
 
                     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")
+                        (self.settings.ADX_STUDY and self.settings.ADX_CHECK_ON_OPEN and self.adx_signal == "STRONG") if self.settings.ADX_STUDY  and self.settings.ADX_CHECK_ON_OPEN else True
+                    ) and (
+                        (self.settings.CANDLE_TREND_STUDY and self.settings.CANDLE_TREND_CHECK_ON_OPEN and self.candle_trend == "BULLISH") if self.settings.CANDLE_TREND_STUDY  and self.settings.CANDLE_TREND_CHECK_ON_OPEN else True
                     )
 
                     # Check for SELL signal
@@ -392,8 +395,9 @@ class Interval:
 
                     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")
+                        (self.settings.ADX_STUDY and self.settings.ADX_CHECK_ON_OPEN and self.adx_signal == "STRONG") if self.settings.ADX_STUDY  and self.settings.ADX_CHECK_ON_OPEN else True
+                    ) and (
+                        (self.settings.CANDLE_TREND_STUDY and self.settings.CANDLE_TREND_CHECK_ON_OPEN and self.candle_trend == "BEARISH") if self.settings.CANDLE_TREND_STUDY  and self.settings.CANDLE_TREND_CHECK_ON_OPEN else True
                     )
 
                     # Determine current signal

bitunix_automated_crypto_trading-3.4.0/bitunix_automated_crypto_trading/version.py

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

{bitunix_automated_crypto_trading-3.3.9 → bitunix_automated_crypto_trading-3.4.0}/bitunix_automated_crypto_trading.egg-info/PKG-INFO

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

bitunix_automated_crypto_trading-3.3.9/bitunix_automated_crypto_trading/version.py

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