marc
/
BrainDock
Template
0
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Bot auto-update: src/__pycache__/main_ml.cpython-310.pyc,src/main_ml.py

This commit is contained in:
Marc Blatter 2026-07-17 10:50:01 +02:00
parent bd68b491f2
commit 3a83ae0d3c
2 changed files with 106 additions and 165 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
src/__pycache__/main_ml.cpython-310.pyc
View File

Binary file not shown.

271
src/main_ml.py
View File

@ -1,101 +1,61 @@
#!/usr/bin/env python3 #!/usr/bin/env python3
"""Trading Bot v0.4 - Dynamic Position Sizing (% of Portfolio)""" """
import os, json, time, logging Trading Bot V0.3 - Strategy Rewrite
Deployed: 2026-07-09 18:30 UTC
Changes: Fresh balance cache, local min signal, hard TP/SL
"""
import os
import time
import logging
from datetime import datetime from datetime import datetime
from dotenv import load_dotenv
from binance.client import Client from binance.client import Client
from binance.exceptions import BinanceAPIException from binance.exceptions import BinanceAPIException
# Setup Logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s | %(levelname)s | %(message)s')
logger = logging.getLogger(__name__)
# Load API Keys # Setup
API_KEY = os.getenv('BINANCE_API_KEY_LIVE') logging.basicConfig(level=logging.INFO, format='%(levelname)s:%(message)s')
API_SECRET = os.getenv('BINANCE_API_SECRET_LIVE') logger = logging.getLogger()
if not API_KEY or not API_SECRET: load_dotenv()
try:
API_KEY = os.getenv('BINANCE_API_KEY_LIVE')
API_SECRET = os.getenv('BINANCE_API_SECRET_LIVE')
except:
logger.error("Missing API keys") logger.error("Missing API keys")
exit(1) exit(1)
# ===== DYNAMIC POSITION SIZING CONSTANTS ===== # Constants
SYMBOLS = ['BTCUSDT', 'ETHUSDT', 'BNBUSDT', 'XRPUSDT', 'SOLUSDT'] SYMBOLS = ['BTCUSDT', 'ETHUSDT', 'BNBUSDT', 'XRPUSDT', 'SOLUSDT']
MIN_USDT = 5.00 MIN_USDT = 5.00
MAX_POSITION_PCT = 0.05 # 5% of portfolio per trade (DYNAMIC!) MAX_TRADE_USDT = 20.00
KELLY_FRACTION = 0.25 # Conservative Kelly
ESTIMATED_WIN_RATE = 0.60 # 60% from bot data
TAKE_PROFIT_PCT = 0.015 # +1.5% TAKE_PROFIT_PCT = 0.015 # +1.5%
STOP_LOSS_PCT = -0.008 # -0.8% STOP_LOSS_PCT = -0.008 # -0.8%
CYCLE_SEC = 60 CYCLE_SEC = 60
class TradingBotV04: class TradingBotV03:
"""Trading Bot v0.4 with Dynamic Position Sizing""" """Trading Bot with Fresh Cache + Local Min Signals + Hard Risk Management"""
def __init__(self): def __init__(self):
self.client = Client(API_KEY, API_SECRET) self.client = Client(API_KEY, API_SECRET)
self.price_history = {sym: [] for sym in SYMBOLS} self.price_history = {sym: [] for sym in SYMBOLS}
self.active_trades = {} self.active_trades = {} # {symbol: {'entry_price': float, 'qty': float}}
self.portfolio_value = 0 logger.info("Bot V0.3 initialized | Fresh Cache + Local Min + Hard TP/SL")
self.max_trade_usdt = 0
# Recover orphaned trades
try:
account = self.client.get_account()
for b in account['balances']:
asset = b['asset']
free = float(b['free'])
for symbol in SYMBOLS:
if symbol.replace('USDT', '') == asset and free > 0.0001:
try:
current_price = float(self.get_current_price(symbol))
self.active_trades[symbol] = {
'entry_price': current_price,
'qty': free,
'entry_time': datetime.now().isoformat()
}
logger.warning(f"RECOVERED orphaned trade: {symbol} {free} coins @ ${current_price:.2f}")
except:
pass
except Exception as e:
logger.warning(f"Trade recovery failed: {e}")
logger.info("Bot V0.4 initialized | Dynamic Position Sizing (% of Portfolio)")
def get_fresh_balance(self): def get_fresh_balance(self):
"""Always fetch FRESH balance from API""" """KEY FIX: Always fetch FRESH balance from API (no stale cache!)"""
try: try:
account = self.client.get_account() account = self.client.get_account()
balances = {} balances = {}
portfolio_value = 0
# Get prices
prices = {'USDT': 1.0}
for p in ['BTCUSDT', 'ETHUSDT', 'SOLUSDT', 'BNBUSDT', 'XRPUSDT']:
try:
t = self.client.get_ticker(symbol=p)
prices[p.replace('USDT', '')] = float(t['lastPrice'])
except:
pass
# Calculate balances & portfolio value
for b in account['balances']: for b in account['balances']:
asset, free = b['asset'], float(b['free']) balances[b['asset']] = float(b['free'])
balances[asset] = free
price = prices.get(asset, 1.0)
portfolio_value += free * price
usdt_available = balances.get('USDT', 0) usdt_available = balances.get('USDT', 0)
logger.info(f"Fresh balance: USDT=${usdt_available:.2f}")
# Store for later use return balances, usdt_available
self.portfolio_value = portfolio_value
self.max_trade_usdt = portfolio_value * MAX_POSITION_PCT
logger.info(f"Fresh balance: USDT=${usdt_available:.2f} | Portfolio=${portfolio_value:.2f} | Max Trade=${self.max_trade_usdt:.2f}")
return balances, usdt_available, portfolio_value
except BinanceAPIException as e: except BinanceAPIException as e:
logger.error(f"Balance fetch failed: {e}") logger.error(f"Balance fetch failed: {e}")
return {}, 0, 0 return {}, 0
def get_current_price(self, symbol): def get_current_price(self, symbol):
"""Get current market price""" """Get current market price"""
@ -108,55 +68,44 @@ class TradingBotV04:
return None return None
def calculate_valid_quantity(self, symbol, usdt_amount): def calculate_valid_quantity(self, symbol, usdt_amount):
"""Calculate correct Qty with Decimal precision""" """Calculate valid order quantity respecting LOT_SIZE"""
try: try:
price = self.get_current_price(symbol) price = self.get_current_price(symbol)
if not price: if not price:
return 0 return 0
# Get exchange info for lot size
info = self.client.get_symbol_info(symbol) info = self.client.get_symbol_info(symbol)
if not info: if not info:
return 0 return 0
# Find LOT_SIZE filter step_size = 0.00001 # default
step_size = None for filt in info.get('filters', []):
for f in info.get('filters', []): if filt['filterType'] == 'LOT_SIZE':
if f['filterType'] == 'LOT_SIZE': step_size = float(filt['stepSize'])
step_size = float(f['stepSize'])
break break
if not step_size: qty = (usdt_amount / price)
return 0 qty = int(qty / step_size) * step_size # Round to step_size
notional = qty * price
qty_float = usdt_amount / price if notional < MIN_USDT:
# Round to step size
qty_float = int(qty_float / step_size) * step_size
# Check minimum notional
min_notional = 5.0
notional = qty_float * price
if notional < min_notional:
logger.debug(f"Order too small: {symbol} ${notional:.2f}") logger.debug(f"Order too small: {symbol} ${notional:.2f}")
return 0 return 0
logger.debug(f"Qty valid: {symbol} {qty_float} (step={step_size})") return qty
return qty_float
except Exception as e: except Exception as e:
logger.warning(f"Qty calc failed: {e}") logger.warning(f"Qty calc failed: {e}")
return 0 return 0
def is_local_minimum(self, symbol): def is_local_minimum(self, symbol):
"""Signal Logic: Buy when price is at local minimum""" """Signal Logic: Buy when price is at local minimum (not random %)"""
if len(self.price_history[symbol]) < 5: if len(self.price_history[symbol]) < 5:
return False return False
recent_prices = self.price_history[symbol][-5:] recent_prices = self.price_history[symbol][-5:]
current_price = recent_prices[-1] current_price = recent_prices[-1]
# Local min condition: current is lower than all recent prices
is_min = all(current_price < p for p in recent_prices[:-1]) is_min = all(current_price < p for p in recent_prices[:-1])
if is_min: if is_min:
@ -183,57 +132,60 @@ class TradingBotV04:
'entry_price': entry_price, 'entry_price': entry_price,
'qty': qty, 'qty': qty,
'order_id': order.get('orderId'), 'order_id': order.get('orderId'),
'entry_time': datetime.now().isoformat() 'entry_time': datetime.now()
} }
logger.info(f"BUY: {qty} {symbol} @ ${entry_price:.2f} (${qty*entry_price:.2f})") logger.info(f"BUY: {qty} {symbol} @ ${entry_price:.2f} (${qty*entry_price:.2f})")
logger.info(f" TP target: +${qty*entry_price*TAKE_PROFIT_PCT:.2f} ({TAKE_PROFIT_PCT*100:.1f}%)") logger.info(f" TP target: +${qty*entry_price*TAKE_PROFIT_PCT:.2f} ({TAKE_PROFIT_PCT*100:.1f}%)")
logger.info(f" SL target: -${qty*entry_price*abs(STOP_LOSS_PCT):.2f} ({STOP_LOSS_PCT*100:.1f}%)") logger.info(f" SL target: -${qty*entry_price*abs(STOP_LOSS_PCT):.2f} ({STOP_LOSS_PCT*100:.1f}%)")
logger.info(f" [DYNAMIC] Portfolio: ${self.portfolio_value:.2f} | Max Position: ${self.max_trade_usdt:.2f}")
return order return order
except BinanceAPIException as e: except BinanceAPIException as e:
logger.error(f"Order failed: {e}") logger.error(f"Buy order failed: {e}")
return None return None
def check_and_close_positions(self): def check_and_close_positions(self):
"""Check TP/SL for all active trades""" """HARD RISK MANAGEMENT: Close positions that hit TP or SL"""
for symbol, trade in list(self.active_trades.items()): for symbol in list(self.active_trades.keys()):
try: trade = self.active_trades[symbol]
current_price = self.get_current_price(symbol) current_price = self.get_current_price(symbol)
if not current_price:
continue if not current_price:
continue
entry_price = trade['entry_price']
qty = trade['qty'] entry_price = trade['entry_price']
pnl_pct = ((current_price - entry_price) / entry_price) * 100 qty = trade['qty']
pnl_pct = (current_price - entry_price) / entry_price
# Check TP pnl_usdt = qty * (current_price - entry_price)
if pnl_pct >= TAKE_PROFIT_PCT * 100:
logger.info(f"SELL (TP): {qty} {symbol} @ ${current_price:.2f} | +{pnl_pct:.2f}%") # Check Take Profit (close winners immediately!)
try: if pnl_pct >= TAKE_PROFIT_PCT:
self.client.order_market_sell(symbol=symbol, quantity=qty) logger.info(f"TAKE PROFIT: {symbol} +{pnl_pct*100:.2f}% (${pnl_usdt:.2f})")
del self.active_trades[symbol] try:
except: self.client.order_market_sell(symbol=symbol, quantity=qty)
pass del self.active_trades[symbol]
except Exception as e:
# Check SL logger.error(f"Sell failed: {e}")
elif pnl_pct <= STOP_LOSS_PCT * 100: continue
logger.info(f"SELL (SL): {qty} {symbol} @ ${current_price:.2f} | {pnl_pct:.2f}%")
try: # Check Stop Loss (cut losers fast!)
self.client.order_market_sell(symbol=symbol, quantity=qty) if pnl_pct <= STOP_LOSS_PCT:
del self.active_trades[symbol] logger.warning(f"STOP LOSS: {symbol} {pnl_pct*100:.2f}% (${pnl_usdt:.2f})")
except: try:
pass self.client.order_market_sell(symbol=symbol, quantity=qty)
except: del self.active_trades[symbol]
pass except Exception as e:
logger.error(f"Sell failed: {e}")
continue
def run_cycle(self): def cycle(self):
"""Main trading cycle""" """Main trading cycle (runs every 60 seconds)"""
logger.info("=" * 70) logger.info("=" * 70)
logger.info(f"CYCLE START @ {datetime.now().strftime('%H:%M:%S CET')}")
# STEP 1: Fresh balance & calculate dynamic position size # STEP 1: Fresh balance (KEY FIX for cache bug!)
balances, usdt_free, portfolio_val = self.get_fresh_balance() balances, usdt_free = self.get_fresh_balance()
if usdt_free < MIN_USDT: if usdt_free < MIN_USDT:
logger.warning(f"Insufficient capital: ${usdt_free:.2f} < ${MIN_USDT}") logger.warning(f"Insufficient capital: ${usdt_free:.2f} < ${MIN_USDT}")
@ -248,6 +200,7 @@ class TradingBotV04:
price = self.get_current_price(symbol) price = self.get_current_price(symbol)
if price: if price:
self.price_history[symbol].append(price) self.price_history[symbol].append(price)
# Keep only last 20 prices
if len(self.price_history[symbol]) > 20: if len(self.price_history[symbol]) > 20:
self.price_history[symbol].pop(0) self.price_history[symbol].pop(0)
@ -260,46 +213,34 @@ class TradingBotV04:
# STEP 5: Place trade if signal exists and we have capital # STEP 5: Place trade if signal exists and we have capital
if best_signal and usdt_free >= MIN_USDT: if best_signal and usdt_free >= MIN_USDT:
trade_amount = min(self.max_trade_usdt, usdt_free * 0.5) # Use max 50% of available capital, but capped at MAX_TRADE_USDT
trade_amount = min(MAX_TRADE_USDT, usdt_free * 0.5)
self.place_buy_order(best_signal, trade_amount) self.place_buy_order(best_signal, trade_amount)
logger.info(f"CYCLE END | Active trades: {len(self.active_trades)} | Free USDT: ${usdt_free:.2f} | Portfolio: ${portfolio_val:.2f}") logger.info(f"CYCLE END | Active trades: {len(self.active_trades)} | Free USDT: ${usdt_free:.2f}")
# Save active trades for dashboard
import json, os
try:
temp_file = '/home/marc/bot-deploy/active_trades.json.tmp'
with open(temp_file, 'w') as f:
json.dump({
'active_trades': self.active_trades,
'count': len(self.active_trades),
'portfolio_value': round(portfolio_val, 2),
'max_trade_usdt': round(self.max_trade_usdt, 2),
'timestamp': datetime.now().isoformat()
}, f)
os.replace(temp_file, '/home/marc/bot-deploy/active_trades.json')
except Exception as e:
logger.warning(f"Failed to save trades: {e}")
logger.info("=" * 70) logger.info("=" * 70)
def run(self):
"""Infinite trading loop"""
logger.info("=" * 70)
logger.info("TRADING BOT V0.3 STARTED")
logger.info(f"Symbols: {SYMBOLS}")
logger.info(f"Strategy: Local Min Signals | Risk: TP=+{TAKE_PROFIT_PCT*100:.1f}% / SL={STOP_LOSS_PCT*100:.1f}%")
logger.info(f"Position size: Max ${MAX_TRADE_USDT}/trade (${usdt_free*0.5} = 50% avail)")
logger.info(f"KEY FIX: Fresh balance fetched EVERY cycle (no stale cache!)")
logger.info("=" * 70)
try:
while True:
self.cycle()
time.sleep(CYCLE_SEC)
except KeyboardInterrupt:
logger.info("Bot stopped by user")
except Exception as e:
logger.error(f"CRITICAL ERROR: {e}")
raise
if __name__ == '__main__': if __name__ == '__main__':
import sys bot = TradingBotV03()
from dotenv import load_dotenv bot.run()
load_dotenv('/home/marc/bot-deploy/.env')
bot = TradingBotV04()
if len(sys.argv) > 1 and sys.argv[1] == '--once':
bot.run_cycle()
else:
logger.info("Starting Bot V0.4 cycle loop...")
while True:
try:
bot.run_cycle()
except Exception as e:
logger.error(f"Cycle error: {e}")
time.sleep(CYCLE_SEC)