bitunix-automated-crypto-trading 3.3.7__py3-none-any.whl → 3.3.9__py3-none-any.whl

bitunix_automated_crypto_trading/AsyncThreadRunner.py

@@ -1,7 +1,7 @@
 import asyncio
 import threading
-from logger import Logger
-import os
+import time
+import logging # Using standard logging for demonstration
 
 class AsyncThreadRunner:
     def __init__(self, async_func, logger, interval, *args, **kwargs):
@@ -13,24 +13,37 @@ class AsyncThreadRunner:
         self._stop_event = threading.Event()
         self.thread = threading.Thread(target=self.thread_function)
         self.task = None
-        self.logger = logger 
+        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.async_func(*self.args, **self.kwargs), self.loop
-                            )                
+                    self.run_once(), self.loop
+                )
             else:
+                # For periodic tasks, schedule the periodic_run
                 self.task = asyncio.run_coroutine_threadsafe(
-                                self.periodic_run(), self.loop
-                            )
+                    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:
-            self.logger.info(f"Async Thread function error: {e}, exiting app")
-            os._exit(1)  # Exit the program if the thread is stopped
+            # 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()
@@ -38,45 +51,82 @@ class AsyncThreadRunner:
                     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:
-                    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
+                    # 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:
-            pass
+            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):
-        self.thread.name = thread_name
+        """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()
 
-    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}")
+    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
 
-        # Stop the event loop safely
-        self.loop.call_soon_threadsafe(self.loop.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 join
-        self.thread.join()
-        self.logger.info(f"{self.thread.name} Thread stopped and event loop cleaned up.")
+        # 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/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 roi > self.settings.PROFIT_PERCENTAGE:
-                                           sl_midpoint = tp_midpoint                                       
+                                    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 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)
+                                    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:
-                                        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:
+                                    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/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/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/version.py

@@ -1 +1 @@
-__version__ = "3.3.7"
+__version__ = "3.3.9"

{bitunix_automated_crypto_trading-3.3.7.dist-info → bitunix_automated_crypto_trading-3.3.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bitunix_automated_crypto_trading
-Version: 3.3.7
+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.7.dist-info → bitunix_automated_crypto_trading-3.3.9.dist-info}/RECORD

@@ -1,19 +1,18 @@
-bitunix_automated_crypto_trading/AsyncThreadRunner.py,sha256=bNIM_1xRYQOFEsIn74EX6qVpC59-GMhhr2CeiPr_GWg,3253
+bitunix_automated_crypto_trading/AsyncThreadRunner.py,sha256=ZTznmxIBQ81oT4nFMa8ic7PGh-3QpStNh6tGG-3RHU0,6502
 bitunix_automated_crypto_trading/BitunixApi.py,sha256=5qg-K5IcsAbb6K1feP9zL7RzSz7JzdGAxoY8R_YWxWE,15666
-bitunix_automated_crypto_trading/BitunixSignal.py,sha256=jPxnlaKA7NJDl1az3m1bfNLpouUsMYa35CixwUCD25E,91091
+bitunix_automated_crypto_trading/BitunixSignal.py,sha256=6YI-X5pXxM9ifvY8S7u0e6HyrXYVlUsYBWXgVpAfxbw,92090
 bitunix_automated_crypto_trading/BitunixWebSocket.py,sha256=uiqAcis3u-ct07tjaTiC87ujzvcAtVRZ31CMiTBDW_M,11309
 bitunix_automated_crypto_trading/DataFrameHtmlRenderer.py,sha256=Pqdzhh_nfIxFEZH9L_R5QXB8moDPbgeTGT_hmBkHWMg,2899
 bitunix_automated_crypto_trading/NotificationManager.py,sha256=exs6REABBA1omTeTGuUuECzxs5dGqdyL7oI8WyxS6Xc,798
 bitunix_automated_crypto_trading/SupportResistance.py,sha256=x_to4M4OHg0h8o40DXDBa4E_5io-y2Lb5qo2VzFnu_8,5765
-bitunix_automated_crypto_trading/ThreadManager.py,sha256=Lw5_1EIT0m3AFSv5CIMpnjtA0DnNw2qQ6JtSpT34LyM,2349
 bitunix_automated_crypto_trading/TickerManager.py,sha256=tYzO7-vxb-60a-yvsRDC4w9GNdTsqWwy8DxbagtsqAc,42023
 bitunix_automated_crypto_trading/__init__.py,sha256=1hzk6nX8NnUCr1tsq8oFq1qGCNhNwnwldWE75641Eew,78
-bitunix_automated_crypto_trading/bitunix.py,sha256=lxwnYARxldA2oU6GdjupilXIlnUh4RX8rQLCOn7x13I,27143
-bitunix_automated_crypto_trading/config.py,sha256=2K-5NzWoVUaU3O2tgi4qt-3dA_sCC6Nm3vFQBZrO5y8,5943
+bitunix_automated_crypto_trading/bitunix.py,sha256=dlf5m0964JW6-9V-xFWv0_4C3OWJ6yTq22E4qWWsGSI,27038
+bitunix_automated_crypto_trading/config.py,sha256=AlcB0mmwOPfVWuiPrEiexk_JK9qhM2l9sZIdPBtNvqM,6146
 bitunix_automated_crypto_trading/logger.py,sha256=NHnA5JZdUFkTAhB7i-1iCAwrdf1fxhDuRvJUkbKPi9Y,2923
-bitunix_automated_crypto_trading/version.py,sha256=Z9dy-a-QtSCS4duPQWpgA6G-wTeWi6aUt5Wi1lK_Ltg,21
-bitunix_automated_crypto_trading-3.3.7.dist-info/METADATA,sha256=pppKFPixMGagASNAjEA4nu5lY9wTbslP4__00JOmNIk,996
-bitunix_automated_crypto_trading-3.3.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-bitunix_automated_crypto_trading-3.3.7.dist-info/entry_points.txt,sha256=UXREYHuSl2XYd_tOtLIq0zg3d1kX3lixX5SpN8yGBw4,82
-bitunix_automated_crypto_trading-3.3.7.dist-info/top_level.txt,sha256=uyFzHUCOsp8elnG2Ovor6xXcf7dxRxY-C-Txiwix64Q,33
-bitunix_automated_crypto_trading-3.3.7.dist-info/RECORD,,
+bitunix_automated_crypto_trading/version.py,sha256=W-NPfrZxGZd77L27ZfNBeZFiVIWjDNLUvZpIjOMIqSY,21
+bitunix_automated_crypto_trading-3.3.9.dist-info/METADATA,sha256=r6O6GEO7JvYJSoWS3ZX08Znm_8-XVjhgsRKykKs1-6w,996
+bitunix_automated_crypto_trading-3.3.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+bitunix_automated_crypto_trading-3.3.9.dist-info/entry_points.txt,sha256=UXREYHuSl2XYd_tOtLIq0zg3d1kX3lixX5SpN8yGBw4,82
+bitunix_automated_crypto_trading-3.3.9.dist-info/top_level.txt,sha256=uyFzHUCOsp8elnG2Ovor6xXcf7dxRxY-C-Txiwix64Q,33
+bitunix_automated_crypto_trading-3.3.9.dist-info/RECORD,,

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()