Bot auto-update: src/main_ml.py,src/main_ml.py.backup.35pct.20240706

src/main_ml.py

@@ -30,12 +30,31 @@ class TradingBot:
         self.client = Client(env.get('BINANCE_API_KEY_LIVE'), env.get('BINANCE_API_SECRET_LIVE'))
         
         self.PAIRS = ['BTCUSDT', 'ETHUSDT', 'SOLUSDT', 'BNBUSDT', 'XRPUSDT']
-        self.SIGNAL_THRESHOLD = 5  # 5% random signal
-        self.INVESTMENT_PERCENT = 35  # 35% per trade (5 parallel = 90% max, 10% buffer)
+        self.SIGNAL_THRESHOLD = 7.5  # 7-8% range (midpoint 7.5%)  # 5% random signal
+        self.INVESTMENT_PERCENT = 25  # 25% standard
+        self.INVESTMENT_PERCENT_HIGH = 35  # 35% when confidence > 85%
+        self.CONFIDENCE_THRESHOLD = 85  # Min confidence for high investment  # 35% per trade (5 parallel = 90% max, 10% buffer)
         self.NOTIONAL_MIN = 5.0  # Override Binance minimum to $3
-        self.STOP_LOSS_PERCENT = 2.5  # -2.5%
-        self.TAKE_PROFIT_PERCENT = 3.0  # +3%
-        self.DAILY_LOSS_LIMIT = -5  # -5% max
+        self.STOP_LOSS_PERCENT = 1.8  # -2.5%
+        self.TAKE_PROFIT_PERCENT = 2.8  # +3%
+        self.DAILY_LOSS_LIMIT = -5
+        
+        # Trailing Stop
+        self.TRAILING_STOP_ENTRY = 1.5  # Activate trailing stop at +1.5%
+        self.TRAILING_STOP_DISTANCE = 0.6  # 0.6% distance
+        
+        # Position & Trade Limits
+        self.MAX_OPEN_POSITIONS = 3  # Max concurrent trades
+        self.MAX_CONSECUTIVE_LOSSES = 3  # Stop after 3 losses
+        self.CONSECUTIVE_LOSS_COOLDOWN = 30 * 60  # 30 minutes in seconds
+        self.MAX_TRADES_PER_DAY = 15
+        self.MIN_WIN_PROBABILITY = 75  # Min expected win %
+        
+        # Tracking
+        self.consecutive_losses = 0
+        self.last_loss_time = None
+        self.trades_today = 0
+        self.last_trade_reset = None  # -5% max
         
         self.active_trades = {}
         self.daily_pnl = 0
@@ -53,7 +72,7 @@ class TradingBot:
         self.telegram_token = env.get('TELEGRAM_BOT_TOKEN')
         self.telegram_chat_id = env.get('TELEGRAM_CHAT_ID')
         
-        logger.info("✅ Bot initialized with Risk Management (SL 2.5%, TP 3%, Daily Limit 5%)")
+        logger.info(f"✅ Bot initialized with Risk Management (SL {self.STOP_LOSS_PERCENT}%, TP {self.TAKE_PROFIT_PERCENT}%, Daily Limit {-self.DAILY_LOSS_LIMIT}%, Max Pos: {self.MAX_OPEN_POSITIONS})")
         
         # Send startup message
         self._send_startup_message()
