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

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

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

{bitunix_automated_crypto_trading-3.3.8 → bitunix_automated_crypto_trading-3.3.9}/README.md

@@ -51,6 +51,13 @@ Supports running the app in multiple instances (bots) with each instance having
 The platform can be configured through the `config.py` file or `config.txt`. Key configuration parameters include:
 - Trading Parameters:
   - `AUTOTRADE` : True or False
+
+  - `ALL_TICKERS`  will be tickers that are not in LONG_TICKERS and SHORT_TICKERS, this willtrade all other tickers that are not in LONG_TICKERS and SHORT_TICKERS
+  - `LONG_TICKERS` will always trade long, even if the signal is SELL
+  - `SHORT_TICKERS` will always trade short, even if the signal is BUY
+  - `IGNORE_TICKERS` will not trade these tickers
+    If you want to trade all tickers except the ones in IGNORE_TICKERS, then set ALL_TICKERS, LONG_TICKERS and SHORT_TICKERS to ""
+  
   - `TICKERS`: supply a list of tickers seperated by comma to trade, e.g., "BTCUSDT,ETHUSDT" or "" to auto select based on MIN_VOLUME and THRESHOLD
   - `LEVERAGE`: Trading leverage (1-100)
   - `THRESHOLD`: Ticker selection based close near high or low of the day
@@ -61,6 +68,8 @@ The platform can be configured through the `config.py` file or `config.txt`. Key
   - `LOSS_AMOUNT`: Maximum loss amount
   - `PROFIT_PERCENTAGE`: Target profit ROI percentage
   - `LOSS_PERCENTAGE`: Maximum loss ROI percentage
+  -  `SL_BREAKEVEN_PERCENTAGE`
+      Percentage of profit to move the stop loss to breakeven, default is 75%
   - `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`

bitunix_automated_crypto_trading-3.3.9/bitunix_automated_crypto_trading/AsyncThreadRunner.py

