bitunix-automated-crypto-trading 3.1.2__py3-none-any.whl → 3.1.5__py3-none-any.whl

bitunix_automated_crypto_trading/BitunixApi.py

@@ -258,6 +258,8 @@ class BitunixApi:
                 url = f'{self.kline_Url}?symbol={ticker}&startTime={st}&interval={interval}&limit={lm}'
                 resp = self.session.get(url)
                 datajs = resp.json()
+                if datajs['data'] == []:
+                    break
                 data.extend(datajs['data'])
                 if len(datajs['data']) < lm:
                     st = int(datajs['data'][-1]['time']) + 1

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=['POLUSDT']
 
         [await self.add_ticker_to_tickerObjects(sym) for sym in self.tickerList]
         self.notifications.add_notification(f"{len(self.tickerList)} ticker list loaded") 
@@ -270,12 +271,7 @@ class BitunixSignal:
     # Function to add data to the last price deque
     async def StoreTickerData(self, message):
         if self.settings.USE_PUBLIC_WEBSOCKET and message:
-            try:
-                data = json.loads(message)
-                if data.get('symbol') and data.get('ch') == 'ticker':
-                    await self.ticker_que.put(data)
-            except json.JSONDecodeError as e:
-                logger.warning(f"Failed to decode message: {message}. Error: {e}")
+            await self.ticker_que.put(message)
 
     # Function to process the last price deque
     async def ProcessTickerData(self):
@@ -284,11 +280,14 @@ class BitunixSignal:
                 latest_data = {}
                 reversed_items = await self.drain_queue(self.ticker_que)
                 while reversed_items:
-                    data = reversed_items.popleft()
-                    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'])}
+                    message = reversed_items.popleft()
+                    data = json.loads(message)
+                    if data.get('symbol') and data.get('ch') == 'ticker':
+                        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'])}
+                    await asyncio.sleep(0.01)
                 # Convert to DataFrame
                 self.tickerdf = pd.DataFrame.from_dict(latest_data, orient="index")
                 if not self.tickerdf.empty:
@@ -299,7 +298,7 @@ class BitunixSignal:
             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)
+            await asyncio.sleep(0.01)
         logger.info(f"ProcessTickerData: exitied out of the loop, exiting app")
         os._exit(1)  # Exit the program 
             
@@ -307,13 +306,8 @@ class BitunixSignal:
     #websocket data to update bid and ask
     async def StoreDepthData(self, message):
         if self.settings.USE_PUBLIC_WEBSOCKET and message:
-            try:
-                data = json.loads(message)
-                if data.get('symbol') and data.get('ch') == 'depth_book1':
-                    await self.depth_que.put(data)
-            except json.JSONDecodeError as e:
-                logger.warning(f"Failed to decode message: {message}. Error: {e}")        
-
+            await self.depth_que.put(message)
+ 
     # Function to process the bid, ask
     async def ProcessDepthData(self):
         while True:
@@ -321,11 +315,14 @@ class BitunixSignal:
                 latest_data = {}
                 reversed_items = await self.drain_queue(self.depth_que)
                 while reversed_items:
-                    data = reversed_items.popleft()
-                    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])}
+                    message = reversed_items.popleft()
+                    data = json.loads(message)
+                    if data.get('symbol') and data.get('ch') == 'depth_book1':
+                        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])}
+                    await asyncio.sleep(0.01)
                 # Convert to DataFrame
                 self.depthdf = pd.DataFrame.from_dict(latest_data, orient="index")
                 if not self.depthdf.empty:
@@ -334,7 +331,7 @@ class BitunixSignal:
             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)
+            await asyncio.sleep(0.01)
         logger.info(f"ProcessDepthData: exitied out of the loop, exiting app")
         os._exit(1)  # Exit the program 
 
@@ -397,7 +394,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()
@@ -562,12 +559,12 @@ class BitunixSignal:
             self.signaldf_filtered = self.tickerObjects.signaldf_filtered
 
             if not self.positiondf.empty and not self.signaldf_full.empty:
-                    columns=['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}_candle_trend", f"{period}_open", f"{period}_close", f"{period}_high", f"{period}_low"]
+                    columns=['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}_trendline", f"{period}_candle_trend", f"{period}_open", f"{period}_close", f"{period}_high", f"{period}_low"]
                     columns2=["qty", "side", "unrealizedPNL", "realizedPNL", "ctime", "avgOpenPrice", "bid", "bidcolor", "last", "lastcolor", "ask", "askcolor", "charts", "bitunix", "action", "add", "reduce"]
                     if set(columns).issubset(self.signaldf_full.columns) and set(columns2).issubset(self.positiondf.columns):
-                        columnOrder= ['symbol', "side",  "unrealizedPNL", "realizedPNL", 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", f"{period}_open", f"{period}_close", f"{period}_high", f"{period}_low", "qty", "ctime", "avgOpenPrice", "bid", "bidcolor", "last", "lastcolor", "ask", "askcolor", "charts", "bitunix", "action", "add", "reduce"]                
+                        columnOrder= ['symbol', "side",  "unrealizedPNL", "realizedPNL", 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}_trendline", f"{period}_adx", f"{period}_candle_trend", f"{period}_open", f"{period}_close", f"{period}_high", f"{period}_low", "qty", "ctime", "avgOpenPrice", "bid", "bidcolor", "last", "lastcolor", "ask", "askcolor", "charts", "bitunix", "action", "add", "reduce"]                
                         self.positiondf2 = pd.merge(self.positiondf, self.signaldf_full[["symbol", f"{period}_open", f"{period}_close", f"{period}_high", f"{period}_low", 
-                                f"{period}_ema_open", f"{period}_ema_close", f"{period}_macd", f"{period}_bbm", f"{period}_rsi", f"{period}_adx", f"{period}_candle_trend",
+                                f"{period}_ema_open", f"{period}_ema_close", f"{period}_macd", f"{period}_bbm", f"{period}_rsi", f"{period}_trendline", f"{period}_adx", f"{period}_candle_trend",
                                 f"{period}_trend",f"{period}_cb", f"{period}_barcolor"]], left_on="symbol", right_index=True, how="left")[columnOrder]    
                         self.positiondfStyle= self.positiondfrenderer.render_html(self.positiondf2)
             else:
@@ -581,7 +578,7 @@ class BitunixSignal:
                     # Assign to self.signaldf for HTML rendering
                     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",
+                        f"{period}_ema_open", f"{period}_ema_close", f"{period}_macd", f"{period}_bbm", f"{period}_rsi", f"{period}_trendline",f"{period}_adx",f"{period}_candle_trend",
                         '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])
@@ -692,7 +689,7 @@ class BitunixSignal:
                     total_pnl = unrealized_pnl + realized_pnl
                     side=row['side']
 
-                    requiredCols=[f'{period}_open', f'{period}_close', f'{period}_high', f'{period}_low', f'{period}_ema_open', f"{period}_ema_close", f'{period}_macd', f'{period}_bbm', f'{period}_rsi', f'{period}_candle_trend', f'{period}_trend', f'{period}_cb', f'{period}_barcolor']    
+                    requiredCols=[f'{period}_open', f'{period}_close', f'{period}_high', f'{period}_low', f'{period}_ema_open', f"{period}_ema_close", f'{period}_macd', f'{period}_bbm', f'{period}_rsi', f'{period}_trendline', f'{period}_candle_trend', f'{period}_trend', f'{period}_cb', f'{period}_barcolor']    
                     required_cols = set(requiredCols)
 
                     # Close position that fall the below criteria
@@ -878,6 +875,41 @@ class BitunixSignal:
                                     )
                                     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:
+                                    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} trendline 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}_trendline'] == "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} trendline 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
+
                             # Close on weak trend after open
                             if self.settings.ADX_STUDY and self.settings.ADX_CHECK_ON_CLOSE:
                                 if row.side == 'BUY' and self.signaldf_full.at[row.symbol, f'{period}_adx'] == "WEAK":

bitunix_automated_crypto_trading/SupportResistance.py

