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

Cleanup: Remove all v0.2/v5/v10 backups and deprecated strategies - Master branch now v0.3 ONLY with clean README

This commit is contained in:
Marc Blatter 2026-07-14 07:21:36 +02:00
parent 0afeb8f99a
commit baa909d85a
11 changed files with 63 additions and 2355 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

165
README.md
View File

@ -1,123 +1,84 @@
# Trading Bot V0.2 — Adaptive Strategy Learning # 🤖 Trading Bot — Version 0.3 (PRODUCTION)
**Production-ready Crypto Trading Bot with Live P&L Dashboard** **Version:** 0.3 | **Status:** 🟢 LIVE | **Updated:** 2026-07-14
## Features ## 📊 Current Performance (Live)
### ✅ Core Trading | Metric | Value | Status |
- **Adaptive Signal Generation**: Win-rate based strategy adjustment (5 levels) |--------|-------|--------|
- **Risk Management**: Stop Loss (-1.8%), Take Profit (+2.8%), Daily Loss Limit (-5%) | **Portfolio** | $107.37 | 🟢 +0.49% |
- **Smart Position Sizing**: Dynamic investment (50-55%) based on signal confidence | **Trades** | 5 live | ✅ Balanced |
- **Trailing Stop**: +1.5% entry, 0.6% trail distance | **Free USDT** | $18.75 | Active |
- **Cooldown Protection**: 30min pause after 3 consecutive losses | **Win Rate** | +2.06%-2.20% | ✅ Consistent |
| **Bot** | RUNNING | ✅ 24/7 |
### ✅ Adaptive Learning (Option 2) ## 🎯 Strategy v0.3
- **Hourly Strategy Evaluation**: Automatically adjusts based on win rate
- **5 Strategy Levels**:
- 🚨 Emergency (<45% WR): Strict signals, minimal trades
- ⚠️ Conservative (45-50%): Reduced risk
- ✅ Standard (50-60%): Default settings
- 🟢 Aggressive (60-70%): Increased signal frequency
- 🔥 Full Throttle (>70%): Maximum trading
### ✅ Monitoring & Reporting **Algorithm:** Local Minimum Detection
- **Live P&L Dashboard**: Real-time portfolio value, profit/loss, holdings - Scan 30min price history
- **Performance Reports**: 3-hour summaries via Telegram - Detect support levels
- **Telegram Alerts**: Strategy changes, trade notifications - TP: +1.5% | SL: -0.8%
- Max 1 open trade
## Architecture **Active Pairs:** BTC, ETH, BNB, XRP, SOL
### Files **Risk:** 50% capital/trade, no leverage, -5% daily pause
- `src/main_ml.py`: Core trading bot (512 lines)
- `src/web_dashboard.py`: FastAPI dashboard (650+ lines)
- `README.md`: This file
### Endpoints ## 📁 Files (v0.3 ONLY)
- **Bot**: Runs async trading cycle (5s loop)
- **Dashboard**: http://localhost:7000 (HTML) + `/api/state` (JSON)
- **Telegram**: Real-time alerts
## Configuration - main_ml.py ✅ (production engine)
- web_dashboard.py (live UI)
- Integrations (Telegram, Obsidian, Dashboard)
### Strategy Parameters (Adaptive) **Removed (cleanup 2026-07-14):**
- ❌ Backups (main_ml_BACKUP*, v2, v4_backup, v6)
- ❌ DCA strategy (deprecated)
- ❌ Old monitoring tools
## 🚀 Quick Start
**Status:**
```bash
systemctl status trading-bot.service
journalctl -u trading-bot.service -f
```
**Dashboard:** https://bot.bizmark.cloud (Port 7000)
**Configure:** Edit `src/main_ml.py`
```python ```python
SIGNAL_THRESHOLD: 5-10% TAKE_PROFIT_PERCENT = 1.5 # 1.0-2.5%
INVESTMENT_PERCENT: 50-55% STOP_LOSS_PERCENT = 0.8 # 0.5-1.5%
TAKE_PROFIT_PERCENT: 1.5-3.5% INVESTMENT_PERCENT = 50 # 10-55%
STOP_LOSS_PERCENT: 1.0-2.2% CYCLE_INTERVAL = 60 # 30-120s
MAX_TRADES_PER_DAY: 5-25
MAX_OPEN_POSITIONS: 1-2
``` ```
### Risk Controls After changes: `git commit` → `git push` → `systemctl restart trading-bot.service`
- Daily Loss Limit: -5%
- Max 3 consecutive losses → 30min cooldown
- Min notional: $5.00 per order
- Slippage buffer: PRICE_FILTER rounding
## Usage ## 📱 Telegram Reports (3h)
### Start Bot Auto-delivery: 00:00, 03:00, 06:00, 09:00, 12:00, 15:00, 18:00, 21:00 UTC
- Marc: 7646180954
- Brother: 8518722579
- Via: @bizMarkTrading_Bot
## 🔄 Versioning
**v0.3 (NOW):** Local Minimum + 3h reports + clean repo
**Downgrade v0.3 → v0.2:**
```bash ```bash
cd src git log --oneline
python3 main_ml.py git checkout <v0.2-hash>
systemctl restart trading-bot.service
``` ```
### Start Dashboard ## 📞 Help
```bash
cd src
uvicorn web_dashboard:app --host 0.0.0.0 --port 7000
```
### View Dashboard - Logs: `journalctl -u trading-bot.service -f`
``` - Status: `curl http://172.16.1.168:7000/api/state | jq '.'`
http://bot.bizmark.cloud - Report: `/home/marc/.pyenv/versions/3.10.16/bin/python3 /home/marc/bot-deploy/send_3h_report.py`
```
## Performance ---
### Current State (2026-07-07) **Repo:** https://git.bizmark.cloud/marc/BrainDock | **Branch:** master (v0.3) | **Status:** 🟢 PRODUCTION READY
- **Portfolio**: $135.99 USD
- **P&L**: -$1.83 (-1.3%)
- **Open Positions**: 1 (XRP 6.7 @ $1.15)
- **Status**: 🟢 LIVE
### Historical
- Total Trades: 10+
- Win Rate: 45-55% (adaptive mode active)
- Largest Win: +2.8% (TP hit)
- Largest Loss: -1.8% (SL hit)
## Version History
### V0.2 (Current) — 2026-07-07
- ✅ Adaptive strategy learning (Option 2)
- ✅ Live P&L dashboard integration
- ✅ 10s refresh rate (optimized)
- ✅ Hourly strategy evaluation
- ✅ Code cleanup (removed V5/V10 labels)
### V0.1 (Previous)
- Static strategy (7.5% signal, 50% investment)
- Basic P&L cart add reporting
## Troubleshooting
### Dashboard shows stale P&L?
- Check `/api/state` endpoint returns new data
- Verify bot is running (`systemctl status trading-bot`)
- Refresh page (clears 10s cache)
### Bot not trading?
- Check daily loss limit (-5% limit may be hit)
- Verify Binance API key has trading permission
- Check MIN_NOTIONAL ($5.00 minimum per order)
### Strategy not adapting?
- Need minimum 5 trades to trigger adaptation
- Strategy updates every hour (check logs)
- Win rate must be >5% points away to trigger new mode
## License
All trades at your own risk. Crypto is volatile.

86
src/frigate_report.py
View File

@ -1,86 +0,0 @@
#!/usr/bin/env python3
"""
Frigate Daily Report Generator
Sends to Telegram every evening at 20:30 CET
"""
import os, json, requests
from datetime import datetime, timedelta
from collections import defaultdict
FRIGATE_URL = "http://localhost:5000"
def get_frigate_events():
"""Get events from last 24 hours"""
try:
resp = requests.get(f"{FRIGATE_URL}/api/events", timeout=5)
events = resp.json()
# Filter for last 24h
now = datetime.now().timestamp()
yesterday = now - (24 * 3600)
recent = [e for e in events if e.get('start_time', 0) > yesterday]
return recent
except Exception as e:
print(f"Error fetching events: {e}")
return []
def generate_report():
"""Generate Frigate daily summary"""
events = get_frigate_events()
if not events:
return "🎥 **Frigate Daily Report** — Keine Events heute\n\nStatus: ✅ Alle Kameras aktiv\nEvents: 0"
# Group by camera & label
by_camera = defaultdict(lambda: defaultdict(int))
by_label = defaultdict(int)
people = set()
for event in events:
camera = event.get('camera', 'Unknown')
label = event.get('label', 'Unknown')
sub_label = event.get('sub_label', None)
by_camera[camera][label] += 1
by_label[label] += 1
if label == 'person' and sub_label:
people.add(sub_label)
# Format report
timestamp = datetime.now().strftime('%Y-%m-%d %H:%M CET')
report = f"""🎥 **Frigate Daily Report** — {timestamp}
📊 **ZUSAMMENFASSUNG**
• Gesamt Events: {len(events)}
• Detektierte Personen: {len(people)}
• Kameras aktiv: {len(by_camera)}
👥 **Erkannte Personen**
"""
for person in sorted(people):
report += f" • {person}\n"
report += f"\n📹 **Nach Kamera**\n"
for camera in sorted(by_camera.keys()):
events_count = sum(by_camera[camera].values())
labels = ", ".join(by_camera[camera].keys())
report += f" 🟢 {camera}: {events_count} Events ({labels})\n"
report += f"\n🏷️ **Nach Objekttyp**\n"
for label in sorted(by_label.keys()):
count = by_label[label]
report += f" • {label.upper()}: {count}\n"
report += f"\n✅ **Status**: Alle Kameras aktiv\n"
report += f"*Report: {datetime.now().strftime('%H:%M:%S UTC')}*"
return report
if __name__ == "__main__":
report = generate_report()
print(report)

220
src/main_ml_BACKUP_before_precision_fix.py
View File

@ -1,220 +0,0 @@
#!/usr/bin/env python3
"""
Trading Bot V5 ENHANCED - Mit kritischen Risk Management Fixes
Implementiert: SL, TP Anpassung, Daily Limit, R:R Ratio
"""
import os, asyncio, logging, random, json, time
from datetime import datetime, timedelta
from binance.client import Client
from binance.exceptions import BinanceAPIException
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)
# Load config
env = {}
with open('/home/marc/bot-deploy/.env') as f:
for line in f:
k, _, v = line.partition('=')
env[k.strip()] = v.strip()
class TradingBotV5Enhanced:
def __init__(self):
self.binance = Client(env.get('BINANCE_API_KEY_LIVE'), env.get('BINANCE_API_SECRET_LIVE'))
self.state_file = '/home/marc/bot-deploy/trades.json'
self.load_state()
# NEW: Risk Management Settings
self.STOP_LOSS_PERCENT = 2.5 # 2.5% SL (-2.5%)
self.TAKE_PROFIT_PERCENT = 3.0 # 3.0% TP (+3%) - was +1%
self.DAILY_LOSS_LIMIT = 5.0 # Max -5% daily
self.MIN_RISK_REWARD = 1.5 # Min R:R ratio
self.MAX_POSITION_PERCENT = 25 # Max 25% per trade
logger.info("✅ Bot initialized with Risk Management (SL 2.5%, TP 3%, Daily Limit 5%)")
def load_state(self):
if os.path.exists(self.state_file):
with open(self.state_file) as f:
self.state = json.load(f)
else:
self.state = {'current': {}, 'completed': [], 'daily_start_balance': 0}
def save_state(self):
with open(self.state_file, 'w') as f:
json.dump(self.state, f, indent=2)
def check_and_place_sl_orders(self, pair, qty, entry_price):
"""
NEW: Automatically place Stop Loss orders for existing positions
SL = Entry - 2.5%
"""
sl_price = entry_price * (1 - self.STOP_LOSS_PERCENT / 100)
try:
# Check if already has SL order
orders = self.binance.get_open_orders(symbol=pair)
has_sl = any(o['side'] == 'SELL' and float(o['price']) < entry_price for o in orders)
if not has_sl:
# Place SL order
order = self.binance.order_limit_sell(
symbol=pair,
quantity=qty,
price=round(sl_price, 8)
)
logger.info(f"🛡️ Stop Loss set: {pair} {qty} @ ${sl_price:.4f}")
return True
except Exception as e:
logger.error(f"SL Error {pair}: {e}")
return False
def place_buy(self, pair):
"""Place market buy with Risk Management checks"""
try:
# Get balance
balance = self.binance.get_account()
usdt_free = float([a['free'] for a in balance['balances'] if a['asset'] == 'USDT'][0])
# NEW: Daily loss check
daily_loss = self.calculate_daily_loss()
if daily_loss <= -self.DAILY_LOSS_LIMIT:
logger.warning(f"⛔ Daily loss limit hit: {daily_loss:.2f}% (limit: -{self.DAILY_LOSS_LIMIT}%)")
return None
# Calculate position size (25% of USDT)
qty_usdt = usdt_free * (self.MAX_POSITION_PERCENT / 100)
if qty_usdt < 10: # Binance minimum
return None
# Get current price
ticker = self.binance.get_symbol_info(pair)
price = float(self.binance.get_ticker(symbol=pair)['lastPrice'])
# Calculate quantity with LOT_SIZE filter
lot_filter = next(f for f in ticker['filters'] if f['filterType'] == 'LOT_SIZE')
step_size = float(lot_filter['stepSize'])
qty = float(int(qty_usdt / price / step_size) * step_size)
if qty < float(lot_filter['minQty']):
return None
# Place market buy
order = self.binance.order_market_buy(symbol=pair, quantity=qty)
logger.info(f"🟢 BUY: {pair} x{qty:.6f} @ ${price:.4f}")
# NEW: Auto-place Stop Loss
self.check_and_place_sl_orders(pair, qty, price)
return order
except Exception as e:
logger.error(f"Buy Error {pair}: {e}")
return None
def check_take_profit(self):
"""NEW: Check and close at +3% TP with SL protection"""
try:
balance = self.binance.get_account()
for pair in ['BTCUSDT', 'ETHUSDT', 'SOLUSDT', 'BNBUSDT', 'XRPUSDT']:
ticker = self.binance.get_ticker(symbol=pair)
current_price = float(ticker['lastPrice'])
# Check if we have open trade
if pair in self.state['current']:
entry_price = self.state['current'][pair]['buy_price']
gain_percent = (current_price - entry_price) / entry_price * 100
# TP at +3%
if gain_percent >= self.TAKE_PROFIT_PERCENT:
qty = self.state['current'][pair]['qty']
try:
order = self.binance.order_market_sell(symbol=pair, quantity=qty)
profit_usd = (current_price - entry_price) * qty
logger.info(f"💰 TP HIT: {pair} +{gain_percent:.2f}% = ${profit_usd:.2f}")
# Record completion
self.state['completed'].append({
'pair': pair,
'qty': qty,
'buy_price': entry_price,
'sell_price': current_price,
'profit_percent': gain_percent,
'profit_usd': profit_usd
})
del self.state['current'][pair]
self.save_state()
except Exception as e:
logger.error(f"TP sell error {pair}: {e}")
# SL at -2.5% (auto-cancelled by limit order but check anyway)
elif gain_percent <= -self.STOP_LOSS_PERCENT:
qty = self.state['current'][pair]['qty']
try:
order = self.binance.order_market_sell(symbol=pair, quantity=qty)
loss_usd = (current_price - entry_price) * qty
logger.warning(f"🛑 SL HIT: {pair} {gain_percent:.2f}% = ${loss_usd:.2f}")
self.state['completed'].append({
'pair': pair,
'qty': qty,
'buy_price': entry_price,
'sell_price': current_price,
'profit_percent': gain_percent,
'profit_usd': loss_usd
})
del self.state['current'][pair]
self.save_state()
except Exception as e:
logger.error(f"SL sell error {pair}: {e}")
except Exception as e:
logger.error(f"TP check error: {e}")
def calculate_daily_loss(self):
"""Calculate daily loss percentage"""
try:
if not self.state['completed']:
return 0
today_trades = [t for t in self.state['completed']
if datetime.fromisoformat(t.get('timestamp', datetime.now().isoformat())).date() == datetime.now().date()]
daily_loss = sum(t.get('profit_usd', 0) for t in today_trades)
balance = self.binance.get_account()
portfolio = sum(float(a['free']) for a in balance['balances'])
loss_percent = (daily_loss / portfolio * 100) if portfolio > 0 else 0
return loss_percent
except:
return 0
async def run(self):
"""Main trading loop"""
logger.info("🚀 Trading Bot V5 ENHANCED started (SL+TP+DailyLimit)")
while True:
try:
# Check exits first (TP/SL)
self.check_take_profit()
# Generate signal (5% probability)
if random.random() < 0.05:
pairs = ['BTCUSDT', 'ETHUSDT', 'SOLUSDT', 'BNBUSDT', 'XRPUSDT']
for pair in pairs:
if pair not in self.state['current']:
self.place_buy(pair)
await asyncio.sleep(5)
except Exception as e:
logger.error(f"Loop error: {e}")
await asyncio.sleep(5)
if __name__ == "__main__":
bot = TradingBotV5Enhanced()
asyncio.run(bot.run())

220
src/main_ml_enhanced.py
View File

@ -1,220 +0,0 @@
#!/usr/bin/env python3
"""
Trading Bot V5 ENHANCED - Mit kritischen Risk Management Fixes
Implementiert: SL, TP Anpassung, Daily Limit, R:R Ratio
"""
import os, asyncio, logging, random, json, time
from datetime import datetime, timedelta
from binance.client import Client
from binance.exceptions import BinanceAPIException
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)
# Load config
env = {}
with open('/home/marc/bot-deploy/.env') as f:
for line in f:
k, _, v = line.partition('=')
env[k.strip()] = v.strip()
class TradingBotV5Enhanced:
def __init__(self):
self.binance = Client(env.get('BINANCE_API_KEY_LIVE'), env.get('BINANCE_API_SECRET_LIVE'))
self.state_file = '/home/marc/bot-deploy/trades.json'
self.load_state()
# NEW: Risk Management Settings
self.STOP_LOSS_PERCENT = 2.5 # 2.5% SL (-2.5%)
self.TAKE_PROFIT_PERCENT = 3.0 # 3.0% TP (+3%) - was +1%
self.DAILY_LOSS_LIMIT = 5.0 # Max -5% daily
self.MIN_RISK_REWARD = 1.5 # Min R:R ratio
self.MAX_POSITION_PERCENT = 25 # Max 25% per trade
logger.info("✅ Bot initialized with Risk Management (SL 2.5%, TP 3%, Daily Limit 5%)")
def load_state(self):
if os.path.exists(self.state_file):
with open(self.state_file) as f:
self.state = json.load(f)
else:
self.state = {'current': {}, 'completed': [], 'daily_start_balance': 0}
def save_state(self):
with open(self.state_file, 'w') as f:
json.dump(self.state, f, indent=2)
def check_and_place_sl_orders(self, pair, qty, entry_price):
"""
NEW: Automatically place Stop Loss orders for existing positions
SL = Entry - 2.5%
"""
sl_price = entry_price * (1 - self.STOP_LOSS_PERCENT / 100)
try:
# Check if already has SL order
orders = self.binance.get_open_orders(symbol=pair)
has_sl = any(o['side'] == 'SELL' and float(o['price']) < entry_price for o in orders)
if not has_sl:
# Place SL order
order = self.binance.order_limit_sell(
symbol=pair,
quantity=qty,
price=round(sl_price, 8)
)
logger.info(f"🛡️ Stop Loss set: {pair} {qty} @ ${sl_price:.4f}")
return True
except Exception as e:
logger.error(f"SL Error {pair}: {e}")
return False
def place_buy(self, pair):
"""Place market buy with Risk Management checks"""
try:
# Get balance
balance = self.binance.get_account()
usdt_free = float([a['free'] for a in balance['balances'] if a['asset'] == 'USDT'][0])
# NEW: Daily loss check
daily_loss = self.calculate_daily_loss()
if daily_loss <= -self.DAILY_LOSS_LIMIT:
logger.warning(f"⛔ Daily loss limit hit: {daily_loss:.2f}% (limit: -{self.DAILY_LOSS_LIMIT}%)")
return None
# Calculate position size (25% of USDT)
qty_usdt = usdt_free * (self.MAX_POSITION_PERCENT / 100)
if qty_usdt < 10: # Binance minimum
return None
# Get current price
ticker = self.binance.get_symbol_info(pair)
price = float(self.binance.get_ticker(symbol=pair)['lastPrice'])
# Calculate quantity with LOT_SIZE filter
lot_filter = next(f for f in ticker['filters'] if f['filterType'] == 'LOT_SIZE')
step_size = float(lot_filter['stepSize'])
qty = float(int(qty_usdt / price / step_size) * step_size)
if qty < float(lot_filter['minQty']):
return None
# Place market buy
order = self.binance.order_market_buy(symbol=pair, quantity=qty)
logger.info(f"🟢 BUY: {pair} x{qty:.6f} @ ${price:.4f}")
# NEW: Auto-place Stop Loss
self.check_and_place_sl_orders(pair, qty, price)
return order
except Exception as e:
logger.error(f"Buy Error {pair}: {e}")
return None
def check_take_profit(self):
"""NEW: Check and close at +3% TP with SL protection"""
try:
balance = self.binance.get_account()
for pair in ['BTCUSDT', 'ETHUSDT', 'SOLUSDT', 'BNBUSDT', 'XRPUSDT']:
ticker = self.binance.get_ticker(symbol=pair)
current_price = float(ticker['lastPrice'])
# Check if we have open trade
if pair in self.state['current']:
entry_price = self.state['current'][pair]['buy_price']
gain_percent = (current_price - entry_price) / entry_price * 100
# TP at +3%
if gain_percent >= self.TAKE_PROFIT_PERCENT:
qty = self.state['current'][pair]['qty']
try:
order = self.binance.order_market_sell(symbol=pair, quantity=qty)
profit_usd = (current_price - entry_price) * qty
logger.info(f"💰 TP HIT: {pair} +{gain_percent:.2f}% = ${profit_usd:.2f}")
# Record completion
self.state['completed'].append({
'pair': pair,
'qty': qty,
'buy_price': entry_price,
'sell_price': current_price,
'profit_percent': gain_percent,
'profit_usd': profit_usd
})
del self.state['current'][pair]
self.save_state()
except Exception as e:
logger.error(f"TP sell error {pair}: {e}")
# SL at -2.5% (auto-cancelled by limit order but check anyway)
elif gain_percent <= -self.STOP_LOSS_PERCENT:
qty = self.state['current'][pair]['qty']
try:
order = self.binance.order_market_sell(symbol=pair, quantity=qty)
loss_usd = (current_price - entry_price) * qty
logger.warning(f"🛑 SL HIT: {pair} {gain_percent:.2f}% = ${loss_usd:.2f}")
self.state['completed'].append({
'pair': pair,
'qty': qty,
'buy_price': entry_price,
'sell_price': current_price,
'profit_percent': gain_percent,
'profit_usd': loss_usd
})
del self.state['current'][pair]
self.save_state()
except Exception as e:
logger.error(f"SL sell error {pair}: {e}")
except Exception as e:
logger.error(f"TP check error: {e}")
def calculate_daily_loss(self):
"""Calculate daily loss percentage"""
try:
if not self.state['completed']:
return 0
today_trades = [t for t in self.state['completed']
if datetime.fromisoformat(t.get('timestamp', datetime.now().isoformat())).date() == datetime.now().date()]
daily_loss = sum(t.get('profit_usd', 0) for t in today_trades)
balance = self.binance.get_account()
portfolio = sum(float(a['free']) for a in balance['balances'])
loss_percent = (daily_loss / portfolio * 100) if portfolio > 0 else 0
return loss_percent
except:
return 0
async def run(self):
"""Main trading loop"""
logger.info("🚀 Trading Bot V5 ENHANCED started (SL+TP+DailyLimit)")
while True:
try:
# Check exits first (TP/SL)
self.check_take_profit()
# Generate signal (5% probability)
if random.random() < 0.05:
pairs = ['BTCUSDT', 'ETHUSDT', 'SOLUSDT', 'BNBUSDT', 'XRPUSDT']
for pair in pairs:
if pair not in self.state['current']:
self.place_buy(pair)
await asyncio.sleep(5)
except Exception as e:
logger.error(f"Loop error: {e}")
await asyncio.sleep(5)
if __name__ == "__main__":
bot = TradingBotV5Enhanced()
asyncio.run(bot.run())

205
src/main_ml_fixed.py
View File

@ -1,205 +0,0 @@
#!/usr/bin/env python3
"""
Trading Bot V5 ENHANCED - Risk Management FIXED
Implementiert: SL (mit korrekter Precision), TP, Daily Limit, R:R Ratio
FIXED: PRICE_FILTER für SL Orders durch Tick-Rounding
"""
import os, asyncio, logging, random, json, time, math
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 = 25 # 25% per trade
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
# Precision cache
self.pair_precision = {}
self._load_pair_precision()
logger.info("✅ Bot initialized with Risk Management (SL 2.5%, TP 3%, Daily Limit 5%)")
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)
}
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"""
tick = self.pair_precision.get(pair, {}).get('tick', 0.01)
return round(price / tick) * tick
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
# Place market buy
order = self.client.order_market_buy(symbol=pair, quantity=qty)
logger.info(f"🟢 BUY: {pair} x{qty:.6f} @ ${entry_price:.2f}")
# Store trade
self.active_trades[pair] = {
'entry': entry_price,
'qty': qty,
'time': datetime.now()
}
# Place SL order (FIXED WITH ROUNDING)
await self.place_stop_loss(pair, entry_price, qty)
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"""
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)
# Place SL order
order = self.client.order_take_profit(
symbol=pair,
side='SELL',
type='STOP_LOSS',
timeInForce='GTC',
quantity=qty,
stopPrice=sl_price,
price=sl_price # Binance requires price = stopPrice for STOP_LOSS
)
logger.info(f"🛡️ SL: {pair} @ ${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 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
# 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
async def run_cycle(self):
"""Main trading cycle"""
while True:
try:
# 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())

682
src/main_ml_v02_backup_1783615772.py
View File

@ -1,682 +0,0 @@
#!/usr/bin/env python3
"""
Trading Bot V0.2 — Adaptive Strategy Learning
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 = 7.5 # 7-8% range (midpoint 7.5%) # 5% random signal
self.INVESTMENT_PERCENT = 50 # 50% (single position for liquidity) (single position)
self.INVESTMENT_PERCENT_HIGH = 55 # 55% when confidence > 85% > 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 = 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 = 1 # Single position for max liquidity # 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
# Profit tracking
self.entry_price_history = {} # symbol -> entry price
self.closed_trades = [] # list of {symbol, entry, exit, profit_pct, profit_usdt}
self.session_start_balance = None
self.active_trades = {}
self.daily_pnl = 0
self.paused = False
# ADAPTIVE TRACKING (Option 2: Win Rate based Strategy)
self.total_trades = 0
self.total_wins = 0
self.total_losses = 0
self.last_win_rate = 50.0 # Start neutral
self.strategy_version = 1
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(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()
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 V0.2 — 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 {self.STOP_LOSS_PERCENT}% 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 swap_coins_to_usdt(self):
"""
AUTO-SWAP: Konvertiere alle freien (unlocked) Coins → USDT
Ignoriert locked Coins (von aktiven Trades)
Skip-list: LDBTTC (shitcoin), LDDOGE (shitcoin), USDC (dust)
"""
skip_coins = ['USDT', 'LDBTTC', 'LDDOGE', 'USDC'] # Never swap these
try:
balance = self.client.get_account()
swapped_total_usdt = 0
swap_log = []
for asset in balance['balances']:
coin = asset['asset']
free_qty = float(asset['free'])
# Skip: small amounts, USDT, locked coins, skip-list
if free_qty < 0.00001 or coin in skip_coins:
continue
try:
symbol = f"{coin}USDT"
# Get current price to estimate value
ticker = self.client.get_symbol_info(symbol)
if not ticker:
logger.warning(f"No ticker for {symbol}")
continue
# Round quantity to step size
qty_to_sell = self._round_quantity(free_qty, symbol)
if qty_to_sell < 0.00001:
continue
# MARKET SELL (immediate)
order = self.client.order_market_sell(symbol=symbol, quantity=qty_to_sell)
# Calculate USDT received
fills = order.get('fills', [])
usdt_received = sum(float(f['qty']) * float(f['price']) for f in fills)
swapped_total_usdt += usdt_received
swap_log.append(f"✅ {coin}: {qty_to_sell:.6f} → ${usdt_received:.2f}")
logger.info(f"Sweep: Sold {qty_to_sell} {coin} for ${usdt_received:.2f}")
except BinanceAPIException as e:
logger.warning(f"Sweep {coin}: Binance Error {e.status_code} - {e.message}")
swap_log.append(f"❌ {coin}: {e.message}")
except Exception as e:
logger.warning(f"Sweep {coin}: {e}")
swap_log.append(f"❌ {coin}: {str(e)}")
# RESULT
result = {
'success': True,
'total_usdt_acquired': swapped_total_usdt,
'swaps_attempted': len(swap_log),
'log': swap_log
}
# Send Telegram notification
msg = f"""🔄 **COINS TO USDT SWAP COMPLETE**
**Total Converted:** ${swapped_total_usdt:.2f} → USDT
{chr(10).join(swap_log)}
**New USDT Balance:** ${self.get_usdt_balance():.2f}
"""
self._send_telegram(msg)
logger.info(f"Swap complete: ${swapped_total_usdt:.2f} converted")
return result
except Exception as e:
logger.error(f"Swap error: {e}")
self._send_telegram(f"❌ **SWAP FAILED**: {e}")
return {'success': False, 'error': str(e)}
def get_usdt_balance(self):
"""Get current USDT balance"""
try:
balance = self.client.get_account()
for asset in balance['balances']:
if asset['asset'] == 'USDT':
return float(asset['free'])
return 0.0
except:
return 0.0
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: V0.2 Adaptive"""
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())
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
def record_entry(self, pair, price, quantity):
"""Record entry price for profit calculation"""
self.entry_price_history[pair] = {
'price': price,
'qty': quantity,
'value': price * quantity,
'timestamp': time.time()
}
def calculate_unrealized_pnl(self):
"""Calculate unrealized P&L for open positions"""
try:
prices = get_live_prices()
total_unrealized = 0
for pair, entry_data in self.entry_price_history.items():
asset = pair.replace('USDT', '')
current_price = prices.get(asset, 0)
if current_price > 0:
current_value = entry_data['qty'] * current_price
unrealized = current_value - entry_data['value']
total_unrealized += unrealized
return total_unrealized
except:
return 0
def calculate_realized_pnl(self):
"""Sum all closed trades realized P&L"""
return sum(t.get('profit_usdt', 0) for t in self.closed_trades)
def get_total_pnl(self):
"""Total P&L = realized + unrealized"""
return self.calculate_realized_pnl() + self.calculate_unrealized_pnl()

246
src/main_ml_v03.py
View File

@ -1,246 +0,0 @@
#!/usr/bin/env python3
"""
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 dotenv import load_dotenv
from binance.client import Client
from binance.exceptions import BinanceAPIException
# Setup
logging.basicConfig(level=logging.INFO, format='%(levelname)s:%(message)s')
logger = logging.getLogger()
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")
exit(1)
# Constants
SYMBOLS = ['BTCUSDT', 'ETHUSDT', 'BNBUSDT', 'XRPUSDT', 'SOLUSDT']
MIN_USDT = 5.00
MAX_TRADE_USDT = 20.00
TAKE_PROFIT_PCT = 0.015 # +1.5%
STOP_LOSS_PCT = -0.008 # -0.8%
CYCLE_SEC = 60
class TradingBotV03:
"""Trading Bot with Fresh Cache + Local Min Signals + Hard Risk Management"""
def __init__(self):
self.client = Client(API_KEY, API_SECRET)
self.price_history = {sym: [] for sym in SYMBOLS}
self.active_trades = {} # {symbol: {'entry_price': float, 'qty': float}}
logger.info("Bot V0.3 initialized | Fresh Cache + Local Min + Hard TP/SL")
def get_fresh_balance(self):
"""KEY FIX: Always fetch FRESH balance from API (no stale cache!)"""
try:
account = self.client.get_account()
balances = {}
for b in account['balances']:
balances[b['asset']] = float(b['free'])
usdt_available = balances.get('USDT', 0)
logger.info(f"Fresh balance: USDT=${usdt_available:.2f}")
return balances, usdt_available
except BinanceAPIException as e:
logger.error(f"Balance fetch failed: {e}")
return {}, 0
def get_current_price(self, symbol):
"""Get current market price"""
try:
trades = self.client.get_recent_trades(symbol=symbol, limit=1)
if trades:
return float(trades[0]['price'])
return None
except:
return None
def calculate_valid_quantity(self, symbol, usdt_amount):
"""Calculate valid order quantity respecting LOT_SIZE"""
try:
price = self.get_current_price(symbol)
if not price:
return 0
info = self.client.get_symbol_info(symbol)
if not info:
return 0
step_size = 0.00001 # default
for filt in info.get('filters', []):
if filt['filterType'] == 'LOT_SIZE':
step_size = float(filt['stepSize'])
break
qty = (usdt_amount / price)
qty = int(qty / step_size) * step_size # Round to step_size
notional = qty * price
if notional < MIN_USDT:
logger.debug(f"Order too small: {symbol} ${notional:.2f}")
return 0
return qty
except Exception as e:
logger.warning(f"Qty calc failed: {e}")
return 0
def is_local_minimum(self, symbol):
"""Signal Logic: Buy when price is at local minimum (not random %)"""
if len(self.price_history[symbol]) < 5:
return False
recent_prices = self.price_history[symbol][-5:]
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])
if is_min:
logger.info(f"Local min detected: {symbol} @ ${current_price:.2f}")
return is_min
def place_buy_order(self, symbol, usdt_amount):
"""Place market buy order with entry price tracking"""
try:
qty = self.calculate_valid_quantity(symbol, usdt_amount)
if qty == 0:
return None
entry_price = self.get_current_price(symbol)
if not entry_price:
return None
# Place market buy
order = self.client.order_market_buy(symbol=symbol, quantity=qty)
# Track entry
self.active_trades[symbol] = {
'entry_price': entry_price,
'qty': qty,
'order_id': order.get('orderId'),
'entry_time': datetime.now()
}
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" SL target: -${qty*entry_price*abs(STOP_LOSS_PCT):.2f} ({STOP_LOSS_PCT*100:.1f}%)")
return order
except BinanceAPIException as e:
logger.error(f"Buy order failed: {e}")
return None
def check_and_close_positions(self):
"""HARD RISK MANAGEMENT: Close positions that hit TP or SL"""
for symbol in list(self.active_trades.keys()):
trade = self.active_trades[symbol]
current_price = self.get_current_price(symbol)
if not current_price:
continue
entry_price = trade['entry_price']
qty = trade['qty']
pnl_pct = (current_price - entry_price) / entry_price
pnl_usdt = qty * (current_price - entry_price)
# Check Take Profit (close winners immediately!)
if pnl_pct >= TAKE_PROFIT_PCT:
logger.info(f"TAKE PROFIT: {symbol} +{pnl_pct*100:.2f}% (${pnl_usdt:.2f})")
try:
self.client.order_market_sell(symbol=symbol, quantity=qty)
del self.active_trades[symbol]
except Exception as e:
logger.error(f"Sell failed: {e}")
continue
# Check Stop Loss (cut losers fast!)
if pnl_pct <= STOP_LOSS_PCT:
logger.warning(f"STOP LOSS: {symbol} {pnl_pct*100:.2f}% (${pnl_usdt:.2f})")
try:
self.client.order_market_sell(symbol=symbol, quantity=qty)
del self.active_trades[symbol]
except Exception as e:
logger.error(f"Sell failed: {e}")
continue
def cycle(self):
"""Main trading cycle (runs every 60 seconds)"""
logger.info("=" * 70)
logger.info(f"CYCLE START @ {datetime.now().strftime('%H:%M:%S CET')}")
# STEP 1: Fresh balance (KEY FIX for cache bug!)
balances, usdt_free = self.get_fresh_balance()
if usdt_free < MIN_USDT:
logger.warning(f"Insufficient capital: ${usdt_free:.2f} < ${MIN_USDT}")
logger.info("=" * 70)
return
# STEP 2: Check existing positions (TP/SL logic)
self.check_and_close_positions()
# STEP 3: Update price history for all symbols
for symbol in SYMBOLS:
price = self.get_current_price(symbol)
if price:
self.price_history[symbol].append(price)
# Keep only last 20 prices
if len(self.price_history[symbol]) > 20:
self.price_history[symbol].pop(0)
# STEP 4: Look for local minimum signal
best_signal = None
for symbol in SYMBOLS:
if symbol not in self.active_trades and self.is_local_minimum(symbol):
best_signal = symbol
break
# STEP 5: Place trade if signal exists and we have capital
if best_signal and usdt_free >= MIN_USDT:
# 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)
logger.info(f"CYCLE END | Active trades: {len(self.active_trades)} | Free USDT: ${usdt_free:.2f}")
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__':
bot = TradingBotV03()
bot.run()

157
src/main_ml_v2.py
View File

@ -1,157 +0,0 @@
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)
self.last_report_time = time.time()
self.report_interval = 10800
self.trades_today = 0
self.wins_today = 0
self.losses_today = 0
self.daily_pnl = 0.0
self.report_count = 0
async def auto_swap_to_usdt(self):
"""Auto-swap holdings to USDT if needed"""
try:
balance = await self.binance.get_balance()
usdt_free = float(balance.get('USDT', {}).get('free', 0)) if balance else 0
# If low on USDT, sell any BTC/ETH/SOL holdings
for crypto in ['BTC', 'ETH', 'SOL']:
crypto_balance = float(balance.get(crypto, {}).get('free', 0)) if balance else 0
if usdt_free < 20 and crypto_balance > 0.0001:
pair = crypto + 'USDT'
logger.info(f'SWAP: Selling {crypto_balance:.6f} {crypto} for USDT')
try:
await self.binance.place_order(pair, 'SELL', 'MARKET', crypto_balance * 0.95)
await self.telegram.send_alert(f'SWAP: Sold {crypto_balance:.6f} {crypto}')
return True
except Exception as e:
logger.error(f'Swap failed: {e}')
except Exception as e:
logger.error(f'Auto-swap error: {e}')
return False
async def find_best_trade(self):
"""Scan multiple pairs for best signal"""
pairs = ['BTCUSDT', 'ETHUSDT', 'SOLUSDT', 'BNBUSDT', 'XRPUSDT']
for pair in pairs:
try:
price = await self.binance.get_ticker_price(pair)
signal = self.strategy.predict(price) if hasattr(self.strategy, 'predict') else 'HOLD'
if signal == 'BUY':
logger.info(f'BUY signal: {pair} at {price:.2f}')
return {'pair': pair, 'price': price, 'signal': signal}
except Exception as e:
logger.debug(f'{pair}: {e}')
return {'pair': None, 'signal': 'HOLD'}
async def monitor_trades(self):
"""Monitor & execute trades"""
try:
balance = await self.binance.get_balance()
usdt = float(balance.get('USDT', {}).get('free', 0)) if balance else 0
# Auto-swap if needed
if usdt < 15:
await self.auto_swap_to_usdt()
return
# Find best trade
trade = await self.find_best_trade()
if trade['signal'] == 'BUY' and usdt > 15:
pair = trade['pair']
price = trade['price']
qty = (usdt * 0.7) / price
logger.info(f'EXECUTE BUY: {qty:.6f} {pair} @ {price:.2f}')
try:
await self.binance.place_order(pair, 'BUY', 'MARKET', qty)
self.trades_today += 1
await self.telegram.send_alert(f'BUY {pair}\n{qty:.6f} @ {price:.2f}')
except Exception as e:
logger.error(f'Trade failed: {e}')
except Exception as e:
logger.debug(f'Monitor: {e}')
async def send_performance_report(self):
"""Send 3-hourly report"""
try:
self.report_count += 1
price = await self.binance.get_ticker_price(self.config.trading_pair)
balance = await self.binance.get_balance()
usdt = float(balance.get('USDT', {}).get('free', 0)) if balance else 0
report = f'''REPORT #{self.report_count}
BTC: {price:.2f}
Balance: {usdt:.2f} USDT
Trades: {self.trades_today}
Wins: {self.wins_today}'''
logger.info(report)
await self.telegram.send_alert(report)
except Exception as e:
logger.error(f'Report error: {e}')
async def run(self):
"""Main bot loop"""
logger.info('BOT STARTED - Multi-Crypto Auto-Trading')
await self.telegram.send_alert('BOT STARTED - Multi-Crypto Mode with Auto-Swap')
while True:
try:
current_time = time.time()
if (current_time - self.last_report_time) >= self.report_interval:
await self.send_performance_report()
self.last_report_time = current_time
await self.monitor_trades()
await asyncio.sleep(60)
except Exception as e:
logger.error(f'Bot error: {e}')
await asyncio.sleep(60)
async def main():
config = get_config()
binance = BinanceClientWrapper(
api_key=config.binance_api_key_live,
api_secret=config.binance_api_secret_live,
testnet=False
)
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)
model = joblib.load(config.model_path) if hasattr(config, 'model_path') else None
scaler = None
bot = MLTradingBot(config, binance, telegram, obsidian, model, scaler)
await bot.run()
if __name__ == '__main__':
asyncio.run(main())

173
src/main_ml_v4_backup.py
View File

@ -1,173 +0,0 @@
#!/usr/bin/env python3
import os, asyncio, aiohttp, logging, random
from datetime import datetime
from binance.client import Client
from decimal import Decimal
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)
with open("/home/marc/bot-deploy/.env") as f:
env = {}
for line in f:
k, _, v = line.partition("=")
env[k.strip()] = v.strip()
class Bot:
def __init__(self):
self.binance = Client(env.get("BINANCE_API_KEY_LIVE"), env.get("BINANCE_API_SECRET_LIVE"))
self.current_trades = {}
self.completed_trades = []
self.balance = {}
self.trades_today = 0
self.daily_pnl = 0.0
self.dashboard = "http://localhost:7000/api/update"
logger.info("🤖 Bot initialized")
def get_balance(self):
try:
acc = self.binance.get_account()
self.balance = {}
for a in acc["balances"]:
free, locked = float(a["free"]), float(a["locked"])
if free + locked > 0:
self.balance[a["asset"]] = {"free": free, "locked": locked, "total": free+locked}
logger.info(f"💰 Balance updated: USDT")
except Exception as e:
logger.error(f"Balance error: {e}")
def place_buy(self, pair):
try:
usdt_free = self.balance.get("USDT", {}).get("free", 0)
if usdt_free < 5:
return None
# Use 25% per trade
qty_usdt = usdt_free * 0.25
ticker = self.binance.get_symbol_ticker(symbol=pair)
price = float(ticker["price"])
# Get symbol info for filters
info = self.binance.get_symbol_info(pair)
filters = {f["filterType"]: f for f in info["filters"]}
# LOT_SIZE check
if "LOT_SIZE" in filters:
lot = filters["LOT_SIZE"]
min_qty = float(lot["minQty"])
step = float(lot["stepSize"])
# Calculate quantity
qty_calc = qty_usdt / price
# Round down to step
qty = round(qty_calc / step) * step
if qty < min_qty or qty <= 0:
return None
else:
qty = float(round(qty_usdt / price, 6))
# Format as string to avoid scientific notation
qty_str = f"{qty:.8f}".rstrip("0").rstrip(".")
try:
order = self.binance.order_market_buy(symbol=pair, quantity=qty_str)
logger.info(f"🟢 BUY: {pair} x{qty_str}")
self.current_trades[pair] = {
"qty": float(qty_str),
"buy_price": price,
"buy_time": datetime.now().isoformat(),
"order_id": order["orderId"]
}
self.trades_today += 1
return order
except Exception as e:
logger.error(f"Buy {pair} error: {e}")
return None
except Exception as e:
logger.error(f"place_buy error: {e}")
return None
def check_tp(self):
remove = []
for pair in list(self.current_trades.keys()):
try:
trade = self.current_trades[pair]
ticker = self.binance.get_symbol_ticker(symbol=pair)
current = float(ticker["price"])
profit_pct = (current / trade["buy_price"]) - 1
if profit_pct >= 0.01:
logger.info(f"🎯 TP HIT: {pair} +{profit_pct*100:.2f}%")
sell = self.binance.order_market_sell(symbol=pair, quantity=trade["qty"])
sell_price = float(sell["fills"][0]["price"]) if sell.get("fills") else current
profit = (sell_price - trade["buy_price"]) * trade["qty"]
self.completed_trades.append({
"pair": pair,
"buy_price": trade["buy_price"],
"sell_price": sell_price,
"qty": trade["qty"],
"profit_usd": profit,
"profit_pct": profit_pct,
"buy_time": trade["buy_time"],
"sell_time": datetime.now().isoformat()
})
self.daily_pnl += profit
remove.append(pair)
except Exception as e:
pass
for p in remove:
del self.current_trades[p]
async def send_dashboard(self):
try:
state = {
"current_trades": self.current_trades,
"completed_trades": self.completed_trades[-20:],
"balance": self.balance,
"trades_today": self.trades_today,
"daily_pnl": self.daily_pnl,
"total_pnl": self.daily_pnl,
"wins_today": len([t for t in self.completed_trades if t.get("profit_usd", 0) > 0]),
"losses_today": len([t for t in self.completed_trades if t.get("profit_usd", 0) < 0]),
"last_update": datetime.now().isoformat()
}
async with aiohttp.ClientSession() as s:
async with s.post(self.dashboard, json=state, timeout=2) as r:
pass
except:
pass
async def run(self):
logger.info("🎯 Bot started")
while True:
try:
self.get_balance()
self.check_tp()
pairs = ['BTCUSDT', 'ETHUSDT', 'SOLUSDT', 'BNBUSDT', 'XRPUSDT']
for pair in pairs:
if pair not in self.current_trades and random.random() < 0.05:
logger.info(f"🟢 Signal: {pair}")
self.place_buy(pair)
await self.send_dashboard()
await asyncio.sleep(5)
except Exception as e:
logger.error(f"Run error: {e}")
await asyncio.sleep(10)
if __name__ == "__main__":
bot = Bot()
asyncio.run(bot.run())

200
src/main_ml_v6.py
View File

@ -1,200 +0,0 @@
#!/usr/bin/env python3
"""
Trading Bot V5 CLEAN — Minimal, Reliable, Profitable
Architecture: Single trading loop, live dashboard updates
"""
import os
import asyncio
import aiohttp
from datetime import datetime
from binance.client import Client
from dotenv import load_dotenv
import logging
logging.basicConfig(
level=logging.INFO,
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)
load_dotenv()
class TradingBotClean:
def __init__(self):
self.binance = Client(
os.getenv('BINANCE_API_KEY'),
os.getenv('BINANCE_API_SECRET')
)
self.pairs = ['BTCUSDT', 'ETHUSDT', 'SOLUSDT', 'BNBUSDT', 'XRPUSDT']
# Trading state - SINGLE SOURCE OF TRUTH
self.current_trades = {}
self.completed_trades = []
self.balance = {}
self.trades_today = 0
self.daily_pnl = 0.0
self.total_pnl = 0.0
self.wins_today = 0
self.losses_today = 0
self.dashboard_url = 'http://localhost:7000/api/update'
self.TP = 1.01
self.SL = 0.97
self.BUY_AMOUNT = 0.5
self.MIN_ORDER = 10
logger.info('🤖 Bot CLEAN initialized')
async def update_balance(self):
"""Get current balance from Binance"""
try:
account = self.binance.get_account()
self.balance = {}
for asset in account['balances']:
free = float(asset['free'])
locked = float(asset['locked'])
if free + locked > 0:
self.balance[asset['asset']] = {
'free': free,
'locked': locked,
'total': free + locked
}
except Exception as e:
logger.error(f'Balance error: {e}')
async def get_ml_signal(self, pair, price):
"""Get ML trading signal"""
import random
return 'BUY' if random.random() > 0.95 else None
async def place_buy_order(self, pair, price):
"""Place BUY order"""
try:
usdt_free = self.balance.get('USDT', {}).get('free', 0)
qty_usdt = usdt_free * self.BUY_AMOUNT
if qty_usdt < self.MIN_ORDER:
return None
qty = qty_usdt / price
order = self.binance.order_market_buy(symbol=pair, quantity=qty)
logger.info(f'🟢 BUY: {pair} x{qty:.4f} @ ${price:.2f}')
self.current_trades[pair] = {
'qty': qty,
'buy_price': price,
'buy_time': datetime.now().isoformat(),
'order_id': order['orderId'],
}
self.trades_today += 1
return order
except Exception as e:
logger.error(f'Buy error {pair}: {e}')
return None
async def check_take_profit(self):
"""Check for +1% take profit"""
pairs_to_remove = []
for pair in list(self.current_trades.keys()):
try:
trade = self.current_trades[pair]
ticker = self.binance.get_symbol_ticker(symbol=pair)
current_price = float(ticker['price'])
profit_pct = (current_price / trade['buy_price']) - 1
if profit_pct >= (self.TP - 1): # +1%
logger.info(f'🎯 TP HIT: {pair} +{profit_pct*100:.2f}%')
sell_order = self.binance.order_market_sell(symbol=pair, quantity=trade['qty'])
sell_price = float(sell_order['fills'][0]['price']) if sell_order.get('fills') else current_price
profit_usd = (sell_price - trade['buy_price']) * trade['qty']
self.completed_trades.append({
'pair': pair,
'buy_price': trade['buy_price'],
'sell_price': sell_price,
'qty': trade['qty'],
'profit_usd': profit_usd,
'profit_pct': profit_pct,
'buy_time': trade['buy_time'],
'sell_time': datetime.now().isoformat()
})
self.daily_pnl += profit_usd
self.total_pnl += profit_usd
self.wins_today += 1
pairs_to_remove.append(pair)
except Exception as e:
logger.warning(f'TP check error {pair}: {e}')
for pair in pairs_to_remove:
del self.current_trades[pair]
async def send_to_dashboard(self):
"""Send state to dashboard"""
try:
state = {
'current_trades': self.current_trades,
'completed_trades': self.completed_trades[-20:],
'balance': self.balance,
'trades_today': self.trades_today,
'daily_pnl': self.daily_pnl,
'total_pnl': self.total_pnl,
'wins_today': self.wins_today,
'losses_today': self.losses_today,
'last_update': datetime.now().isoformat()
}
async with aiohttp.ClientSession() as session:
async with session.post(self.dashboard_url, json=state, timeout=2) as resp:
pass
except Exception as e:
logger.warning(f'Dashboard send error: {e}')
async def run(self):
"""Main trading loop"""
logger.info('🎯 Bot started')
while True:
try:
await self.update_balance()
for pair in self.pairs:
if pair in self.current_trades:
continue
try:
ticker = self.binance.get_symbol_ticker(symbol=pair)
price = float(ticker['price'])
signal = await self.get_ml_signal(pair, price)
if signal == 'BUY':
logger.info(f'🟢 BUY signal: {pair}')
await self.place_buy_order(pair, price)
except Exception as e:
pass
await self.check_take_profit()
await self.send_to_dashboard()
await asyncio.sleep(1)
except Exception as e:
logger.error(f'Loop error: {e}')
await asyncio.sleep(5)
async def main():
bot = TradingBotClean()
await bot.run()
if __name__ == '__main__':
asyncio.run(main())

64
src/strategies/dca.py
View File

@ -1,64 +0,0 @@
from datetime import datetime, timedelta
from typing import Optional
from pydantic import BaseModel
class DCAStrategy(BaseModel):
"""Dollar-Cost-Averaging strategy configuration and logic."""
trading_pair: str # e.g., "BTCUSDT"
dca_amount_usd: float # Amount to invest per cycle
interval_hours: float # Time between buys
stop_loss_percent: float # Stop loss percentage
class Config:
validate_assignment = True
def should_execute_dca(self, last_order_time: Optional[datetime] = None) -> bool:
"""
Determine if DCA order should execute.
Args:
last_order_time: Datetime of last order, or None if never ordered
Returns:
True if interval has elapsed, False otherwise
"""
if last_order_time is None:
return True
elapsed = datetime.utcnow() - last_order_time
interval = timedelta(hours=self.interval_hours)
return elapsed >= interval
def calculate_buy_quantity(self, current_price: float) -> float:
"""
Calculate BTC quantity from USD amount.
Args:
current_price: Current BTC price in USD
Returns:
Quantity in BTC (truncated to 4 decimals per Binance)
"""
if current_price <= 0:
raise ValueError("Price must be positive")
quantity = self.dca_amount_usd / current_price
# Truncate to 4 decimals (Binance precision for spot)
quantity = int(quantity * 10000) / 10000
return quantity
def calculate_stop_loss_price(self, entry_price: float) -> float:
"""
Calculate stop loss price.
Args:
entry_price: Price at which order was filled
Returns:
Stop loss price (entry - percentage)
"""
stop_price = entry_price * (1 - self.stop_loss_percent / 100)
# Round to 2 decimals per Binance USDT pair precision
return round(stop_price, 2)