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

bitunix_automated_crypto_trading/SupportResistance.py

@@ -1,10 +1,7 @@
 import pandas as pd
 import numpy as np
 from scipy.signal import find_peaks
-
-class SupportResistance:
-    import pandas as pd
-import numpy as np
+import talib
 
 class SupportResistance:
     def _find_peaks(self, prices, prominence=None, distance=None):
@@ -33,7 +30,7 @@ class SupportResistance:
         intercept = price1 - slope * index1
         return slope * np.arange(length) + intercept
 
-    def support_resistance_trend_lines(self, data, lookback=20, prominence=None, distance=None):
+    def support_resistance_trend_lines(self, data, lookback=24, prominence=None, distance=None):
         if data is None or len(data) < lookback:
             return pd.DataFrame()
         try:
@@ -44,39 +41,69 @@ class SupportResistance:
 
             # 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
+            if len(peak_indices_all) > 0:
+                if len(peak_indices_all) >= 2:
+                    resistance_line_full = self._get_line(peak_indices_all[-1], high_prices[peak_indices_all[-1]],
+                                                        peak_indices_all[-2], high_prices[peak_indices_all[-2]], lookback)
+                    # Set values before the second peak to NaN
+                    resistance_line[peak_indices_all[-2]:] = resistance_line_full[peak_indices_all[-2]:]
+                elif len(peak_indices_all) == 1:
+                    resistance_line[peak_indices_all[-1]:] = high_prices[peak_indices_all[-1]] # Horizontal line from the peak onwards
+
+            if len(trough_indices_all) > 0:
+                if len(trough_indices_all) >= 2:
+                    support_line_full = self._get_line(trough_indices_all[-1], low_prices[trough_indices_all[-1]],
+                                                    trough_indices_all[-2], low_prices[trough_indices_all[-2]], lookback)
+                    # Set values before the second trough to NaN
+                    support_line[trough_indices_all[-2]:] = support_line_full[trough_indices_all[-2]:]
+                elif len(trough_indices_all) == 1:
+                    support_line[trough_indices_all[-1]:] = low_prices[trough_indices_all[-1]] # 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"trendline error occurred: {e}")
+            return pd.DataFrame()
+        
+    def support_resistance_bos_lines(self, data, length, lookback=24):
+        if data is None or len(data) < lookback:
+            return pd.DataFrame()
+        try:
+            recent_data = data.iloc[-length:].copy()
+            highs = recent_data['high'].values
+            high_prices = np.full_like(highs, np.nan, dtype=np.float64)
+            high_prices[-lookback:] = highs[-lookback:]
+            
+            lows = recent_data['low'].values
+            low_prices = np.full_like(lows, np.nan, dtype=np.float64)
+            low_prices[-lookback:] = lows[-lookback:]
+
+            ts = recent_data['time'].values
+
+            support_line = np.full(length, np.nan)
+            resistance_line = np.full(length, np.nan)
+
+            # Find all local peaks and troughs and its highest and lowest values
+            peak_indices_all = self._find_peaks(high_prices)
+            if len(peak_indices_all) == 0:
+                highest_peak_index = peak_indices_all[np.argmax(high_prices[peak_indices_all])]
+                highest_peak_value = high_prices[highest_peak_index]
+                resistance_line[highest_peak_index:] = high_prices[highest_peak_index] # Horizontal line from the highest point onwards
+
+            trough_indices_all = self._find_troughs(low_prices)
+            if len(trough_indices_all) == 0:
+                lowest_peak_index = trough_indices_all[np.argmin(low_prices[trough_indices_all])]
+                lowest_peak_value = low_prices[lowest_peak_index]
+                support_line[lowest_peak_index:] = low_prices[lowest_peak_index] # Horizontal line from the lowset point onwards
 
             results_df = pd.DataFrame({
                 'time': ts,
@@ -85,5 +112,6 @@ class SupportResistance:
             })
             return results_df
         except Exception as e:
-            print(f"An error occurred: {e}")
-            return pd.DataFrame()
+            print(f"bos error occurred: {e}")
+            return pd.DataFrame()
+

bitunix_automated_crypto_trading/ThreadManager.py