@@ -0,0 +1,89 @@
+import pandas as pd
+import numpy as np
+from scipy.signal import find_peaks
+
+class SupportResistance:
+    import pandas as pd
+import numpy as np
+
+class SupportResistance:
+    def _find_peaks(self, prices, prominence=None, distance=None):
+        """Finds local peaks using scipy.signal.find_peaks."""
+        peaks, _ = find_peaks(prices, prominence=prominence, distance=distance)
+        return peaks
+
+    def _find_troughs(self, prices, prominence=None, distance=None):
+        """Finds local troughs by finding peaks in the inverted prices."""
+        troughs, _ = find_peaks(-prices, prominence=prominence, distance=distance)
+        return troughs
+
+    def _get_n_most_recent_prominent(self, indices, prices, n=2):
+        """Gets the indices of the n most recent prominent peaks or troughs."""
+        if not indices.size:
+            return np.array([])
+        # Sort indices by time (which is the index itself in our case) in descending order
+        sorted_indices_by_time = np.sort(indices)[::-1]
+        return sorted_indices_by_time[:n]
+
+    def _get_line(self, index1, price1, index2, price2, length):
+        """Calculates the line equation (y = mx + c)."""
+        if index1 == index2:
+            return np.full(length, price1)  # Horizontal line
+        slope = (price2 - price1) / (index2 - index1)
+        intercept = price1 - slope * index1
+        return slope * np.arange(length) + intercept
+
+    def support_resistance_trend_lines(self, data, lookback=20, prominence=None, distance=None):
+        if data is None or len(data) < lookback:
+            return pd.DataFrame()
+        try:
+            recent_data = data.iloc[-lookback:].copy()
+            high_prices = recent_data['high'].values
+            low_prices = recent_data['low'].values
+            ts = recent_data['time'].values
+
+            # Find all local peaks and troughs
+            peak_indices_all = self._find_peaks(high_prices, prominence=prominence, distance=distance)
+            if len(peak_indices_all) > 0 and peak_indices_all[-1] < lookback - 2 and high_prices[-2] >  high_prices[lookback - peak_indices_all[-1]]:
+                peak_indices_all = np.append(peak_indices_all,lookback - 2)
+            trough_indices_all = self._find_troughs(low_prices, prominence=prominence, distance=distance)
+            if len(trough_indices_all) > 0 and trough_indices_all[-1] < lookback - 2 and low_prices[-2] < low_prices[lookback - trough_indices_all[-1]]:
+                trough_indices_all = np.append(trough_indices_all, lookback - 2)
+            # Get the two most recent prominent peaks
+            most_recent_peaks_indices = self._get_n_most_recent_prominent(peak_indices_all, high_prices, n=2)
+
+            # Get the two most recent prominent troughs
+            most_recent_troughs_indices = self._get_n_most_recent_prominent(trough_indices_all, low_prices, n=2)
+
+            support_line = np.full(lookback, np.nan)
+            resistance_line = np.full(lookback, np.nan)
+
+            if len(most_recent_peaks_indices) >= 2:
+                # Sort by index (time) to ensure correct order
+                sorted_peak_indices = most_recent_peaks_indices #np.sort(most_recent_peaks_indices)
+                resistance_line_full = self._get_line(sorted_peak_indices[0], high_prices[sorted_peak_indices[0]],
+                                                      sorted_peak_indices[1], high_prices[sorted_peak_indices[1]], lookback)
+                # Set values before the second peak to NaN
+                resistance_line[sorted_peak_indices[1]:] = resistance_line_full[sorted_peak_indices[1]:]
+            elif len(most_recent_peaks_indices) == 1:
+                resistance_line[most_recent_peaks_indices[0]:] = high_prices[most_recent_peaks_indices[0]] # Horizontal line from the peak onwards
+
+            if len(most_recent_troughs_indices) >= 2:
+                # Sort by index (time) to ensure correct order
+                sorted_trough_indices = most_recent_troughs_indices #np.sort(most_recent_troughs_indices)
+                support_line_full = self._get_line(sorted_trough_indices[0], low_prices[sorted_trough_indices[0]],
+                                                   sorted_trough_indices[1], low_prices[sorted_trough_indices[1]], lookback)
+                # Set values before the second trough to NaN
+                support_line[sorted_trough_indices[1]:] = support_line_full[sorted_trough_indices[1]:]
+            elif len(most_recent_troughs_indices) == 1:
+                support_line[most_recent_troughs_indices[0]:] = low_prices[most_recent_troughs_indices[0]] # Horizontal line from the trough onwards
+
+            results_df = pd.DataFrame({
+                'time': ts,
+                'support_line': support_line,
+                'resistance_line': resistance_line
+            })
+            return results_df
+        except Exception as e:
+            print(f"An error occurred: {e}")
+            return pd.DataFrame()

bitunix_automated_crypto_trading/TickerManager.py

