bitunix-automated-crypto-trading 3.1.1__py3-none-any.whl → 3.1.3__py3-none-any.whl

bitunix_automated_crypto_trading/BitunixApi.py

@@ -249,21 +249,21 @@ class BitunixApi:
             function_name = stack[-2].name
             logger.info(f"Function: {function_name}, {e}, {e.args}, {type(e).__name__}")           
 
-    async def GetKlineHistory(self, ticker, interval, limit):
+    async def GetKlineHistory(self, ticker, interval, limit, starttime):
         data = []
         lm=limit
-        current_unix_timestamp = int(time.time())
+        st=starttime
         try:
             while True:
-                url = f'{self.kline_Url}?symbol={ticker}&startTime={current_unix_timestamp}&interval={interval}&limit={lm}'
+                url = f'{self.kline_Url}?symbol={ticker}&startTime={st}&interval={interval}&limit={lm}'
                 resp = self.session.get(url)
                 datajs = resp.json()
-                if len(datajs['data']) > 0:
-                    current_unix_timestamp = str(int(datajs['data'][-1]['time']) + 1) # Adjust 'time' to match the appropriate key in your data
-                    data.extend(datajs['data'])
+                if datajs['data'] == []:
+                    break
+                data.extend(datajs['data'])
+                if len(datajs['data']) < lm:
+                    st = int(datajs['data'][-1]['time']) + 1
                     lm=limit-len(data)
-                    if len(data) >= limit:
-                        break
                 else:
                     break
             return data

bitunix_automated_crypto_trading/BitunixSignal.py

@@ -110,7 +110,8 @@ class BitunixSignal:
             olist = [entry['symbol'] for entry in self.pendingOrders['orderList']]
         newlist=olist+plist+list(set(symbols))
         self.tickerList=newlist[:300]
-        #self.tickerList=['IMXUSDT']
+        self.tickerList.remove("STMXUSDT")
+        #self.tickerList=['PIXELUSDT']
 
         [await self.add_ticker_to_tickerObjects(sym) for sym in self.tickerList]
         self.notifications.add_notification(f"{len(self.tickerList)} ticker list loaded") 
@@ -218,7 +219,7 @@ class BitunixSignal:
         intervals = self.tickerObjects.get_intervalIds()
         for ticker in self.tickerList:
             for intervalId in intervals:
-                data = await self.bitunixApi.GetKlineHistory(ticker, intervalId, self.settings.BARS)
+                data = await self.bitunixApi.GetKlineHistory(ticker, intervalId, self.settings.BARS, int(time.time()))
                 if data is not None:
                    self.tickerObjects.load_kline_history(ticker, intervalId, self.settings.BARS, data)
         if self.settings.VERBOSE_LOGGING:
@@ -397,7 +398,7 @@ class BitunixSignal:
                 self.notifications.add_notification("AutoTradeProcess or GetTickerData is not running")
                 os._exit(1) 
                 break
-            await asyncio.sleep(300)
+            await asyncio.sleep(60*30)
 
     async def GetportfolioData(self):
         start=time.time()

bitunix_automated_crypto_trading/TickerManager.py

@@ -36,11 +36,57 @@ class Interval:
         return self._data
 
     def set_data(self, new_value):
-        self._data =  self.calculate_study(new_value)
-            
+        study = self.calculate_study(new_value)
+        self._data = study
+
+    def support_resistance_trend_lines(self, data, lookback=20):
+        recent_data = data[-lookback:]
+        high_prices = recent_data['high'].values
+        low_prices = recent_data['low'].values
+        candle_indices = np.arange(lookback)
+        ts = recent_data['time']
+
+        # 1. Identify highest high and lowest low candle
+        highest_high_index = np.argmax(high_prices)
+        lowest_low_index = np.argmin(low_prices)
+        highest_high_price = high_prices[highest_high_index]
+        lowest_low_price = low_prices[lowest_low_index]
+
+        # 2. Top line: Tilt down from highest high to touch a subsequent high (if any)
+        slope_top = -float('inf')  # Initialize with a very steep negative slope
+        intercept_top = highest_high_price - slope_top * highest_high_index
+
+        for i in range(highest_high_index + 1, lookback):
+            current_slope = (high_prices[i] - highest_high_price) / (i - highest_high_index) if (i - highest_high_index) != 0 else 0
+            if current_slope > slope_top:
+                slope_top = current_slope
+                intercept_top = highest_high_price - slope_top * highest_high_index
+
+        top_line = slope_top * candle_indices + intercept_top
+
+        # 3. Bottom line: Tilt up from lowest low to touch a subsequent low (if any)
+        slope_bottom = float('inf')  # Initialize with a very steep positive slope
+        intercept_bottom = lowest_low_price - slope_bottom * lowest_low_index
+
+        for i in range(lowest_low_index + 1, lookback):
+            current_slope = (low_prices[i] - lowest_low_price) / (i - lowest_low_index) if (i - lowest_low_index) != 0 else 0
+            if current_slope < slope_bottom:
+                slope_bottom = current_slope
+                intercept_bottom = lowest_low_price - slope_bottom * lowest_low_index
+
+        bottom_line = slope_bottom * candle_indices + intercept_bottom   
+      
+        results_df = pd.DataFrame({
+            'time': ts,
+            'top_line': top_line,
+            'bottom_line': bottom_line
+        })
+          
+        return results_df
+           
     def calculate_study(self, new_value):
         df = pd.DataFrame(new_value)