@@ -10,7 +10,7 @@
 import time
 import threading
 from logger import Logger
-logger = Logger(__name__).get_logger()
+global LOG_FILE
 
 def job_func(*args, **kwargs):
     print(f"Job running with arguments: {args}, {kwargs}")        
@@ -20,13 +20,14 @@ def run_threaded(job_func, args):
     job_thread.start()
 
 class ManagedThread(threading.Thread):
-    def __init__(self, interval, target, *args, **kwargs):
+    def __init__(self, interval, target, logger, *args, **kwargs):
         super().__init__()
         self.target = target
         self.interval = interval
         self.args = args
         self.kwargs = kwargs
         self._stop_event = threading.Event()
+        self.logger = logger
 
     def run(self):
         while not self._stop_event.is_set():
@@ -34,7 +35,7 @@ class ManagedThread(threading.Thread):
             try:
                 self.target(self, *self.args, **self.kwargs)
             except Exception as e:
-                logger.info(f"error in thread {self.name}, {e}, {e.args}, {type(e).__name__}")  
+                self.logger.info(f"error in thread {self.name}, {e}, {e.args}, {type(e).__name__}")  
             elapsed_time = time.time() - stime
             if self.interval==0:
                 break

bitunix_automated_crypto_trading/TickerManager.py

@@ -7,25 +7,27 @@ import asyncio
 import talib
 import traceback
 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):
+    def __init__(self, symbol, intervalId, delta, data, settings, logger):
         self.symbol = symbol
         self.intervalId = intervalId
         self.delta = delta
         self.settings=settings
         self._data = data
+        self.logger = logger
+        
         
         #these signals are used to list stocks in the signals sections on the main page
         self.current_signal="HOLD"
         self.ema_open_signal="HOLD"
         self.ema_close_signal="HOLD"
         self.trendline_signal = "HOLD"
+        self.bos_signal = "HOLD"
         self.macd_signal="HOLD"
         self.bbm_signal="HOLD"
         self.rsi_signal="HOLD"
@@ -63,20 +65,6 @@ 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)
@@ -245,27 +233,47 @@ class Interval:
                     # Drop RSI columns if not used
                     df.drop(['rsi_fast', 'rsi_slow', 'rsi_slope', 'rsi_angle'], axis=1, inplace=True, errors='ignore')  
 
+                # Break of Strcuture
+                if self.settings.BOS_STUDY:
+                    df_sr= sr.support_resistance_bos_lines(df[['time','open', 'high', 'low', 'close']], len(df), self.settings.BOS_PERIOD)
+                    if df_sr is not None and len(df_sr) >= 1:
+                        df['bos_support_line'] = df_sr['support_line']
+                        df['bos_resistance_line'] = df_sr['resistance_line']
+                        df.fillna({'bos_support_line':0}, inplace=True)
+                        df.fillna({'bos_resistance_line':0}, inplace=True)
+
+                        if df['high'].size > 1 and df['low'].size > 1 and df['close'].size > 1:
+                            if df['close'].iloc[-1] > df['bos_resistance_line'].iloc[-1]:    
+                                self.bos_signal = "BUY"
+                            elif df['close'].iloc[-1] < df['bos_support_line'].iloc[-1]:
+                                self.bos_signal = "SELL"
+                            else:
+                                self.bos_signal = "HOLD"
+                        else:
+                            self.bos_signal = "HOLD"
+
                 #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)
+                        df['trend_support_line'] = df_sr['support_line']
+                        df['trend_resistance_line'] = df_sr['resistance_line']
+                        df.fillna({'trend_support_line':0}, inplace=True)
+                        df.fillna({'trend_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]:     
+                                if df['close'].iloc[-1] > df['trend_resistance_line'].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]:     
+                                elif df['close'].iloc[-1] < df['trend_support_line'].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]:
+                                if df['close'].iloc[-1] < df['trend_resistance_line'].iloc[-1]  and df['close'].iloc[-2] < df['open'].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]:
+                                elif df['close'].iloc[-1] > df['trend_support_line'].iloc[-1] and df['close'].iloc[-2] > df['open'].iloc[-2] and df['close'].iloc[-1] > df['open'].iloc[-1]:
                                     self.trendline_signal = "BUY"
                                 else:
                                     self.trendline_signal = "HOLD"
