bitunix-automated-crypto-trading 3.1.7__py3-none-any.whl → 3.1.8__py3-none-any.whl

bitunix_automated_crypto_trading/AsyncThreadRunner.py

@@ -2,10 +2,9 @@ import asyncio
 import threading
 from logger import Logger
 import os
-logger = Logger(__name__).get_logger()
 
 class AsyncThreadRunner:
-    def __init__(self, async_func, interval, *args, **kwargs):
+    def __init__(self, async_func, logger, interval, *args, **kwargs):
         self.async_func = async_func
         self.interval = interval
         self.args = args
@@ -14,6 +13,7 @@ class AsyncThreadRunner:
         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)
@@ -28,7 +28,7 @@ class AsyncThreadRunner:
                             )
             self.loop.run_forever()
         except Exception as e:
-            logger.info(f"Async Thread function error: {e}, exiting app")
+            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)
@@ -47,10 +47,10 @@ class AsyncThreadRunner:
                 try:
                     await self.async_func(*self.args, **self.kwargs)
                 except Exception as e:
-                    logger.info(f"error in periodic_run async thread {self.thread.name} {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)
-            logger.info(f"periodic {self.thread.name} Thread stopped, exiting app.")
+            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
@@ -70,13 +70,13 @@ class AsyncThreadRunner:
             try:
                 await asyncio.wrap_future(self.task)  # Wait for the cancellation to propagate
             except asyncio.CancelledError:
-                logger.info(f"{self.thread.name} Task cancelled successfully.")
+                self.logger.info(f"{self.thread.name} Task cancelled successfully.")
             except Exception as e:
-                logger.error(f"Unexpected error while cancelling the task {self.thread.name}: {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()
-        logger.info(f"{self.thread.name} Thread stopped and event loop cleaned up.")
+        self.logger.info(f"{self.thread.name} Thread stopped and event loop cleaned up.")

bitunix_automated_crypto_trading/BitunixApi.py

@@ -9,15 +9,14 @@ from urllib.parse import urlencode
 from typing import Dict, Any
 import traceback
 from logger import Logger
-logger = Logger(__name__).get_logger()
 
 
 class BitunixApi:
     
-    def __init__(self, api_key, secret_key, settings):
+    def __init__(self, api_key, secret_key, settings, logger):
         self.api_key = api_key
         self.secret_key = secret_key
-        
+        self.logger = logger
         self.session = requests.Session()
         self.session.headers.update({
             'Content-Type': 'application/json',
@@ -115,7 +114,7 @@ class BitunixApi:
         headers["sign"] = signature
 
         response = self.session.post(endpoint, data=body_string, headers=headers)
-        logger.info(f"Response: {body_string} {response.json()}")
+        self.logger.info(f"Response: {body_string} {response.json()}")
         response.raise_for_status()
         return response.json()
 
@@ -153,28 +152,28 @@ class BitunixApi:
         if tradeHistory['code']==0:
             return tradeHistory['data']
         else:
-            logger.info(tradeHistory['msg'])
+            self.logger.info(tradeHistory['msg'])
 
     async def GetPendingOrderData(self,dictparm={}):
         orders=await self._get_authenticated(self.pending_order_url, dictparm)
         if orders['code']==0:
             return orders['data']
         else:
-            logger.info(orders['msg'])
+            self.logger.info(orders['msg'])
 
     async def GetPendingPositionData(self, dictparm={}):
         positions=await self._get_authenticated(self.pending_positions_URL, dictparm)
         if positions['code']==0:
             return positions['data']
         else:
-            logger.info(positions['msg'])
+            self.logger.info(positions['msg'])
 
     async def GetPositionHistoryData(self, dictparm={}):
         tradeHistory=await self._get_authenticated(self.position_history_Url, dictparm)
         if tradeHistory['code']==0:
             return tradeHistory['data']
         else:
-            logger.info(tradeHistory['msg'])
+            self.logger.info(tradeHistory['msg'])
 
     
     async def GetportfolioData(self):
@@ -182,7 +181,7 @@ class BitunixApi:
         if portfolio['code']==0:
             return portfolio['data']
         else:
-            logger.info(portfolio['msg'])
+            self.logger.info(portfolio['msg'])
            
 
     async def GetTickerslastPrice(self, tickersStr):
@@ -223,7 +222,7 @@ class BitunixApi:
         except Exception as e:
             stack = traceback.extract_stack()
             function_name = stack[-2].name
-            logger.info(f"Function: {function_name}, {e}, {e.args}, {type(e).__name__}")
+            self.logger.info(f"Function: {function_name}, {e}, {e.args}, {type(e).__name__}")
             
     async def GetTickerData(self):
         try:
@@ -235,7 +234,7 @@ class BitunixApi:
         except Exception as e:
             stack = traceback.extract_stack()
             function_name = stack[-2].name
-            logger.info(f"Function: {function_name}, {e}, {e.args}, {type(e).__name__}")           
+            self.logger.info(f"Function: {function_name}, {e}, {e.args}, {type(e).__name__}")           
 
     async def GetDepthData(self,symbol,limit):
         try:
@@ -247,7 +246,7 @@ class BitunixApi:
         except Exception as e:
             stack = traceback.extract_stack()
             function_name = stack[-2].name
-            logger.info(f"Function: {function_name}, {e}, {e.args}, {type(e).__name__}")           
+            self.logger.info(f"Function: {function_name}, {e}, {e.args}, {type(e).__name__}")           
 
     async def GetKlineHistory(self, ticker, interval, limit, starttime):
         data = []
@@ -270,7 +269,7 @@ class BitunixApi:
         except Exception as e:
             stack = traceback.extract_stack()
             function_name = stack[-2].name
-            logger.info(f"Function: {function_name}, {e}, {e.args}, {type(e).__name__}") 
+            self.logger.info(f"Function: {function_name}, {e}, {e.args}, {type(e).__name__}") 
 
     def __del__(self):
             """Cleanup method to close the session"""

bitunix_automated_crypto_trading/BitunixSignal.py

@@ -13,7 +13,6 @@ from AsyncThreadRunner import AsyncThreadRunner
 from TickerManager import Tickers, Ticker, Interval
 from DataFrameHtmlRenderer import DataFrameHtmlRenderer
 from logger import Logger, Colors
-logger = Logger(__name__).get_logger()
 colors = Colors()
 import gc
 import os
@@ -27,16 +26,17 @@ import threading
 cst = pytz.timezone('US/Central')
 
 class BitunixSignal:
-    def __init__(self, api_key, secret_key, settings, threadManager, notifications, bitunixApi):
+    def __init__(self, api_key, secret_key, settings, threadManager, 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
               
         #Ticker object
-        self.tickerObjects = Tickers(self.settings)
+        self.tickerObjects = Tickers(self.settings, self.logger)
         
         #these are used for html rendering as well as storing
         self.signaldf= pd.DataFrame()
@@ -78,8 +78,8 @@ class BitunixSignal:
         self.bitunixPrivateWebSocketClient = BitunixPrivateWebSocketClient(self.api_key, self.secret_key)
         
         if self.settings.USE_PUBLIC_WEBSOCKET:
-            self.bitunixPublicDepthWebSocketClient = BitunixPublicWebSocketClient(self.api_key, self.secret_key, "depth")
-            self.bitunixPublicTickerWebSocketClient = BitunixPublicWebSocketClient(self.api_key, self.secret_key, "ticker")
+            self.bitunixPublicDepthWebSocketClient = BitunixPublicWebSocketClient(self.api_key, self.secret_key, "depth", logger)
+            self.bitunixPublicTickerWebSocketClient = BitunixPublicWebSocketClient(self.api_key, self.secret_key, "ticker", logger)
 
         self.tickerList=[]
 
@@ -129,52 +129,52 @@ class BitunixSignal:
         await asyncio.create_task(self.DefinehtmlRenderers())
 
         #async thread that runs forever jobs
-        self.GetportfolioDataTask = AsyncThreadRunner(self.GetportfolioData, interval=int(self.settings.PORTFOLIO_API_INTERVAL))
+        self.GetportfolioDataTask = AsyncThreadRunner(self.GetportfolioData, self.logger, interval=int(self.settings.PORTFOLIO_API_INTERVAL))
         self.GetportfolioDataTask.start_thread(thread_name="GetportfolioData")
 
-        self.GetPendingPositionDataTask = AsyncThreadRunner(self.GetPendingPositionData, interval=int(self.settings.PENDING_POSITIONS_API_INTERVAL))
+        self.GetPendingPositionDataTask = AsyncThreadRunner(self.GetPendingPositionData, self.logger, interval=int(self.settings.PENDING_POSITIONS_API_INTERVAL))
         self.GetPendingPositionDataTask.start_thread(thread_name="GetPendingPositionData")
 
-        self.GetPendingOrderDataTask = AsyncThreadRunner(self.GetPendingOrderData, interval=int(self.settings.PENDING_ORDERS_API_INTERVAL))
+        self.GetPendingOrderDataTask = AsyncThreadRunner(self.GetPendingOrderData, self.logger, interval=int(self.settings.PENDING_ORDERS_API_INTERVAL))
         self.GetPendingOrderDataTask.start_thread(thread_name="GetPendingOrderData")
 
-        self.GetTradeHistoryDataTask = AsyncThreadRunner(self.GetTradeHistoryData, interval=int(self.settings.TRADE_HISTORY_API_INTERVAL))
+        self.GetTradeHistoryDataTask = AsyncThreadRunner(self.GetTradeHistoryData, self.logger, interval=int(self.settings.TRADE_HISTORY_API_INTERVAL))
         self.GetTradeHistoryDataTask.start_thread(thread_name="GetTradeHistoryData")
        
-        self.GetPositionHistoryDataTask = AsyncThreadRunner(self.GetPositionHistoryData, interval=int(self.settings.POSITION_HISTORY_API_INTERVAL))
+        self.GetPositionHistoryDataTask = AsyncThreadRunner(self.GetPositionHistoryData, self.logger, interval=int(self.settings.POSITION_HISTORY_API_INTERVAL))
         self.GetPositionHistoryDataTask.start_thread(thread_name="GetPositionHistoryData")
        
-        self.ProcessPrivateDataTask = AsyncThreadRunner(self.bitunixPrivateWebSocketClient.run_websocket, 0, self.ProcessPrivateData)
+        self.ProcessPrivateDataTask = AsyncThreadRunner(self.bitunixPrivateWebSocketClient.run_websocket, self.logger, 0, self.ProcessPrivateData)
         self.ProcessPrivateDataTask.start_thread(thread_name="ProcessPrivateData")
 
         if self.settings.USE_PUBLIC_WEBSOCKET:
             self.bitunixPublicDepthWebSocketClient.tickerList = self.tickerList
-            self.StoreDepthDataTask = AsyncThreadRunner(self.bitunixPublicDepthWebSocketClient.run_websocket, 0, self.StoreDepthData)
+            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, interval=0) # run only once
+            self.ProcessDepthDataTask = AsyncThreadRunner(self.ProcessDepthData, self.logger, interval=0) # run only once
             self.ProcessDepthDataTask.start_thread(thread_name="ProcessDepthData")
 
             self.bitunixPublicTickerWebSocketClient.tickerList = self.tickerList
-            self.StoreTickerDataTask = AsyncThreadRunner(self.bitunixPublicTickerWebSocketClient.run_websocket, 0, self.StoreTickerData)
+            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, interval=0) # run only once
+            self.ProcessTickerDataTask = AsyncThreadRunner(self.ProcessTickerData, self.logger, interval=0) # run only once
             self.ProcessTickerDataTask.start_thread(thread_name="ProcessTickerData")
             
 
         #normal processes
-        self.LoadKlineHistoryTask = AsyncThreadRunner(self.LoadKlineHistory, interval=0) # run only once
+        self.LoadKlineHistoryTask = AsyncThreadRunner(self.LoadKlineHistory, self.logger, interval=0) # run only once
         self.LoadKlineHistoryTask.start_thread(thread_name="LoadKlineHistory")
 
-        self.AutoTradeProcessTask = AsyncThreadRunner(self.AutoTradeProcess, interval=int(self.settings.SIGNAL_CHECK_INTERVAL))
+        self.AutoTradeProcessTask = AsyncThreadRunner(self.AutoTradeProcess, self.logger, interval=int(self.settings.SIGNAL_CHECK_INTERVAL))
         self.AutoTradeProcessTask.start_thread(thread_name="AutoTradeProcess")
 
-        self.checkTickerAndAutotradeStatusTask = AsyncThreadRunner(self.checkTickerAndAutotradeStatus, interval=0)
+        self.checkTickerAndAutotradeStatusTask = AsyncThreadRunner(self.checkTickerAndAutotradeStatus, self.logger, interval=0)
         self.checkTickerAndAutotradeStatusTask.start_thread(thread_name="checkTickerAndAutotradeStatus")
 
         if not self.settings.USE_PUBLIC_WEBSOCKET:
-            self.GetTickerDataTask = AsyncThreadRunner(self.GetTickerData, interval=int(self.settings.TICKER_DATA_API_INTERVAL))
+            self.GetTickerDataTask = AsyncThreadRunner(self.GetTickerData, self.logger, interval=int(self.settings.TICKER_DATA_API_INTERVAL))
             self.GetTickerDataTask.start_thread(thread_name="GetTickerData")
 
 
@@ -227,7 +227,7 @@ class BitunixSignal:
                 if data is not None:
                    self.tickerObjects.load_kline_history(ticker, intervalId, self.settings.BARS, data)
         if self.settings.VERBOSE_LOGGING:
-            logger.info(f"kline_history: elapsed time {time.time()-start}")
+            self.logger.info(f"kline_history: elapsed time {time.time()-start}")
         self.notifications.add_notification("Kline history loaded")
 
     #api data       
@@ -258,7 +258,7 @@ class BitunixSignal:
 
             self.lastTickerDataTime = time.time()
             if self.settings.VERBOSE_LOGGING:
-                logger.info(f"GetTickerData: elapsed time {time.time()-start}")
+                self.logger.info(f"GetTickerData: elapsed time {time.time()-start}")
             if self.settings.BENCHMARK:
                 self.connection = sqlite3.connect("bitunix.db") 
                 self.cursor = self.connection.cursor()
@@ -300,10 +300,10 @@ class BitunixSignal:
                     self.tickerObjects.form_candle(self.tuples_list)
                     self.lastTickerDataTime = time.time()
             except Exception as e:
-                logger.info(f"Function: ProcessTickerData, {e}, {e.args}, {type(e).__name__}")
-                logger.info(traceback.print_exc())
+                self.logger.info(f"Function: ProcessTickerData, {e}, {e.args}, {type(e).__name__}")
+                self.logger.info(traceback.print_exc())
             await asyncio.sleep(0.01)
-        logger.info(f"ProcessTickerData: exitied out of the loop, exiting app")
+        self.logger.info(f"ProcessTickerData: exitied out of the loop, exiting app")
         os._exit(1)  # Exit the program 
             
 
@@ -333,10 +333,10 @@ class BitunixSignal:
                     self.depthdf["tickerObj"] = self.depthdf.index.map(self.tickerObjects.get_tickerDict())
                     self.depthdf.apply(self.apply_depth_data2, axis=1)
             except Exception as e:
-                logger.info(f"Function: ProcessTickerData, {e}, {e.args}, {type(e).__name__}")
-                logger.info(traceback.print_exc())
+                self.logger.info(f"Function: ProcessTickerData, {e}, {e.args}, {type(e).__name__}")
+                self.logger.info(traceback.print_exc())
             await asyncio.sleep(0.01)
-        logger.info(f"ProcessDepthData: exitied out of the loop, exiting app")
+        self.logger.info(f"ProcessDepthData: exitied out of the loop, exiting app")
         os._exit(1)  # Exit the program 
 
     def apply_depth_data2(self, row):
@@ -367,9 +367,9 @@ class BitunixSignal:
             del data, tickerdf, tuples_list
             gc.collect()
         except Exception as e:
-            logger.info(e)
+            self.logger.info(e)
         if self.settings.VERBOSE_LOGGING:
-            logger.info(f"apply_last_data: elapsed time {time.time()-start}")
+            self.logger.info(f"apply_last_data: elapsed time {time.time()-start}")
         
     # non websocket method
     # this is called to update bid and ask, 
@@ -411,9 +411,9 @@ class BitunixSignal:
             self.portfoliodfStyle= self.portfoliodfrenderer.render_html(self.portfoliodf)
             
         except Exception as e:
-            logger.info(f"Function: GetportfolioData, {e}, {e.args}, {type(e).__name__}")
+            self.logger.info(f"Function: GetportfolioData, {e}, {e.args}, {type(e).__name__}")
         if self.settings.VERBOSE_LOGGING:
-            logger.info(f"GetportfolioData: elapsed time {time.time()-start}")
+            self.logger.info(f"GetportfolioData: elapsed time {time.time()-start}")
                 
     async def GetPendingPositionData(self):
         start=time.time()
@@ -470,9 +470,9 @@ class BitunixSignal:
                     
 
         except Exception as e:
-            logger.info(f"Function: GetPendingPositionData, {e}, {e.args}, {type(e).__name__}")
+            self.logger.info(f"Function: GetPendingPositionData, {e}, {e.args}, {type(e).__name__}")
         if self.settings.VERBOSE_LOGGING:
-            logger.info(f"GetPendingPositionData: elapsed time {time.time()-start}")
+            self.logger.info(f"GetPendingPositionData: elapsed time {time.time()-start}")
 
     async def GetPendingOrderData(self):
         start=time.time()
@@ -489,9 +489,9 @@ class BitunixSignal:
             self.orderdfStyle= self.orderdfrenderer.render_html(self.orderdf)                
             
         except Exception as e:
-            logger.info(f"Function: GetPendingOrderData, {e}, {e.args}, {type(e).__name__}")
+            self.logger.info(f"Function: GetPendingOrderData, {e}, {e.args}, {type(e).__name__}")
         if self.settings.VERBOSE_LOGGING:
-            logger.info(f"GetPendingOrderData: elapsed time {time.time()-start}")
+            self.logger.info(f"GetPendingOrderData: elapsed time {time.time()-start}")
 
     async def GetPositionHistoryData(self):
         start=time.time()
@@ -509,9 +509,9 @@ class BitunixSignal:
             self.positionHistorydfStyle= self.positionHistorydfrenderer.render_html(self.positionHistorydf)
             
         except Exception as e:
-            logger.info(f"Function: GetPositionHistoryData, {e}, {e.args}, {type(e).__name__}")
+            self.logger.info(f"Function: GetPositionHistoryData, {e}, {e.args}, {type(e).__name__}")
         if self.settings.VERBOSE_LOGGING:
-            logger.info(f"GetPositionHistoryData: elapsed time {time.time()-start}")
+            self.logger.info(f"GetPositionHistoryData: elapsed time {time.time()-start}")
 
     async def GetTradeHistoryData(self):
         start=time.time()
@@ -526,9 +526,9 @@ class BitunixSignal:
                         # Filter trades for the current symbol and convert them to a list of dicts
                         tickerObj.trades = grouped_trades.get_group(symbol).to_dict("records")                
         except Exception as e:
-            logger.info(f"Function: GetTradeHistoryData, {e}, {e.args}, {type(e).__name__}")
+            self.logger.info(f"Function: GetTradeHistoryData, {e}, {e.args}, {type(e).__name__}")
         if self.settings.VERBOSE_LOGGING:
-            logger.info(f"GetTradeHistoryData: elapsed time {time.time()-start}")
+            self.logger.info(f"GetTradeHistoryData: elapsed time {time.time()-start}")
 
         
     ###########################################################################################################
@@ -545,6 +545,7 @@ class BitunixSignal:
             inuseTickers = set(inuse1 + inuse2)
             
             # Extract buy/sell ticker data
+            self.signaldf_filtered = pd.DataFrame();
             self.tickerObjects.getCurrentData(period)
 
             self.signaldf_full = self.tickerObjects.signaldf_full
@@ -616,14 +617,14 @@ class BitunixSignal:
                         )  
 
         except Exception as e:
-            logger.info(f"Function: BuySellList, {e}, {e.args}, {type(e).__name__}")
-            logger.info(traceback.print_exc())
+            self.logger.info(f"Function: BuySellList, {e}, {e.args}, {type(e).__name__}")
+            self.logger.info(traceback.print_exc())
         del inuse1, inuse2, inuseTickers
         gc.collect()
 
     async def AutoTradeProcess(self):
         if self.settings.VERBOSE_LOGGING:
-            logger.info(f"AutoTradeProcess started")
+            self.logger.info(f"AutoTradeProcess started")
         start=time.time()
         
         period = self.settings.OPTION_MOVING_AVERAGE
@@ -885,6 +886,41 @@ class BitunixSignal:
                                     )
                                     continue
 
+                            # BOS
+                            if self.settings.BOS_STUDY and self.settings.BOS_CHECK_ON_CLOSE: 
+                                if row.side == 'BUY' and self.signaldf_full.at[row.symbol, f'{period}_bos'] == "SELL" and total_pnl>0:
+                                    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 {period} bos 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 row.side == 'SELL' and self.signaldf_full.at[row.symbol, f'{period}_bos'] == "BUY" and total_pnl>0:
+                                    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 {period} bos 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
+
                             # TrendLine
                             if self.settings.TRENDLINE_STUDY and self.settings.TRENDLINE_CHECK_ON_CLOSE: 
                                 if row.side == 'BUY' and self.signaldf_full.at[row.symbol, f'{period}_trendline'] == "SELL" and total_pnl>0:
@@ -996,11 +1032,11 @@ class BitunixSignal:
         except Exception as e:
             stack = traceback.extract_stack()
             function_name = stack[-1].name
-            logger.info(f"Function: {function_name}, {e}, {e.args}, {type(e).__name__}")
-            logger.info(traceback.print_exc())
+            self.logger.info(f"Function: {function_name}, {e}, {e.args}, {type(e).__name__}")
+            self.logger.info(traceback.print_exc())
                 
         if self.settings.VERBOSE_LOGGING:
-            logger.info(f"AutoTradeProcess: elapsed time {time.time()-start}")
+            self.logger.info(f"AutoTradeProcess: elapsed time {time.time()-start}")
         if self.settings.BENCHMARK:
             self.connection = sqlite3.connect("bitunix.db") 
             self.cursor = self.connection.cursor()
@@ -1066,7 +1102,7 @@ class BitunixSignal:
                 
                 self.available = data['available']
                 self.margin = data['margin']
-                # logger.info(feed)
+                # self.logger.info(feed)
 
             elif channel == 'position':
                 
@@ -1104,7 +1140,7 @@ class BitunixSignal:
             del feed
             gc.collect()
         except Exception as e:
-            logger.info(f"Function: ProcessPrivateData, {e}, {e.args}, {type(e).__name__}")
+            self.logger.info(f"Function: ProcessPrivateData, {e}, {e.args}, {type(e).__name__}")
             
     def color_cells(val, color):
         return f'background-color: {color}' if val else ''

bitunix_automated_crypto_trading/BitunixWebSocket.py

@@ -8,11 +8,10 @@ import string
 from typing import Callable
 import threading
 from logger import Logger
-logger = Logger(__name__).get_logger()
 import gc
 
 class BitunixPublicWebSocketClient:
-    def __init__(self, api_key, secret_key, type):
+    def __init__(self, api_key, secret_key, type, logger):
         self.api_key = api_key
         self.secret_key = secret_key
         self.type = type
@@ -22,6 +21,7 @@ class BitunixPublicWebSocketClient:
         self.loop = asyncio.new_event_loop()
         self.loop_thread = threading.Thread(target=self.start_loop)
         self.loop_thread.daemon = True  # Ensure the thread closes with the program
+        self.logger=logger
         self.loop_thread.start()
 
 
@@ -35,7 +35,7 @@ class BitunixPublicWebSocketClient:
 
         # Wait for the thread to finish
         self.loop_thread.join()
-        logger.info("Event loop stopped cleanly")
+        self.logger.info("Event loop stopped cleanly")
                             
 
     async def run_websocket(self, process_func: Callable):
@@ -44,7 +44,7 @@ class BitunixPublicWebSocketClient:
             try:
                 async with websockets.connect(self.url, ping_interval=None, open_timeout=30) as self.websocket:
                     connect_response = await self.websocket.recv()
-                    logger.info(f"{self.url} {self.type} websocket connect Response: {connect_response}")
+                    self.logger.info(f"{self.url} {self.type} websocket connect Response: {connect_response}")
 
                     self.heartbeat_task =  asyncio.create_task(self.send_heartbeat(self.websocket))
 
@@ -81,12 +81,12 @@ class BitunixPublicWebSocketClient:
                 await process_func(message)
             logger.warning(f"{self.url} {self.type}  WebSocket connection closed")
         except asyncio.CancelledError:
-            logger.info(f"{self.url} {self.type}  WebSocket receive task cancelled")
+            self.logger.info(f"{self.url} {self.type}  WebSocket receive task cancelled")
             self.running = False                        
         except websockets.exceptions.ConnectionClosedError as e:
-            logger.info(f"{self.url} {self.type}  Websocket: Connection closed: {e}")
+            self.logger.info(f"{self.url} {self.type}  Websocket: Connection closed: {e}")
         except Exception as e:
-            logger.info(f"{self.url} {self.type}  Websocket: Unexpected error: {e}")
+            self.logger.info(f"{self.url} {self.type}  Websocket: Unexpected error: {e}")
             pass
         del message, process_func
         gc.collect()
@@ -97,11 +97,11 @@ class BitunixPublicWebSocketClient:
                 await websocket.send(json.dumps({"op": "ping", "ping": int(time.time())}))
                 await asyncio.sleep(30)
         except asyncio.CancelledError:
-            logger.info(f"{self.url} {self.type}  WebSocket hearbeat task cancelled")
+            self.logger.info(f"{self.url} {self.type}  WebSocket hearbeat task cancelled")
         except websockets.exceptions.ConnectionClosed:
-            logger.info(f"{self.url} {self.type}  WebSocket connection for heartbeat is closed")
+            self.logger.info(f"{self.url} {self.type}  WebSocket connection for heartbeat is closed")
         except Exception as e:
-            logger.info(f"{self.url} {self.type}  Websocket for heartbeat: Unexpected error: {e}")
+            self.logger.info(f"{self.url} {self.type}  Websocket for heartbeat: Unexpected error: {e}")
             pass       
   
     async def stop_websocket(self):
@@ -124,7 +124,7 @@ class BitunixPublicWebSocketClient:
         finally:
             # Stop the event loop
             self.loop.call_soon_threadsafe(self.loop.stop)
-            logger.info(f"{self.url} {self.type} WebSocket thread stopped and resources cleaned up.")
+            self.logger.info(f"{self.url} {self.type} WebSocket thread stopped and resources cleaned up.")
 
 class BitunixPrivateWebSocketClient:
     def __init__(self, api_key, secret_key):
@@ -149,7 +149,7 @@ class BitunixPrivateWebSocketClient:
 
         # Wait for the thread to finish
         self.loop_thread.join()
-        logger.info("Event loop stopped cleanly")
+        self.logger.info("Event loop stopped cleanly")
 
     async def run_websocket(self, process_func: Callable):
         self.running = True
@@ -157,7 +157,7 @@ class BitunixPrivateWebSocketClient:
             try:
                 async with websockets.connect(self.url, ping_interval=None, open_timeout=30) as self.websocket:
                     connect_response = await self.websocket.recv()
-                    logger.info(f"{self.url} websocket connect Response: {connect_response}")
+                    self.logger.info(f"{self.url} websocket connect Response: {connect_response}")
 
                     self.heartbeat_task = asyncio.create_task(self.send_heartbeat(self.websocket))
 
@@ -176,7 +176,7 @@ class BitunixPrivateWebSocketClient:
                     }
                     await self.websocket.send(json.dumps(login_request))
                     login_response = await self.websocket.recv()
