bitunix-automated-crypto-trading 3.0.4__tar.gz → 3.0.7__tar.gz

{bitunix_automated_crypto_trading-3.0.4 → bitunix_automated_crypto_trading-3.0.7}/PKG-INFO

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

{bitunix_automated_crypto_trading-3.0.4 → bitunix_automated_crypto_trading-3.0.7}/bitunix_automated_crypto_trading/BitunixSignal.py

@@ -16,7 +16,13 @@ from logger import Logger, Colors
 logger = Logger(__name__).get_logger()
 colors = Colors()
 import gc
+import os
 from concurrent.futures import ProcessPoolExecutor
+import sqlite3
+import queue
+from collections import deque
+import threading
+
 
 cst = pytz.timezone('US/Central')
 
@@ -70,6 +76,7 @@ class BitunixSignal:
 
         #websockets
         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")
@@ -84,6 +91,9 @@ class BitunixSignal:
         self.lastAutoTradeTime = time.time()
         self.lastTickerDataTime = time.time()
         
+        #sqllite database connection
+        self.connection = sqlite3.connect("bitunix.db") 
+        
     async def update_settings(self, settings):
         self.settings = settings
         self.tickerObjects.update_settings(settings)
@@ -129,94 +139,39 @@ class BitunixSignal:
         self.GetPositionHistoryDataTask = AsyncThreadRunner(self.GetPositionHistoryData, interval=int(self.settings.POSITION_HISTORY_API_INTERVAL))
         self.GetPositionHistoryDataTask.start_thread(thread_name="GetPositionHistoryData")
        
-        #run restartable asynch thread
-        await self.restartable_jobs()
-
-    async def restart_jobs(self):
-
-        #stop websocket async thread jobs
-        await self.bitunixPrivateWebSocketClient.stop_websocket()
-        await self.ProcessPrivateDataTask.stop_thread()
-        
-        if self.settings.USE_PUBLIC_WEBSOCKET:
-            await self.bitunixPublicDepthWebSocketClient.stop_websocket()
-            await self.UpdateDepthDataTask.stop_thread()
-            
-            await self.bitunixPublicTickerWebSocketClient.stop_websocket()
-            await self.UpdateTickerDataTask.stop_thread()
-
-            #kill the loop to restart public websocket
-            #not using for now
-            #await self.restartPublicWebsocketTask.stop_thread()
-
-        #stop onetime / periodic async thread jobs
-        await self.LoadKlineHistoryTask.stop_thread()
-        await self.GetTickerDataTask.stop_thread()
-        await self.AutoTradeProcessTask.stop_thread()   
-
-        #start jobs
-        await self.load_tickers()
-        await self.restartable_jobs()
-
-    async def restartable_jobs(self):
-        #start cancelable async jobs
-        #websocket jobs
         self.ProcessPrivateDataTask = AsyncThreadRunner(self.bitunixPrivateWebSocketClient.run_websocket, 0, self.ProcessPrivateData)
         self.ProcessPrivateDataTask.start_thread(thread_name="ProcessPrivateData")
 
         if self.settings.USE_PUBLIC_WEBSOCKET:
-
             self.bitunixPublicDepthWebSocketClient.tickerList = self.tickerList