@@ -0,0 +1,132 @@
+import asyncio
+import threading
+import time
+import logging # Using standard logging for demonstration
+
+class AsyncThreadRunner:
+    def __init__(self, async_func, logger, interval, *args, **kwargs):
+        self.async_func = async_func
+        self.interval = interval
+        self.args = args
+        self.kwargs = kwargs
+        self.loop = asyncio.new_event_loop()
+        self._stop_event = threading.Event()
+        self.thread = threading.Thread(target=self.thread_function)
+        self.task = None
+        self.logger = logger
+        self.exception_occurred = False # New flag to indicate if an unhandled exception occurred
+
+    def thread_function(self):
+        """This function runs in the separate thread."""
+        asyncio.set_event_loop(self.loop)
+        self.exception_occurred = False # Reset on thread start
+
+        try:
+            if self.interval == 0:
+                # For one-off tasks, run it and then stop the loop
+                self.task = asyncio.run_coroutine_threadsafe(
+                    self.run_once(), self.loop
+                )
+            else:
+                # For periodic tasks, schedule the periodic_run
+                self.task = asyncio.run_coroutine_threadsafe(
+                    self.periodic_run(), self.loop
+                )
+            
+            # This will run until loop.stop() is called
+            self.logger.info(f"Thread '{self.thread.name}' event loop started.")
+            self.loop.run_forever()
+        except Exception as e:
+            # This catches exceptions that bubble up from run_forever,
+            # which usually means a serious issue or the loop being stopped unexpectedly.
+            self.logger.error(f"Async Thread '{self.thread.name}' main function error: {type(e).__name__} - {e}", exc_info=True)
+            self.exception_occurred = True # Mark as failed
+        finally:
+            self.logger.info(f"Thread '{self.thread.name}' event loop stopping.")
+            # Clean up pending tasks
+            pending = asyncio.all_tasks(self.loop)
+            for task in pending:
+                task.cancel()
+                try:
+                    self.loop.run_until_complete(task)
+                except asyncio.CancelledError:
+                    pass
+                except Exception as e:
+                    self.logger.error(f"Error during task cancellation in thread '{self.thread.name}': {e}")
+            
+            # Shutdown async generators and close the loop
+            self.loop.run_until_complete(self.loop.shutdown_asyncgens())
+            self.loop.close()
+            self.logger.info(f"Thread '{self.thread.name}' event loop closed.")
+
+    async def run_once(self):
+        """Helper for one-off tasks."""
+        try:
+            await self.async_func(*self.args, **self.kwargs)
+            self.logger.info(f"Thread '{self.thread.name}' one-off task completed.")
+        except Exception as e:
+            self.logger.error(f"Error in one-off task for thread '{self.thread.name}': {type(e).__name__} - {e}", exc_info=True)
+            self.exception_occurred = True # Mark as failed if the one-off task itself fails
+        finally:
+            # Stop the event loop after a one-off task completes or fails
+            self.loop.call_soon_threadsafe(self.loop.stop)
+
+
+    async def periodic_run(self):
+        """Runs the async function periodically."""
+        try:
+            while not self._stop_event.is_set():
+                try:
+                    await self.async_func(*self.args, **self.kwargs)
+                except Exception as e:
+                    # Log the error but continue the loop for periodic tasks,
+                    # assuming the next run might succeed.
+                    self.logger.error(f"Error in periodic_run for thread '{self.thread.name}': {type(e).__name__} - {e}", exc_info=True)
+                    # If you want a critical failure here to stop the thread entirely for restart,
+                    # you would set self.exception_occurred = True and then break the loop.
+                    # 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
+                
+                # Use asyncio.sleep to allow graceful cancellation
+                try:
+                    await asyncio.sleep(self.interval)
+                except asyncio.CancelledError:
+                    self.logger.info(f"Periodic sleep for '{self.thread.name}' cancelled.")
+                    break # Exit loop if sleep is cancelled
+            
+            self.logger.info(f"Periodic run for '{self.thread.name}' loop stopped.")
+        except asyncio.CancelledError:
+            self.logger.info(f"Periodic run for '{self.thread.name}' task cancelled.")
+        except Exception as e:
+            self.logger.error(f"Unexpected error in periodic_run for thread '{self.thread.name}': {type(e).__name__} - {e}", exc_info=True)
+            self.exception_occurred = True # Mark as failed if periodic_run itself has an unhandled error
+
+    def start_thread(self, thread_name=None):
+        """Starts the underlying threading.Thread."""
+        self.thread.name = thread_name if thread_name else f"AsyncRunner-{id(self)}"
+        self.logger.info(f"Starting background thread '{self.thread.name}'.")
+        self.thread.start()
+
+    def stop_thread(self):
+        """Gracefully signals the async thread to stop."""
+        self.logger.info(f"Signaling thread '{self.thread.name}' to stop.")
+        self._stop_event.set() # Signal the periodic task to stop
+
+        # If it's a one-off task, the loop will stop itself.
+        # If it's a periodic task, we need to cancel its main task to unblock run_forever.
+        if self.task and not self.task.done():
+            self.loop.call_soon_threadsafe(self.task.cancel)
+        
+        # Stop the event loop if it's running
+        if self.loop.is_running():
+            self.loop.call_soon_threadsafe(self.loop.stop)
+
+        # Wait for the thread to actually finish its execution
+        self.thread.join(timeout=10) # Give it some time to clean up
+        if self.thread.is_alive():
+            self.logger.warning(f"Thread '{self.thread.name}' did not terminate gracefully after join timeout.")
+        else:
+            self.logger.info(f"Thread '{self.thread.name}' successfully stopped.")

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

@@ -28,11 +28,10 @@ import threading
 cst = pytz.timezone('US/Central')
 
 class BitunixSignal:
-    def __init__(self, api_key, secret_key, settings, threadManager, notifications, bitunixApi, logger):
+    def __init__(self, api_key, secret_key, settings, notifications, bitunixApi, logger):
         self.api_key = api_key
         self.secret_key = secret_key
         self.settings=settings
-        self.threadManager = threadManager
         self.notifications = notifications
         self.bitunixApi = bitunixApi
         self.logger = logger
@@ -101,7 +100,7 @@ class BitunixSignal:
         self.tickerObjects.update_settings(settings)
         
     async def load_tickers(self):
-        if self.settings.TICKERS=="":
+        if self.settings.LONG_TICKERS=="" and self.settings.SHORT_TICKERS=="" and self.settings.ALL_TICKERS=="":
             symbols = await self.bitunixApi.GetTickerList(float(self.settings.THRESHOLD), float(self.settings.MIN_VOLUME))
             self.pendingPositions= await self.bitunixApi.GetPendingPositionData()
             self.pendingOrders= await self.bitunixApi.GetPendingOrderData()