@@ -314,7 +322,7 @@ class Interval:
 
                     # Check for BUY signal
                     buy_conditions = (
-                        (self.settings.BOS_STUDY and self.bos_signal == "BUY") or
+                        (self.settings.BOS_STUDY and self.settings.BOS_CHECK_ON_OPEN 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
@@ -328,7 +336,7 @@ class Interval:
 
                     # Check for SELL signal
                     sell_conditions = (
-                        (self.settings.BOS_STUDY and self.bos_signal == "SELL") or
+                        (self.settings.BOS_STUDY and self.settings.BOS_CHECK_ON_OPEN 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
@@ -349,7 +357,7 @@ class Interval:
                         self.current_signal = "HOLD"
                 else:
                     buy_conditions = (
-                        (self.settings.BOS_STUDY and self.bos_signal == "BUY")
+                        (self.settings.BOS_STUDY and self.settings.BOS_CHECK_ON_OPEN 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")
@@ -383,7 +391,7 @@ class Interval:
 
                     # Check for SELL signal
                     sell_conditions = (
-                        (self.settings.BOS_STUDY and self.bos_signal == "SELL")
+                        (self.settings.BOS_STUDY and self.settings.BOS_CHECK_ON_OPEN 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")
@@ -425,8 +433,8 @@ class Interval:
                     
                    
             except Exception as e:
-                logger.info(f"Function: calculate_study, {e}, {e.args}, {type(e).__name__}")
-                logger.info(traceback.print_exc())
+                self.logger.info(f"Function: calculate_study, {e}, {e.args}, {type(e).__name__}")
+                self.logger.info(traceback.print_exc())
             retval =  df.to_dict('records')
             del df
             gc.collect()            
@@ -434,10 +442,10 @@ class Interval:
     
 class Ticker:
     
-    def __init__(self, symbol, intervalIds, settings):
+    def __init__(self, symbol, intervalIds, settings, logger):
         self.symbol=symbol
         self.settings=settings
-        
+        self.logger=logger
         self._ts=0
         self._bid = 0.0
         self.bidcolor = ""
@@ -448,11 +456,11 @@ class Ticker:
         self._mtv=0.0
         self.intervalIds=intervalIds
         self._intervals = {
-            '1m' : Interval(self.symbol, '1m', 60000,    [], self.settings),
-            '5m' : Interval(self.symbol, '5m', 300000,   [], self.settings),
-            '15m': Interval(self.symbol, '15m', 900000,  [], self.settings),
-            '1h' : Interval(self.symbol, '1h', 3600000,  [], self.settings),
-            '1d' : Interval(self.symbol, '1d', 86400000, [], self.settings),
+            '1m' : Interval(self.symbol, '1m', 60000,    [], self.settings, self.logger),
+            '5m' : Interval(self.symbol, '5m', 300000,   [], self.settings, self.logger),
+            '15m': Interval(self.symbol, '15m', 900000,  [], self.settings, self.logger),
+            '1h' : Interval(self.symbol, '1h', 3600000,  [], self.settings, self.logger),
+            '1d' : Interval(self.symbol, '1d', 86400000, [], self.settings, self.logger),
         }
         self.current_data={}
         self.trades = []
@@ -460,6 +468,8 @@ class Ticker:
         self.green="#A5DFDF"
         self.red="#FFB1C1"
         
+        self.logger = logger
+        
     def update_settings(self, settings):
         self.settings=settings
         for intervalId in self.intervalIds:
@@ -577,12 +587,12 @@ class Ticker:
             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.print_exc())
+            self.logger.info(f"Function: create_bar_with_last_and_ts, {e}, {e.args}, {type(e).__name__}")
+            self.logger.info(traceback.print_exc())
 
               
 class Tickers:
-    def __init__(self, settings):
+    def __init__(self, settings, logger):
         self.settings=settings
         
         self._tickerObjects={}
@@ -595,13 +605,15 @@ class Tickers:
         
         self.intervalIds=['1m','5m','15m','1h','1d']
         
+        self.logger = logger
+        
     def update_settings(self, settings):
         self.settings=settings
         for symbol in self._tickerObjects:
             self._tickerObjects[symbol].update_settings(settings)        
         
     def add(self, symbol):
-        ticker = Ticker(symbol, self.intervalIds, self.settings)
+        ticker = Ticker(symbol, self.intervalIds, self.settings, self.logger)
         self._tickerObjects[symbol]=ticker
 
     def get_tickerDict(self):
@@ -727,13 +739,13 @@ 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}_bos": intervalObj.bos_signal,
                             f"{period}_trendline": intervalObj.trendline_signal,
                             f"{period}_adx":intervalObj.adx_signal,                                       
                             f"{period}_candle_trend":intervalObj.candle_trend, 
@@ -779,8 +791,8 @@ class Tickers:
                 ]
                 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.print_exc())
+            self.logger.info(f"Function: getCurrentData, {e}, {e.args}, {type(e).__name__}")
+            self.logger.info(traceback.print_exc())
         finally:
             del df, current_data
             gc.collect()       

bitunix_automated_crypto_trading/bitunix.py

@@ -1,5 +1,6 @@
 import asyncio
 import os
+import sys
 import uvicorn
 import numpy as np
 import pandas as pd
@@ -17,7 +18,6 @@ from NotificationManager import NotificationManager
 from DataFrameHtmlRenderer import DataFrameHtmlRenderer
 from config import Settings
 from logger import Logger
-logger = Logger(__name__).get_logger()
 
 from fastapi import FastAPI, Request, Form, WebSocket, WebSocketDisconnect, Depends, Query
 from fastapi.responses import HTMLResponse , JSONResponse, RedirectResponse, StreamingResponse
@@ -34,9 +34,24 @@ from pydantic import ValidationError
 
 import sqlite3
 
-ENV_FILE = ".env"
-CONFIG_FILE = os.path.dirname(os.path.abspath(__file__))+"/config.txt"
-LOG_FILE = "app.log"
+
+global LOG_FILE
+global ENV_FILE
+global CONFIG_FILE
+global API_KEY
+global SECRET_KEY
+global SECRET
+global PASSWORD
+global HOST
+global port
+
+env_file = sys.argv[1] if len(sys.argv) > 1 else ".env"
+config_file=sys.argv[2] if len(sys.argv) > 2 else "config.txt"
+port = sys.argv[3] if len(sys.argv) > 3 else "8000"
+
+ENV_FILE = os.path.dirname(os.path.abspath(__file__))+"/"+env_file
+CONFIG_FILE = os.path.dirname(os.path.abspath(__file__))+"/"+config_file
+LOG_FILE = os.path.dirname(os.path.abspath(__file__))+"/"+config_file.replace(".txt", ".log")
 
 #load environment variables
 load_dotenv(ENV_FILE)
@@ -46,23 +61,24 @@ SECRET = os.getenv('SECRET')
 PASSWORD = os.getenv('PASSWORD')
 HOST = os.getenv('HOST')
 
-#load config variables using setting class in config.py validating using pydantic
-settings = Settings()
+logger = Logger(__name__, LOG_FILE).get_logger()
+
+#logger.info(f"secret: {SECRET}, api_key: {API_KEY}, secret_key: {SECRET_KEY}, password: {PASSWORD}, host: {HOST}, port: {port}, config_file: {config_file}")
 
 class bitunix():
-    def __init__(self, password, api_key, secret_key, settings):
+    def __init__(self, password, api_key, secret_key, settings, logger):
         self.screen_refresh_interval =settings.SCREEN_REFRESH_INTERVAL
-
+        self.logger=logger
         self.autoTrade=settings.AUTOTRADE
 
         self.threadManager = ThreadManager()
-        self.notifications = NotificationManager()
-        self.bitunixApi = BitunixApi(api_key, secret_key, settings)
-        self.bitunixSignal = BitunixSignal(api_key, secret_key, settings, self.threadManager, self.notifications, self.bitunixApi)
+        self.notifications = NotificationManager(logger)
+        self.bitunixApi = BitunixApi(api_key, secret_key, settings, self.logger)
+        self.bitunixSignal = BitunixSignal(api_key, secret_key, settings, self.threadManager, self.notifications, self.bitunixApi, self.logger)
 
         self.websocket_connections = set()
         self.DB = {"admin": {"password": password}}
-        
+
         #sqllite database connection
         self.connection = sqlite3.connect("bitunix.db") 
         #create table if not exist
@@ -104,7 +120,7 @@ app.add_middleware(
     allow_headers=["*"],
 )
 templates = Jinja2Templates(directory=os.path.dirname(os.path.abspath(__file__))+"/templates")
-SECRET=os.getenv('SECRET')
+#SECRET=os.getenv('SECRET')
 login_manager = LoginManager(SECRET, token_url="/auth/login", use_cookie=True)
 login_manager.cookie_name = "auth_token"
 
@@ -242,6 +258,7 @@ async def wsmain(websocket):
                     "profit" : bitunix.bitunixSignal.profit,
                     "atctime": atctime,
                     "tdctime": tdctime,
+                    "port" : port,
                     "status_messages": [] if len(notifications)==0 else notifications
                 }
 
@@ -402,6 +419,8 @@ async def wscharts(websocket):
                         "ema_chart": settings.EMA_CHART,
                         "trendline_study": settings.TRENDLINE_STUDY,
                         "trendline_chart": settings.TRENDLINE_CHART,
+                        "bos_study": settings.BOS_STUDY,
+                        "bos_chart": settings.BOS_CHART,
                         "macd_study": settings.MACD_STUDY,
                         "macd_chart": settings.MACD_CHART,
                         "bbm_study": settings.BBM_STUDY,
@@ -491,6 +510,8 @@ async def wschart(websocket):
                         "ema_chart": settings.EMA_CHART,
                         "trendline_study": settings.TRENDLINE_STUDY,
                         "trendline_chart": settings.TRENDLINE_CHART,
+                        "bos_study": settings.BOS_STUDY,
+                        "bos_chart": settings.BOS_CHART,
                         "macd_study": settings.MACD_STUDY,
                         "macd_chart": settings.MACD_CHART,
                         "bbm_study": settings.BBM_STUDY,
@@ -604,14 +625,19 @@ async def stream_log_file(websocket: WebSocket):
 
 def main():
     global bitunix
-    bitunix = bitunix(PASSWORD, API_KEY, SECRET_KEY, settings)
-    bitunix.bitunixSignal.notifications.add_notification(f"Starting....................")
+    global settings
+    
+    #load config variables using setting class in config.py validating using pydantic
+    settings = Settings()
+
+    bitunix = bitunix(PASSWORD, API_KEY, SECRET_KEY, settings, logger)
+    bitunix.bitunixSignal.notifications.add_notification(f"Starting auto trade on port {port} using {env_file} and {config_file} ....................")
     import uvicorn
     if settings.VERBOSE_LOGGING:
         llevel = "debug"
     else:
         llevel = "error"
-    config1 = uvicorn.Config(app, host=HOST, port=8000, log_level=llevel, reload=False)
+    config1 = uvicorn.Config(app, host=HOST, port=port, log_level=llevel, reload=False)
     server = uvicorn.Server(config1)
     server.run()
 

bitunix_automated_crypto_trading/config.py

@@ -1,6 +1,7 @@
 from pydantic import Field, SecretStr, validator
 from pydantic_settings import BaseSettings
 import os
+import sys
 import sqlite3
 
 class Settings(BaseSettings):
@@ -37,7 +38,12 @@ class Settings(BaseSettings):
     # Technical Indicators
     OPEN_ON_ANY_SIGNAL: bool = Field(default=True)
 
+    BOS_PERIOD: int = Field(default=20, ge=1)
     BOS_STUDY: bool = Field(default=True)
+    BOS_CHART: bool = Field(default=True)
+    BOS_CHECK_ON_OPEN: bool = Field(default=False)
+    BOS_CHECK_ON_CLOSE: bool = Field(default=False)
+
     EMA_CHART: bool = Field(default=True)
     EMA_STUDY: bool = Field(default=True)
     EMA_CROSSING: bool = Field(default=False)
@@ -103,7 +109,8 @@ class Settings(BaseSettings):
 
     class Config:
         # Specify the file name for loading environment variables
-        env_file = os.path.dirname(os.path.abspath(__file__))+"/config.txt"
+        config_file=sys.argv[2] if len(sys.argv) > 1 else "config.txt"
+        env_file = os.path.dirname(os.path.abspath(__file__))+"/"+config_file
 
    
     @classmethod

bitunix_automated_crypto_trading/logger.py

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

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

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

bitunix_automated_crypto_trading-3.1.8.dist-info/RECORD

@@ -0,0 +1,18 @@
+bitunix_automated_crypto_trading/AsyncThreadRunner.py,sha256=bNIM_1xRYQOFEsIn74EX6qVpC59-GMhhr2CeiPr_GWg,3253
+bitunix_automated_crypto_trading/BitunixApi.py,sha256=udgBwbWowf7v46jVVyfs-VjeNh9ajnghTiJf70lvn5w,11269
+bitunix_automated_crypto_trading/BitunixSignal.py,sha256=hZvu1FKhdHqESIUmDMMlVdnxsROnJHTMCfGSitrXNiM,70882
+bitunix_automated_crypto_trading/BitunixWebSocket.py,sha256=-_7wRAZxJXG63joBq2k3TUC4qd06v7Miki-LGVtNIDk,11234
+bitunix_automated_crypto_trading/DataFrameHtmlRenderer.py,sha256=Pqdzhh_nfIxFEZH9L_R5QXB8moDPbgeTGT_hmBkHWMg,2899
+bitunix_automated_crypto_trading/NotificationManager.py,sha256=exs6REABBA1omTeTGuUuECzxs5dGqdyL7oI8WyxS6Xc,798
+bitunix_automated_crypto_trading/SupportResistance.py,sha256=_aP9G_DQ16bHqZv8HdxIairqeZzqB8ipRUhBPijN7lk,5767
+bitunix_automated_crypto_trading/ThreadManager.py,sha256=Lw5_1EIT0m3AFSv5CIMpnjtA0DnNw2qQ6JtSpT34LyM,2349
+bitunix_automated_crypto_trading/TickerManager.py,sha256=B9HlgvBLIZ2skBCEojY0M0BS5ZvZR2rw4l25LhuTt1o,42307
+bitunix_automated_crypto_trading/__init__.py,sha256=1hzk6nX8NnUCr1tsq8oFq1qGCNhNwnwldWE75641Eew,78
+bitunix_automated_crypto_trading/bitunix.py,sha256=wEzJpa1Gv84tYJK1iV-kQVezbn1TxJuAk-CY7kwKShM,26887
+bitunix_automated_crypto_trading/config.py,sha256=cdbPFRNbDPw2mxEKL4asffVtfUcq_zM0zTVqY0o3Hg4,5300
+bitunix_automated_crypto_trading/logger.py,sha256=NHnA5JZdUFkTAhB7i-1iCAwrdf1fxhDuRvJUkbKPi9Y,2923
+bitunix_automated_crypto_trading-3.1.8.dist-info/METADATA,sha256=pMRfJvAcx91aQ8_8ltWv8Uo2IGn5s1nGBOQmdkgH-3U,996
+bitunix_automated_crypto_trading-3.1.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+bitunix_automated_crypto_trading-3.1.8.dist-info/entry_points.txt,sha256=UXREYHuSl2XYd_tOtLIq0zg3d1kX3lixX5SpN8yGBw4,82
+bitunix_automated_crypto_trading-3.1.8.dist-info/top_level.txt,sha256=uyFzHUCOsp8elnG2Ovor6xXcf7dxRxY-C-Txiwix64Q,33
+bitunix_automated_crypto_trading-3.1.8.dist-info/RECORD,,

bitunix_automated_crypto_trading-3.1.6.dist-info/RECORD

@@ -1,18 +0,0 @@
-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=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=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=aBBHdkMnw4ODzcwQl1CCx_r1O08hShDRGlSA6JXt5lg,5024
-bitunix_automated_crypto_trading/logger.py,sha256=tAaTQcv5r--zupk_Fhfe1USfBAzSiXzVa4QRnaOFIFY,2933
-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,,