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

bitunix_automated_crypto_trading/config.txt

@@ -0,0 +1,60 @@
+AUTOTRADE=True
+OPTION_MOVING_AVERAGE=1h
+MAX_AUTO_TRADES=10
+PROFIT_AMOUNT=0
+LOSS_AMOUNT=0
+LEVERAGE=20
+THRESHOLD=5
+MIN_VOLUME=10000000
+ORDER_AMOUNT_PERCENTAGE=5
+BARS=100
+MA_FAST=12
+MA_MEDIUM=26
+MA_SLOW=50
+RSI_FAST=6
+RSI_SLOW=24
+BBM_PERIOD=20
+BBM_STD=2
+MACD_PERIOD=9
+MACD_SHORT=12
+MACD_LONG=26
+ADX_PERIOD=14
+OPEN_ON_ANY_SIGNAL=True
+EMA_CHART=True
+EMA_STUDY=True
+EMA_CROSSING=True
+EMA_CHECK_ON_OPEN=True
+EMA_CHECK_ON_CLOSE=True
+MACD_CHART=False
+MACD_STUDY=True
+MACD_CROSSING=True
+MACD_CHECK_ON_OPEN=True
+MACD_CHECK_ON_CLOSE=False
+BBM_CHART=False
+BBM_STUDY=True
+BBM_CROSSING=True
+BBM_CHECK_ON_OPEN=True
+BBM_CHECK_ON_CLOSE=False
+RSI_CHART=False
+RSI_STUDY=True
+RSI_CROSSING=True
+RSI_CHECK_ON_OPEN=True
+RSI_CHECK_ON_CLOSE=False
+ADX_STUDY=True
+ADX_CHECK_ON_OPEN=True
+ADX_CHECK_ON_CLOSE=False
+CANDLE_TREND_STUDY=False
+CANDLE_TREND_CHECK_ON_OPEN=False
+CANDLE_TREND_CHECK_ON_CLOSE=False
+SCREEN_REFRESH_INTERVAL=1
+SIGNAL_CHECK_INTERVAL=30
+PORTFOLIO_API_INTERVAL=3
+PENDING_POSITIONS_API_INTERVAL=3
+PENDING_ORDERS_API_INTERVAL=3
+TRADE_HISTORY_API_INTERVAL=3
+POSITION_HISTORY_API_INTERVAL=3
+TICKER_DATA_API_INTERVAL=120
+PUBLIC_WEBSOCKET_RESTART_INTERVAL=10800
+USE_PUBLIC_WEBSOCKET=False
+VERBOSE_LOGGING=False
+BENCHMARK=False

bitunix_automated_crypto_trading/logger.py

@@ -0,0 +1,85 @@
+import logging
+import os
+from logging.handlers import RotatingFileHandler
+from datetime import datetime, timezone
+from zoneinfo import ZoneInfo
+from colorama import init, Fore, Style
+
+# Initialize colorama for Windows support
+init()
+
+class Colors:
+    RESET = Style.RESET_ALL
+    RED = Fore.RED
+    GREEN = Fore.GREEN
+    YELLOW = Fore.YELLOW
+    BLUE = Fore.BLUE
+    PURPLE = Fore.MAGENTA
+    CYAN = Fore.CYAN
+    LBLUE = Fore.LIGHTBLUE_EX
+
+
+class ColoredFormatter(logging.Formatter):
+    COLORS = {
+        'DEBUG': Colors.BLUE,
+        'INFO': Colors.GREEN,
+        'WARNING': Colors.YELLOW,
+        'ERROR': Colors.RED,
+        'CRITICAL': Colors.PURPLE,
+    }
+
+    def format(self, record):
+        # Add color to the level name
+        color = self.COLORS.get(record.levelname, Colors.RESET)
+        record.msg = f"{color}{record.msg}{Colors.RESET}"
+        return super().format(record)
+
+class CSTFormatter(logging.Formatter):
+    def formatTime(self, record, datefmt=None):
+        # Convert UTC time to CST
+        utc_time = datetime.fromtimestamp(record.created, tz=timezone.utc)
+        cst_time = utc_time.astimezone(ZoneInfo("US/Central"))
+        if datefmt:
+            return cst_time.strftime(datefmt)
+        else:
+            return cst_time.isoformat()
+
+class Logger:
+    def __init__(self, logger_name, log_file='app.log', level=logging.DEBUG, max_bytes=5 * 1024 * 1024, backup_count=3):
+        """
+        Initialize the logger.
+
+        :param logger_name: Name of the logger.
+        :param log_file: Log file path.
+        :param level: Logging level (default: DEBUG).
+        :param max_bytes: Max size of the log file before rotation (default: 5MB).
+        :param backup_count: Number of backup files to keep (default: 3).
+        """
+        # Create the logger
+        self.logger = logging.getLogger(logger_name)
+        self.logger.setLevel(level)
+        colors=Colors()
+
+        # Check if handlers are already attached
+        if not self.logger.handlers:
+            # Create a file handler with rotation
+            file_handler = RotatingFileHandler(log_file, maxBytes=max_bytes, backupCount=backup_count)
+            file_formatter = CSTFormatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s', datefmt='%Y-%m-%d %H:%M:%S')
+            file_handler.setFormatter(file_formatter)
+
+            # Create a console handler
+            console_handler = logging.StreamHandler()
+            console_formatter = CSTFormatter(f'{colors.RESET}%(asctime)s - %(name)s - %(levelname)s - %(message)s', datefmt='%Y-%m-%d %H:%M:%S')
+            console_handler.setFormatter(console_formatter)
+
+            # Add handlers to the logger
+            self.logger.addHandler(file_handler)
+            self.logger.addHandler(console_handler)
+
+    def get_logger(self):
+        """
+        Return the configured logger.
+
+        :return: Configured logger instance.
+        """
+        return self.logger

