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

bitunix_automated_crypto_trading/BitunixSignal.py

@@ -99,19 +99,23 @@ class BitunixSignal:
         self.tickerObjects.update_settings(settings)
         
     async def load_tickers(self):
-        symbols = await self.bitunixApi.GetTickerList(float(self.settings.THRESHOLD), float(self.settings.MIN_VOLUME))
-        self.pendingPositions= await self.bitunixApi.GetPendingPositionData()
-        self.pendingOrders= await self.bitunixApi.GetPendingOrderData()
-        olist=[]
-        plist=[]
-        if self.pendingPositions:
-            plist = [entry['symbol'] for entry in self.pendingPositions]
-        if self.pendingOrders['orderList']:
-            olist = [entry['symbol'] for entry in self.pendingOrders['orderList']]
-        newlist=olist+plist+list(set(symbols))
-        self.tickerList=newlist[:300]
-        self.tickerList.remove("STMXUSDT")
-        #self.tickerList=['PIXELUSDT']
+        if self.settings.TICKERS=="":
+            symbols = await self.bitunixApi.GetTickerList(float(self.settings.THRESHOLD), float(self.settings.MIN_VOLUME))
+            self.pendingPositions= await self.bitunixApi.GetPendingPositionData()
+            self.pendingOrders= await self.bitunixApi.GetPendingOrderData()
+            olist=[]
+            plist=[]
+            if self.pendingPositions:
+                plist = [entry['symbol'] for entry in self.pendingPositions]
+            if self.pendingOrders['orderList']:
+                olist = [entry['symbol'] for entry in self.pendingOrders['orderList']]
+            newlist=olist+plist+list(set(symbols))
+            self.tickerList=newlist[:300]
+            self.tickerList.remove("STMXUSDT")
+            #self.tickerList=['POLUSDT']
+        else:
+            self.tickerList = self.settings.TICKERS.split(",")
+            self.tickerList = [sym.strip().upper() for sym in self.tickerList if sym.strip()]
 
         [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 +275,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 +284,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 +302,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 +310,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 +319,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 +335,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 +563,17 @@ 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}_bos",
+                             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}_bos",
+                                      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}_bos",                                                               
+                                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 +587,8 @@ 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}_bos",
+                        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])
@@ -644,7 +650,7 @@ class BitunixSignal:
                     #open position upto a max of max_auto_trades from the signal list
                     df=self.signaldf.copy(deep=False)
                     for index, row in df.iterrows():
-                        side = "BUY" if row[f'{period}_barcolor'] == self.green else "SELL" if row[f'{period}_barcolor'] == self.red else ""
+                        side = "BUY" if row[f'{period}_barcolor'] == self.green and row[f'{period}_trend'] == "BUY"  else "SELL" if row[f'{period}_barcolor'] == self.red and row[f'{period}_trend'] == "SELL" else ""
                         if side != "":
                             select = True
                             self.pendingPositions = await self.bitunixApi.GetPendingPositionData({'symbol': row.symbol})
@@ -693,7 +699,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 +885,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":
@@ -914,8 +955,8 @@ class BitunixSignal:
                                     continue
 
                             # candle reversed
-                            if self.settings.CANDLE_TREND_STUDY and self.settings.CANDLE_TREND_CHECK_ON_CLOSE:
-                                if row.side == 'BUY' and self.signaldf_full.at[row.symbol, f'{period}_barcolor'] == self.red and self.signaldf_full.at[row.symbol, f'{period}_candle_trend'] == "BEARISH":
+                            if self.settings.CANDLE_TREND_STUDY and self.settings.CANDLE_TREND_REVERSAL_CHECK_ON_CLOSE:
+                                if row.side == 'BUY' and self.signaldf_full.at[row.symbol, f'{period}_barcolor'] == self.red and self.signaldf_full.at[row.symbol, f'{period}_cb'] > 1 and self.signaldf_full.at[row.symbol, f'{period}_candle_trend'] == "BULLISH":
                                     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
 
@@ -932,7 +973,7 @@ class BitunixSignal:
                                     )
                                     continue
 
-                                if row.side == 'SELL' and self.signaldf_full.at[row.symbol, f'{period}_barcolor'] == self.green  and self.signaldf_full.at[row.symbol, f'{period}_candle_trend'] == "BULLISH":
+                                if row.side == 'SELL' and self.signaldf_full.at[row.symbol, f'{period}_barcolor'] == self.green and self.signaldf_full.at[row.symbol, f'{period}_cb'] > 1 and self.signaldf_full.at[row.symbol, f'{period}_candle_trend'] == "BULLISH":
                                     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
 