@@ -1,5 +1,7 @@
 import pandas as pd
-#pd.set_option('future.no_silent_downcasting', True)
+pd.set_option('future.no_silent_downcasting', True)
+import warnings
+warnings.filterwarnings("ignore", category=RuntimeWarning)
 import numpy as np
 import asyncio
 import talib
@@ -8,6 +10,8 @@ from logger import Logger
 logger = Logger(__name__).get_logger()
 import gc
 from concurrent.futures import ProcessPoolExecutor
+from SupportResistance import SupportResistance
+sr = SupportResistance()
 
 class Interval:
     def __init__(self, symbol, intervalId, delta, data, settings):
@@ -21,6 +25,7 @@ class Interval:
         self.current_signal="HOLD"
         self.ema_open_signal="HOLD"
         self.ema_close_signal="HOLD"
+        self.trendline_signal = "HOLD"
         self.macd_signal="HOLD"
         self.bbm_signal="HOLD"
         self.rsi_signal="HOLD"
@@ -36,11 +41,19 @@ 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 get_line(self, lookback, candle_indices, index1, price1, index2, price2):
+        if index1 == index2:
+            return np.full(lookback, price1)  # Horizontal line
+        slope = (price2 - price1) / (index2 - index1)
+        intercept = price1 - slope * index1
+        return slope * candle_indices + intercept
+                
     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,54 +66,56 @@ class Interval:
                 # Calculate the Moving Averages
                 if self.settings.EMA_STUDY:
                     df['ma_fast'] = talib.EMA(df['close'], timeperiod=self.settings.MA_FAST)
-                    df.dropna(subset=['ma_fast'], inplace=True)
+                    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']))    
                     df.fillna({'ma_fast_slope':0}, inplace=True)
                     df.fillna({'ma_fast_angle':0}, inplace=True)  
 
                     df['ma_medium'] = talib.EMA(df['close'], timeperiod=self.settings.MA_MEDIUM)
-                    df.dropna(subset=['ma_medium'], inplace=True)
+                    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']))    
                     df.fillna({'ma_medium_slope':0}, inplace=True)
                     df.fillna({'ma_medium_angle':0}, inplace=True)  
                                                       
                     df['ma_slow'] = talib.EMA(df['close'], timeperiod=self.settings.MA_SLOW)
-                    df.dropna(subset=['ma_slow'],inplace=True)
+                    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']))    
                     df.fillna({'ma_slow_slope':0}, inplace=True)
                     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')
@@ -111,7 +126,7 @@ 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.dropna(subset=['MACD_Line', 'MACD_Signal', 'MACD_Histogram'], 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)
@@ -119,19 +134,21 @@ class Interval:
                                                     
                         
                     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')