bitunix_automated_crypto_trading/sampleenv.txt

@@ -0,0 +1,5 @@
+API_KEY=your_api_key
+SECRET_KEY=your_secret_key
+SECRET=your_token_secret
+PASSWORD=whatever_is_here_is_your_webpage_password
+HOST=0.0.0.0 

bitunix_automated_crypto_trading/static/chart.css

@@ -0,0 +1,28 @@
+.chart-body { 
+    flex: 1;
+    display: flex;
+    flex-direction: column;
+    overflow-y: auto; /* Enable vertical scrolling */
+    height: calc(100vh - 100px); /* Ensure it accounts for header height */
+    box-sizing: border-box; /* Prevent height calculation issues due to padding */
+} 
+
+.chart-grid {
+    display: grid;
+    grid-template-columns: repeat(2, 1fr);
+    grid-template-rows: repeat(3, 1fr);
+    gap: 10px;
+    height: auto; /* Let the grid adapt naturally */
+    overflow-y: auto; /* Add vertical scrolling for grid */
+
+}
+.chart-container {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+}
+canvas {
+    width: 100% !important;
+    height: 100% !important;
+}
+

bitunix_automated_crypto_trading/static/chart.js

@@ -0,0 +1,362 @@
+const charts = {};
+
+const createOrUpdateChart = (
+    chartId, data, buysell, ema_study, ema_display, macd_study, macd_display, bbm_study, bbm_display, rsi_study, rsi_display, timeUnit
+) => {
+    const datasets = [];
+    const scales = {}; // Dynamic y-axis configuration
+
+    const studyColors = {
+        ema_slow: 'rgba(0, 123, 255, 0.7)',    // Blue for EMA Slow
+        ema_medium: 'rgba(255, 123, 0, 0.7)',  // Orange for EMA Medium
+        ema_fast: 'rgba(0, 255, 123, 0.7)',    // Green for EMA Fast
+        macd_line: 'rgba(255, 0, 0, 0.7)',     // Red for MACD Line
+        macd_signal: 'rgba(123, 0, 255, 0.7)', // Purple for MACD Signal
+        macd_histogram: 'rgba(123, 123, 123, 0.7)', // Gray for Histogram
+        bbl: 'rgba(0, 0, 255, 0.7)',           // Dark Blue for BBL
+        bbm: 'rgba(26, 26, 17, 0.7)',         // Dark Gray for BBM
+        bbu: 'rgba(0, 123, 0, 0.7)',            // Green for BBU
+        rsi_slow: 'rgba(112, 91, 99, 0.7)',    // Purple for RSI Slow
+        rsi_fast: 'rgba(156, 23, 23, 0.7)',    // Red for RSI Fast  
+    };
+
+    const candlestickData = data.map(d => ({
+        x: parseInt(d.time),
+        o: parseFloat(d.open),
+        h: parseFloat(d.high),
+        l: parseFloat(d.low),
+        c: parseFloat(d.close)
+    }));
+
+    const mapOptionalData = (data, key, yKey = key.replace('_', '')) => {
+        return data.filter(d => typeof d[key] !== 'undefined' && parseFloat(d[key]) !== 0).map(d => ({
+            x: parseInt(d.time),
+            y: parseFloat(d[key])
+        }));
+    };
+
+    const slowMA = mapOptionalData(data, 'ma_slow');
+    const mediumMA = mapOptionalData(data, 'ma_medium');
+    const fastMA = mapOptionalData(data, 'ma_fast');
+    const macdLine = mapOptionalData(data, 'MACD_Line');
+    const signalLine = mapOptionalData(data, 'MACD_Signal');
+    const macdHistogram = mapOptionalData(data, 'MACD_Histogram');
+    const BBL = mapOptionalData(data, 'BBL');
+    const BBM = mapOptionalData(data, 'BBM');
+    const BBU = mapOptionalData(data, 'BBU');
+    const rsi_slow = mapOptionalData(data, 'rsi_slow');
+    const rsi_fast = mapOptionalData(data, 'rsi_fast');
+
+    // Find the min and max time from candlestickData
+    const times = candlestickData.map(d => d.x);
+    const minTime = Math.min(...times);
+    const maxTime = Math.max(...times);
+
+    const buyselldata = buysell.filter(d => {
+        const time = parseInt(d.ctime);
+        return time >= minTime && time <= maxTime;
+    }).map(d => ({
+        x: parseInt(d.ctime),
+        y: parseFloat(d.price),
+        side: d.side,
+        backgroundColor: d.side === 'BUY' ? 'rgba(0, 255, 0, 0.9)' : 'rgba(255, 0, 0, 0.9)', // Color based on buy/sell
+        borderColor: d.side === 'BUY' ? 'rgba(0, 255, 0, 1)' : 'rgba(255, 0, 0, 1)',
+        borderWidth: 2,
+        pointRadius: 5, // Increased for better visibility
+        pointStyle: 'triangle' // Changed for better visibility
+    }));
+
+    const timeSettings = {
+        second: { unit: 'second', stepSize: 1, displayFormats: { second: 'HH:mm:ss' } },
+        minute: { unit: 'minute', stepSize: 1, displayFormats: { minute: 'HH:mm' } },
+        hour: { unit: 'hour', stepSize: 1, displayFormats: { hour: 'HH:mm' } },
+        day: { unit: 'day', stepSize: 1, displayFormats: { day: 'MMM dd' } }
+    };
+
+    const timeConfig = timeSettings[timeUnit] || timeSettings['second'];
+
+
+    // Candlestick Data
+    scales['y-axis'] = {
+        type: 'linear',
+        position: 'left',
+        title: { display: true, text: 'CandleStick' }
+    };
+
+    datasets.push({
+        type: 'candlestick',
+        label: 'Candlestick Data',
+        data: candlestickData,
+        borderColor: 'rgba(0, 0, 0, 1)',
+        backgroundColor: 'rgba(75, 192, 192, 0.2)',
+        yAxisID: 'y-axis' // Unique y-axis ID
+    });
+
+    // EMA Study
+    if (ema_study) {
+        datasets.push({
+            label: 'EMA Slow',
+            data: slowMA,
+            backgroundColor: studyColors.ema_slow,
+            borderColor: studyColors.ema_slow,
+            borderWidth: 1,
+            fill: false,
+            type: 'line',
+            pointRadius: 0,
+            yAxisID: 'y-axis',
+            hidden: true
+        });
+    
+        datasets.push({
+            label: 'EMA Medium',
+            data: mediumMA,
+            backgroundColor: studyColors.ema_medium,
+            borderColor: studyColors.ema_medium,
+            borderWidth: 1,
+            fill: false,
+            type: 'line',
+            pointRadius: 0,
+            yAxisID: 'y-axis',
+            hidden: !ema_display // Hide if not displayed
+        });
+
+        datasets.push({
+            label: 'EMA Fast',
+            data: fastMA,
+            backgroundColor: studyColors.ema_fast,
+            borderColor: studyColors.ema_fast,
+            borderWidth: 1,
+            fill: false,
+            type: 'line',
+            pointRadius: 0,
+            yAxisID: 'y-axis',
+            hidden: !ema_display // Hide if not displayed
+        });
+    }
+
+    // BBM Study
+    if (bbm_study) {
+        datasets.push({
+            label: 'BBU',
+            data: BBU,
+            backgroundColor: studyColors.bbu,
+            borderColor: studyColors.bbu,
+            borderWidth: 1,
+            fill: false,
+            type: 'line',
+            pointRadius: 0,
+            yAxisID: 'y-axis',
+            hidden: !bbm_display // Hide if not displayed
+        });
+
+        datasets.push({
+            label: 'BBM',
+            data: BBM,
+            backgroundColor: studyColors.bbm,
+            borderColor: studyColors.bbm,
+            borderWidth: 1,
+            fill: false,
+            type: 'line',
+            pointRadius: 0,
+            yAxisID: 'y-axis',
+            hidden: !bbm_display // Hide if not displayed
+        });
+
+        datasets.push({
+            label: 'BBL',
+            data: BBL,
+            backgroundColor: studyColors.bbl,
+            borderColor: studyColors.bbl,
+            borderWidth: 1,
+            fill: false,
+            type: 'line',
+            pointRadius: 0,
+            yAxisID: 'y-axis',
+            hidden: !bbm_display // Hide if not displayed
+        });
+    }
+
+    // MACD Study
+    if (macd_study) {
+
+        scales['y-axis-macd'] = {
+            type: 'linear',
+            position: 'left',
+            title: { display: true, text: 'MACD' }
+        };
+
+        datasets.push({
+            label: 'MACD Line',
+            data: macdLine,
+            backgroundColor: studyColors.macd_line,
+            borderColor: studyColors.macd_line,
+            borderWidth: 1,
+            fill: false,
+            type: 'line',
+            pointRadius: 0,
+            yAxisID: 'y-axis-macd',
+            hidden: !macd_display // Hide if not displayed
+        });
+
+        datasets.push({
+            label: 'MACD Signal',
+            data: signalLine,
+            backgroundColor: studyColors.macd_signal,
+            borderColor: studyColors.macd_signal,
+            borderWidth: 1,
+            fill: false,
+            type: 'line',
+            pointRadius: 0,
+            yAxisID: 'y-axis-macd',
+            hidden: !macd_display // Hide if not displayed
+        });
+
+        scales['y-axis-macd-histogram'] = {
+            type: 'linear',
+            position: 'left',
+            title: { display: true, text: 'MACD Histogram' }
+        };
+        datasets.push({
+            label: 'MACD Histogram',
+            data: macdHistogram,
+            backgroundColor: studyColors.macd_histogram,
+            borderColor: studyColors.macd_histogram,
+            borderWidth: 0,
+            type: 'bar',
+            yAxisID: 'y-axis-macd-histogram',
+            hidden: true
+        });
+    }
+
+    // RSI Study
+    if (rsi_study) {
+
+        scales['y-axis-rsi'] = {
+            type: 'linear',
+            position: 'left',
+            title: { display: true, text: 'RSI' }
+        };
+
+        datasets.push({
+            label: 'RSI SLOW',
+            data: rsi_slow,
+            backgroundColor: studyColors.rsi_slow,
+            borderColor: studyColors.rsi_slow,
+            borderWidth: 1,
+            fill: false,
+            type: 'line',
+            pointRadius: 0,
+            yAxisID: 'y-axis-rsi',
+            hidden: !rsi_display // Hide if not displayed
+        });
+
+        datasets.push({
+            label: 'RSI FAST',
+            data: rsi_fast,
+            backgroundColor: studyColors.rsi_fast,
+            borderColor: studyColors.rsi_fast,
+            borderWidth: 1,
+            fill: false,
+            type: 'line',
+            pointRadius: 0,
+            yAxisID: 'y-axis-rsi',
+            hidden: !rsi_display // Hide if not displayed
+        });
+    }
+
+    // Buy/Sell data points
+    datasets.push({
+        label: 'BuySell',
+        data: buyselldata,
+        type: 'scatter',
+        backgroundColor: buyselldata.map(d => d.backgroundColor),
+        borderColor: buyselldata.map(d => d.borderColor),
+        borderWidth: buyselldata.map(d => d.borderWidth),
+        pointRadius: buyselldata.map(d => d.pointRadius),
+        pointStyle: buyselldata.map(d => d.pointStyle),
+        yAxisID: 'y-axis' // Unique y-axis ID
+    });
+
+
+    // Define chart configuration
+    const chartConfig = {
+        type: 'candlestick',
+        data: { datasets },
+        options: {
+            scales: {
+                x: {
+                    type: 'time',
+                    time: timeConfig
+                },
+                ...scales // Dynamically include y-axis configurations
+            },
+            plugins: {
+                responsive: true,
+                tooltip: {
+                    callbacks: {
+                        label: function (context) {
+                            
+                            // Handle cases where context.parsed might be undefined
+                            if (!context.parsed) {
+                                return `${context.dataset.label}: Data unavailable`;
+                            }
+                
+                            const x = context.parsed.x !== undefined ? context.parsed.x : 'N/A';
+                            const y = context.parsed.y !== undefined ? context.parsed.y : 'N/A';
+                
+                            // Check if the dataset is buysell
+                            if (context.dataset.label === 'BuySell') {
+                                const side = context.raw.side !== undefined ? context.raw.side : 'N/A'; // Side
+                                const price = context.raw.y !== undefined ? context.raw.y : 'N/A'; // Price
+                                const time = context.raw.x !== undefined ? context.raw.x : 'N/A'; // Time
+                                return `${context.dataset.label}: (Side: ${side}, Price: ${price}, Time: ${time})`;
+                            }
+                            // Check if the dataset is candlestick
+                            else if (context.dataset.type === 'candlestick') {
+                                const o = context.raw.o !== undefined ? context.raw.o : 'N/A'; // Open
+                                const h = context.raw.h !== undefined ? context.raw.h : 'N/A'; // High
+                                const l = context.raw.l !== undefined ? context.raw.l : 'N/A'; // Low
+                                const c = context.raw.c !== undefined ? context.raw.c : 'N/A'; // Close
+                                return `${context.dataset.label}: (Open: ${o}, High: ${h}, Low: ${l}, Close: ${c})`;
+                            }
+                            else {
+                                // Default for other datasets
+                                return `${context.dataset.label}: (${x}, ${y})`;
+                            }
+                        }
+                    }
+                }
+                
+            }
+        }
+    };
+
+    // Render or update the chart
+    if (charts[chartId]) {
+        // Assign only the 'data' of the specified dataset (indexed by x)
+        chartConfig.data.datasets.forEach((dataset, index) => {
+            if (charts[chartId].data.datasets[index]) {
+                charts[chartId].data.datasets[index].data = dataset.data; // Update only the data property
+            }
+        });
+        charts[chartId].options = chartConfig.options;
+        charts[chartId].update();
+    }
+    else {
+        if (charts[chartId]) {
+            charts[chartId].destroy(); // Destroy the existing chart instance
+            delete charts[chartId]
+        }
+
+        const chartContainer = document.querySelector(`.chart-container#${chartId}`);
+        chartContainer.innerHTML=""
+        const newCanvas = document.createElement('canvas');
+        newCanvas.id = chartId;
+        chartContainer.appendChild(newCanvas);
+
+        const ctx = newCanvas.getContext('2d');
+        charts[chartId] = new Chart(ctx, chartConfig);
+    }
+};
+
+

