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

bitunix_automated_crypto_trading/BitunixSignal.py

@@ -111,7 +111,7 @@ class BitunixSignal:
         newlist=olist+plist+list(set(symbols))
         self.tickerList=newlist[:300]
         self.tickerList.remove("STMXUSDT")
-        #self.tickerList=['PIXELUSDT']
+        #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") 
@@ -271,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):
@@ -285,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:
@@ -300,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 
             
@@ -308,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:
@@ -322,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:
@@ -335,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 
 
@@ -563,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:
@@ -582,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])
@@ -693,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
@@ -879,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"
@@ -39,51 +44,13 @@ class Interval:
         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 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):
@@ -258,14 +225,24 @@ class Interval:
 
                 #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)
+                    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:
@@ -314,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
@@ -326,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
@@ -349,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
@@ -361,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
@@ -379,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()            
@@ -531,7 +512,7 @@ class Ticker:
 
         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:
@@ -639,7 +620,7 @@ class Tickers:
                 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:
+                        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
@@ -647,6 +628,7 @@ class Tickers:
                             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 
@@ -683,6 +665,7 @@ class Tickers:
                             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,
@@ -704,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) 
@@ -713,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/config.py

@@ -61,7 +61,8 @@ class Settings(BaseSettings):
 
     TRENDLINE_CHART: bool = Field(default=True)
     TRENDLINE_STUDY: bool = Field(default=True)
-    TRENDLINE_LOOKBACK: int = Field(default=20, ge=10, le=100)
+    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)
 

{bitunix_automated_crypto_trading-3.1.3.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.3
+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.3.dist-info → bitunix_automated_crypto_trading-3.1.5.dist-info}/RECORD

@@ -1,17 +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=17_VPwagjax-vFJ-A20cMApcyBtPCGdzis8EhAVoNrk,64734
+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=W4UuW1RyU_4w_6IV0eDOlJ0PUFNorQOY9Ust4bI-69s,36785
+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=Jj1AXFU9c3RHKRnxnAS7lJ6UIyfl6qRByoVbOVrEz1k,4857
+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.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.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.3.dist-info → bitunix_automated_crypto_trading-3.1.5.dist-info}/WHEEL

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