-        if not df.empty and df.shape[0] >= int(self.settings.BARS):
+        if not df.empty: #and df.shape[0] >= int(self.settings.BARS):
                         
             try:
                 #consecutive same color candle 
@@ -53,7 +99,6 @@ class Interval:
                 # Calculate the Moving Averages
                 if self.settings.EMA_STUDY:
                     df['ma_fast'] = talib.EMA(df['close'], timeperiod=self.settings.MA_FAST)
-                    df['ma_fast'] = df['ma_fast'].bfill()
                     df.fillna({'ma_fast':0}, inplace=True)
                     df['ma_fast_slope'] = df['ma_fast'].diff()
                     df['ma_fast_angle'] = np.degrees(np.arctan(df['ma_fast_slope']))    
@@ -61,7 +106,6 @@ class Interval:
                     df.fillna({'ma_fast_angle':0}, inplace=True)  
 
                     df['ma_medium'] = talib.EMA(df['close'], timeperiod=self.settings.MA_MEDIUM)
-                    df['ma_medium'] = df['ma_medium'].bfill()
                     df.fillna({'ma_medium':0}, inplace=True)
                     df['ma_medium_slope'] = df['ma_medium'].diff()
                     df['ma_medium_angle'] = np.degrees(np.arctan(df['ma_medium_slope']))    
@@ -69,7 +113,6 @@ class Interval:
                     df.fillna({'ma_medium_angle':0}, inplace=True)  
                                                       
                     df['ma_slow'] = talib.EMA(df['close'], timeperiod=self.settings.MA_SLOW)
-                    df['ma_slow'] = df['ma_slow'].bfill()
                     df.fillna({'ma_slow':0}, inplace=True)
                     df['ma_slow_slope'] = df['ma_slow'].diff()
                     df['ma_slow_angle'] = np.degrees(np.arctan(df['ma_slow_slope']))    
@@ -77,33 +120,35 @@ class Interval:
                     df.fillna({'ma_slow_angle':0}, inplace=True)  
                 
                     if self.settings.EMA_CROSSING:
-                        if df['ma_medium'].iloc[-2] <= df['ma_slow'].iloc[-2] and df['ma_medium'].iloc[-1] > df['ma_slow'].iloc[-1]:
-                            self.ema_open_signal = "BUY"
-                            self.ema_close_signal = "BUY"
-                        elif df['ma_medium'].iloc[-2] >= df['ma_slow'].iloc[-2] and df['ma_medium'].iloc[-1] < df['ma_slow'].iloc[-1]:
-                            self.ema_open_signal = "SELL"
-                            self.ema_close_signal = "SELL"
-                        else:
-                            self.ema_open_signal = "HOLD"
-                            self.ema_close_signal = "HOLD"
-
-                        if self.settings.EMA_CLOSE_ON_FAST_MEDIUM:
-                            if df['ma_fast'].iloc[-2] <= df['ma_medium'].iloc[-2] and df['ma_fast'].iloc[-1] > df['ma_medium'].iloc[-1]:
+                        if df is not None and len(df) >= 2:
+                            if df['ma_medium'].iloc[-2] <= df['ma_slow'].iloc[-2] and df['ma_medium'].iloc[-1] > df['ma_slow'].iloc[-1]:
+                                self.ema_open_signal = "BUY"
                                 self.ema_close_signal = "BUY"
-                            elif df['ma_fast'].iloc[-2] >= df['ma_medium'].iloc[-2] and df['ma_fast'].iloc[-1] < df['ma_medium'].iloc[-1]:
+                            elif df['ma_medium'].iloc[-2] >= df['ma_slow'].iloc[-2] and df['ma_medium'].iloc[-1] < df['ma_slow'].iloc[-1]:
+                                self.ema_open_signal = "SELL"
                                 self.ema_close_signal = "SELL"
                             else:
+                                self.ema_open_signal = "HOLD"
                                 self.ema_close_signal = "HOLD"
+
+                            if self.settings.EMA_CLOSE_ON_FAST_MEDIUM:
+                                if df['ma_fast'].iloc[-2] <= df['ma_medium'].iloc[-2] and df['ma_fast'].iloc[-1] > df['ma_medium'].iloc[-1]:
+                                    self.ema_close_signal = "BUY"
+                                elif df['ma_fast'].iloc[-2] >= df['ma_medium'].iloc[-2] and df['ma_fast'].iloc[-1] < df['ma_medium'].iloc[-1]:
+                                    self.ema_close_signal = "SELL"
+                                else:
+                                    self.ema_close_signal = "HOLD"
                     else:
-                        if df['close'].iloc[-1] > df['ma_medium'].iloc[-1] and df['ma_medium'].iloc[-1] > df['ma_slow'].iloc[-1]:
-                            self.ema_open_signal = "BUY"
-                            self.ema_close_signal = "BUY"
-                        elif df['close'].iloc[-1] < df['ma_medium'].iloc[-1] and df['ma_medium'].iloc[-1] < df['ma_slow'].iloc[-1]:
-                            self.ema_open_signal = "SELL"
-                            self.ema_close_signal = "SELL"
-                        else:
-                            self.ema_open_signal = "HOLD"
-                            self.ema_close_signal = "HOLD"
+                        if df is not None and len(df) >= 1:
+                            if df['close'].iloc[-1] > df['ma_medium'].iloc[-1] and df['ma_medium'].iloc[-1] > df['ma_slow'].iloc[-1]:
+                                self.ema_open_signal = "BUY"
+                                self.ema_close_signal = "BUY"
+                            elif df['close'].iloc[-1] < df['ma_medium'].iloc[-1] and df['ma_medium'].iloc[-1] < df['ma_slow'].iloc[-1]:
+                                self.ema_open_signal = "SELL"
+                                self.ema_close_signal = "SELL"
+                            else:
+                                self.ema_open_signal = "HOLD"
+                                self.ema_close_signal = "HOLD"
                 else:
                     # Drop EMA columns if not used
                     df.drop(['ma_fast', 'ma_medium', 'ma_slow', 'ma_slope', 'ma_angle'], axis=1, inplace=True, errors='ignore')
@@ -114,29 +159,29 @@ class Interval:
                     df['MACD_Signal'] = 0.0
                     df['MACD_Histogram'] = 0.0
                     df['MACD_Line'], df['MACD_Signal'], df['MACD_Histogram'] = talib.MACD(df['close'], fastperiod=self.settings.MACD_SHORT, slowperiod=self.settings.MACD_LONG, signalperiod=self.settings.MACD_PERIOD)
-                    df.fillna({'MACD_Line':0}, inplace=True)
-                    df.fillna({'MACD_Signal':0}, inplace=True)
-                    df.fillna({'MACD_Histogram':0}, inplace=True)
-                            
+                    df.fillna({'MACD_Line':0, 'MACD_Signal':0, 'MACD_Histogram':0}, inplace=True)
                     df['MACD_Line_slope'] = df['MACD_Line'].diff()
                     df['MACD_Line_angle'] = np.degrees(np.arctan(df['MACD_Line_slope']))                                        
                     df.fillna({'MACD_Line_slope':0}, inplace=True)
-                    df.fillna({'MACD_Line_angle':0}, inplace=True)                                    
+                    df.fillna({'MACD_Line_angle':0}, inplace=True)   
+                                                    
                         
                     if self.settings.MACD_CROSSING:
-                        if df['MACD_Line'].iloc[-2] <= df['MACD_Signal'].iloc[-2] and df['MACD_Line'].iloc[-1] > df['MACD_Signal'].iloc[-1]: 
-                            self.macd_signal = "BUY"
-                        elif df['MACD_Line'].iloc[-2] >= df['MACD_Signal'].iloc[-2] and df['MACD_Line'].iloc[-1] < df['MACD_Signal'].iloc[-1]: 
-                            self.macd_signal = "SELL"
-                        else:
-                            self.macd_signal = "HOLD"
+                        if df is not None and len(df) >= 2:
+                            if df['MACD_Line'].iloc[-2] <= df['MACD_Signal'].iloc[-2] and df['MACD_Line'].iloc[-1] > df['MACD_Signal'].iloc[-1]: 
+                                self.macd_signal = "BUY"
+                            elif df['MACD_Line'].iloc[-2] >= df['MACD_Signal'].iloc[-2] and df['MACD_Line'].iloc[-1] < df['MACD_Signal'].iloc[-1]: 
+                                self.macd_signal = "SELL"
+                            else:
+                                self.macd_signal = "HOLD"
                     else:
-                        if df['MACD_Line'].iloc[-1] > df['MACD_Signal'].iloc[-1]: 
-                            self.macd_signal = "BUY"
-                        elif df['MACD_Line'].iloc[-1] < df['MACD_Signal'].iloc[-1]:
-                            self.macd_signal = "SELL"
-                        else:
-                            self.macd_signal = "HOLD"
+                        if df is not None and len(df) >= 1:
+                            if df['MACD_Line'].iloc[-1] > df['MACD_Signal'].iloc[-1]: 
+                                self.macd_signal = "BUY"
+                            elif df['MACD_Line'].iloc[-1] < df['MACD_Signal'].iloc[-1]:
+                                self.macd_signal = "SELL"
+                            else:
+                                self.macd_signal = "HOLD"
                 else:
                     # Drop MACD columns if not used
                     df.drop(['MACD_Line', 'MACD_Signal', 'MACD_Histogram', 'MACD_slope', 'MACD_angle'], axis=1, inplace=True, errors='ignore')