@@ -231,7 +250,7 @@ Reports: Alle 3h via Telegram 📊"""
     async def place_stop_loss(self, pair, entry_price, qty):
         """Place stop loss order with correct precision & API method"""
         try:
-            # Calculate SL price with 2.5% loss
+            # Calculate SL price with {self.STOP_LOSS_PERCENT}% loss
             sl_price = entry_price * (1 - self.STOP_LOSS_PERCENT / 100)
             
             # ROUND TO TICK SIZE (CRITICAL FIX!)
@@ -432,3 +451,91 @@ async def main():
 
 if __name__ == '__main__':
     asyncio.run(main())
+
+
+    def get_signal_confidence(self):
+        """Calculate confidence level for current signal (0-100%)"""
+        # This can be enhanced with actual ML model
+        # For now: random 30-95%
+        import random
+        return random.uniform(30, 95)
+    
+    def get_investment_percent(self, confidence):
+        """Select investment % based on confidence"""
+        return self.INVESTMENT_PERCENT_HIGH if confidence > self.CONFIDENCE_THRESHOLD else self.INVESTMENT_PERCENT
+    
+    def check_consecutive_loss_cooldown(self):
+        """Check if bot is in cooldown after 3 consecutive losses"""
+        if self.consecutive_losses >= self.MAX_CONSECUTIVE_LOSSES:
+            if self.last_loss_time is None:
+                return False  # First loss, no cooldown
+            
+            time_elapsed = time.time() - self.last_loss_time
+            if time_elapsed < self.CONSECUTIVE_LOSS_COOLDOWN:
+                logger.warning(f"🚫 Cooldown active: {int(self.CONSECUTIVE_LOSS_COOLDOWN - time_elapsed)}s remaining")
+                return False
+            else:
+                # Cooldown expired, reset counter
+                self.consecutive_losses = 0
+                logger.info("✅ Cooldown expired, consecutive loss counter reset")
+                return True
+        return True
+    
+    def check_volatility(self, pair):
+        """Check market volatility (simplified)"""
+        try:
+            ticker = self.client.get_symbol_ticker(symbol=pair)
+            current_price = float(ticker['price'])
+            
+            # Get 1h candle for volatility estimate
+            candles = self.client.get_klines(symbol=pair, interval='1h', limit=5)
+            
+            high_prices = [float(c[2]) for c in candles]
+            low_prices = [float(c[3]) for c in candles]
+            
+            volatility = (max(high_prices) - min(low_prices)) / min(low_prices) * 100
+            
+            # Flag as extreme if > 5% 1h volatility
+            if volatility > 5:
+                logger.warning(f"⚠️ High volatility {pair}: {volatility:.2f}% (skipping trade)")
+                return False
+            return True
+        except:
+            return True  # If check fails, allow trade
+    
+    def check_daily_trade_limit(self):
+        """Check if daily trade limit reached"""
+        import datetime
+        
+        now = datetime.datetime.now()
+        today_start = now.replace(hour=0, minute=0, second=0, microsecond=0)
+        
+        if self.last_trade_reset is None or self.last_trade_reset < today_start:
+            self.trades_today = 0
+            self.last_trade_reset = now
+        
+        if self.trades_today >= self.MAX_TRADES_PER_DAY:
+            logger.warning(f"⚠️ Daily limit reached: {self.trades_today}/{self.MAX_TRADES_PER_DAY} trades")
+            return False
+        
+        return True
+    
+    def update_trailing_stop(self, pair, current_price, entry_price):
+        """Update trailing stop for an open position"""
+        if pair not in self.active_trades:
+            return False
+        
+        trade_data = self.active_trades[pair]
+        profit_pct = ((current_price - entry_price) / entry_price) * 100
+        
+        # Activate trailing stop when profit >= 1.5%
+        if profit_pct >= self.TRAILING_STOP_ENTRY:
+            trailing_stop_price = current_price * (1 - self.TRAILING_STOP_DISTANCE / 100)
+            trade_data['trailing_stop'] = trailing_stop_price
+            
+            # If price falls below trailing stop, close position
+            if current_price < trailing_stop_price:
+                logger.info(f"🛑 Trailing stop triggered {pair}: Sell @ ${current_price:.2f}")
+                return True
+        
+        return False

src/main_ml.py.backup.35pct.20240706

@@ -0,0 +1,434 @@
+#!/usr/bin/env python3
+"""
+Trading Bot V5 ENHANCED - FULLY FIXED VERSION
+Implementiert: SL, TP, Daily Limit, R:R Ratio
+FIXED: Binance API method (order_take_profit → create_order)
+FIXED: PRICE_FILTER für SL Orders durch Tick-Rounding
+FIXED: Quantity rounding mit Decimal (no floating point errors)
+FIXED: Quantity string formatting für Binance
+NEW: Startup Message + 3h Performance Reports via Telegram
+"""
+import os, asyncio, logging, random, json, time, math, requests
+from decimal import Decimal, ROUND_DOWN
+from binance.client import Client
+from binance.exceptions import BinanceAPIException
+from datetime import datetime, timedelta
+
+# Logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# Load env
+env = {}
+with open('/home/marc/bot-deploy/.env') as f:
+    for line in f:
+        k,_,v = line.partition('=')
+        env[k.strip()] = v.strip()
+
+class TradingBot:
+    def __init__(self):
+        self.client = Client(env.get('BINANCE_API_KEY_LIVE'), env.get('BINANCE_API_SECRET_LIVE'))
+        
+        self.PAIRS = ['BTCUSDT', 'ETHUSDT', 'SOLUSDT', 'BNBUSDT', 'XRPUSDT']
+        self.SIGNAL_THRESHOLD = 5  # 5% random signal
+        self.INVESTMENT_PERCENT = 35  # 35% per trade (5 parallel = 90% max, 10% buffer)
+        self.NOTIONAL_MIN = 5.0  # Override Binance minimum to $3
+        self.STOP_LOSS_PERCENT = 2.5  # -2.5%
+        self.TAKE_PROFIT_PERCENT = 3.0  # +3%
+        self.DAILY_LOSS_LIMIT = -5  # -5% max
+        
+        self.active_trades = {}
+        self.daily_pnl = 0
+        self.paused = False
+        self.start_time = datetime.now()
+        self.trades_today = 0
+        self.wins_today = 0
+        self.losses_today = 0
+        
+        # Precision cache
+        self.pair_precision = {}
+        self._load_pair_precision()
+        
+        # Telegram
+        self.telegram_token = env.get('TELEGRAM_BOT_TOKEN')
+        self.telegram_chat_id = env.get('TELEGRAM_CHAT_ID')
+        
+        logger.info("✅ Bot initialized with Risk Management (SL 2.5%, TP 3%, Daily Limit 5%)")
+        
+        # Send startup message
+        self._send_startup_message()
+    
+    def _send_telegram(self, message):
+        """Send message to Telegram"""
+        try:
+            if not self.telegram_token or not self.telegram_chat_id:
+                logger.warning("Telegram not configured")
+                return False
+            
+            url = f"https://api.telegram.org/bot{self.telegram_token}/sendMessage"
+            data = {
+                'chat_id': self.telegram_chat_id,
+                'text': message,
+                'parse_mode': 'Markdown'
+            }
+            response = requests.post(url, data=data, timeout=5)
+            return response.status_code == 200
+        except Exception as e:
+            logger.error(f"Telegram Error: {e}")
+            return False
+    
+    def _send_startup_message(self):
+        """Send startup message with current strategy"""
+        message = """🤖 **TRADING BOT V5 — STARTED!**
+
+⚙️ **AKTUELLE STRATEGIE:**
+
+**Entry:**
+• Signal: 5% Random (5 sec cycle)
+• Investment: 18% USDT per trade ← FIXED!
+• Pairs: BTC, ETH, SOL, BNB, XRP
+• Max Parallel: 5 trades (5×18% = 90% max)
+
+**Exit:**
+• Take Profit: +3.0% ✅
+• Stop Loss: -2.5% ✅
+• Risk/Reward: 1:1.2
+
+**Risk Management:**
+• Daily Loss Limit: -5%
+• Position Size Cap: 18%
+• Buffer Reserve: 10% USDT
+• SL Auto-Place: Ja (korrekt gerundet)
+
+**Status:** 🟢 LIVE
+• Time: """ + datetime.now().strftime('%Y-%m-%d %H:%M UTC') + """
+• Capital Ready: 100% USDT
+
+---
+Reports: Alle 3h via Telegram 📊"""
+        
+        self._send_telegram(message)
+        logger.info("📱 Startup message sent to Telegram")
+    
+    def _load_pair_precision(self):
+        """Load Binance precision rules for each pair"""
+        for pair in self.PAIRS:
+            try:
+                info = self.client.get_symbol_info(symbol=pair)
+                for f in info['filters']:
+                    if f['filterType'] == 'PRICE_FILTER':
+                        tick = float(f['tickSize'])
+                        self.pair_precision[pair] = {
+                            'tick': tick,
+                            'decimals': self._get_decimals(tick)
+                        }
+                    if f['filterType'] == 'LOT_SIZE':
+                        step = float(f['stepSize'])
+                        if pair not in self.pair_precision:
+                            self.pair_precision[pair] = {}
+                        self.pair_precision[pair]['step'] = step
+                        self.pair_precision[pair]['step_decimals'] = self._get_decimals(step)
+                    if f['filterType'] == 'NOTIONAL':
+                        min_notional = float(f['minNotional'])
+                        if pair not in self.pair_precision:
+                            self.pair_precision[pair] = {}
+                        self.pair_precision[pair]['min_notional'] = min_notional
+            except Exception as e:
+                logger.error(f"Precision load {pair}: {e}")
+    
+    def _get_decimals(self, tick):
+        """Get decimal places from tick size"""
+        s = str(tick)
+        if 'e' in s:
+            return int(s.split('e-')[1]) if 'e-' in s else 0
+        return len(s.split('.')[1]) if '.' in s else 0
+    
+    def _round_to_tick(self, price, pair):
+        """Round price to Binance tick size using Decimal"""
+        tick = self.pair_precision.get(pair, {}).get('tick', 0.01)
+        price_decimal = Decimal(str(price))
+        tick_decimal = Decimal(str(tick))
+        
+        rounded = (price_decimal / tick_decimal).quantize(Decimal('1'), rounding=ROUND_DOWN) * tick_decimal
+        return float(rounded)
+    
+    def _round_quantity(self, qty, pair):
+        """Round quantity to Binance step size using Decimal - NO PRECISION LOSS"""
+        step = self.pair_precision.get(pair, {}).get('step', 0.00001)
+        step_decimals = self.pair_precision.get(pair, {}).get('step_decimals', 5)
+        
+        qty_decimal = Decimal(str(qty))
+        step_decimal = Decimal(str(step))
+        
+        # Round down (safe side)
+        rounded = (qty_decimal / step_decimal).quantize(Decimal('1'), rounding=ROUND_DOWN) * step_decimal
+        
+        # Format as string with exactly the right decimals
+        format_str = f"0.{'':<{step_decimals}}"
+        if step_decimals == 0:
+            return int(rounded)
+        
+        return float(rounded)
+    
+    async def signal_buy(self, pair):
+        """Generate random 5% buy signal"""
+        rand = random.randint(1, 100)
+        return rand <= self.SIGNAL_THRESHOLD
+    
+    async def place_buy_order(self, pair):
+        """Place market buy order"""
+        try:
+            # Get current price
+            ticker = self.client.get_ticker(symbol=pair)
+            entry_price = float(ticker['lastPrice'])
+            
+            # Calculate quantity
+            account = self.client.get_account()
+            usdt_balance = next((b['free'] for b in account['balances'] if b['asset'] == 'USDT'), 0)
+            usdt = float(usdt_balance) * (self.INVESTMENT_PERCENT / 100)
+            
+            qty = usdt / entry_price
+            
+            # ROUND QUANTITY TO STEP SIZE (CRITICAL FIX WITH DECIMAL!)
+            qty = self._round_quantity(qty, pair)
+            
+            # Check if qty is valid (not zero after rounding)
+            if qty <= 0:
+                logger.warning(f"Quantity too small for {pair}: {qty}")
+                return False
+            
+            # VALIDATE NOTIONAL (order_value must be >= 3.0 MINIMUM)
+            order_value = qty * entry_price
+            NOTIONAL_MIN = 5.0  # Minimum $3
+            
+            if order_value < NOTIONAL_MIN:
+                logger.warning(f"Order value too small {pair}: ${order_value:.2f} < ${NOTIONAL_MIN:.2f} (qty={qty}, price={entry_price})")
+                return False
+            
+            logger.info(f"✅ NOTIONAL Check Passed: {pair} ${order_value:.2f} >= ${NOTIONAL_MIN:.2f}")
+            
+            # Place market buy
+            order = self.client.order_market_buy(symbol=pair, quantity=qty)
+            logger.info(f"🟢 BUY: {pair} x{qty} @ ${entry_price:.2f} (value: ${order_value:.2f})")
+            
+            # Store trade
+            self.active_trades[pair] = {
+                'entry': entry_price,
+                'qty': qty,
+                'time': datetime.now()
+            }
+            
+            # Place SL order (FIXED WITH CORRECT API METHOD)
+            await self.place_stop_loss(pair, entry_price, qty)
+            
+            self.trades_today += 1
+            return True
+            
+        except Exception as e:
+            logger.error(f"Buy Error {pair}: {e}")
+            return False
+    
+    async def place_stop_loss(self, pair, entry_price, qty):
+        """Place stop loss order with correct precision & API method"""
+        try:
+            # Calculate SL price with 2.5% loss
+            sl_price = entry_price * (1 - self.STOP_LOSS_PERCENT / 100)
+            
+            # ROUND TO TICK SIZE (CRITICAL FIX!)
+            sl_price = self._round_to_tick(sl_price, pair)
+            
+            # ROUND QUANTITY TO STEP SIZE (WITH DECIMAL!)
+            qty_rounded = self._round_quantity(qty, pair)
+            
+            # Place SL order using create_order (correct Binance API method)
+            order = self.client.create_order(
+                symbol=pair,
+                side='SELL',
+                type='STOP_LOSS_LIMIT',
+                timeInForce='GTC',
+                quantity=qty_rounded,
+                stopPrice=sl_price,
+                price=sl_price  # For STOP_LOSS_LIMIT, need price = stopPrice
+            )
+            logger.info(f"🛡️ SL: {pair} x{qty_rounded} @ ${sl_price:.4f} (-{self.STOP_LOSS_PERCENT}%)")
+            
+        except BinanceAPIException as e:
+            logger.error(f"SL Error {pair}: {e}")
+    
+    async def monitor_positions(self):
+        """Monitor open positions for TP/SL"""
+        try:
+            account = self.client.get_account()
+            
+            for pair in list(self.active_trades.keys()):
+                ticker = self.client.get_ticker(symbol=pair)
+                current = float(ticker['lastPrice'])
+                entry = self.active_trades[pair]['entry']
+                
+                gain_percent = ((current - entry) / entry) * 100
+                
+                # Check TP
+                if gain_percent >= self.TAKE_PROFIT_PERCENT:
+                    await self.close_position(pair, 'TP', current)
+                
+                # Check SL (secondary check)
+                elif gain_percent <= -self.STOP_LOSS_PERCENT:
+                    await self.close_position(pair, 'SL', current)
+        
+        except Exception as e:
+            logger.error(f"Monitor Error: {e}")
+    
+    async def close_position(self, pair, reason, current_price):
+        """Close position"""
+        if pair not in self.active_trades:
+            return
+        
+        qty = self.active_trades[pair]['qty']
+        entry = self.active_trades[pair]['entry']
+        pnl = (current_price - entry) * qty
+        
+        logger.info(f"📊 {reason}: {pair} closed @ ${current_price:.2f}, PnL: ${pnl:.2f}")
+        
+        del self.active_trades[pair]
+        self.daily_pnl += pnl
+        
+        if pnl > 0:
+            self.wins_today += 1
+        else:
+            self.losses_today += 1
+        
+        # Check daily loss limit
+        if self.daily_pnl <= self.DAILY_LOSS_LIMIT:
+            logger.warning(f"⚠️ DAILY LOSS LIMIT REACHED: ${self.daily_pnl:.2f}")
+            self.paused = True
+    
+    def get_performance_report(self):
+        """Get current performance metrics"""
+        try:
+            account = self.client.get_account()
+            balance = {}
+            
+            for asset_data in account['balances']:
+                asset = asset_data['asset']
+                free = float(asset_data['free'])
+                locked = float(asset_data['locked'])
+                total = free + locked
+                
+                if total > 0.00001:
+                    balance[asset] = {
+                        'free': free,
+                        'locked': locked,
+                        'total': total
+                    }
+            
+            # Get prices
+            prices = {}
+            for pair in self.PAIRS:
+                try:
+                    ticker = self.client.get_ticker(symbol=pair)
+                    asset = pair.replace('USDT', '')
+                    prices[asset] = float(ticker['lastPrice'])
+                except:
+                    pass
+            prices['USDT'] = 1.0
+            
+            # Calculate portfolio
+            portfolio = 0
+            tracked = ['BTC', 'ETH', 'SOL', 'BNB', 'XRP', 'USDT']
+            for asset in tracked:
+                if asset in balance:
+                    portfolio += balance[asset]['total'] * prices.get(asset, 0)
+            
+            return {
+                'portfolio': round(portfolio, 2),
+                'usdt_free': balance.get('USDT', {}).get('free', 0),
+                'daily_pnl': self.daily_pnl,
+                'trades_today': self.trades_today,
+                'wins': self.wins_today,
+                'losses': self.losses_today,
+                'active_trades': len(self.active_trades),
+                'paused': self.paused
+            }
+        except Exception as e:
+            logger.error(f"Performance Report Error: {e}")
+            return None
+    
+    def send_performance_report(self):
+        """Send 3h performance report via Telegram"""
+        report = self.get_performance_report()
+        if not report:
+            return
+        
+        win_rate = 0
+        if report['trades_today'] > 0:
+            win_rate = (report['wins'] / report['trades_today']) * 100
+        
+        status = "🟢 RUNNING" if not report['paused'] else "⏸️ PAUSED"
+        
+        message = f"""📊 **3H PERFORMANCE REPORT**
+
+**Portfolio Status:**
+• Total: ${report['portfolio']:.2f}
+• USDT Free: ${report['usdt_free']:.2f}
+• Status: {status}
+
+**Today's Trading:**
+• Trades Executed: {report['trades_today']}
+• Wins: {report['wins']} ✅
+• Losses: {report['losses']} ❌
+• Win Rate: {win_rate:.1f}%
+
+**P&L:**
+• Daily P&L: ${report['daily_pnl']:.2f}
+• Open Positions: {report['active_trades']}
+
+**Risk Status:**
+• Daily Loss Limit: -5%
+• Current Daily Loss: ${report['daily_pnl']:.2f}
+• Pause Active: {'Yes ⏸️' if report['paused'] else 'No ✅'}
+
+---
+Time: {datetime.now().strftime('%Y-%m-%d %H:%M UTC')}
+Bot: V5 ENHANCED (FULLY FIXED)"""
+        
+        self._send_telegram(message)
+        logger.info("📱 Performance report sent to Telegram")
+    
+    async def run_cycle(self):
+        """Main trading cycle"""
+        last_report_hour = None
+        
+        while True:
+            try:
+                # Check if it's time for 3h report
+                current_hour = datetime.now().hour
+                if current_hour % 3 == 0 and last_report_hour != current_hour:
+                    self.send_performance_report()
+                    last_report_hour = current_hour
+                
+                # Check daily loss limit pause
+                if self.paused:
+                    logger.info("⏸️ Bot PAUSED (daily loss limit reached)")
+                    await asyncio.sleep(60)
+                    continue
+                
+                # Signal generation
+                for pair in self.PAIRS:
+                    if pair not in self.active_trades and await self.signal_buy(pair):
+                        await self.place_buy_order(pair)
+                
+                # Monitor positions
+                await self.monitor_positions()
+                
+                await asyncio.sleep(5)
+                
+            except Exception as e:
+                logger.error(f"Cycle Error: {e}")
+                await asyncio.sleep(5)
+
+async def main():
+    bot = TradingBot()
+    await bot.run_cycle()
+
+if __name__ == '__main__':
+    asyncio.run(main())