-                    logger.info(f"{self.url} Login Response: {login_response}")
+                    self.logger.info(f"{self.url} Login Response: {login_response}")
 
                     self.recv_task = asyncio.create_task(self.receive_messages(process_func))
                     await self.recv_task                    
@@ -195,12 +195,12 @@ class BitunixPrivateWebSocketClient:
                 await process_func(message)
             logger.warning(f"{self.type} WebSocket connection closed")
         except asyncio.CancelledError:
-            logger.info(f"{self.url} WebSocket receive task cancelled")
+            self.logger.info(f"{self.url} WebSocket receive task cancelled")
             self.running = False                        
         except websockets.exceptions.ConnectionClosedError as e:
-            logger.info(f"{self.url} Websocket: Connection closed: {e}")
+            self.logger.info(f"{self.url} Websocket: Connection closed: {e}")
         except Exception as e:
-            logger.info(f"{self.url} Websocket: Unexpected error: {e}")
+            self.logger.info(f"{self.url} Websocket: Unexpected error: {e}")
             pass
         del message, process_func
         gc.collect()
@@ -211,11 +211,11 @@ class BitunixPrivateWebSocketClient:
                 await websocket.send(json.dumps({"op": "ping", "ping": int(time.time())}))
                 await asyncio.sleep(30)
         except asyncio.CancelledError:
-            logger.info(f"{self.url} WebSocket hearbeat task cancelled")
+            self.logger.info(f"{self.url} WebSocket hearbeat task cancelled")
         except websockets.exceptions.ConnectionClosed:
-            logger.info(f"{self.url} WebSocket connection for heartbeat is closed")
+            self.logger.info(f"{self.url} WebSocket connection for heartbeat is closed")
         except Exception as e:
-            logger.info(f"{self.url} Websocket for heartbeat: Unexpected error: {e}")
+            self.logger.info(f"{self.url} Websocket for heartbeat: Unexpected error: {e}")
             pass            
 
     async def stop_websocket(self):
@@ -238,7 +238,7 @@ class BitunixPrivateWebSocketClient:
         finally:
             # Stop the event loop
             self.loop.call_soon_threadsafe(self.loop.stop)
-            logger.info(f"{self.url} WebSocket thread stopped and resources cleaned up.")
+            self.logger.info(f"{self.url} WebSocket thread stopped and resources cleaned up.")
        
 
     async def generate_signature(self, api_key, secret_key, nonce):

bitunix_automated_crypto_trading/NotificationManager.py

@@ -1,19 +1,19 @@
 from datetime import datetime
 import pytz
 from logger import Logger
-logger = Logger(__name__).get_logger()
 
 class NotificationManager:
-    def __init__(self, max_size=100):
+    def __init__(self, logger, max_size=100):
         self.max_size = max_size
         self.notifications = []
+        self.logger = logger
 
     def add_notification(self, notification):
         # Add the new notification at the top
         timezone = pytz.timezone('America/Chicago')
         timestamp = datetime.now(timezone).strftime('%Y-%m-%d %H:%M:%S')
         self.notifications.insert(0, f'({timestamp}) {notification}')
-        logger.info(f'({timestamp}) {notification}')
+        self.logger.info(f'({timestamp}) {notification}')
         # Ensure the list doesn't exceed the maximum size
         if len(self.notifications) > self.max_size:
             self.notifications.pop()