bitunix-automated-crypto-trading 2.6.0__py3-none-any.whl → 2.6.1__py3-none-any.whl

bitunix_automated_crypto_trading/bitunix.py

@@ -0,0 +1,593 @@
+import asyncio
+import os
+import uvicorn
+import numpy as np
+import pandas as pd
+import json
+import time
+from datetime import datetime
+import pytz
+from ThreadManager import ThreadManager
+from BitunixApi import BitunixApi
+from BitunixSignal import BitunixSignal
+from NotificationManager import NotificationManager
+
+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
+from fastapi.templating import Jinja2Templates
+
+from fastapi.security import OAuth2PasswordRequestForm
+from fastapi_login import LoginManager
+from fastapi_login.exceptions import InvalidCredentialsException
+from DataFrameHtmlRenderer import DataFrameHtmlRenderer
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+
+from dotenv import load_dotenv, dotenv_values, set_key
+from config import Settings
+from pydantic import ValidationError
+
+ENV_FILE = ".env"
+CONFIG_FILE = "bitunix_automated_crypto_trading/config.txt"
+LOG_FILE = "app.log"
+
+#load environment variables
+load_dotenv(ENV_FILE)
+API_KEY = os.getenv('API_KEY')
+SECRET_KEY = os.getenv('SECRET_KEY')
+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()
+
+class bitunix():
+    def __init__(self, password, api_key, secret_key, settings):
+        self.screen_refresh_interval =settings.SCREEN_REFRESH_INTERVAL
+
+        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.websocket_connections = set()
+        self.DB = {"admin": {"password": password}}
+
+    async def update_settings(self, settings):
+        self.settings = settings
+        await self.bitunixSignal.update_settings(settings)
+        await self.bitunixApi.update_settings(settings)
+
+    async def start(self):
+        await asyncio.create_task(self.bitunixSignal.load_tickers())
+        await asyncio.create_task(self.bitunixSignal.start_jobs())
+
+    async def restart(self):
+       await asyncio.create_task(self.bitunixSignal.restart_jobs())
+
+    async def send_message_to_websocket(self,message):
+        async def send_to_all():
+            for ws in self.bitunixSignal.websocket_connections:
+                await ws.send_text(message)
+        asyncio.run(send_to_all())
+
+    async def send_async_message_to_websocket(self,message):
+            for ws in self.bitunixSignal.websocket_connections:
+                await ws.send_text(message)
+
+app = FastAPI()
+app.mount("/static", StaticFiles(directory="bitunix_automated_crypto_trading/static"), name="static")
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Adjust this for production
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+templates = Jinja2Templates(directory="bitunix_automated_crypto_trading/templates")
+SECRET=os.getenv('SECRET')
+login_manager = LoginManager(SECRET, token_url="/auth/login", use_cookie=True)
+login_manager.cookie_name = "auth_token"
+
+
+@app.post("/auth/login")
+async def login(data: OAuth2PasswordRequestForm = Depends()):
+    start=time.time()
+    username = data.username
+    password = data.password
+
+    user = load_user(username, some_callable_object)
+    if not user or password != user["password"]:
+        raise InvalidCredentialsException
+    access_token = login_manager.create_access_token(data={"sub": username})
+    response = RedirectResponse(url="/main", status_code=302)
+    login_manager.set_cookie(response, access_token)
+    logger.info(f"/auth/login: elapsed time {time.time()-start}")
+    return response
+
+def some_callable_object():
+    logger.info("called")
+
+@login_manager.user_loader(some_callable=some_callable_object)
+def load_user(username, some_callable=some_callable_object):
+    user = bitunix.DB.get(username)
+    return user
+
+@app.get("/private")
+async def get_private_endpoint(user=Depends(login_manager)):
+    return "You are an authenticated user"
+
+@app.on_event("startup")
+async def startup_event():
+    await asyncio.create_task(get_server_states(app, settings))
+    await bitunix.start()
+
+#load inital states for html
+async def get_server_states(app, settings):
+    app.state.element_states = {}
+    app.state.element_states['autoTrade']=settings.AUTOTRADE
+    app.state.element_states['optionMovingAverage']=settings.OPTION_MOVING_AVERAGE
+    app.state.element_states['maxAutoTrades']=settings.MAX_AUTO_TRADES
+
+@app.post("/reload")
+async def refresh_detected():
+    bitunix.bitunixSignal.notifications.add_notification("Reload detected!")
+    await asyncio.create_task(bitunix.restart())
+
+@app.post("/save_states")
+async def save_states(states: dict):
+    app.state.element_states.update(states)
+    return {"message": "States saved"}
+
+@app.post("/get_states")
+async def get_states(payload: dict):
+    element_ids = payload.get("element_ids", [])
+    states = {element_id: app.state.element_states.get(element_id, "No state found") for element_id in element_ids}
+    return {"states": states}
+
+async def set_server_states():
+    settings.AUTOTRADE = True if app.state.element_states['autoTrade']=='true' else False
+
+    if settings.AUTOTRADE:
+        settings.OPTION_MOVING_AVERAGE = app.state.element_states['optionMovingAverage']
+        settings.notifications.add_notification(f"optionMovingAverage: {settings.OPTION_MOVING_AVERAGE}")
+
+        settings.PROFIT_AMOUNT = app.state.element_states['profitAmount']
+        settings.notifications.add_notification(f"profitAmount: {settings.PROFIT_AMOUNT}")
+
+        settings.LOSS_AMOUNT = app.state.element_states['lossAmount']
+        settings.notifications.add_notification(f"lossAmount: {settings.LOSS_AMOUNT}")
+
+        settings.MAX_AUTO_TRADES = app.state.element_states['maxAutoTrades']
+        settings.notifications.add_notification(f"maxAutoTrades: {settings.MAX_AUTO_TRADES}")
+
+    settings.notifications.add_notification(" AutoTrade activated" if settings.AUTOTRADE else "AutoTrade de-activated")
+
+
+@app.post("/autotrade")
+async def handle_autotrade():
+    await asyncio.create_task(set_server_states())
+    return {"status":settings.AUTOTRADE}
+
+@app.get("/", response_class=HTMLResponse)
+async def read_root(request: Request):
+    return templates.TemplateResponse({"request": request}, "login.html")
+
+#when main page requested
+@app.get("/main", response_class=HTMLResponse)
+async def main_page(request: Request,  user=Depends(login_manager)):
+    return templates.TemplateResponse({"request": request, "user": user}, "main.html")
+
+#when main page opened
+@app.websocket("/wsmain")
+async def websocket_endpoint(websocket: WebSocket):
+    await asyncio.create_task(wsmain(websocket))
+
+async def wsmain(websocket):
+    query_params = websocket.query_params
+
+    try:
+        logger.info("local main page WebSocket connection opened")
+
+        await websocket.accept()
+        bitunix.websocket_connections.add(websocket)
+
+        queue = asyncio.Queue()
+        queueTask = asyncio.create_task(send_data_queue(websocket, queue))
+        while True:
+            stime=time.time()
+            data={}
+            try:
+
+                # Handle incoming ping messages
+                await asyncio.create_task(send_pong(websocket,queue))
+
+                #combined data
+                dataframes={
+                    "portfolio" : bitunix.bitunixSignal.portfoliodfStyle,
+                    "positions" : bitunix.bitunixSignal.positiondfStyle,
+                    "orders" : bitunix.bitunixSignal.orderdfStyle,
+                    "signals" : bitunix.bitunixSignal.signaldfStyle,
+                    "study" : bitunix.bitunixSignal.allsignaldfStyle,
+                    "positionHistory" : bitunix.bitunixSignal.positionHistorydfStyle
+                }
+                notifications=bitunix.bitunixSignal.notifications.get_notifications()
+
+                utc_time = datetime.fromtimestamp(bitunix.bitunixSignal.lastAutoTradeTime, tz=pytz.UTC)
+                atctime = utc_time.astimezone(pytz.timezone('US/Central')).strftime('%Y-%m-%d %H:%M:%S')
+                utc_time = datetime.fromtimestamp(bitunix.bitunixSignal.lastTickerDataTime, tz=pytz.UTC)
+                tdctime = utc_time.astimezone(pytz.timezone('US/Central')).strftime('%Y-%m-%d %H:%M:%S')
+
+                data = {
+                    "dataframes": dataframes,
+                    "profit" : bitunix.bitunixSignal.profit,
+                    "atctime": atctime,
+                    "tdctime": tdctime,
+                    "status_messages": [] if len(notifications)==0 else notifications
+                }
+
+                await queue.put(json.dumps(data))
+
+            except WebSocketDisconnect:
+                bitunix.websocket_connections.remove(websocket)
+                logger.info("local main page WebSocket connection closed")
+                break
+            except Exception as e:
+                logger.info(f"local main page websocket unexpected error1: {e}")
+                break
+
+            elapsed_time = time.time() - stime
+
+            if settings.VERBOSE_LOGGING:
+                logger.info(f"wsmain: elapsed time {elapsed_time}")
+            time_to_wait = max(0.01, bitunix.screen_refresh_interval - elapsed_time)
+
+            await asyncio.sleep(time_to_wait)
+
+    except Exception as e:
+        logger.info(f"local main page websocket unexpected error2: {e}")
+    finally:
+        queueTask.cancel()
+        try:
+            await queueTask
+        except asyncio.CancelledError:
+            pass
+
+async def send_pong(websocket, queue):
+    # Handle incoming ping messages
+    try:
+        message = await asyncio.wait_for(websocket.receive_text(), timeout=0.01)
+        if message == "ping":
+            await queue.put("pong")
+    except asyncio.TimeoutError:
+        pass
+
+async def send_data_queue(websocket, queue):
+    while True:
+        try:
+            data = await queue.get()
+            await websocket.send_text(data)
+        except Exception as e:
+            pass
+
+@app.get("/send-message/{msg}")
+async def send_message(msg: str):
+    await asyncio.create_task(bitunix.send_message_to_websocket(msg))
+    return {"message": f"Sent: {msg}"}
+
+
+@app.post("/handle_bitunix_click")
+async def handle_bitunix_click(symbol: str = Form(...)):
+    # Handle the row click event here
+    message = f"https://www.bitunix.com/contract-trade/{symbol}"
+    return {"message": message}
+
+@app.post("/handle_order_close_click")
+async def handle_order_close_click(symbol: str = Form(...), orderId: str = Form(...)):
+    datajs = await bitunix.bitunixApi.CancelOrder(symbol, orderId)
+    bitunix.bitunixSignal.notifications.add_notification(f'closing pending order for {symbol} {datajs["msg"]}')
+
+@app.post("/handle_close_click")
+async def handle_close_click(symbol: str = Form(...), positionId: str = Form(...), qty: str = Form(...), unrealizedPNL: str = Form(...), realizedPNL: str = Form(...)):
+    datajs = await bitunix.bitunixApi.FlashClose(positionId)
+    pnl=float(unrealizedPNL)+float(realizedPNL)
+    bitunix.bitunixSignal.notifications.add_notification(f'closing {qty} {symbol} with a profit/loss of {pnl} ({datajs["code"]} {datajs["msg"]}')
+
+@app.post("/handle_buy_click")
+async def handle_buy_click(symbol: str = Form(...), close: str = Form(...)):
+    balance = bitunix.bitunixSignal.get_portfolio_tradable_balance()
+    qty= str(balance * (float(settings.ORDER_AMOUNT_PERCENTAGE) / 100) / float(close) * int(settings.LEVERAGE))
+    datajs = await bitunix.bitunixApi.PlaceOrder(symbol,qty,close,'BUY')
+    bitunix.bitunixSignal.notifications.add_notification(f'Buying {qty} {symbol} @ {close} ({datajs["code"]} {datajs["msg"]})')
+
+@app.post("/handle_add_click")
+async def handle_add_click(symbol: str = Form(...), close: str = Form(...)):
+    row = bitunix.bitunixSignal.positiondf.loc[bitunix.bitunixSignal.positiondf['symbol'] == symbol]
+    if not row.empty:
+        balance = float(bitunix.bitunixSignal.portfoliodf["available"])+float(bitunix.bitunixSignal.portfoliodf["crossUnrealizedPNL"])
+        qty= str(balance * (float(settings.ORDER_AMOUNT_PERCENTAGE) / 100) / float(close) * int(settings.LEVERAGE))
+        datajs = await bitunix.bitunixApi.PlaceOrder(symbol,qty,close,row['side'].values[0])
+        bitunix.bitunixSignal.notifications.add_notification(f'adding {row["side"].values[0]} {qty} {symbol} @ {close} ({datajs["code"]} {datajs["msg"]})')
+
+@app.post("/handle_sell_click")
+async def handle_sell_click(symbol: str = Form(...), close: str = Form(...)):
+    balance = bitunix.bitunixSignal.get_portfolio_tradable_balance()
+    qty= str(balance * (float(settings.ORDER_AMOUNT_PERCENTAGE) / 100) / float(close) * int(settings.LEVERAGE))
+    datajs = await bitunix.bitunixApi.PlaceOrder(symbol,qty,close,'SELL')
+    bitunix.bitunixSignal.notifications.add_notification(f'Selling {qty} {symbol} @ {close} ({datajs["code"]} {datajs["msg"]})')
+
+@app.post("/handle_reduce_click")
+async def handle_reduce_click(symbol: str = Form(...), positionId: str = Form(...), qty: str = Form(...),  close: str = Form(...)):
+    row = bitunix.bitunixSignal.positiondf.loc[bitunix.bitunixSignal.positiondf['symbol'] == symbol]
+    if not row.empty:
+        balance = bitunix.bitunixSignal.get_portfolio_tradable_balance()
+        qty= str(float(qty) / 2)
+        datajs = await bitunix.bitunixApi.PlaceOrder(symbol,qty,close,'BUY' if row['side'].values[0]=='SELL' else 'SELL',positionId=positionId, reduceOnly=True)
+        bitunix.bitunixSignal.notifications.add_notification(f'reducing {row["side"]} {qty} {symbol} @ {close} ({datajs["code"]} {datajs["msg"]})')
+
+@app.post("/handle_charts_click")
+async def handle_charts_click(symbol: str = Form(...)):
+    chart_url = f"/charts?symbol={symbol}"
+    return JSONResponse(content={"message": chart_url})
+
+# when charts page requested (multiple period)
+@app.get("/charts", response_class=HTMLResponse)
+async def show_charts(request: Request, symbol: str):
+    return templates.TemplateResponse({"request": request, "data": symbol}, "charts.html")
+
+# when charts page opened (multiple period)
+@app.websocket("/wscharts")
+async def websocket_endpoint(websocket: WebSocket):
+    await asyncio.create_task(wscharts(websocket))
+
+async def wscharts(websocket):
+    query_params = websocket.query_params
+    ticker = query_params.get("ticker")
+
+    try:
+        logger.info("local charts page WebSocket connection opened")
+
+        await websocket.accept()
+        bitunix.websocket_connections.add(websocket)
+
+        queue = asyncio.Queue()
+        queueTask = asyncio.create_task(send_data_queue(websocket, queue))
+
+        while True:
+            stime=time.time()
+            try:
+
+                # Handle incoming ping messages
+                await asyncio.create_task(send_pong(websocket,queue))
+
+                if ticker in bitunix.bitunixSignal.tickerObjects.symbols():
+                    bars=settings.BARS
+                    chart1m=list(bitunix.bitunixSignal.tickerObjects.get(ticker).get_interval_ticks('1m').get_data()[-bars:])
+                    chart5m=list(bitunix.bitunixSignal.tickerObjects.get(ticker).get_interval_ticks('5m').get_data()[-bars:])
+                    chart15m=list(bitunix.bitunixSignal.tickerObjects.get(ticker).get_interval_ticks('15m').get_data()[-bars:])
+                    chart1h=list(bitunix.bitunixSignal.tickerObjects.get(ticker).get_interval_ticks('1h').get_data()[-bars:])
+                    chart1d=list(bitunix.bitunixSignal.tickerObjects.get(ticker).get_interval_ticks('1d').get_data()[-bars:])
+                    buysell=list(bitunix.bitunixSignal.tickerObjects.get(ticker).trades)
+                    close=bitunix.bitunixSignal.tickerObjects.get(ticker).get_last()
+
+                    data = {
+                        "symbol": ticker,
+                        "close":close,
+                        "chart1m":chart1m,
+                        "chart5m":chart5m,
+                        "chart15m":chart15m,
+                        "chart1h":chart1h,
+                        "chart1d":chart1d,
+                        "buysell": buysell,
+                        "ema_study": settings.EMA_STUDY,
+                        "ema_chart": settings.EMA_CHART,
+                        "macd_study": settings.MACD_STUDY,
+                        "macd_chart": settings.MACD_CHART,
+                        "bbm_study": settings.BBM_STUDY,
+                        "bbm_chart": settings.BBM_CHART,
+                        "rsi_study": settings.RSI_STUDY,
+                        "rsi_chart": settings.RSI_CHART,
+                    }
+
+                    await queue.put(json.dumps(data))
+
+            except WebSocketDisconnect:
+                bitunix.websocket_connections.remove(websocket)
+                logger.info("local charts page WebSocket connection closed")
+                break
+            except Exception as e:
+                logger.info(f"local charts page websocket unexpected error1: {e}")
+                break
+
+
+            elapsed_time = time.time() - stime
+            if settings.VERBOSE_LOGGING:
+                logger.info(f"wscharts: elapsed time {elapsed_time}")
+            time_to_wait = max(0.01, bitunix.screen_refresh_interval - elapsed_time)
+            await asyncio.sleep(time_to_wait)
+    except Exception as e:
+        logger.info(f"local charts page websocket unexpected error2: {e}")
+    finally:
+        queueTask.cancel()
+        try:
+            await queueTask
+        except asyncio.CancelledError:
+            pass
+
+# when modal chart page requested (current period)
+@app.get("/chart", response_class=HTMLResponse)
+async def chart_page(request: Request):
+    return templates.TemplateResponse("modal-chart.html", {"request": request})
+
+# when chart page opened (current period)
+@app.websocket("/wschart")
+async def websocket_endpoint(websocket: WebSocket):
+    await asyncio.create_task(wschart(websocket))
+
+async def wschart(websocket):
+    query_params = websocket.query_params
+    ticker = query_params.get("ticker")
+
+    try:
+        logger.info("local chart page WebSocket connection opened")
+
+        await websocket.accept()
+        bitunix.websocket_connections.add(websocket)
+
+        queue = asyncio.Queue()
+        queueTask = asyncio.create_task(send_data_queue(websocket, queue))
+
+        while True:
+            stime=time.time()
+            try:
+
+                # Handle incoming ping messages
+                await asyncio.create_task(send_pong(websocket,queue))
+
+                if ticker in bitunix.bitunixSignal.tickerObjects.symbols():
+                    period=settings.OPTION_MOVING_AVERAGE
+                    bars=settings.BARS
+                    chart=list(bitunix.bitunixSignal.tickerObjects.get(ticker).get_interval_ticks(period).get_data()[-bars:])
+                    buysell=list(bitunix.bitunixSignal.tickerObjects.get(ticker).trades)
+                    close=bitunix.bitunixSignal.tickerObjects.get(ticker).get_last()
+                    data = {
+                        "symbol": ticker,
+                        "close":close,
+                        "chart":chart,
+                        "buysell": buysell,
+                        "period": period,
+                        "ema_study": settings.EMA_STUDY,
+                        "ema_chart": settings.EMA_CHART,
+                        "macd_study": settings.MACD_STUDY,
+                        "macd_chart": settings.MACD_CHART,
+                        "bbm_study": settings.BBM_STUDY,
+                        "bbm_chart": settings.BBM_CHART,
+                        "rsi_study": settings.RSI_STUDY,
+                        "rsi_chart": settings.RSI_CHART,
+                    }
+
+                    await queue.put(json.dumps(data))
+
+            except WebSocketDisconnect:
+                bitunix.websocket_connections.remove(websocket)
+                logger.info("local chart page WebSocket connection closed")
+                break
+            except Exception as e:
+                logger.info(f"local chart page websocket unexpected error1: {e}")
+                break
+
+
+            elapsed_time = time.time() - stime
+            if settings.VERBOSE_LOGGING:
+                logger.info(f"wschart: elapsed time {elapsed_time}")
+            time_to_wait = max(0.01, bitunix.screen_refresh_interval - elapsed_time)
+            await asyncio.sleep(time_to_wait)
+    except Exception as e:
+        logger.info(f"local chart page websocket unexpected error2: {e}")
+    finally:
+        queueTask.cancel()
+        try:
+            await queueTask
+        except asyncio.CancelledError:
+            pass
+
+@app.get("/config", response_class=HTMLResponse)
+async def config_page(request: Request):
+    return templates.TemplateResponse("modal-config.html", {"request": request})
+
+@app.get("/get-config")
+async def get_env_variables():
+    config = read_config(CONFIG_FILE)  # Load .env variables
+    return JSONResponse(content=config)
+
+# Save updated environment variables
+@app.post("/save-config")
+async def save_env_variable(key: str = Form(...), value: str = Form(...)):
+    global settings
+    # Read the existing configuration
+    config = read_config(CONFIG_FILE)
+    # Temporarily update the config dictionary for validation
+    config[key] = value
+    try:
+        # Test the new configuration using the Settings class
+        temp_settings = Settings(**config)
+        # Write the valid configuration back to the file
+        write_config(CONFIG_FILE, config)
+        settings = temp_settings
+        await bitunix.update_settings(settings)
+        await asyncio.create_task(get_server_states(app, settings))
+        bitunix.bitunixSignal.notifications.add_notification(f"Updated {key} = {value} successfully")
+        return {"message": f"Updated {key} = {value} successfully"}
+    except ValidationError as e:
+        bitunix.bitunixSignal.notifications.add_notification(f"{key} = {value} validation failed {e.errors()}")
+        return {"error": f"Validation failed, details: {e.errors()}"}
+
+def read_config(file_path):
+    """Read the config file into a dictionary."""
+    config = {}
+    if os.path.exists(file_path):
+        with open(file_path, "r") as file:
+            for line in file:
+                if "=" in line:
+                    key, value = line.strip().split("=", 1)
+                    config[key] = value
+    return config
+
+def write_config(file_path, config):
+    """Write the dictionary back to the config file."""
+    with open(file_path, "w") as file:
+        for key, value in config.items():
+            file.write(f"{key}={value}\n")
+
+@app.get("/logs", response_class=HTMLResponse)
+async def log_page(request: Request):
+    return templates.TemplateResponse("modal-logs.html", {"request": request})
+
+@app.websocket("/wslogs")
+async def websocket_endpoint(websocket: WebSocket):
+    await websocket.accept()  # Accept the WebSocket connection
+    await stream_log_file(websocket)
+
+async def stream_log_file(websocket: WebSocket):
+    try:
+        with open(LOG_FILE, "r") as log_file:
+            # Read all lines into memory
+            lines = log_file.readlines()
+            # Determine starting point: offset_from_end
+            start_index = max(len(lines) - 100, 0)
+            for line in lines[start_index:]:  # Yield existing lines from offset
+                await websocket.send_text(line)
+            # Stream new lines added to the file
+            log_file.seek(0, 2)  # Go to the end of the file
+            while True:
+                line = log_file.readline()
+                if not line:
+                    await asyncio.sleep(0.1)  # Wait briefly if no new line is added
+                    continue
+                await websocket.send_text(line)
+    except WebSocketDisconnect:
+        print("log Client disconnected. Stopping the log stream.")
+
+
+def main():
+    global bitunix
+    bitunix = bitunix(PASSWORD, API_KEY, SECRET_KEY, settings)
+    bitunix.bitunixSignal.notifications.add_notification(f"Starting....................")
+    import uvicorn
+    if settings.VERBOSE_LOGGING:
+        llevel = "debug"
+    else:
+        llevel = "error"
+    config1 = uvicorn.Config(app, host=HOST, port=8000, log_level=llevel, reload=False)
+    server = uvicorn.Server(config1)
+    server.run()
+
+if __name__ == '__main__':
+    main()
+