@@ -142,7 +159,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.dropna(subset=['BBM', 'BBU', 'BBL'], 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']))                                        
@@ -150,19 +167,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') 
@@ -170,14 +189,14 @@ class Interval:
                 # Calculate the RSI
                 if self.settings.RSI_STUDY:
                     df['rsi_fast'] = talib.RSI(df['close'],timeperiod=self.settings.RSI_FAST)
-                    df.dropna(subset=['rsi_fast'], inplace=True)
+                    df.fillna({'rsi_fast':0}, inplace=True)
                     df['rsi_fast_slope'] = df['rsi_fast'].diff()
                     df['rsi_fast_angle'] = np.degrees(np.arctan(df['rsi_fast_slope']))                                        
                     df.fillna({'rsi_fast_slope':0}, inplace=True)
                     df.fillna({'rsi_fast_angle':0}, inplace=True)                                    
                     
                     df['rsi_slow'] = talib.RSI(df['close'],timeperiod=self.settings.RSI_SLOW)
-                    df.dropna(subset=['rsi_slow'], inplace=True)
+                    df.fillna({'rsi_slow':0}, inplace=True)
                     df['rsi_slow_slope'] = df['rsi_slow'].diff()
                     df['rsi_slow_angle'] = np.degrees(np.arctan(df['rsi_slow_slope']))                                        
                     df.fillna({'rsi_slow_slope':0}, inplace=True)
@@ -185,54 +204,79 @@ 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:
+                    loopback = len(df) 
+                    df_sr= sr.support_resistance_trend_lines(df[['time','open', 'high', 'low', 'close']], loopback, prominence=None, distance=None if self.settings.TRENDLINE_PEAK_DISTANCE==0 else self.settings.TRENDLINE_PEAK_DISTANCE)
+                    if df_sr is not None and len(df_sr) >= 1:
+                        df['support_line'] = df_sr['support_line']
+                        df['resistance_line'] = df_sr['resistance_line']
+                        df.fillna({'support_line':0}, inplace=True)
+                        df.fillna({'resistance_line':0}, inplace=True)
+                        if df is not None and len(df) >= 2:
+                            if df['high'].iloc[-3] >= df['support_line'].iloc[-3] and df['close'].iloc[-2] < df['support_line'].iloc[-2] and df['close'].iloc[-1] < df['open'].iloc[-1]:
+                                self.trendline_signal = "SELL"
+                            elif df['low'].iloc[-3] <= df['resistance_line'].iloc[-3] and df['close'].iloc[-2] > df['resistance_line'].iloc[-2] and df['close'].iloc[-1] > df['open'].iloc[-1]:
+                                self.trendline_signal = "BUY"
+                            elif df['close'].iloc[-3] > df['support_line'].iloc[-3] and df['close'].iloc[-2] > df['support_line'].iloc[-2] and df['close'].iloc[-1] > df['open'].iloc[-1]:     
+                                    self.trendline_signal = "BUY"
+                            elif df['close'].iloc[-3] < df['resistance_line'].iloc[-3] and df['close'].iloc[-2] < df['resistance_line'].iloc[-2] and df['close'].iloc[-1] < df['open'].iloc[-1]:     
+                                    self.trendline_signal = "SELL"
+                            else:
+                                 self.trendline_signal = "HOLD"
+ 
                 # 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)
                 
@@ -247,7 +291,8 @@ class Interval:
                         (self.settings.EMA_STUDY and self.settings.EMA_CHECK_ON_OPEN and self.ema_open_signal == "BUY") or
                         (self.settings.MACD_STUDY and self.settings.MACD_CHECK_ON_OPEN and self.macd_signal == "BUY") or
                         (self.settings.BBM_STUDY and self.settings.BBM_CHECK_ON_OPEN and self.bbm_signal == "BUY") or
-                        (self.settings.RSI_STUDY and self.settings.RSI_CHECK_ON_OPEN and self.rsi_signal == "BUY")
+                        (self.settings.RSI_STUDY and self.settings.RSI_CHECK_ON_OPEN and self.rsi_signal == "BUY") or
+                        (self.settings.TRENDLINE_STUDY and self.settings.TRENDLINE_CHECK_ON_OPEN and self.trendline_signal == "BUY")
                     )
                     additional_buy_conditions = (
                         (not self.settings.ADX_STUDY or not self.settings.ADX_CHECK_ON_OPEN or self.adx_signal == "STRONG") or
@@ -259,7 +304,8 @@ class Interval:
                         (self.settings.EMA_STUDY and self.settings.EMA_CHECK_ON_OPEN and self.ema_open_signal == "SELL") or
                         (self.settings.MACD_STUDY and self.settings.MACD_CHECK_ON_OPEN and self.macd_signal == "SELL") or
                         (self.settings.BBM_STUDY and self.settings.BBM_CHECK_ON_OPEN and self.bbm_signal == "SELL") or
-                        (self.settings.RSI_STUDY and self.settings.RSI_CHECK_ON_OPEN and self.rsi_signal == "SELL")
+                        (self.settings.RSI_STUDY and self.settings.RSI_CHECK_ON_OPEN and self.rsi_signal == "SELL") or
+                        (self.settings.TRENDLINE_STUDY and self.settings.TRENDLINE_CHECK_ON_OPEN and self.trendline_signal == "SELL")
                     )
                     additional_sell_conditions = (
                         (self.settings.ADX_STUDY and self.settings.ADX_CHECK_ON_OPEN and self.adx_signal == "STRONG") or
@@ -282,7 +328,8 @@ class Interval:
                         (not self.settings.EMA_STUDY or not self.settings.EMA_CHECK_ON_OPEN or self.ema_open_signal == "BUY") and
                         (not self.settings.MACD_STUDY or not self.settings.MACD_CHECK_ON_OPEN or self.macd_signal == "BUY") and
                         (not self.settings.BBM_STUDY or not self.settings.BBM_CHECK_ON_OPEN or self.bbm_signal == "BUY") and
-                        (not self.settings.RSI_STUDY or not self.settings.RSI_CHECK_ON_OPEN or self.rsi_signal == "BUY")
+                        (not self.settings.RSI_STUDY or not self.settings.RSI_CHECK_ON_OPEN or self.rsi_signal == "BUY") and
+                        (not self.settings.TRENDLINE_STUDY or not self.settings.TRENDLINE_CHECK_ON_OPEN or self.trendline_signal == "BUY")
                     )
                     additional_buy_conditions = (
                         (not self.settings.ADX_STUDY or not self.settings.ADX_CHECK_ON_OPEN or self.adx_signal == "STRONG") and
@@ -294,7 +341,8 @@ class Interval:
                         (not self.settings.EMA_STUDY or not self.settings.EMA_CHECK_ON_OPEN or self.ema_open_signal == "SELL") and
                         (not self.settings.MACD_STUDY or not self.settings.MACD_CHECK_ON_OPEN or self.macd_signal == "SELL") and
                         (not self.settings.BBM_STUDY or not self.settings.BBM_CHECK_ON_OPEN or self.bbm_signal == "SELL") and
-                        (not self.settings.RSI_STUDY or not self.settings.RSI_CHECK_ON_OPEN or self.rsi_signal == "SELL")
+                        (not self.settings.RSI_STUDY or not self.settings.RSI_CHECK_ON_OPEN or self.rsi_signal == "SELL") and
+                        (not self.settings.TRENDLINE_STUDY or not self.settings.TRENDLINE_CHECK_ON_OPEN or self.trendline_signal == "SELL")
                     )
                     additional_sell_conditions = (
                         (not self.settings.ADX_STUDY or not self.settings.ADX_CHECK_ON_OPEN or self.adx_signal == "STRONG") and
@@ -312,7 +360,7 @@ class Interval:
                    
             except Exception as e:
                 logger.info(f"Function: calculate_study, {e}, {e.args}, {type(e).__name__}")
-                logger.info(traceback.logger.info_exc())
+                logger.info(traceback.print_exc())
             retval =  df.to_dict('records')
             del df
             gc.collect()            
@@ -404,7 +452,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
@@ -443,6 +492,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]
@@ -457,11 +507,12 @@ 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:
             logger.info(f"Function: create_bar_with_last_and_ts, {e}, {e.args}, {type(e).__name__}")