@@ -951,7 +992,7 @@ class BitunixSignal:
 
                     await asyncio.sleep(0)
             
-                self.lastAutoTradeTime = time.time()
+            self.lastAutoTradeTime = time.time()
         except Exception as e:
             stack = traceback.extract_stack()
             function_name = stack[-1].name

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):
@@ -96,6 +63,20 @@ class Interval:
                 # Get the last color and its consecutive count
                 self.signal_strength = df['Consecutive'].iloc[-1]
 
+                # Break of Strcuture
+                if self.settings.BOS_STUDY:
+                    high = df.iloc[:-1]['high'].max()
+                    low = df.iloc[:-1]['low'].min()
+                    close = df['close'].iloc[-1]
+                    if close > high:
+                        self.bos_signal = "BUY"
+                    elif close < low:
+                        self.bos_signal = "SELL"
+                    else:
+                        self.bos_signal = "HOLD"
+                else:
+                    self.bos_signal = "HOLD"
+
                 # Calculate the Moving Averages
                 if self.settings.EMA_STUDY:
                     df['ma_fast'] = talib.EMA(df['close'], timeperiod=self.settings.MA_FAST)
@@ -149,6 +130,14 @@ class Interval:
                             else:
                                 self.ema_open_signal = "HOLD"
                                 self.ema_close_signal = "HOLD"
+
+                            if self.settings.EMA_CLOSE_ON_FAST_MEDIUM:
+                                if df['close'].iloc[-1] > df['ma_fast'].iloc[-1] and df['ma_fast'].iloc[-1] > df['ma_medium'].iloc[-1]:
+                                    self.ema_close_signal = "BUY"
+                                elif df['close'].iloc[-1] < df['ma_fast'].iloc[-1] and df['ma_fast'].iloc[-1] < df['ma_medium'].iloc[-1]:
+                                    self.ema_close_signal = "SELL"
+                                else:
+                                    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')
@@ -258,14 +247,28 @@ 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 self.settings.TRENDLINE_BREAKOUT:
+                                if df['close'].iloc[-2] > df['support_line'].iloc[-2] and df['open'].iloc[-1] > df['support_line'].iloc[-1] and df['close'].iloc[-1] > df['open'].iloc[-1]:     
+                                        self.trendline_signal = "BUY"
+                                elif df['close'].iloc[-2] < df['resistance_line'].iloc[-2] and df['open'].iloc[-1] < df['resistance_line'].iloc[-1] and df['close'].iloc[-1] < df['open'].iloc[-1]:     
+                                        self.trendline_signal = "SELL"
+                                else:
+                                    self.trendline_signal = "HOLD"
+                            else:
+                                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"
+                                else:
+                                    self.trendline_signal = "HOLD"
  
                 # Calculate the ADX
                 if self.settings.ADX_STUDY:
@@ -311,10 +314,12 @@ class Interval:
 
                     # Check for BUY signal
                     buy_conditions = (
+                        (self.settings.BOS_STUDY and self.bos_signal == "BUY") or
                         (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
@@ -323,10 +328,12 @@ class Interval:
 
                     # Check for SELL signal
                     sell_conditions = (
+                        (self.settings.BOS_STUDY and self.bos_signal == "SELL") or
                         (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
@@ -341,16 +348,34 @@ class Interval:
                     else:
                         self.current_signal = "HOLD"
                 else:
-                    # If EMA is enabled and crossing and MACD is enabled and crossing and BBM is enabled and crossing and RSI is enbabled and crossing
-                    # and 
-                    # ADX is enabled and strong and candle trend is enabled and bullish
-                    # then BUY or SELL
                     buy_conditions = (
-                        (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")
+                        (self.settings.BOS_STUDY and self.bos_signal == "BUY")
+                        or not self.settings.BOS_STUDY
+                    ) and (
+                        (self.settings.EMA_STUDY and self.settings.EMA_CHECK_ON_OPEN and self.ema_open_signal == "BUY")
+                        or not self.settings.EMA_STUDY or not self.settings.EMA_CHECK_ON_OPEN
+                    ) and (
+                        (self.settings.MACD_STUDY and self.settings.MACD_CHECK_ON_OPEN and self.macd_signal == "BUY")
+                        or not self.settings.MACD_STUDY or not self.settings.MACD_CHECK_ON_OPEN
+                    ) and (
+                        (self.settings.BBM_STUDY and self.settings.BBM_CHECK_ON_OPEN and self.bbm_signal == "BUY")
+                        or not self.settings.BBM_STUDY or not self.settings.BBM_CHECK_ON_OPEN
+                    ) and (
+                        (self.settings.RSI_STUDY and self.settings.RSI_CHECK_ON_OPEN and self.rsi_signal == "BUY")
+                        or not self.settings.RSI_STUDY or not self.settings.RSI_CHECK_ON_OPEN
+                    ) and (
+                        (self.settings.TRENDLINE_STUDY and self.settings.TRENDLINE_CHECK_ON_OPEN and self.trendline_signal == "BUY")
+                        or not self.settings.TRENDLINE_STUDY or not self.settings.TRENDLINE_CHECK_ON_OPEN
                     )
+                    if not any([
+                        self.settings.EMA_STUDY, self.settings.MACD_STUDY, self.settings.BBM_STUDY,
+                        self.settings.RSI_STUDY, self.settings.TRENDLINE_STUDY
+                    ]) and not any([
+                        self.settings.EMA_CHECK_ON_OPEN, self.settings.MACD_CHECK_ON_OPEN, self.settings.BBM_CHECK_ON_OPEN,
+                        self.settings.RSI_CHECK_ON_OPEN, self.settings.TRENDLINE_CHECK_ON_OPEN
+                    ]):
+                        buy_conditions = False
+
                     additional_buy_conditions = (
                         (not self.settings.ADX_STUDY or not self.settings.ADX_CHECK_ON_OPEN or self.adx_signal == "STRONG") and
                         (not self.settings.CANDLE_TREND_STUDY or not self.settings.CANDLE_TREND_CHECK_ON_OPEN or self.candle_trend == "BULLISH")
@@ -358,14 +383,36 @@ class Interval:
 
                     # Check for SELL signal
                     sell_conditions = (
-                        (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")
+                        (self.settings.BOS_STUDY and self.bos_signal == "SELL")
+                        or not self.settings.BOS_STUDY
+                    ) and (
+                        (self.settings.EMA_STUDY and self.settings.EMA_CHECK_ON_OPEN and self.ema_open_signal == "SELL")
+                        or not self.settings.EMA_STUDY or not self.settings.EMA_CHECK_ON_OPEN
+                    ) and (
+                        (self.settings.MACD_STUDY and self.settings.MACD_CHECK_ON_OPEN and self.macd_signal == "SELL")
+                        or not self.settings.MACD_STUDY or not self.settings.MACD_CHECK_ON_OPEN
+                    ) and (
+                        (self.settings.BBM_STUDY and self.settings.BBM_CHECK_ON_OPEN and self.bbm_signal == "SELL")
+                        or not self.settings.BBM_STUDY or not self.settings.BBM_CHECK_ON_OPEN
+                    ) and (
+                        (self.settings.RSI_STUDY and self.settings.RSI_CHECK_ON_OPEN and self.rsi_signal == "SELL")
+                        or not self.settings.RSI_STUDY or not self.settings.RSI_CHECK_ON_OPEN
+                    ) and (
+                        (self.settings.TRENDLINE_STUDY and self.settings.TRENDLINE_CHECK_ON_OPEN and self.trendline_signal == "SELL")
+                        or not self.settings.TRENDLINE_STUDY or not self.settings.TRENDLINE_CHECK_ON_OPEN
                     )
+                    if not any([
+                        self.settings.EMA_STUDY, self.settings.MACD_STUDY, self.settings.BBM_STUDY,
+                        self.settings.RSI_STUDY, self.settings.TRENDLINE_STUDY
+                    ]) and not any([
+                        self.settings.EMA_CHECK_ON_OPEN, self.settings.MACD_CHECK_ON_OPEN, self.settings.BBM_CHECK_ON_OPEN,
+                        self.settings.RSI_CHECK_ON_OPEN, self.settings.TRENDLINE_CHECK_ON_OPEN
+                    ]):
+                        sell_conditions = False
+
                     additional_sell_conditions = (
-                        (not self.settings.ADX_STUDY or not self.settings.ADX_CHECK_ON_OPEN or self.adx_signal == "STRONG") and
-                        (not self.settings.CANDLE_TREND_STUDY or not self.settings.CANDLE_TREND_CHECK_ON_OPEN or self.candle_trend == "BEARISH")
+                        (self.settings.ADX_STUDY and self.settings.ADX_CHECK_ON_OPEN and self.adx_signal == "STRONG") or
+                        (self.settings.CANDLE_TREND_STUDY and self.settings.CANDLE_TREND_CHECK_ON_OPEN or self.candle_trend == "BEARISH")
                     )
 
                     # Determine current signal
@@ -379,7 +426,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 +578,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,14 +686,16 @@ 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).bos_signal = interval.bos_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 
@@ -678,11 +727,14 @@ class Tickers:
                             f"{period}_trend": intervalObj.current_signal,
                             f"{period}_cb": intervalObj.signal_strength,
                             f"{period}_barcolor": lastcandle['barcolor'],
+                            f"{period}_bos": intervalObj.bos_signal,
+                            f"{period}_ema_open": intervalObj.ema_open_signal,
                             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,
@@ -704,7 +756,8 @@ 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}_bos": "", 
+                    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 +766,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

@@ -6,11 +6,14 @@ import sqlite3
 class Settings(BaseSettings):
     # Start autotrading on start
     AUTOTRADE: bool = Field(default=False)
+    
+    #Ticker list
+    TICKERS:str = Field(default="")
+    THRESHOLD: float = Field(default=5.0, ge=0.0)
+    MIN_VOLUME: int = Field(default=10_000_000, ge=0)
 
     # Trading Parameters
     LEVERAGE: int = Field(default=20, ge=1, le=100)
-    THRESHOLD: float = Field(default=5.0, ge=0.0)
-    MIN_VOLUME: int = Field(default=10_000_000, ge=0)
     ORDER_AMOUNT_PERCENTAGE: float = Field(default=0.01, ge=0.0, le=100)
     MAX_AUTO_TRADES: int = Field(default=10, ge=0)
     PROFIT_AMOUNT: float = Field(default=0.25, ge=0.0)
@@ -34,6 +37,7 @@ class Settings(BaseSettings):
     # Technical Indicators
     OPEN_ON_ANY_SIGNAL: bool = Field(default=True)
 
+    BOS_STUDY: bool = Field(default=True)
     EMA_CHART: bool = Field(default=True)
     EMA_STUDY: bool = Field(default=True)
     EMA_CROSSING: bool = Field(default=False)
@@ -59,9 +63,10 @@ class Settings(BaseSettings):
     RSI_CHECK_ON_OPEN: bool = Field(default=False)
     RSI_CHECK_ON_CLOSE: bool = Field(default=False)
 
+    TRENDLINE_PEAK_DISTANCE: int = Field(default=1, ge=0, le=30)
     TRENDLINE_CHART: bool = Field(default=True)
     TRENDLINE_STUDY: bool = Field(default=True)
-    TRENDLINE_LOOKBACK: int = Field(default=20, ge=10, le=100)
+    TRENDLINE_BREAKOUT: bool = Field(default=False)
     TRENDLINE_CHECK_ON_OPEN: bool = Field(default=False)
     TRENDLINE_CHECK_ON_CLOSE: bool = Field(default=False)
 
@@ -71,7 +76,7 @@ class Settings(BaseSettings):
 
     CANDLE_TREND_STUDY: bool = Field(default=True)
     CANDLE_TREND_CHECK_ON_OPEN: bool = Field(default=False)
-    CANDLE_TREND_CHECK_ON_CLOSE: bool = Field(default=False)
+    CANDLE_TREND_REVERSAL_CHECK_ON_CLOSE: bool = Field(default=False)
 
     # Time Intervals
     SCREEN_REFRESH_INTERVAL: int = Field(default=1, ge=1)
@@ -100,6 +105,7 @@ class Settings(BaseSettings):
         # Specify the file name for loading environment variables
         env_file = os.path.dirname(os.path.abspath(__file__))+"/config.txt"
 
+   
     @classmethod
     def load_from_db(cls, db_path: str, table_name: str = "settings"):
         # Connect to SQLite database

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bitunix_automated_crypto_trading
-Version: 3.1.3
+Version: 3.1.6
 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.6.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=JIJumU3nYcO_NRS5xMqrPeisMIiy_TM0EOEA5nr44cQ,67993
 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=n2GyvfH2YMuZ31Q_IcLd4U3ZOEIOLhLwMIR8iI5Gp5A,41460
 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=aBBHdkMnw4ODzcwQl1CCx_r1O08hShDRGlSA6JXt5lg,5024
 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.6.dist-info/METADATA,sha256=CzoCXqOg2hhZOrZZ9UMEnC3ohtqNrWEi6xT17G7pjq0,996
+bitunix_automated_crypto_trading-3.1.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+bitunix_automated_crypto_trading-3.1.6.dist-info/entry_points.txt,sha256=UXREYHuSl2XYd_tOtLIq0zg3d1kX3lixX5SpN8yGBw4,82
+bitunix_automated_crypto_trading-3.1.6.dist-info/top_level.txt,sha256=uyFzHUCOsp8elnG2Ovor6xXcf7dxRxY-C-Txiwix64Q,33
+bitunix_automated_crypto_trading-3.1.6.dist-info/RECORD,,

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

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