bitunix_automated_crypto_trading/clearenv.py

@@ -0,0 +1,8 @@
+import os
+
+# Clear all environment variables
+for key in list(os.environ.keys()):
+    del os.environ[key]
+
+# Verify that all environment variables are cleared
+print(os.environ)

bitunix_automated_crypto_trading/config.py

@@ -0,0 +1,90 @@
+from pydantic import Field, SecretStr, validator
+from pydantic_settings import BaseSettings
+import os
+
+class Settings(BaseSettings):
+    # Start autotrading on start
+    AUTOTRADE: bool = Field(default=False)
+
+    # 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)
+    LOSS_AMOUNT: float = Field(default=5.0, ge=0.0)
+    OPTION_MOVING_AVERAGE: str = Field(default="1h")
+    BARS: int = Field(default=100, ge=1)
+
+    # Technical Indicators Parameters
+    MA_FAST: int = Field(default=12, ge=1)
+    MA_MEDIUM: int = Field(default=26, ge=1)
+    MA_SLOW: int = Field(default=50, ge=1)
+    RSI_FAST: int = Field(default=6, ge=1)
+    RSI_SLOW: int = Field(default=24, ge=1)
+    BBM_PERIOD: int = Field(default=20, ge=1)
+    BBM_STD: int = Field(default=2, ge=1)
+    MACD_PERIOD: int = Field(default=9, ge=1)
+    MACD_SHORT: int = Field(default=12, ge=1)
+    MACD_LONG: int = Field(default=26, ge=1)
+    ADX_PERIOD: int = Field(default=14, ge=1)
+
+    # Technical Indicators
+    OPEN_ON_ANY_SIGNAL: bool = Field(default=True)
+
+    EMA_CHART: bool = Field(default=True)
+    EMA_STUDY: bool = Field(default=True)
+    EMA_CROSSING: bool = Field(default=False)
+    EMA_CHECK_ON_OPEN: bool = Field(default=True)
+    EMA_CHECK_ON_CLOSE: bool = Field(default=True)
+
+    MACD_CHART: bool = Field(default=False)
+    MACD_STUDY: bool = Field(default=True)
+    MACD_CROSSING: bool = Field(default=False)
+    MACD_CHECK_ON_OPEN: bool = Field(default=False)
+    MACD_CHECK_ON_CLOSE: bool = Field(default=False)
+
+    BBM_CHART: bool = Field(default=False)
+    BBM_STUDY: bool = Field(default=True)
+    BBM_CROSSING: bool = Field(default=False)
+    BBM_CHECK_ON_OPEN: bool = Field(default=False)
+    BBM_CHECK_ON_CLOSE: bool = Field(default=False)
+
+    RSI_CHART: bool = Field(default=False)
+    RSI_STUDY: bool = Field(default=True)
+    RSI_CROSSING: bool = Field(default=False)
+    RSI_CHECK_ON_OPEN: bool = Field(default=False)
+    RSI_CHECK_ON_CLOSE: bool = Field(default=False)
+
+    ADX_STUDY: bool = Field(default=True)
+    ADX_CHECK_ON_OPEN: bool = Field(default=False)
+    ADX_CHECK_ON_CLOSE: bool = Field(default=False)
+
+    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)
+
+    # Time Intervals
+    SCREEN_REFRESH_INTERVAL: int = Field(default=1, ge=1)
+    SIGNAL_CHECK_INTERVAL: int = Field(default=15, ge=1)
+    PORTFOLIO_API_INTERVAL: int = Field(default=3, ge=1)
+    PENDING_POSITIONS_API_INTERVAL: int = Field(default=3, ge=1)
+    PENDING_ORDERS_API_INTERVAL: int = Field(default=3, ge=1)
+    TRADE_HISTORY_API_INTERVAL: int = Field(default=3, ge=1)
+    POSITION_HISTORY_API_INTERVAL: int = Field(default=3, ge=1)
+    TICKER_DATA_API_INTERVAL: int = Field(default=30, ge=1)
+    PUBLIC_WEBSOCKET_RESTART_INTERVAL: int = Field(default=10_800, ge=1)
+
+    # Use websocket or API
+    USE_PUBLIC_WEBSOCKET: bool = Field(default=False)  # If there is lagging issue then use API
+
+    # Logger
+    VERBOSE_LOGGING: bool = Field(default=False)
+
+    # Benchmark
+    BENCHMARK: bool = Field(default=False)
+
+    class Config:
+        # Specify the file name for loading environment variables
+        env_file = "bitunix_automated_crypto_trading/config.txt"