@@ -113,15 +112,17 @@ class BitunixSignal:
                 olist = [entry['symbol'] for entry in self.pendingOrders['orderList']]
             newlist=olist+plist+list(set(symbols))
             self.tickerList=newlist[:300]
-            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(",")
+            all_tickers = self.settings.LONG_TICKERS + "," + self.settings.SHORT_TICKERS + "," + self.settings.ALL_TICKERS;
+            self.tickerList = all_tickers.split(",")
             self.tickerList = [sym.strip().upper() for sym in self.tickerList if sym.strip()]
-
+            
+        #remove ignore tickers
+        if self.settings.IGNORE_TICKERS!="":
+            ignore_tickers = self.settings.IGNORE_TICKERS.split(",")
+            ignore_tickers = [sym.strip().upper() for sym in ignore_tickers if sym.strip()]
+            self.tickerList = [sym for sym in self.tickerList if sym not in ignore_tickers]
+            
         [await self.add_ticker_to_tickerObjects(sym) for sym in self.tickerList]
         self.notifications.add_notification(f"{len(self.tickerList)} ticker list loaded") 
         
@@ -309,7 +310,7 @@ class BitunixSignal:
                 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 
+        #os._exit(1)  # Exit the program 
             
 
     #websocket data to update bid and ask
@@ -342,7 +343,7 @@ class BitunixSignal:
                 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 
+        #os._exit(1)  # Exit the program 
 
     def apply_depth_data2(self, row):
         row["tickerObj"].set_ask(row["ask"])
@@ -399,11 +400,11 @@ class BitunixSignal:
     ###########################################################################################################
     async def checkTickerAndAutotradeStatus(self):
         while True:
-            if self.lastAutoTradeTime + 300 < time.time(): # or self.lastTickerDataTime + 300 < time.time():
+            if self.lastAutoTradeTime + 1500 < time.time() or self.lastTickerDataTime + 1500 < time.time():
                 self.notifications.add_notification("AutoTradeProcess or GetTickerData is not running")
                 os._exit(1) 
                 break
-            await asyncio.sleep(300)
+            await asyncio.sleep(1500)
 
     async def GetportfolioData(self):
         start=time.time()
@@ -650,14 +651,16 @@ class BitunixSignal:
         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())
-        #print(f"trade_time_unix: {trade_time_unix}, trade_time: {trade_time}")
+        print(f"last_trade_time: {trade_time}, last_trade_time_unix: {trade_time_unix}")
         # 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')}")
+        current_time = time.time()
+        current_time_unix = int(current_time)
+        formatted_time = datetime.fromtimestamp(current_time).strftime("%y-%m-%d %H:%M:%S")
+        print(f"current_time: {formatted_time}, current_time_unix: {current_time_unix}")
         # 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}")
+        print(f"duration_minutes: {duration_minutes}")
         
         return round(duration_minutes)
 
@@ -722,14 +725,20 @@ class BitunixSignal:
                         # Calculate the duration in minutes since the position was opened
                         data = await self.bitunixApi.GetPositionHistoryData({'symbol': row['symbol']})
                         duration_minutes = None
+                        mtime = None
                         if data and 'positionList' in data and len(data['positionList']) > 0:
                             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)
-                        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'}")
+                        self.logger.info(f"row.symbol: {row.symbol} , last trade time: {mtime}, duration_minutes: {duration_minutes}")
                         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 row['symbol'] in self.settings.LONG_TICKERS.split(","):
+                                side = "BUY"
+                                self.logger.info(f"row.symbol: {row.symbol} , will always be long")
+                            if row['symbol'] in self.settings.SHORT_TICKERS.split(","):
+                                side = "SELL"
+                                self.logger.info(f"row.symbol: {row.symbol} , will always be short")
                             if side != "":
                                 select = True
                                 self.pendingPositions = await self.bitunixApi.GetPendingPositionData({'symbol': row.symbol})
@@ -875,69 +884,68 @@ class BitunixSignal:
                                             tporderId = order['id']
                                             tpStopType = order['tpStopType']
                                             tpOrderType = order['tpOrderType']