@@ -147,9 +192,7 @@ class Interval:
                     df['BBM'] = 0.0
                     df['BBU'] = 0.0
                     df['BBU'], df['BBM'], df['BBL'] = talib.BBANDS(df['close'], timeperiod=self.settings.BBM_PERIOD, nbdevup=self.settings.BBM_STD, nbdevdn=self.settings.BBM_STD, )
-                    df.fillna({'BBL':0}, inplace=True)
-                    df.fillna({'BBM':0}, inplace=True)
-                    df.fillna({'BBU':0}, inplace=True)
+                    df.fillna({'BBM':0, 'BBU':0, 'BBL':0}, inplace=True)
 
                     df['BBM_slope'] = df['BBM'].diff()
                     df['BBM_angle'] = np.degrees(np.arctan(df['BBM_slope']))                                        
@@ -157,19 +200,21 @@ class Interval:
                     df.fillna({'BBM_angle':0}, inplace=True)                                    
 
                     if self.settings.BBM_CROSSING:
-                        if df['close'].iloc[-2] <= df['BBM'].iloc[-2] and df['close'].iloc[-1] > df['BBM'].iloc[-1]:
-                            self.bbm_signal = "BUY"
-                        elif df['close'].iloc[-2] >= df['BBM'].iloc[-2] and df['close'].iloc[-1] < df['BBM'].iloc[-1]:
-                            self.bbm_signal = "SELL"
-                        else:
-                            self.bbm_signal = "HOLD"
+                        if df is not None and len(df) >= 2:
+                            if df['close'].iloc[-2] <= df['BBM'].iloc[-2] and df['close'].iloc[-1] > df['BBM'].iloc[-1]:
+                                self.bbm_signal = "BUY"
+                            elif df['close'].iloc[-2] >= df['BBM'].iloc[-2] and df['close'].iloc[-1] < df['BBM'].iloc[-1]:
+                                self.bbm_signal = "SELL"
+                            else:
+                                self.bbm_signal = "HOLD"
                     else:
-                        if df['close'].iloc[-1] > df['BBM'].iloc[-1] and df['close'].iloc[-2] > df['BBM'].iloc[-2]:
-                            self.bbm_signal = "BUY"
-                        elif df['close'].iloc[-1] < df['BBM'].iloc[-1] and df['close'].iloc[-2] < df['BBM'].iloc[-2]:
-                            self.bbm_signal = "SELL"
-                        else:
-                            self.bbm_signal = "HOLD"
+                        if df is not None and len(df) >= 1:
+                            if df['close'].iloc[-1] > df['BBM'].iloc[-1]:
+                                self.bbm_signal = "BUY"
+                            elif df['close'].iloc[-1] < df['BBM'].iloc[-1]:
+                                self.bbm_signal = "SELL"
+                            else:
+                                self.bbm_signal = "HOLD"
                 else:
                     # Drop BBM columns if not used
                     df.drop(['BBL', 'BBM', 'BBU', 'BBM_slope', 'BBM_angle'], axis=1, inplace=True, errors='ignore') 
@@ -192,54 +237,69 @@ class Interval:
                 
 
                     if self.settings.RSI_CROSSING:
-                        if df['rsi_fast'].iloc[-2] <= df['rsi_slow'].iloc[-2] and df['rsi_fast'].iloc[-1] > df['rsi_slow'].iloc[-1]:
-                            self.rsi_signal = "BUY"
-                        elif df['rsi_fast'].iloc[-2] >= df['rsi_slow'].iloc[-2] and df['rsi_fast'].iloc[-1] < df['rsi_slow'].iloc[-1]:
-                            self.rsi_signal = "SELL"
-                        else:
-                            self.rsi_signal = "HOLD"
+                        if df is not None and len(df) >= 2:
+                            if df['rsi_fast'].iloc[-2] <= df['rsi_slow'].iloc[-2] and df['rsi_fast'].iloc[-1] > df['rsi_slow'].iloc[-1]:
+                                self.rsi_signal = "BUY"
+                            elif df['rsi_fast'].iloc[-2] >= df['rsi_slow'].iloc[-2] and df['rsi_fast'].iloc[-1] < df['rsi_slow'].iloc[-1]:
+                                self.rsi_signal = "SELL"
+                            else:
+                                self.rsi_signal = "HOLD"
                     else:
-                        if df['rsi_fast'].iloc[-1] > df['rsi_slow'].iloc[-1]:
-                            self.rsi_signal = "BUY"
-                        elif df['rsi_fast'].iloc[-1] < df['rsi_slow'].iloc[-1]:
-                            self.rsi_signal = "SELL"
-                        else:
-                            self.rsi_signal = "HOLD"
+                        if df is not None and len(df) >= 1:
+                            if df['rsi_fast'].iloc[-1] > df['rsi_slow'].iloc[-1]:
+                                self.rsi_signal = "BUY"
+                            elif df['rsi_fast'].iloc[-1] < df['rsi_slow'].iloc[-1]:
+                                self.rsi_signal = "SELL"
+                            else:
+                                self.rsi_signal = "HOLD"
                 else:
                     # Drop RSI columns if not used
                     df.drop(['rsi_fast', 'rsi_slow', 'rsi_slope', 'rsi_angle'], axis=1, inplace=True, errors='ignore')  
 
+                #Trendline
+                if self.settings.TRENDLINE_STUDY:
+                    lookback = self.settings.TRENDLINE_LOOKBACK
+                    trend_df = self.support_resistance_trend_lines(df, lookback)
+                   
+                    df['support_line'] = trend_df['top_line']
+                    df.fillna({'support_line':0}, inplace=True)
+
+                    df['resistance_line'] = trend_df['bottom_line']
+                    df.fillna({'resistance_line':0}, inplace=True)
+ 
                 # Calculate the ADX
                 if self.settings.ADX_STUDY:
-                    df['ADX'] = talib.ADX(df['high'], df['low'], df['close'], timeperiod=self.settings.ADX_PERIOD)
-                    df.fillna({'ADX':0}, inplace=True)
-                    if df['ADX'].iloc[-1] > 25:
-                        self.adx_signal = "STRONG"
-                    else:
-                        self.adx_signal = "WEAK"  
+                    if df is not None and len(df) >= 1:
+                        df['ADX'] = talib.ADX(df['high'], df['low'], df['close'], timeperiod=self.settings.ADX_PERIOD)
+                        df.fillna({'ADX':0}, inplace=True)
+                        if df['ADX'].iloc[-1] > 25:
+                            self.adx_signal = "STRONG"
+                        else:
+                            self.adx_signal = "WEAK"  
                 else:
                     # Drop ADX columns if not used
                     df.drop(['ADX'], axis=1, inplace=True, errors='ignore')
                         
                 # Calculate the close proximity
                 if self.settings.CANDLE_TREND_STUDY:                
-                    df['range'] = df['high'] - df['low']
-                    df['candle_trend'] = ((df['close'] - df['low'])/df['range'])*100
-                    df.fillna({'candle_trend':0}, inplace=True)
-                    df.fillna({'range':0}, inplace=True)
-
-                    #open and close criteria
-                    if df['candle_trend'].iloc[-1] > 70:
-                        self.candle_trend = 'BULLISH'
-                    elif df['candle_trend'].iloc[-1] < 30:
-                        self.candle_trend = 'BEARISH'
-                    else:
-                        self.candle_trend = 'HOLD'      
+                    if df is not None and len(df) >= 1:
+                        df['range'] = df['high'] - df['low']
+                        df['candle_trend'] = ((df['close'] - df['low'])/df['range'])*100
+                        df.fillna({'candle_trend':0}, inplace=True)
+                        df.fillna({'range':0}, inplace=True)
+
+                        #open and close criteria
+                        if df['candle_trend'].iloc[-1] > 70:
+                            self.candle_trend = 'BULLISH'
+                        elif df['candle_trend'].iloc[-1] < 30:
+                            self.candle_trend = 'BEARISH'
+                        else:
+                            self.candle_trend = 'HOLD'      
                 else:
                     # Drop candle trend columns if not used
                     df.drop(['candle_trend', 'range'], axis=1, inplace=True, errors='ignore')
 
-                    
+                
                 #replace infinity   
                 df.replace([np.inf, -np.inf], 0, inplace=True)
                 
@@ -411,7 +471,8 @@ class Ticker:
         self._intervals = intervals
 
     def get_interval_ticks(self, intervalId):
-        return self._intervals.get(intervalId, None)
+        interval = self._intervals.get(intervalId, None)
+        return interval
 
     def set_interval_ticks(self, intervalId, new_value):
         self._intervals[intervalId] = new_value
@@ -450,6 +511,7 @@ class Ticker:
             ticks_interval=intervalObj.get_data()
             if ticks_interval is None:
                 return
+            #print('create_bar_with_last_and_ts', self.symbol, intervalId, len(ticks_interval))
             if len(ticks_interval)==0 or self._ts - ticks_interval[-1]['time'] >= intervalObj.delta:
                 ticks_interval.append(new_item)
                 current_bar = ticks_interval[-1]
@@ -464,6 +526,7 @@ class Ticker:
                 current_bar['barcolor'] = self.red if current_bar['close'] <= current_bar['open'] else self.green
                 #print(f'{self.symbol} {self._last}, {self._ts} {intervalId} {ticks_interval[-1]['time']} c' )
 
+            #print ('create_bar_with_last_and_ts', ticks_interval[-1])
             intervalObj.set_data(ticks_interval)
 
         except Exception as e:
@@ -567,24 +630,29 @@ class Tickers:
     # since the calulation is done at a different thread and uses a different memory space, 
     # the caluated value has to be reassigned to the original ticker class instance from the caluated ticker instance
     def form_candle(self, tuples_list):
-        with ProcessPoolExecutor() as executor:
-            results = executor.map(self.process_ticker_candle, tuples_list, chunksize=10)
-            for args, result in zip(tuples_list, results):
-                for intervalId, interval in result[3].items():
-                    if not interval._data is None:
-                        args[0].get_interval_ticks(intervalId)._data = interval._data
-                        args[0].get_interval_ticks(intervalId).current_signal = interval.current_signal                        
-                        args[0].get_interval_ticks(intervalId).ema_open_signal = interval.ema_open_signal
-                        args[0].get_interval_ticks(intervalId).ema_close_signal = interval.ema_close_signal
-                        args[0].get_interval_ticks(intervalId).macd_signal = interval.macd_signal
-                        args[0].get_interval_ticks(intervalId).bbm_signal = interval.bbm_signal                        
-                        args[0].get_interval_ticks(intervalId).rsi_signal = interval.rsi_signal
-                        args[0].get_interval_ticks(intervalId).candle_trend = interval.candle_trend
-                        args[0].get_interval_ticks(intervalId).adx_signal = interval.adx_signal
-                        args[0].get_interval_ticks(intervalId).signal_strength = interval.signal_strength 
-                        args[0]._last = result[0]
-                        args[0].lastcolor = result[1]
-                        args[0]._ts = result[2]
+        if not self.settings.CPU_PROCCESING:
+            for args in tuples_list:
+                ticker_obj, last, ts = args
+                result = self.process_ticker_candle(args)
+        else:
+            with ProcessPoolExecutor() as executor:
+                results = executor.map(self.process_ticker_candle, tuples_list, chunksize=10)
+                for args, result in zip(tuples_list, results):
+                    for intervalId, interval in result[3].items():
+                        if not interval._data is None:
+                            args[0].get_interval_ticks(intervalId)._data = interval._data
+                            args[0].get_interval_ticks(intervalId).current_signal = interval.current_signal                        
+                            args[0].get_interval_ticks(intervalId).ema_open_signal = interval.ema_open_signal
+                            args[0].get_interval_ticks(intervalId).ema_close_signal = interval.ema_close_signal
+                            args[0].get_interval_ticks(intervalId).macd_signal = interval.macd_signal
+                            args[0].get_interval_ticks(intervalId).bbm_signal = interval.bbm_signal                        
+                            args[0].get_interval_ticks(intervalId).rsi_signal = interval.rsi_signal
+                            args[0].get_interval_ticks(intervalId).candle_trend = interval.candle_trend
+                            args[0].get_interval_ticks(intervalId).adx_signal = interval.adx_signal
+                            args[0].get_interval_ticks(intervalId).signal_strength = interval.signal_strength 
+                            args[0]._last = result[0]
+                            args[0].lastcolor = result[1]
+                            args[0]._ts = result[2]
                                     
     def getCurrentData(self, period):
         current_data = []
@@ -603,33 +671,32 @@ class Tickers:
                     ticks = intervalObj.get_data()
                     if not ticks:
                         continue
-                    if len(ticks)>=int(self.settings.BARS):
-                        lastcandle = intervalObj.get_data()[-1]
-                        if len(lastcandle) >= 20:
-                            new_row = {
-                                'symbol' : symbol,
-                                f"{period}_trend": intervalObj.current_signal,
-                                f"{period}_cb": intervalObj.signal_strength,
-                                f"{period}_barcolor": lastcandle['barcolor'],
-                                f"{period}_ema_open": intervalObj.ema_open_signal,
-                                f"{period}_ema_close": intervalObj.ema_close_signal,
-                                f"{period}_macd":intervalObj.macd_signal,
-                                f"{period}_bbm":intervalObj.bbm_signal,
-                                f"{period}_rsi":intervalObj.rsi_signal,
-                                f"{period}_adx":intervalObj.adx_signal,                                       
-                                f"{period}_candle_trend":intervalObj.candle_trend, 
-                                'bid' : bid,
-                                'bidcolor' : bidcolor,
-                                'last' : last,
-                                'lastcolor' : lastcolor,
-                                'ask' : ask,
-                                'askcolor' : askcolor,
-                                f"{period}_open": lastcandle['open'],
-                                f"{period}_close": lastcandle['close'],
-                                f"{period}_high": lastcandle['high'],
-                                f"{period}_low": lastcandle['low'],
-                            }
-                            current_data.append(new_row)
+                    lastcandle = intervalObj.get_data()[-1]
+                    if len(lastcandle) >= 20:
+                        new_row = {
+                            'symbol' : symbol,
+                            f"{period}_trend": intervalObj.current_signal,
+                            f"{period}_cb": intervalObj.signal_strength,
+                            f"{period}_barcolor": lastcandle['barcolor'],
+                            f"{period}_ema_open": intervalObj.ema_open_signal,
+                            f"{period}_ema_close": intervalObj.ema_close_signal,
+                            f"{period}_macd":intervalObj.macd_signal,
+                            f"{period}_bbm":intervalObj.bbm_signal,
+                            f"{period}_rsi":intervalObj.rsi_signal,
+                            f"{period}_adx":intervalObj.adx_signal,                                       
+                            f"{period}_candle_trend":intervalObj.candle_trend, 
+                            'bid' : bid,
+                            'bidcolor' : bidcolor,
+                            'last' : last,
+                            'lastcolor' : lastcolor,
+                            'ask' : ask,
+                            'askcolor' : askcolor,
+                            f"{period}_open": lastcandle['open'],
+                            f"{period}_close": lastcandle['close'],
+                            f"{period}_high": lastcandle['high'],
+                            f"{period}_low": lastcandle['low'],
+                        }
+                        current_data.append(new_row)
                         
             df = pd.DataFrame(current_data)
             if not df.empty:

bitunix_automated_crypto_trading/bitunix.py

@@ -70,76 +70,6 @@ class bitunix():
         #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
         await self.bitunixSignal.update_settings(settings)
@@ -470,6 +400,8 @@ async def wscharts(websocket):
                         "buysell": buysell,
                         "ema_study": settings.EMA_STUDY,
                         "ema_chart": settings.EMA_CHART,
+                        "trendline_study": settings.TRENDLINE_STUDY,
+                        "trendline_chart": settings.TRENDLINE_CHART,
                         "macd_study": settings.MACD_STUDY,
                         "macd_chart": settings.MACD_CHART,
                         "bbm_study": settings.BBM_STUDY,
@@ -557,6 +489,8 @@ async def wschart(websocket):
                         "period": period,
                         "ema_study": settings.EMA_STUDY,
                         "ema_chart": settings.EMA_CHART,
+                        "trendline_study": settings.TRENDLINE_STUDY,
+                        "trendline_chart": settings.TRENDLINE_CHART,
                         "macd_study": settings.MACD_STUDY,
                         "macd_chart": settings.MACD_CHART,
                         "bbm_study": settings.BBM_STUDY,

bitunix_automated_crypto_trading/config.py

@@ -59,6 +59,12 @@ class Settings(BaseSettings):
     RSI_CHECK_ON_OPEN: bool = Field(default=False)
     RSI_CHECK_ON_CLOSE: bool = Field(default=False)
 
+    TRENDLINE_CHART: bool = Field(default=True)
+    TRENDLINE_STUDY: bool = Field(default=True)
+    TRENDLINE_LOOKBACK: int = Field(default=20, ge=10, le=100)
+    TRENDLINE_CHECK_ON_OPEN: bool = Field(default=False)
+    TRENDLINE_CHECK_ON_CLOSE: bool = Field(default=False)
+
     ADX_STUDY: bool = Field(default=True)
     ADX_CHECK_ON_OPEN: bool = Field(default=False)
     ADX_CHECK_ON_CLOSE: bool = Field(default=False)
@@ -84,6 +90,9 @@ class Settings(BaseSettings):
     # Logger
     VERBOSE_LOGGING: bool = Field(default=False)
 
+    #use CPU
+    CPU_PROCCESING: bool = Field(default=True)
+
     # Benchmark
     BENCHMARK: bool = Field(default=False)
 

{bitunix_automated_crypto_trading-3.1.1.dist-info → bitunix_automated_crypto_trading-3.1.3.dist-info}/METADATA

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

bitunix_automated_crypto_trading-3.1.3.dist-info/RECORD