-            logger.info(traceback.logger.info_exc())
+            logger.info(traceback.print_exc())
 
               
 class Tickers:
@@ -560,24 +611,30 @@ 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 and len(interval._data) >= self.settings.BARS:
+                            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).trendline_signal, = interval.trendline_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 = []
@@ -596,33 +653,33 @@ 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}_trendline": intervalObj.trendline_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:
@@ -630,7 +687,7 @@ class Tickers:
                     'lastcolor': "", 'bidcolor': "", 'askcolor': "", 'bid': 0.0, 'ask': 0.0, 'last': 0.0,
                     f"{period}_cb":0, f"{period}_barcolor": "", f"{period}_trend": "",
                     f"{period}_open": 0.0, f"{period}_close": 0.0, f"{period}_high": 0.0, f"{period}_low": 0.0,
-                    f"{period}_ema": "", f"{period}_macd": "", f"{period}_bbm": "", f"{period}_rsi": "", f"{period}_candle_trend": "", f"{period}_adx": ""
+                    f"{period}_ema": "", f"{period}_macd": "", f"{period}_bbm": "", f"{period}_rsi": "", f"{period}_trendline": "", f"{period}_candle_trend": "", f"{period}_adx": ""
                 }
                 df.fillna(fill_values, inplace=True)
                 df.set_index("symbol", inplace=True, drop=False) 
@@ -639,19 +696,21 @@ class Tickers:
                 trending_conditions = [
                     (
                         (df[f'{period}_trend']=='BUY') &
-                        (df[f'{period}_cb']>1) &
-                        (df[f'{period}_barcolor']==self.green) 
+                        (df[f'{period}_cb']>1) 
+                        #&
+                        #(df[f'{period}_barcolor']==self.green) 
                     ),
                     (
                         (df[f'{period}_trend']=='SELL') &
-                        (df[f'{period}_cb']>1) &
-                        (df[f'{period}_barcolor']==self.red) 
+                        (df[f'{period}_cb']>1) 
+                        #&
+                        #(df[f'{period}_barcolor']==self.red) 
                     )
                 ]
                 self.signaldf_filtered = df[np.any(trending_conditions, axis=0)].copy()
         except Exception as e:
             logger.info(f"Function: getCurrentData, {e}, {e.args}, {type(e).__name__}")