-            self.UpdateDepthDataTask = AsyncThreadRunner(self.bitunixPublicDepthWebSocketClient.run_websocket, 0, self.UpdateDepthData)
-            self.UpdateDepthDataTask.start_thread(thread_name="UpdateDepthData")
+            self.StoreDepthDataTask = AsyncThreadRunner(self.bitunixPublicDepthWebSocketClient.run_websocket, 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.start_thread(thread_name="ProcessDepthData")
 
             self.bitunixPublicTickerWebSocketClient.tickerList = self.tickerList
-            self.UpdateTickerDataTask = AsyncThreadRunner(self.bitunixPublicTickerWebSocketClient.run_websocket, 0, self.UpdateTickerData)
-            self.UpdateTickerDataTask.start_thread(thread_name="UpdateTickerData")
+            self.StoreTickerDataTask = AsyncThreadRunner(self.bitunixPublicTickerWebSocketClient.run_websocket, 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.start_thread(thread_name="ProcessTickerData")
+            
 
         #normal processes
         self.LoadKlineHistoryTask = AsyncThreadRunner(self.LoadKlineHistory, interval=0) # run only once
         self.LoadKlineHistoryTask.start_thread(thread_name="LoadKlineHistory")
 
-        self.GetTickerDataTask = AsyncThreadRunner(self.GetTickerData, interval=int(self.settings.TICKER_DATA_API_INTERVAL))
-        self.GetTickerDataTask.start_thread(thread_name="GetTickerData")
-
         self.AutoTradeProcessTask = AsyncThreadRunner(self.AutoTradeProcess, interval=int(self.settings.SIGNAL_CHECK_INTERVAL))
         self.AutoTradeProcessTask.start_thread(thread_name="AutoTradeProcess")
 
-        #start the loop to restart public websocket
-        #if self.settings.USE_PUBLIC_WEBSOCKET:
-        #    self.restartPublicWebsocketTask = AsyncThreadRunner(self.restartPublicWebsocket, interval=0)
-        #    self.restartPublicWebsocketTask.start_thread(thread_name="restartPublicWebsocket")
-
-    #this is a normal task runing in a async thread, that can be cancelled
-    # this runs in a async thread to stop and start the public websocket, as we found some lagging when it runs continously
-    #not used now
-    async def restartPublicWebsocket(self): 
-        while True:
-            await asyncio.sleep(int(self.settings.PUBLIC_WEBSOCKET_RESTART_INTERVAL))
-            
-            if self.settings.VERBOSE_LOGGING:
-                self.notifications.add_notification('Restarting public websocket')
-                logger.info(f"Restarting public websocket")
-            
-            if self.settings.USE_PUBLIC_WEBSOCKET:
-                await self.UpdateDepthDataTask.stop_thread()
-                await self.UpdateTickerDataTask.stop_thread() 
-            
-            await asyncio.sleep(30)
-
-            if self.settings.USE_PUBLIC_WEBSOCKET:
-                self.bitunixPublicDepthWebSocketClient.tickerList = self.tickerList
-                self.UpdateDepthDataTask = AsyncThreadRunner(self.bitunixPublicDepthWebSocketClient.run_websocket, 0, self.UpdateDepthData)
-                self.UpdateDepthDataTask.start_thread(thread_name="UpdateDepthData")
+        if not self.settings.USE_PUBLIC_WEBSOCKET:
+            self.GetTickerDataTask = AsyncThreadRunner(self.GetTickerData, interval=int(self.settings.TICKER_DATA_API_INTERVAL))
+            self.GetTickerDataTask.start_thread(thread_name="GetTickerData")
 
-                self.bitunixPublicTickerWebSocketClient.tickerList = self.tickerList
-                self.UpdateTickerDataTask = AsyncThreadRunner(self.bitunixPublicTickerWebSocketClient.run_websocket, 0, self.UpdateTickerData)
-                self.UpdateTickerDataTask.start_thread(thread_name="UpdateTickerData")
+            self.checkPeriodicProcessTask = AsyncThreadRunner(self.checkPeriodicProcess, interval=0)
+            self.checkPeriodicProcessTask.start_thread(thread_name="checkPeriodicProcess")
 
-            if self.settings.VERBOSE_LOGGING:
-                self.notifications.add_notification('Restared public websocket')
 
     ###########################################################################################################
     async def DefinehtmlRenderers(self):
@@ -271,86 +226,115 @@ class BitunixSignal:
 
     #api data       
     async def GetTickerData(self):
-        start=time.time()
-
-        # Get the current time and set the seconds and microseconds to zero
-        current_time = datetime.now()
-        current_minute = current_time.replace(second=0, microsecond=0)
-        ts = int(current_minute.timestamp())*1000
+        if not self.settings.USE_PUBLIC_WEBSOCKET:
+            start=time.time()
+            # Get the current time and set the seconds and microseconds to zero
+            current_time = datetime.now()
+            current_minute = current_time.replace(second=0, microsecond=0)
+            ts = int(current_minute.timestamp())*1000
 
-        #api used insted of websocket
-        data = await self.bitunixApi.GetTickerData()
-        self.tickerdf = pd.DataFrame()
-        if data:
-            
-            # Create a DataFrame from the data
-            self.tickerdf = pd.DataFrame(data, columns=["symbol", "last"])
-            
-            #remove not required symbols
-            self.tickerdf.loc[~self.tickerdf['symbol'].isin(self.tickerObjects.symbols()), :] = None
-            self.tickerdf.dropna(inplace=True)
-            
-            self.tickerdf['ts']=ts
-            self.tickerdf["tickerObj"] = self.tickerdf["symbol"].map(self.tickerObjects.get_tickerDict())
-            self.tuples_list = list(zip(self.tickerdf["tickerObj"],  self.tickerdf["last"].astype(float), self.tickerdf["ts"]))
-            self.tickerObjects.form_candle(self.tuples_list)
+            #api used insted of websocket
+            data = await self.bitunixApi.GetTickerData()
+            self.tickerdf = pd.DataFrame()
+            if data:
+                
+                # Create a DataFrame from the data
+                self.tickerdf = pd.DataFrame(data, columns=["symbol", "last"])
+                
+                #remove not required symbols
+                self.tickerdf.loc[~self.tickerdf['symbol'].isin(self.tickerObjects.symbols()), :] = None
+                self.tickerdf.dropna(inplace=True)
+                
+                self.tickerdf['ts']=ts
+                self.tickerdf["tickerObj"] = self.tickerdf["symbol"].map(self.tickerObjects.get_tickerDict())
+                self.tuples_list = list(zip(self.tickerdf["tickerObj"],  self.tickerdf["last"].astype(float), self.tickerdf["ts"]))
+                self.tickerObjects.form_candle(self.tuples_list)
 
-        self.lastTickerDataTime = time.time()
-        if self.settings.VERBOSE_LOGGING:
-            logger.info(f"GetTickerData: elapsed time {time.time()-start}")
+            self.lastTickerDataTime = time.time()
+            if self.settings.VERBOSE_LOGGING:
+                logger.info(f"GetTickerData: elapsed time {time.time()-start}")
+            if self.settings.BENCHMARK:
+                self.connection = sqlite3.connect("bitunix.db") 
+                self.cursor = self.connection.cursor()
+                self.cursor.execute("INSERT INTO benchmark (process_name, time) VALUES (?, ?)", ("GetTickerData", time.time()-start))
+                self.connection.commit()
     
     
-    #websocket data
-    async def UpdateTickerData(self, message):
-        if message=="":
-            return
-        try:
+    #websocket data to update ticker lastprice and other relavent data
+    # Function to add data to the last price deque
+    async def StoreTickerData(self, message):
+        if self.settings.USE_PUBLIC_WEBSOCKET:
+            if message=="":
+                return
             data = json.loads(message)
             if 'symbol' in data and data['ch'] in ['ticker']:
-                symbol = data['symbol']
-                ts = data['ts']
-                last= float(data['data']['la'])
-                highest= float(data['data']['h'])
-                lowest= float(data['data']['l'])
-                volume= float(data['data']['b'])
-                volumeInCurrency= float(data['data']['q'])
-                tickerObj = self.tickerObjects.get(symbol)
-                if tickerObj:
-                    tickerObj.set_24hrData(highest,lowest,volume,volumeInCurrency)
-                    tickerObj.form_candle(last, ts)
-                del tickerObj
-                gc.collect()
-            del data  
-            gc.collect()
-        except Exception as e:
-            logger.info(f"Function: UpdateTickerData, {e}, {e.args}, {type(e).__name__}")
-        if self.settings.VERBOSE_LOGGING:
-            logger.info(f"Function: UpdateTickerData, time:{ts}, symbol:{symbol}, highest:{highest}, lowest:{lowest}, volume:{volume}, volumeInCurrency:{volumeInCurrency}")
+                await self.ticker_que.put(data)
 
-    #websocket data    
-    async def UpdateDepthData(self, message):
-        if message=="":
-            return
-        try:
+    # Function to process the last price deque
+    async def ProcessTickerData(self):
+        while True:
+            try:
+                batch_size = self.settings.BATCH_PROCESS_SIZE   
+                latest_data = {}
+                reversed_items = list(self.ticker_que._queue)[::-1]
+                self.ticker_que._queue.clear()
+                for i in range(min(batch_size, len(reversed_items))):
+                    data = reversed_items[i]
+                    symbol = data["symbol"]
+                    ts = data["ts"]
+                    if symbol not in latest_data or ts > latest_data[symbol]['ts']:
+                        latest_data[symbol] = {'ts': ts, 'last': float(data['data']['la'])}
+                # Convert to DataFrame
+                self.tickerdf = pd.DataFrame.from_dict(latest_data, orient="index")
+                if not self.tickerdf.empty:
+                    self.tickerdf["tickerObj"] = self.tickerdf.index.map(self.tickerObjects.get_tickerDict())
+                    self.tuples_list = list(zip(self.tickerdf["tickerObj"],  self.tickerdf["last"].astype(float), self.tickerdf["ts"]))
+                    self.tickerObjects.form_candle(self.tuples_list)
+                    self.lastTickerDataTime = time.time()
+            except Exception as e:
+                logger.info(f"Function: ProcessTickerData, {e}, {e.args}, {type(e).__name__}")
+                logger.info(traceback.print_exc())
+            await asyncio.sleep(0.5)
+
+    #websocket data to update bid and ask
+    async def StoreDepthData(self, message):
+        if self.settings.USE_PUBLIC_WEBSOCKET:
+            if message=="":
+                return
             data = json.loads(message)
             if 'symbol' in data and data['ch'] in ['depth_book1']:
-                symbol = data['symbol']
-                ts = data['ts']
-                bid = float(data['data']['b'][0][0])
-                ask = float(data['data']['a'][0][0])
-                tickerObj = self.tickerObjects.get(symbol)
-                if tickerObj:
-                    tickerObj.set_bid(bid)
-                    tickerObj.set_ask(ask)
-                del tickerObj
-                gc.collect()
-            del data
-            gc.collect()    
-        except Exception as e:
-            logger.info(f"Function: UpdateDepthData, {e}, {e.args}, {type(e).__name__}")
-        if self.settings.VERBOSE_LOGGING:
-            logger.info(f"Function: UpdateDepthData, time:{ts}, symbol:{symbol}, bid:{bid}, ask:{ask}")
+                await self.depth_que.put(data)
 
+    # Function to process the bid, ask
+    async def ProcessDepthData(self):
+        while True:
+            try:
+                batch_size = self.settings.BATCH_PROCESS_SIZE   
+                latest_data = {}
+                reversed_items = list(self.depth_que._queue)[::-1]
+                self.depth_que._queue.clear()
+                for i in range(min(batch_size, len(reversed_items))):
+                    data = reversed_items[i]
+                    symbol = data["symbol"]
+                    ts = data["ts"]
+                    if symbol not in latest_data or ts > latest_data[symbol]['ts']:
+                        latest_data[symbol] = {'ts': ts, 'bid': float(data['data']['b'][0][0]), 'ask': float(data['data']['a'][0][0])}
+                # Convert to DataFrame
+                self.depthdf = pd.DataFrame.from_dict(latest_data, orient="index")
+                if not self.depthdf.empty:
+                    self.depthdf["tickerObj"] = self.depthdf.index.map(self.tickerObjects.get_tickerDict())
+                    self.depthdf.apply(self.apply_depth_data2, axis=1)
+            except Exception as e:
+                logger.info(f"Function: ProcessTickerData, {e}, {e.args}, {type(e).__name__}")
+                logger.info(traceback.print_exc())
+            await asyncio.sleep(0.5)
+
+    def apply_depth_data2(self, row):
+        row["tickerObj"].set_ask(row["ask"])
+        row["tickerObj"].set_bid(row["bid"])
+        return row
+        
+    # non websocket method
     # this is called to update last price, as the websocket is lagging
     # this is only called for the tickers in the pendingpositions
     # and for first few records in the signaldf    
@@ -377,6 +361,7 @@ class BitunixSignal:
         if self.settings.VERBOSE_LOGGING:
             logger.info(f"apply_last_data: elapsed time {time.time()-start}")
         
+    # non websocket method
     # this is called to update bid and ask, 
     # as it is time consuming to call the api for each ticker, 
     # this is only called for the tickers in the pendingpositions
@@ -397,6 +382,13 @@ class BitunixSignal:
         gc.collect()
                 
     ###########################################################################################################
+    async def checkPeriodicProcess(self):
+        while True:
+            if self.lastAutoTradeTime + 300 < time.time()  or self.lastTickerDataTime + 300 < time.time():
+                self.notifications.add_notification("AutoTradeProcess or GetTickerData is not running")
+                os._exit(1) 
+                break
+            await asyncio.sleep(300)
 
     async def GetportfolioData(self):
         start=time.time()
@@ -457,14 +449,14 @@ class BitunixSignal:
             #if not self.settings.USE_PUBLIC_WEBSOCKET:                    
             #get bid las ask using api for the symbols in pending psotion
             if not self.positiondf.empty:
-                if self.settings.USE_PUBLIC_WEBSOCKET:
+                if not self.settings.USE_PUBLIC_WEBSOCKET:
                     await asyncio.create_task(self.apply_last_data(','.join(self.positiondf['symbol'].astype(str).tolist())))                                                
-                await asyncio.gather(
-                    *[
-                        asyncio.create_task(self.apply_depth_data(row['symbol']))
-                        for index, row in self.positiondf.iterrows()
-                    ]
-                )                
+                    await asyncio.gather(
+                        *[
+                            asyncio.create_task(self.apply_depth_data(row['symbol']))
+                            for index, row in self.positiondf.iterrows()
+                        ]
+                    )                
                     
 
         except Exception as e:
@@ -581,7 +573,7 @@ class BitunixSignal:
                     self.signaldf = self.signaldf_filtered[[
                         "symbol", f"{period}_trend",f"{period}_cb", f"{period}_barcolor",
                         f"{period}_ema_open", f"{period}_ema_close", f"{period}_macd", f"{period}_bbm", f"{period}_rsi",f"{period}_adx",f"{period}_candle_trend",
-                        'lastcolor', 'bidcolor', 'askcolor', 'bid', 'ask', 'last',
+                        'lastcolor', 'bidcolor', 'askcolor', 'bid', 'last', 'ask',
                         f"{period}_open", f"{period}_close", f"{period}_high", f"{period}_low", 
                     ]].sort_values(by=[f'{period}_cb'], ascending=[False])
 
@@ -598,14 +590,14 @@ class BitunixSignal:
                 #get bid las ask using api for max_auto_trades rows
                 if not self.signaldf.empty:
                     m = min(self.signaldf.shape[0], int(self.settings.MAX_AUTO_TRADES))
-                    if self.settings.USE_PUBLIC_WEBSOCKET:
+                    if not self.settings.USE_PUBLIC_WEBSOCKET:
                         await asyncio.create_task(self.apply_last_data(','.join(self.signaldf['symbol'][:m].astype(str).tolist())))                 
-                    await asyncio.gather(
-                        *[
-                            asyncio.create_task(self.apply_depth_data(row['symbol']))
-                            for index, row in self.signaldf[:m].iterrows()
-                        ]
-                    )  
+                        await asyncio.gather(
+                            *[
+                                asyncio.create_task(self.apply_depth_data(row['symbol']))
+                                for index, row in self.signaldf[:m].iterrows()
+                            ]
+                        )  
 
         except Exception as e:
             logger.info(f"Function: BuySellList, {e}, {e.args}, {type(e).__name__}")
@@ -958,6 +950,11 @@ class BitunixSignal:
                 
         if self.settings.VERBOSE_LOGGING:
             logger.info(f"AutoTradeProcess: elapsed time {time.time()-start}")
+        if self.settings.BENCHMARK:
+            self.connection = sqlite3.connect("bitunix.db") 
+            self.cursor = self.connection.cursor()
+            self.cursor.execute("INSERT INTO benchmark (process_name, time) VALUES (?, ?)", ("AutoTradeProcess", time.time()-start))
+            self.connection.commit()
 
         del df
         gc.collect()

{bitunix_automated_crypto_trading-3.0.4 → bitunix_automated_crypto_trading-3.0.7}/bitunix_automated_crypto_trading/bitunix.py

@@ -32,6 +32,8 @@ from fastapi.staticfiles import StaticFiles
 from dotenv import load_dotenv, dotenv_values, set_key
 from pydantic import ValidationError
 
+import sqlite3
+
 ENV_FILE = ".env"
 CONFIG_FILE = os.path.dirname(os.path.abspath(__file__))+"/config.txt"
 LOG_FILE = "app.log"
@@ -60,6 +62,83 @@ class bitunix():
 
         self.websocket_connections = set()
         self.DB = {"admin": {"password": password}}
+        
+        #sqllite database connection
+        self.connection = sqlite3.connect("bitunix.db") 
+        #create table if not exist
+        self.cursor = self.connection.cursor()
+        #create benchmark table
+        self.cursor.execute("CREATE TABLE IF NOT EXISTS benchmark (id INTEGER PRIMARY KEY, process_name TEXT, time INTEGER)")
+        
+        #create settings table        
+        self.cursor.execute("CREATE TABLE IF NOT EXISTS settings (param TEXT PRIMARY KEY, value TEXT)")
+        self.cursor.execute(f"SELECT param, value FROM settings")
+        rows = self.cursor.fetchall()
+        if len(rows) == 0:
+            # fille value from confix.txt file to db
+            self.cursor.execute("INSERT INTO settings (param, value) VALUES (?, ?)", ("AUTOTRADE","True"))
+            self.cursor.execute("INSERT INTO settings (param, value) VALUES (?, ?)", ("OPTION_MOVING_AVERAGE","1h"))
+            self.cursor.execute("INSERT INTO settings (param, value) VALUES (?, ?)", ("MAX_AUTO_TRADES","10"))
+            self.cursor.execute("INSERT INTO settings (param, value) VALUES (?, ?)", ("PROFIT_AMOUNT","3"))
+            self.cursor.execute("INSERT INTO settings (param, value) VALUES (?, ?)", ("LOSS_AMOUNT","0"))
+            self.cursor.execute("INSERT INTO settings (param, value) VALUES (?, ?)", ("LEVERAGE","20"))
+            self.cursor.execute("INSERT INTO settings (param, value) VALUES (?, ?)", ("THRESHOLD","5"))
+            self.cursor.execute("INSERT INTO settings (param, value) VALUES (?, ?)", ("MIN_VOLUME","10000000"))
+            self.cursor.execute("INSERT INTO settings (param, value) VALUES (?, ?)", ("ORDER_AMOUNT_PERCENTAGE","5"))
+            self.cursor.execute("INSERT INTO settings (param, value) VALUES (?, ?)", ("BARS","100"))
+            self.cursor.execute("INSERT INTO settings (param, value) VALUES (?, ?)", ("MA_FAST","10"))
+            self.cursor.execute("INSERT INTO settings (param, value) VALUES (?, ?)", ("MA_MEDIUM","20"))
+            self.cursor.execute("INSERT INTO settings (param, value) VALUES (?, ?)", ("MA_SLOW","50"))
+            self.cursor.execute("INSERT INTO settings (param, value) VALUES (?, ?)", ("RSI_FAST","6"))
+            self.cursor.execute("INSERT INTO settings (param, value) VALUES (?, ?)", ("RSI_SLOW","24"))
+            self.cursor.execute("INSERT INTO settings (param, value) VALUES (?, ?)", ("BBM_PERIOD","20"))
+            self.cursor.execute("INSERT INTO settings (param, value) VALUES (?, ?)", ("BBM_STD","2"))
+            self.cursor.execute("INSERT INTO settings (param, value) VALUES (?, ?)", ("MACD_PERIOD","9"))
+            self.cursor.execute("INSERT INTO settings (param, value) VALUES (?, ?)", ("MACD_SHORT","12"))
+            self.cursor.execute("INSERT INTO settings (param, value) VALUES (?, ?)", ("MACD_LONG","26"))
+            self.cursor.execute("INSERT INTO settings (param, value) VALUES (?, ?)", ("ADX_PERIOD","14"))
+            self.cursor.execute("INSERT INTO settings (param, value) VALUES (?, ?)", ("OPEN_ON_ANY_SIGNAL","True"))
+            self.cursor.execute("INSERT INTO settings (param, value) VALUES (?, ?)", ("EMA_STUDY","True"))
+            self.cursor.execute("INSERT INTO settings (param, value) VALUES (?, ?)", ("EMA_CHART","True"))
+            self.cursor.execute("INSERT INTO settings (param, value) VALUES (?, ?)", ("EMA_CROSSING","True"))
+            self.cursor.execute("INSERT INTO settings (param, value) VALUES (?, ?)", ("EMA_CHECK_ON_OPEN","True"))
+            self.cursor.execute("INSERT INTO settings (param, value) VALUES (?, ?)", ("EMA_CHECK_ON_CLOSE","True"))
+            self.cursor.execute("INSERT INTO settings (param, value) VALUES (?, ?)", ("EMA_CLOSE_ON_FAST_MEDIUM","True"))
+            self.cursor.execute("INSERT INTO settings (param, value) VALUES (?, ?)", ("MACD_STUDY","True"))
+            self.cursor.execute("INSERT INTO settings (param, value) VALUES (?, ?)", ("MACD_CHART","True"))
+            self.cursor.execute("INSERT INTO settings (param, value) VALUES (?, ?)", ("MACD_CROSSING","True"))
+            self.cursor.execute("INSERT INTO settings (param, value) VALUES (?, ?)", ("MACD_CHECK_ON_OPEN","True"))
+            self.cursor.execute("INSERT INTO settings (param, value) VALUES (?, ?)", ("MACD_CHECK_ON_CLOSE","True"))
+            self.cursor.execute("INSERT INTO settings (param, value) VALUES (?, ?)", ("BBM_STUDY","True"))
+            self.cursor.execute("INSERT INTO settings (param, value) VALUES (?, ?)", ("BBM_CHART","False"))
+            self.cursor.execute("INSERT INTO settings (param, value) VALUES (?, ?)", ("BBM_CROSSING","False"))
+            self.cursor.execute("INSERT INTO settings (param, value) VALUES (?, ?)", ("BBM_CHECK_ON_OPEN","False"))
+            self.cursor.execute("INSERT INTO settings (param, value) VALUES (?, ?)", ("BBM_CHECK_ON_CLOSE","False"))
+            self.cursor.execute("INSERT INTO settings (param, value) VALUES (?, ?)", ("RSI_STUDY","True"))
+            self.cursor.execute("INSERT INTO settings (param, value) VALUES (?, ?)", ("RSI_CHART","True"))
+            self.cursor.execute("INSERT INTO settings (param, value) VALUES (?, ?)", ("RSI_CROSSING","False"))
+            self.cursor.execute("INSERT INTO settings (param, value) VALUES (?, ?)", ("RSI_CHECK_ON_OPEN","False"))
+            self.cursor.execute("INSERT INTO settings (param, value) VALUES (?, ?)", ("RSI_CHECK_ON_CLOSE","False"))
+            self.cursor.execute("INSERT INTO settings (param, value) VALUES (?, ?)", ("ADX_STUDY","True"))
+            self.cursor.execute("INSERT INTO settings (param, value) VALUES (?, ?)", ("ADX_CHECK_ON_OPEN","True"))
+            self.cursor.execute("INSERT INTO settings (param, value) VALUES (?, ?)", ("ADX_CHECK_ON_CLOSE","False"))
+            self.cursor.execute("INSERT INTO settings (param, value) VALUES (?, ?)", ("CANDLE_TREND_STUDY","False"))
+            self.cursor.execute("INSERT INTO settings (param, value) VALUES (?, ?)", ("CANDLE_TREND_CHECK_ON_OPEN","False"))
+            self.cursor.execute("INSERT INTO settings (param, value) VALUES (?, ?)", ("CANDLE_TREND_CHECK_ON_CLOSE","False"))
+            self.cursor.execute("INSERT INTO settings (param, value) VALUES (?, ?)", ("SCREEN_REFRESH_INTERVAL","1"))
+            self.cursor.execute("INSERT INTO settings (param, value) VALUES (?, ?)", ("SIGNAL_CHECK_INTERVAL","15"))
+            self.cursor.execute("INSERT INTO settings (param, value) VALUES (?, ?)", ("PORTFOLIO_API_INTERVAL","3"))
+            self.cursor.execute("INSERT INTO settings (param, value) VALUES (?, ?)", ("PENDING_POSITIONS_API_INTERVAL","3"))
+            self.cursor.execute("INSERT INTO settings (param, value) VALUES (?, ?)", ("PENDING_ORDERS_API_INTERVAL","3"))
+            self.cursor.execute("INSERT INTO settings (param, value) VALUES (?, ?)", ("TRADE_HISTORY_API_INTERVAL","3"))
+            self.cursor.execute("INSERT INTO settings (param, value) VALUES (?, ?)", ("POSITION_HISTORY_API_INTERVAL","3"))
+            self.cursor.execute("INSERT INTO settings (param, value) VALUES (?, ?)", ("TICKER_DATA_API_INTERVAL","120"))
+            self.cursor.execute("INSERT INTO settings (param, value) VALUES (?, ?)", ("BATCH_PROCESS_SIZE","1000"))
+            self.cursor.execute("INSERT INTO settings (param, value) VALUES (?, ?)", ("USE_PUBLIC_WEBSOCKET","True"))
+            self.cursor.execute("INSERT INTO settings (param, value) VALUES (?, ?)", ("VERBOSE_LOGGING","False"))
+            self.cursor.execute("INSERT INTO settings (param, value) VALUES (?, ?)", ("BENCHMARK","False"))
+            self.connection.commit() 
+        
 
     async def update_settings(self, settings):
         self.settings = settings

{bitunix_automated_crypto_trading-3.0.4 → bitunix_automated_crypto_trading-3.0.7}/bitunix_automated_crypto_trading/config.py

@@ -1,6 +1,7 @@
 from pydantic import Field, SecretStr, validator
 from pydantic_settings import BaseSettings
 import os
+import sqlite3
 
 class Settings(BaseSettings):
     # Start autotrading on start
@@ -75,7 +76,7 @@ class Settings(BaseSettings):
     TRADE_HISTORY_API_INTERVAL: int = Field(default=3, ge=1)
     POSITION_HISTORY_API_INTERVAL: int = Field(default=3, ge=1)
     TICKER_DATA_API_INTERVAL: int = Field(default=30, ge=1)
-    PUBLIC_WEBSOCKET_RESTART_INTERVAL: int = Field(default=10_800, ge=1)
+    BATCH_PROCESS_SIZE: int = Field(default=1000, ge=1)
 
     # Use websocket or API
     USE_PUBLIC_WEBSOCKET: bool = Field(default=False)  # If there is lagging issue then use API
@@ -89,3 +90,26 @@ class Settings(BaseSettings):
     class Config:
         # Specify the file name for loading environment variables
         env_file = os.path.dirname(os.path.abspath(__file__))+"/config.txt"
+
+    @classmethod
+    def load_from_db(cls, db_path: str, table_name: str = "settings"):
+        # Connect to SQLite database
+        connection = sqlite3.connect(db_path)
+        cursor = connection.cursor()
+
+        # Fetch all parameters and values from the database
+        cursor.execute(f"SELECT param, value FROM {table_name}")
+        rows = cursor.fetchall()
+        connection.close()
+
+        # Map fetched data to the class attributes dynamically
+        settings_dict = {}
+        for param, value in rows:
+            # Convert string 'value' to proper type based on attribute type
+            if hasattr(cls, param):
+                attr_type = type(getattr(cls(), param))
+                settings_dict[param] = attr_type(value) if attr_type != bool else value.lower() in ("true", "1")
+
+        # Create the Settings instance with mapped data
+        return cls(**settings_dict)
+

{bitunix_automated_crypto_trading-3.0.4 → bitunix_automated_crypto_trading-3.0.7}/bitunix_automated_crypto_trading/logger.py

@@ -45,7 +45,7 @@ class CSTFormatter(logging.Formatter):
             return cst_time.isoformat()
 
 class Logger:
-    def __init__(self, logger_name, log_file='app.log', level=logging.DEBUG, max_bytes=5 * 1024 * 1024, backup_count=3):
+    def __init__(self, logger_name, log_file='app.log', level=logging.DEBUG, max_bytes=50 * 1024 * 1024, backup_count=100):
         """
         Initialize the logger.
 

{bitunix_automated_crypto_trading-3.0.4 → bitunix_automated_crypto_trading-3.0.7}/bitunix_automated_crypto_trading.egg-info/PKG-INFO

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

{bitunix_automated_crypto_trading-3.0.4 → bitunix_automated_crypto_trading-3.0.7}/setup.py

@@ -66,7 +66,7 @@ class CustomInstall(install):
 
 setup(
     name="bitunix_automated_crypto_trading",
-    version="3.0.4",
+    version="3.0.7",
     license="MIT",
     author="tcj2001",
     author_email="thomsonmathews@hotmail.com",