bitunix_automated_crypto_trading/static/modal.css

@@ -0,0 +1,68 @@
+  .scrollable-view {
+    height: 80%;
+    overflow-y: auto; /* Enable vertical scrolling */
+    margin-bottom: 20px;
+  }
+  
+  .modal-overlay {
+    display: none; /* Hidden initially */
+    position: fixed;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    background: rgba(0, 0, 0, 0.5);
+    z-index: 999;
+  }
+  
+  .modal-overlay.modal-open { /* Only show overlay when modal is active */
+    display: block;
+  }
+  
+  .modal-open {
+    display: block;
+  }
+  
+  .modal-container { /* Added container for positioning */
+    width: 100%;
+    height: 100vw; /* Set height equal to the screen width */
+    max-height: 100vw; /* Ensure height does not exceed the width */
+    position: fixed;
+    z-index: 1000;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    pointer-events: none; /* Allow clicks to pass through when hidden */
+  }
+  
+  .modal {
+    width: 100%;
+    height: 100vw; /* Set height equal to the screen width */
+    max-height: 100vw; /* Ensure height does not exceed the width */
+    background-color: white;
+    padding: 20px;
+    border: 1px solid #ccc;
+    box-shadow: 0px 4px 8px rgba(0, 0, 0, 0.2);
+    resize: none; /* Disable default resizing */
+    pointer-events: auto; /* Make modal interactable */
+  }
+  
+  .modal .resize-handle {
+    position: absolute;
+    width: 10px;
+    height: 10px;
+    background-color: gray;
+    cursor: nwse-resize; /* Change cursor to indicate resizing */
+  }
+  
+  .resize-top-right { top: 0; right: 0; cursor: nesw-resize; }
+  .resize-bottom-right { bottom: 0; right: 0; cursor: nwse-resize; }
+  .resize-bottom-left { bottom: 0; left: 0; cursor: nesw-resize; }
+  .resize-top-left { top: 0; left: 0; cursor: nwse-resize; }
+
+
+