-            logger.info(traceback.logger.info_exc())
+            logger.info(traceback.print_exc())
         finally:
             del df, current_data
             gc.collect()       

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,13 @@ 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_PEAK_DISTANCE: int = Field(default=1, ge=0, le=30)
+    TRENDLINE_LOOKBACK: int = Field(default=20, ge=10, le=200)
+    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 +91,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.2.dist-info → bitunix_automated_crypto_trading-3.1.5.dist-info}/METADATA

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

bitunix_automated_crypto_trading-3.1.5.dist-info/RECORD

@@ -0,0 +1,18 @@
+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=TOseCeTNpCwVcReXRvHoq1sQybhoiIkFvATbu05wQ8c,67215
+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/SupportResistance.py,sha256=Dx4uBC4On-GO1t2EFk02jzSmZzaMD48mUJI9rG2rgMo,4946
+bitunix_automated_crypto_trading/ThreadManager.py,sha256=WmYRQu8aNrgp5HwSqpBqX1WESNSEpbD2CznPFpd9HuI,2330
+bitunix_automated_crypto_trading/TickerManager.py,sha256=JTlXUL9GadRjloK6Gw2HhacjvIe31CiiIFl1KGkWztA,37444
+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=zeNmV1KK8Yv5cHzBxaly0lmcjwSZEBAMUm_OvFSBCK4,4922
+bitunix_automated_crypto_trading/logger.py,sha256=tAaTQcv5r--zupk_Fhfe1USfBAzSiXzVa4QRnaOFIFY,2933
+bitunix_automated_crypto_trading-3.1.5.dist-info/METADATA,sha256=YJdYd5cjlCI7XA-Ef9WMVDCnblI22sSxyX--HmMcK-Q,996
+bitunix_automated_crypto_trading-3.1.5.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
+bitunix_automated_crypto_trading-3.1.5.dist-info/entry_points.txt,sha256=UXREYHuSl2XYd_tOtLIq0zg3d1kX3lixX5SpN8yGBw4,82
+bitunix_automated_crypto_trading-3.1.5.dist-info/top_level.txt,sha256=uyFzHUCOsp8elnG2Ovor6xXcf7dxRxY-C-Txiwix64Q,33
+bitunix_automated_crypto_trading-3.1.5.dist-info/RECORD,,

{bitunix_automated_crypto_trading-3.1.2.dist-info → bitunix_automated_crypto_trading-3.1.5.dist-info}/WHEEL

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

bitunix_automated_crypto_trading-3.1.2.dist-info/RECORD

@@ -1,17 +0,0 @@
-bitunix_automated_crypto_trading/AsyncThreadRunner.py,sha256=LJ6ny1KSCVoIbfeNypsY4aHYcbkGME9M3epQ9e8B1O8,3224
-bitunix_automated_crypto_trading/BitunixApi.py,sha256=gmhWi83k4EHOMIY7ZPa3x2NuIgVyzH13Sjk9AlVKjtQ,11163
-bitunix_automated_crypto_trading/BitunixSignal.py,sha256=z8-mvwZOR1VAAmrgy9HjgFyv-IRx1GxogcXjwCPJ4oY,64687
-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=g9Imr3uJijWeLqJbmCDrcDBwCHaBXV6P6sse73akmTA,33082
-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.2.dist-info/METADATA,sha256=5hhgVdOaJ-kqG0zdmen-OXVGpvBtXJxXjoU-tg_8-WI,996
-bitunix_automated_crypto_trading-3.1.2.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-bitunix_automated_crypto_trading-3.1.2.dist-info/entry_points.txt,sha256=UXREYHuSl2XYd_tOtLIq0zg3d1kX3lixX5SpN8yGBw4,82
-bitunix_automated_crypto_trading-3.1.2.dist-info/top_level.txt,sha256=uyFzHUCOsp8elnG2Ovor6xXcf7dxRxY-C-Txiwix64Q,33
-bitunix_automated_crypto_trading-3.1.2.dist-info/RECORD,,