One post tagged with "algorithmic-trading"

class TradingBot:
    def __init__(self, api_key, api_secret, symbol):
        self.api_key = api_key
        self.api_secret = api_secret
        self.symbol = symbol
        self.position = None
        self.orders = []
        
    def connect(self):
        # Kết nối với sàn giao dịch
        self.exchange = ccxt.binance({
            'apiKey': self.api_key,
            'secret': self.api_secret
        })

    def check_connection(self):
        try:
            self.exchange.fetch_balance()
            return True
        except Exception as e:
            log_error(f"Lỗi kết nối: {e}")
            return False
            
    def reconnect(self):
        max_attempts = 3
        for attempt in range(max_attempts):
            if self.check_connection():
                return True
            time.sleep(5)
        return False

    def fetch_market_data(self, timeframe='1m', limit=100):
        try:
            ohlcv = self.exchange.fetch_ohlcv(
                self.symbol,
                timeframe=timeframe,
                limit=limit
            )
            df = pd.DataFrame(
                ohlcv,
                columns=['timestamp', 'open', 'high', 'low', 'close', 'volume']
            )
            df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms')
            return df
        except Exception as e:
            log_error(f"Lỗi lấy dữ liệu: {e}")
            return None

    def process_signals(self, data):
        # Áp dụng chiến lược giao dịch
        data = self.strategy.generate_signals(data)
        
        # Lọc tín hiệu mới nhất
        latest_signal = data['Signal'].iloc[-1]
        
        return latest_signal

    def place_order(self, side, amount, price=None):
        try:
            if price:
                order = self.exchange.create_limit_order(
                    self.symbol,
                    side,
                    amount,
                    price
                )
            else:
                order = self.exchange.create_market_order(
                    self.symbol,
                    side,
                    amount
                )
            
            self.orders.append(order)
            return order
        except Exception as e:
            log_error(f"Lỗi đặt lệnh: {e}")
            return None

    def manage_position(self, signal):
        if signal == 1 and not self.position:  # Tín hiệu mua
            amount = self.calculate_position_size()
            self.place_order('buy', amount)
            self.position = 'long'
            
        elif signal == -1 and self.position == 'long':  # Tín hiệu bán
            amount = self.get_position_size()
            self.place_order('sell', amount)
            self.position = None

    def check_market_conditions(self):
        # Kiểm tra biến động giá
        volatility = self.calculate_volatility()
        if volatility > self.max_volatility:
            return False
            
        # Kiểm tra thanh khoản
        liquidity = self.check_liquidity()
        if liquidity < self.min_liquidity:
            return False
            
        return True

    def manage_capital(self):
        # Tính toán vốn có sẵn
        balance = self.exchange.fetch_balance()
        available = balance['free'][self.base_currency]
        
        # Kiểm tra giới hạn rủi ro
        if available < self.min_capital:
            return False
            
        return True

    def monitor_performance(self):
        # Tính toán các chỉ số
        returns = self.calculate_returns()
        sharpe = self.calculate_sharpe_ratio()
        drawdown = self.calculate_drawdown()
        
        # Lưu kết quả
        self.performance_metrics = {
            'returns': returns,
            'sharpe_ratio': sharpe,
            'max_drawdown': drawdown
        }

    def send_report(self):
        # Tạo báo cáo
        report = {
            'timestamp': datetime.now(),
            'performance': self.performance_metrics,
            'positions': self.get_positions(),
            'orders': self.get_recent_orders()
        }
        
        # Gửi qua email hoặc API
        self.notification_service.send(report)

    def run(self):
        while True:
            try:
                # Kiểm tra kết nối
                if not self.check_connection():
                    self.reconnect()
                    continue
                
                # Lấy và xử lý dữ liệu
                data = self.fetch_market_data()
                signal = self.process_signals(data)
                
                # Kiểm tra điều kiện thị trường
                if self.check_market_conditions():
                    # Quản lý vị thế
                    self.manage_position(signal)
                
                # Giám sát hiệu suất
                self.monitor_performance()
                
                # Gửi báo cáo định kỳ
                if self.should_send_report():
                    self.send_report()
                
                time.sleep(self.interval)
                
            except Exception as e:
                log_error(f"Lỗi trong vòng lặp chính: {e}")
                time.sleep(60)