-                                            tpPrice = float(order['tpPrice'])
-                                            old_tpPrice = tpPrice
+                                            old_tpPrice = float(order['tpPrice'])
                                         if order['slPrice'] is not None:
                                             slorderId = order['id']
                                             slStopType = order['slStopType']
                                             slOrderType = order['slOrderType']
-                                            slPrice = float(order['slPrice'])
-                                            old_slPrice = slPrice
+                                            old_slPrice = float(order['slPrice'])
 
                                 # move TP and SL in the direction of profit
                                 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"):
+                                if self.settings.BOT_TRAIL_TP and 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)
+                                    tp_midpoint = Decimal(await self.str_precision(tp_midpoint))
+                                    tp_midpoint =float(str(tp_midpoint.quantize(Decimal(f'1e-{decimal_places}'))))
 
+                                    if 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))
 
-                                            
-                                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 tpPrice is not None:
+                                        self.notifications.add_notification(
+                                            f'{colors.CYAN} {row.symbol} avgOpenPrice: {avgOpenPrice}, current price: {price}, ROI: {roi}%, old_TP: {old_tpPrice}, TP midpoint: {tp_midpoint}, TP: {tpPrice}'
+                                        )
+                                        if old_tpPrice < tpPrice if side== "BUY" else old_tpPrice > tpPrice:
+                                            if old_tpPrice is None or tpPrice != old_tpPrice:
+                                                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}'
+                                                    )
+
+                                breakeven_calc = False                                            
+                                sl_midpoint = None
+                                if self.settings.BOT_TRAIL_SL and old_slPrice is not None:
+                                    if roi > self.settings.PROFIT_PERCENTAGE * self.settings.SL_BREAKEVEN_PERCENTAGE/100 and self.settings.PROFIT_PERCENTAGE < self.settings.LOSS_PERCENTAGE:
+                                        sl_midpoint =  old_slPrice / (1 - self.settings.PROFIT_PERCENTAGE/100/self.settings.LEVERAGE) if side == "BUY" else old_slPrice / (1 + self.settings.PROFIT_PERCENTAGE/100/self.settings.LEVERAGE)
+                                        breakeven_calc = True
+                                    else:
+                                        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) 
+                                    sl_midpoint = Decimal(await self.str_precision(sl_midpoint))
+                                    sl_midpoint =float(str(sl_midpoint.quantize(Decimal(f'1e-{decimal_places}'))))
                                        
-                                    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 * 0.75 and self.settings.PROFIT_PERCENTAGE < self.settings.LOSS_PERCENTAGE:
-                                            slPrice = price * (1 - float(self.settings.PROFIT_PERCENTAGE * 0.75) / 100 / self.settings.LEVERAGE) if side == "BUY" else avgOpenPrice * (1 + float(self.settings.PROFIT_PERCENTAGE) / 100 / self.settings.LEVERAGE)
+                                    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)
                                         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} 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}'
-                                    )
-
-
-                                if self.settings.BOT_TRAIL_TP and tpPrice is not None and tpOrderPrice is not None:
-                                    if old_tpPrice is None or tpPrice != old_tpPrice:
-                                        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:
-                                    if old_slPrice is None or slPrice != old_slPrice:
-                                        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 * 0.75 and self.settings.PROFIT_PERCENTAGE < self.settings.LOSS_PERCENTAGE:
+                                    if slPrice is not None:
+                                        self.notifications.add_notification(
+                                            f'{colors.CYAN} {row.symbol} avgOpenPrice: {avgOpenPrice}, current price: {price}, ROI: {roi}%, old_SL: {old_slPrice}, SL midpoint: {sl_midpoint}, SL: {slPrice}'
+                                        )
+                                        if old_slPrice < slPrice if side== "BUY" else old_slPrice > 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 breakeven {slPrice}'
+                                                    f'{colors.CYAN} Stop Loss order for {row.symbol} moved from {old_slPrice} to  {"break even" if breakeven_calc  else ""} {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:

{bitunix_automated_crypto_trading-3.3.8 → bitunix_automated_crypto_trading-3.3.9}/bitunix_automated_crypto_trading/bitunix.py

@@ -12,7 +12,6 @@ from pathlib import Path
 import re
 
 
-from ThreadManager import ThreadManager
 from BitunixApi import BitunixApi
 from BitunixSignal import BitunixSignal
 from NotificationManager import NotificationManager
