Place-Order-Trading-Bot/performance_analysis_clean.py

#!/usr/bin/env python3
"""
📊 Performance Analysis - Clean Data
Umfassende Analyse mit bereinigten Daten
"""

import sqlite3
import pandas as pd
from datetime import datetime
import numpy as np

conn = sqlite3.connect('trading_bot.db')

print('=' * 80)
print('📊 PERFORMANCE ANALYSE - Mit sauberen Daten')
print('=' * 80)
print(f'Datum: {datetime.now().strftime("%Y-%m-%d %H:%M:%S")}')
print()

# ==========================================
# 1. GESAMT-PERFORMANCE
# ==========================================
print('1️⃣ GESAMT-PERFORMANCE')
print('-' * 80)

overall = pd.read_sql_query('''
    SELECT
        COUNT(*) as total_trades,
        SUM(CASE WHEN net_profit > 0 THEN 1 ELSE 0 END) as wins,
        SUM(CASE WHEN net_profit < 0 THEN 1 ELSE 0 END) as losses,
        SUM(CASE WHEN net_profit = 0 THEN 1 ELSE 0 END) as breakeven,
        ROUND(SUM(net_profit), 2) as total_profit,
        ROUND(AVG(net_profit), 2) as avg_profit_per_trade,
        ROUND(AVG(CASE WHEN net_profit > 0 THEN net_profit END), 2) as avg_win,
        ROUND(AVG(CASE WHEN net_profit < 0 THEN net_profit END), 2) as avg_loss,
        ROUND(MAX(net_profit), 2) as best_trade,
        ROUND(MIN(net_profit), 2) as worst_trade,
        MIN(entry_time) as first_trade,
        MAX(entry_time) as last_trade
    FROM trades
''', conn)

total = overall['total_trades'][0]
wins = overall['wins'][0]
losses = overall['losses'][0]
win_rate = (wins / total * 100) if total > 0 else 0
avg_win = overall['avg_win'][0]
avg_loss = overall['avg_loss'][0]
profit_factor = abs(avg_win / avg_loss) if avg_loss != 0 else 0
expectancy = (win_rate/100 * avg_win) + ((100-win_rate)/100 * avg_loss)

print(f'Total Trades: {total}')
print(f'Zeitraum: {overall["first_trade"][0]} bis {overall["last_trade"][0]}')
print()
print(f'Wins: {wins} ({win_rate:.1f}%)')
print(f'Losses: {losses} ({(losses/total*100):.1f}%)')
print(f'Breakeven: {overall["breakeven"][0]}')
print()
print(f'Total Profit: ${overall["total_profit"][0]:,.2f}')
print(f'Avg Profit/Trade: ${overall["avg_profit_per_trade"][0]:.2f}')
print()
print(f'Avg Win: ${avg_win:.2f}')
print(f'Avg Loss: ${avg_loss:.2f}')
print(f'Profit Factor: {profit_factor:.2f}')
print(f'Expectancy: ${expectancy:.2f}/Trade')
print()
print(f'Best Trade: ${overall["best_trade"][0]:.2f}')
print(f'Worst Trade: ${overall["worst_trade"][0]:.2f}')
print()

# ==========================================
# 2. SESSION PERFORMANCE
# ==========================================
print('=' * 80)
print('2️⃣ SESSION PERFORMANCE (sortiert nach Profit/Trade)')
print('-' * 80)

session_perf = pd.read_sql_query('''
    SELECT
        session,
        COUNT(*) as trades,
        SUM(CASE WHEN net_profit > 0 THEN 1 ELSE 0 END) as wins,
        SUM(CASE WHEN net_profit < 0 THEN 1 ELSE 0 END) as losses,
        ROUND(AVG(confidence), 1) as avg_conf,
        ROUND(SUM(net_profit), 2) as total_profit,
        ROUND(AVG(net_profit), 2) as avg_profit,
        ROUND(MAX(net_profit), 2) as best,
        ROUND(MIN(net_profit), 2) as worst
    FROM trades
    GROUP BY session
    ORDER BY avg_profit DESC
''', conn)

session_perf['win_rate'] = (session_perf['wins'] / session_perf['trades'] * 100).round(1)

print(session_perf.to_string(index=False))
print()

# ==========================================
# 3. QUALITY PERFORMANCE
# ==========================================
print('=' * 80)
print('3️⃣ SIGNAL QUALITY PERFORMANCE')
print('-' * 80)

quality_perf = pd.read_sql_query('''
    SELECT
        quality,
        COUNT(*) as trades,
        ROUND(MIN(confidence), 1) as min_conf,
        ROUND(AVG(confidence), 1) as avg_conf,
        ROUND(MAX(confidence), 1) as max_conf,
        SUM(CASE WHEN net_profit > 0 THEN 1 ELSE 0 END) as wins,
        SUM(CASE WHEN net_profit < 0 THEN 1 ELSE 0 END) as losses,
        ROUND(SUM(net_profit), 2) as total_profit,
        ROUND(AVG(net_profit), 2) as avg_profit
    FROM trades
    WHERE quality IS NOT NULL
    GROUP BY quality
    ORDER BY avg_conf DESC
''', conn)

quality_perf['win_rate'] = (quality_perf['wins'] / quality_perf['trades'] * 100).round(1)

print(quality_perf.to_string(index=False))
print()