@@ -0,0 +1,17 @@
+bitunix_automated_crypto_trading/AsyncThreadRunner.py,sha256=LJ6ny1KSCVoIbfeNypsY4aHYcbkGME9M3epQ9e8B1O8,3224
+bitunix_automated_crypto_trading/BitunixApi.py,sha256=W0uem1wIs1uM-jaGtXXzL_JQfnCDb7imyTZ2Tqjk8e8,11230
+bitunix_automated_crypto_trading/BitunixSignal.py,sha256=17_VPwagjax-vFJ-A20cMApcyBtPCGdzis8EhAVoNrk,64734
+bitunix_automated_crypto_trading/BitunixWebSocket.py,sha256=mbuvk8UFWKgv4KLV07TgLgxLVTRJnOKuf02mLB-VoCY,11143
+bitunix_automated_crypto_trading/DataFrameHtmlRenderer.py,sha256=Pqdzhh_nfIxFEZH9L_R5QXB8moDPbgeTGT_hmBkHWMg,2899
+bitunix_automated_crypto_trading/NotificationManager.py,sha256=pqDquEe-oujD2v8B543524vo62aRMjfB4YW-3DMhVGQ,795
+bitunix_automated_crypto_trading/ThreadManager.py,sha256=WmYRQu8aNrgp5HwSqpBqX1WESNSEpbD2CznPFpd9HuI,2330
+bitunix_automated_crypto_trading/TickerManager.py,sha256=W4UuW1RyU_4w_6IV0eDOlJ0PUFNorQOY9Ust4bI-69s,36785
+bitunix_automated_crypto_trading/__init__.py,sha256=1hzk6nX8NnUCr1tsq8oFq1qGCNhNwnwldWE75641Eew,78
+bitunix_automated_crypto_trading/bitunix.py,sha256=Zyrf8P-xi7DJogX_bcc6uDW66J7FAxdS-0jbuHRPFfM,25845
+bitunix_automated_crypto_trading/config.py,sha256=Jj1AXFU9c3RHKRnxnAS7lJ6UIyfl6qRByoVbOVrEz1k,4857
+bitunix_automated_crypto_trading/logger.py,sha256=tAaTQcv5r--zupk_Fhfe1USfBAzSiXzVa4QRnaOFIFY,2933
+bitunix_automated_crypto_trading-3.1.3.dist-info/METADATA,sha256=UoUpv4RK83MLzcKnh8A6R3p0wltVYqLTQEpR6_ZzzCY,996
+bitunix_automated_crypto_trading-3.1.3.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
+bitunix_automated_crypto_trading-3.1.3.dist-info/entry_points.txt,sha256=UXREYHuSl2XYd_tOtLIq0zg3d1kX3lixX5SpN8yGBw4,82
+bitunix_automated_crypto_trading-3.1.3.dist-info/top_level.txt,sha256=uyFzHUCOsp8elnG2Ovor6xXcf7dxRxY-C-Txiwix64Q,33
+bitunix_automated_crypto_trading-3.1.3.dist-info/RECORD,,

{bitunix_automated_crypto_trading-3.1.1.dist-info → bitunix_automated_crypto_trading-3.1.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (78.1.0)
+Generator: setuptools (79.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

bitunix_automated_crypto_trading-3.1.1.dist-info/RECORD

@@ -1,17 +0,0 @@
-bitunix_automated_crypto_trading/AsyncThreadRunner.py,sha256=LJ6ny1KSCVoIbfeNypsY4aHYcbkGME9M3epQ9e8B1O8,3224
-bitunix_automated_crypto_trading/BitunixApi.py,sha256=wJhknpmVFrckoL89h-nlWUAMsPxhIacY0nOGJT9M6Vw,11360
-bitunix_automated_crypto_trading/BitunixSignal.py,sha256=LKxWy_-alKkawB_l9_AdzwtCt0rx6lTqfBDuiGBMoe4,64669
-bitunix_automated_crypto_trading/BitunixWebSocket.py,sha256=mbuvk8UFWKgv4KLV07TgLgxLVTRJnOKuf02mLB-VoCY,11143
-bitunix_automated_crypto_trading/DataFrameHtmlRenderer.py,sha256=Pqdzhh_nfIxFEZH9L_R5QXB8moDPbgeTGT_hmBkHWMg,2899
-bitunix_automated_crypto_trading/NotificationManager.py,sha256=pqDquEe-oujD2v8B543524vo62aRMjfB4YW-3DMhVGQ,795
-bitunix_automated_crypto_trading/ThreadManager.py,sha256=WmYRQu8aNrgp5HwSqpBqX1WESNSEpbD2CznPFpd9HuI,2330
-bitunix_automated_crypto_trading/TickerManager.py,sha256=eeOK5paiae10XHjKMbucJnVAZkAsEC86N37bRPuCcFc,33427
-bitunix_automated_crypto_trading/__init__.py,sha256=1hzk6nX8NnUCr1tsq8oFq1qGCNhNwnwldWE75641Eew,78
-bitunix_automated_crypto_trading/bitunix.py,sha256=c5vKRuN1-UaNz_ZB5Txu4-2UM6PsnRhs-ztvhRtpEzc,32779
-bitunix_automated_crypto_trading/config.py,sha256=QWAe5Ruq8A5anaFS-CamVm-3t1wMJjGG1DWaPIIWfiM,4521
-bitunix_automated_crypto_trading/logger.py,sha256=tAaTQcv5r--zupk_Fhfe1USfBAzSiXzVa4QRnaOFIFY,2933
-bitunix_automated_crypto_trading-3.1.1.dist-info/METADATA,sha256=5cwQuEB4OsaVHSAxpiYo0gIDSK3Rs39TgID_E7dCihU,996
-bitunix_automated_crypto_trading-3.1.1.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-bitunix_automated_crypto_trading-3.1.1.dist-info/entry_points.txt,sha256=UXREYHuSl2XYd_tOtLIq0zg3d1kX3lixX5SpN8yGBw4,82
-bitunix_automated_crypto_trading-3.1.1.dist-info/top_level.txt,sha256=uyFzHUCOsp8elnG2Ovor6xXcf7dxRxY-C-Txiwix64Q,33
-bitunix_automated_crypto_trading-3.1.1.dist-info/RECORD,,