@@ -75,10 +74,9 @@ class bitunix():
         self.logger=logger
         self.autoTrade=settings.AUTOTRADE
         self.settings = settings
-        self.threadManager = ThreadManager()
         self.notifications = NotificationManager(logger)
         self.bitunixApi = BitunixApi(api_key, secret_key, settings, self.logger)
-        self.bitunixSignal = BitunixSignal(api_key, secret_key, settings, self.threadManager, self.notifications, self.bitunixApi, self.logger)
+        self.bitunixSignal = BitunixSignal(api_key, secret_key, settings, self.notifications, self.bitunixApi, self.logger)
 
         self.websocket_connections = set()
         self.DB = {"admin": {"password": password}}

{bitunix_automated_crypto_trading-3.3.8 → bitunix_automated_crypto_trading-3.3.9}/bitunix_automated_crypto_trading/config.py

@@ -9,7 +9,10 @@ class Settings(BaseSettings):
     AUTOTRADE: bool = Field(default=False)
     
     #Ticker list
-    TICKERS:str = Field(default="")
+    ALL_TICKERS:str = Field(default="")
+    LONG_TICKERS:str = Field(default="")
+    SHORT_TICKERS:str = Field(default="")
+    IGNORE_TICKERS:str = Field(default="")
     THRESHOLD: float = Field(default=100.0, ge=0.0)
     MIN_VOLUME: int = Field(default=500000000, ge=0)
 
@@ -19,6 +22,7 @@ class Settings(BaseSettings):
     MAX_AUTO_TRADES: int = Field(default=10, ge=0)
     PROFIT_PERCENTAGE: float = Field(default=10, ge=0.0)
     LOSS_PERCENTAGE: float = Field(default=10, ge=0.0)
+    SL_BREAKEVEN_PERCENTAGE: float = Field(default=50, ge=0.0, le=100.0)
     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)

bitunix_automated_crypto_trading-3.3.9/bitunix_automated_crypto_trading/version.py

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

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

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

{bitunix_automated_crypto_trading-3.3.8 → bitunix_automated_crypto_trading-3.3.9}/bitunix_automated_crypto_trading.egg-info/SOURCES.txt

@@ -7,7 +7,6 @@ bitunix_automated_crypto_trading/BitunixWebSocket.py
 bitunix_automated_crypto_trading/DataFrameHtmlRenderer.py
 bitunix_automated_crypto_trading/NotificationManager.py
 bitunix_automated_crypto_trading/SupportResistance.py
-bitunix_automated_crypto_trading/ThreadManager.py
 bitunix_automated_crypto_trading/TickerManager.py
 bitunix_automated_crypto_trading/__init__.py
 bitunix_automated_crypto_trading/bitunix.py

bitunix_automated_crypto_trading-3.3.8/bitunix_automated_crypto_trading/AsyncThreadRunner.py