# ==========================================
# 4. CONFIDENCE BANDS ANALYSE
# ==========================================
print('=' * 80)
print('4️⃣ CONFIDENCE BANDS ANALYSE (wichtig für Adaptive Sizing!)')
print('-' * 80)

confidence_bands = pd.read_sql_query('''
    SELECT
        CASE
            WHEN confidence >= 95 THEN '95-100% (Excellent)'
            WHEN confidence >= 90 THEN '90-94% (Very Strong)'
            WHEN confidence >= 85 THEN '85-89% (Strong)'
            WHEN confidence >= 80 THEN '80-84% (High)'
            WHEN confidence >= 75 THEN '75-79% (Good)'
            WHEN confidence >= 70 THEN '70-74% (Medium)'
            ELSE '<70% (Low)'
        END as conf_band,
        COUNT(*) as trades,
        ROUND(AVG(confidence), 1) as avg_conf,
        SUM(CASE WHEN net_profit > 0 THEN 1 ELSE 0 END) as wins,
        ROUND(SUM(net_profit), 2) as total_profit,
        ROUND(AVG(net_profit), 2) as avg_profit
    FROM trades
    WHERE confidence IS NOT NULL
    GROUP BY conf_band
    ORDER BY avg_conf DESC
''', conn)

confidence_bands['win_rate'] = (confidence_bands['wins'] / confidence_bands['trades'] * 100).round(1)

print(confidence_bands.to_string(index=False))
print()

# ==========================================
# 5. VOLUME ANALYSE
# ==========================================
print('=' * 80)
print('5️⃣ VOLUME (LOT SIZE) ANALYSE')
print('-' * 80)

volume_stats = pd.read_sql_query('''
    SELECT
        volume,
        COUNT(*) as trades,
        ROUND(AVG(confidence), 1) as avg_conf,
        SUM(CASE WHEN net_profit > 0 THEN 1 ELSE 0 END) as wins,
        ROUND(SUM(net_profit), 2) as total_profit,
        ROUND(AVG(net_profit), 2) as avg_profit
    FROM trades
    GROUP BY volume
    ORDER BY volume DESC
''', conn)

volume_stats['win_rate'] = (volume_stats['wins'] / volume_stats['trades'] * 100).round(1)

print(volume_stats.to_string(index=False))
print()

# ==========================================
# 6. MONATLICHE PERFORMANCE
# ==========================================
print('=' * 80)
print('6️⃣ MONATLICHE PERFORMANCE')
print('-' * 80)

monthly = pd.read_sql_query('''
    SELECT
        strftime('%Y-%m', entry_time) as month,
        COUNT(*) as trades,
        SUM(CASE WHEN net_profit > 0 THEN 1 ELSE 0 END) as wins,
        ROUND(SUM(net_profit), 2) as profit,
        ROUND(AVG(net_profit), 2) as avg_profit
    FROM trades
    GROUP BY month
    ORDER BY month DESC
''', conn)

monthly['win_rate'] = (monthly['wins'] / monthly['trades'] * 100).round(1)

print(monthly.to_string(index=False))
print()

# ==========================================
# 7. DRAWDOWN ANALYSE
# ==========================================
print('=' * 80)
print('7️⃣ DRAWDOWN & EQUITY CURVE')
print('-' * 80)

trades_timeline = pd.read_sql_query('''
    SELECT
        DATE(entry_time) as date,
        net_profit
    FROM trades
    ORDER BY entry_time
''', conn)

# Calculate cumulative profit
trades_timeline['cumulative_profit'] = trades_timeline['net_profit'].cumsum()
trades_timeline['running_max'] = trades_timeline['cumulative_profit'].cummax()
trades_timeline['drawdown'] = trades_timeline['cumulative_profit'] - trades_timeline['running_max']

max_dd = trades_timeline['drawdown'].min()
max_dd_pct = (max_dd / trades_timeline['running_max'].max() * 100) if trades_timeline['running_max'].max() > 0 else 0

print(f'Max Drawdown: ${max_dd:.2f} ({max_dd_pct:.1f}%)')
print(f'Current Equity: ${trades_timeline["cumulative_profit"].iloc[-1]:.2f}')
print(f'Peak Equity: ${trades_timeline["running_max"].max():.2f}')
print()

# ==========================================
# 8. TOP TRADES
# ==========================================
print('=' * 80)
print('8️⃣ TOP 5 BEST TRADES')
print('-' * 80)

best_trades = pd.read_sql_query('''
    SELECT
        DATE(entry_time) as date,
        session,
        quality,
        ROUND(confidence, 1) as conf,
        volume,
        ROUND(net_profit, 2) as profit
    FROM trades
    ORDER BY net_profit DESC
    LIMIT 5
''', conn)

print(best_trades.to_string(index=False))
print()

print('=' * 80)
print('9️⃣ TOP 5 WORST TRADES')
print('-' * 80)

worst_trades = pd.read_sql_query('''
    SELECT
        DATE(entry_time) as date,
        session,
        quality,
        ROUND(confidence, 1) as conf,
        volume,
        ROUND(net_profit, 2) as profit
    FROM trades
    ORDER BY net_profit ASC
    LIMIT 5
''', conn)

print(worst_trades.to_string(index=False))
print()

conn.close()

print('=' * 80)
print('✅ ANALYSE ABGESCHLOSSEN')
print('=' * 80)