BrainDock/src/main_ml.py.backup.auto-trading

import asyncio, logging, joblib, time
from datetime import datetime
from src.config import get_config
from src.bot.binance_client import BinanceClientWrapper
from src.integrations.telegram_notifier import TelegramNotifier
from src.integrations.obsidian_logger import ObsidianLogger
from src.strategies.ml_strategy import MLStrategy

logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

class MLTradingBot:
    def __init__(self, config, binance, telegram, obsidian, model, scaler):
        self.config = config
        self.binance = binance
        self.telegram = telegram
        self.obsidian = obsidian
        self.model = model
        self.scaler = scaler
        self.strategy = MLStrategy(trading_pair=config.trading_pair)
        
        # Trading state
        self.last_report_time = time.time()
        self.report_interval = 10800  # 3 HOURS (10800 seconds)
        self.trades_today = 0
        self.wins_today = 0
        self.losses_today = 0
        self.daily_pnl = 0.0
        self.report_count = 0
    
    async def get_market_data(self):
        """Fetch current market price and stats"""
        try:
            ticker = self.config.trading_pair.split('/')[0]  # BTC from BTCUSDT
            symbol = f"{ticker}USDT"
            
            # Get current price
            price_data = await self.binance.get_ticker_price(symbol)
            if not price_data:
                return None
            
            current_price = float(price_data)
            
            return {
                'ticker': ticker,
                'current_price': current_price,
                'symbol': symbol
            }
        except Exception as e:
            logger.error(f"Market data fetch error: {e}")
            return None
    
    async def get_account_balance(self):
        """Get current account balance"""
        try:
            balance = self.binance.get_balance('USDT')
            if balance:
                return {'USDT': {'total': balance}}
            return {}
        except Exception as e:
            logger.error(f"Balance fetch error: {e}")
            return {}
    
    async def send_performance_report(self):
        """Send 3-hourly performance report"""
        try:
            self.report_count += 1
            
            # Get market data
            market = await self.get_market_data()
            if not market:
                logger.warning("No market data available")
                return
            
            # Get account balance
            balances = await self.get_account_balance()
            usdt_balance = balances.get('USDT', {}).get('total', 0)
            
            # Build report
            timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S UTC')
            report = f"""
📊 **PERFORMANCE REPORT #{self.report_count}** — {timestamp}

🎯 **MARKET STATUS:**
├─ {market['ticker']}/USDT: ${market['current_price']:,.2f}
├─ Trades Today: {self.trades_today}
├─ Wins: {self.wins_today} | Losses: {self.losses_today}
└─ Daily P&L: ${self.daily_pnl:+.2f}

💰 **ACCOUNT STATUS:**
├─ USDT Balance: ${usdt_balance:,.2f}
├─ Device: CPU
├─ Mode: Live Trading
└─ Strategy: ML (92% accuracy, 60% threshold)

📈 **BOT STATUS: RUNNING ✅**
"""
            
            # Send to Telegram (FIXED — now actually sends!)
            success = await self.telegram.send_alert(report.strip())
            if success:
                logger.info(f"✅ Performance report #{self.report_count} sent to Telegram")
            else:
                logger.warning(f"❌ Failed to send report #{self.report_count} to Telegram")
            
        except Exception as e:
            logger.error(f"Report error: {e}")
    
    async def monitor_trades(self):
        """Monitor open trades and check signals"""
        try:
            symbol = f"{self.config.trading_pair.split('/')[0]}USDT"
            orders = self.binance.get_open_orders(symbol)
            
            if orders and len(orders) > 0:
                logger.info(f"📈 Open orders: {len(orders)}")
            
        except Exception as e:
            logger.debug(f"Trade monitoring: {e}")
    
    async def run(self):
        """Main bot loop"""
        logger.info(f"🤖 Starting ML Trading Bot — {self.config.trading_pair}")
        
        startup_msg = f"""🤖 **BOT STARTED - V2 ML ADAPTIVE**

✅ Strategy: ML Adaptive (60% threshold)
✅ Models: BTC 92% accuracy
✅ Device: CPU (Live)
✅ Reporting: EVERY 3 HOURS
✅ Status: ACTIVE & MONITORING"""
        
        await self.telegram.send_alert(startup_msg)
        logger.info("✅ Startup message sent to Telegram")
        
        logger.info("🟢 Bot running — sending reports every 3 hours...")
        
        while True:
            try:
                current_time = time.time()
                
                # Send 3-hourly performance report
                if (current_time - self.last_report_time) >= self.report_interval:
                    logger.info(f"⏰ Time for Report #{self.report_count + 1}")
                    await self.send_performance_report()
                    self.last_report_time = current_time
                
                # Monitor trades every 5 minutes
                await self.monitor_trades()
                
                # Sleep for 5 minutes
                await asyncio.sleep(60)  # Check every 1 min instead of 5 min for trading opportunities
                
            except KeyboardInterrupt:
                logger.info("Bot interrupted by user")
                break
            except Exception as e:
                logger.error(f"Bot error: {e}")
                try:
                    await self.telegram.send_alert(f"❌ Bot Error: {str(e)[:100]}")
                except:
                    pass
                await asyncio.sleep(60)

async def main():
    config = get_config()
    
    if config.environment == 'testnet':
        api_key, api_secret = config.binance_api_key_testnet, config.binance_api_secret_testnet
    else:
        api_key, api_secret = config.binance_api_key_live, config.binance_api_secret_live
    
    binance = BinanceClientWrapper(api_key=api_key, api_secret=api_secret, testnet=(config.environment=='testnet'))
    telegram = TelegramNotifier(bot_token=config.telegram_bot_token, chat_id=config.telegram_chat_id)
    obsidian = ObsidianLogger(vault_path=config.obsidian_vault_path, trade_log_file=config.obsidian_trade_log_file)
    
    try:
        # Load BTC model
        model = joblib.load('/tmp/model_BTC.pkl')
        scaler = joblib.load('/tmp/scaler_BTC.pkl')
        logger.info(f'✅ ML Model loaded: BTC (92% accuracy)')
    except Exception as e:
        logger.error(f'❌ ML Model Error: {e}')
        return
    
    bot = MLTradingBot(config, binance, telegram, obsidian, model, scaler)
    await bot.run()

if __name__ == '__main__':
    asyncio.run(main())