@@ -1,82 +0,0 @@
-import asyncio
-import threading
-from logger import Logger
-import os
-
-class AsyncThreadRunner:
-    def __init__(self, async_func, logger, interval, *args, **kwargs):
-        self.async_func = async_func
-        self.interval = interval
-        self.args = args
-        self.kwargs = kwargs
-        self.loop = asyncio.new_event_loop()
-        self._stop_event = threading.Event()
-        self.thread = threading.Thread(target=self.thread_function)
-        self.task = None
-        self.logger = logger 
-
-    def thread_function(self):
-        asyncio.set_event_loop(self.loop)
-        try:
-            if self.interval == 0:
-                self.task = asyncio.run_coroutine_threadsafe(
-                                self.async_func(*self.args, **self.kwargs), self.loop
-                            )                
-            else:
-                self.task = asyncio.run_coroutine_threadsafe(
-                                self.periodic_run(), self.loop
-                            )
-            self.loop.run_forever()
-        except Exception as e:
-            self.logger.info(f"Async Thread function error: {e}, exiting app")
-            os._exit(1)  # Exit the program if the thread is stopped
-        finally:
-            pending = asyncio.all_tasks(self.loop)
-            for task in pending:
-                task.cancel()
-                try:
-                    self.loop.run_until_complete(task)
-                except asyncio.CancelledError:
-                    pass
-            self.loop.run_until_complete(self.loop.shutdown_asyncgens())
-            self.loop.close()
-
-    async def periodic_run(self):
-        try:
-            while not self._stop_event.is_set():
-                try:
-                    await self.async_func(*self.args, **self.kwargs)
-                except Exception as e:
-                    self.logger.info(f"error in periodic_run async thread {self.thread.name} {e}")
-                    os._exit(1)  # Exit the program if the thread is stopped
-                await asyncio.sleep(self.interval)
-            self.logger.info(f"periodic {self.thread.name} Thread stopped, exiting app.")
-            os._exit(1)  # Exit the program if the thread is stopped
-        except asyncio.CancelledError:
-            pass
-
-    def start_thread(self, thread_name=None):
-        self.thread.name = thread_name
-        self.thread.start()
-
-    async def stop_thread(self):
-        """Gracefully stop the async thread."""
-        # Signal any periodic task to stop
-        self._stop_event.set()
-
-        # Cancel and await the running task
-        if self.task:
-            self.task.cancel()
-            try:
-                await asyncio.wrap_future(self.task)  # Wait for the cancellation to propagate
-            except asyncio.CancelledError:
-                self.logger.info(f"{self.thread.name} Task cancelled successfully.")
-            except Exception as e:
-                self.logger.error(f"Unexpected error while cancelling the task {self.thread.name}: {e}")
-
-        # Stop the event loop safely
-        self.loop.call_soon_threadsafe(self.loop.stop)
-
-        # Wait for the thread to join
-        self.thread.join()
-        self.logger.info(f"{self.thread.name} Thread stopped and event loop cleaned up.")

bitunix_automated_crypto_trading-3.3.8/bitunix_automated_crypto_trading/ThreadManager.py

@@ -1,70 +0,0 @@
-#usage
-#start threads
-#self.threadManager.start_thread("GetportfolioData", 1, self.GetportfolioData) 
-#self.threadManager.start_thread("GetPendingPositionData", 0, self.GetPendingPositionData) 
-#self.threadManager.start_thread("GetOrderData", 1, self.GetPendingOrderData) 
-#self.threadManager.start_thread("GetTradeHistoryData", 1, self.GetTradeHistoryData) 
-#self.threadManager.start_thread("BuySellList", 60, self.BuySellList) 
-#self.threadManager.start_thread("AutoTradeProcess", 60, self.AutoTradeProcess) 
-
-import time
-import threading
-from logger import Logger
-global LOG_FILE
-
-def job_func(*args, **kwargs):
-    print(f"Job running with arguments: {args}, {kwargs}")        
-        
-def run_threaded(job_func, args):
-    job_thread = threading.Thread(target=job_func, args=args)
-    job_thread.start()
-
-class ManagedThread(threading.Thread):
-    def __init__(self, interval, target, logger, *args, **kwargs):
-        super().__init__()
-        self.target = target
-        self.interval = interval
-        self.args = args
-        self.kwargs = kwargs
-        self._stop_event = threading.Event()
-        self.logger = logger
-
-    def run(self):
-        while not self._stop_event.is_set():
-            stime=time.time()
-            try:
-                self.target(self, *self.args, **self.kwargs)
-            except Exception as e:
-                self.logger.info(f"error in thread {self.name}, {e}, {e.args}, {type(e).__name__}")  
-            elapsed_time = time.time() - stime
-            if self.interval==0:
-                break
-            time_to_wait = max(0.05, self.interval - elapsed_time)
-            time.sleep(time_to_wait)
-
-    def stop(self):
-        self._stop_event.set()
-        
-    def should_stop(self): 
-        return self._stop_event.is_set()        
-
-class ThreadManager:
-    def __init__(self):
-        self.threads = []
-
-    def start_thread(self, name, interval, thread, *args, **kwargs):
-        thread = ManagedThread(interval, thread, *args, **kwargs)
-        thread.name = name
-        thread.start()
-        self.threads.append(thread)
-        thread.join(interval)
-        return thread
-
-    def stop_all_threads(self):
-        for thread in self.threads:
-            thread.stop()
-        for thread in self.threads:
-            thread.join()
-        self.threads = []
-
-threadManager = ThreadManager()

bitunix_automated_crypto_trading-3.3.8/bitunix_automated_crypto_trading/version.py

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