popov/gogo2
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

main cleanup

Browse Source
This commit is contained in:
Dobromir Popov
2025-09-30 23:56:36 +03:00
parent 468a2c2a66
commit 608da8233f
52 changed files with 5308 additions and 9985 deletions
Download Patch File Download Diff File Expand all files Collapse all files

105
debug/test_fixed_issues.py
View File

@@ -1,105 +0,0 @@
#!/usr/bin/env python3
"""
Test script to verify that both model prediction and trading statistics issues are fixed
"""
import sys
import os
sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
from core.orchestrator import TradingOrchestrator
from core.data_provider import DataProvider
from core.trading_executor import TradingExecutor
import asyncio
import logging
# Set up logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
async def test_model_predictions():
"""Test that model predictions are working correctly"""
logger.info("=" * 60)
logger.info("TESTING MODEL PREDICTIONS")
logger.info("=" * 60)
# Initialize components
data_provider = DataProvider()
orchestrator = TradingOrchestrator(data_provider)
# Check model registration
logger.info("1. Checking model registration...")
models = orchestrator.model_registry.get_all_models()
logger.info(f" Registered models: {list(models.keys()) if models else 'None'}")
# Test making a decision
logger.info("2. Testing trading decision generation...")
decision = await orchestrator.make_trading_decision('ETH/USDT')
if decision:
logger.info(f" ✅ Decision generated: {decision.action} (confidence: {decision.confidence:.3f})")
logger.info(f" ✅ Reasoning: {decision.reasoning}")
return True
else:
logger.error(" ❌ No decision generated")
return False
def test_trading_statistics():
"""Test that trading statistics calculations are working correctly"""
logger.info("=" * 60)
logger.info("TESTING TRADING STATISTICS")
logger.info("=" * 60)
# Initialize trading executor
trading_executor = TradingExecutor()
# Check if we have any trades
trade_history = trading_executor.get_trade_history()
logger.info(f"1. Current trade history: {len(trade_history)} trades")
# Get daily stats
daily_stats = trading_executor.get_daily_stats()
logger.info("2. Daily statistics from trading executor:")
logger.info(f" Total trades: {daily_stats.get('total_trades', 0)}")
logger.info(f" Winning trades: {daily_stats.get('winning_trades', 0)}")
logger.info(f" Losing trades: {daily_stats.get('losing_trades', 0)}")
logger.info(f" Win rate: {daily_stats.get('win_rate', 0.0) * 100:.1f}%")
logger.info(f" Avg winning trade: ${daily_stats.get('avg_winning_trade', 0.0):.2f}")
logger.info(f" Avg losing trade: ${daily_stats.get('avg_losing_trade', 0.0):.2f}")
logger.info(f" Total P&L: ${daily_stats.get('total_pnl', 0.0):.2f}")
# If no trades, we can't test calculations
if daily_stats.get('total_trades', 0) == 0:
logger.info("3. No trades found - cannot test calculations without real trading data")
logger.info(" Run the system and execute some real trades to test statistics")
return False
return True
async def main():
"""Run all tests"""
logger.info("🚀 STARTING COMPREHENSIVE FIXES TEST")
logger.info("Testing both model prediction fixes and trading statistics fixes")
# Test model predictions
prediction_success = await test_model_predictions()
# Test trading statistics
stats_success = test_trading_statistics()
logger.info("=" * 60)
logger.info("TEST SUMMARY")
logger.info("=" * 60)
logger.info(f"Model Predictions: {'✅ FIXED' if prediction_success else '❌ STILL BROKEN'}")
logger.info(f"Trading Statistics: {'✅ FIXED' if stats_success else '❌ STILL BROKEN'}")
if prediction_success and stats_success:
logger.info("🎉 ALL ISSUES FIXED! The system should now work correctly.")
else:
logger.error("❌ Some issues remain. Check the logs above for details.")
if __name__ == "__main__":
asyncio.run(main())

210
debug/test_trading_fixes.py
View File

@@ -1,210 +0,0 @@
#!/usr/bin/env python3
"""
Test script to verify trading fixes:
1. Position sizes with leverage
2. ETH-only trading
3. Correct win rate calculations
4. Meaningful P&L values
"""
import sys
import os
sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
from core.trading_executor import TradingExecutor
from core.trading_executor import TradeRecord
from datetime import datetime
import logging
# Set up logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
def test_position_sizing():
"""Test that position sizing now includes leverage and meaningful amounts"""
logger.info("=" * 60)
logger.info("TESTING POSITION SIZING WITH LEVERAGE")
logger.info("=" * 60)
# Initialize trading executor
trading_executor = TradingExecutor()
# Test position calculation
confidence = 0.8
current_price = 2500.0 # ETH price
position_value = trading_executor._calculate_position_size(confidence, current_price)
quantity = position_value / current_price
logger.info(f"1. Position calculation test:")
logger.info(f" Confidence: {confidence}")
logger.info(f" ETH Price: ${current_price}")
logger.info(f" Position Value: ${position_value:.2f}")
logger.info(f" Quantity: {quantity:.6f} ETH")
# Check if position is meaningful
if position_value > 1000: # Should be >$1000 with 10x leverage
logger.info(" ✅ Position size is meaningful (>$1000)")
else:
logger.error(f" ❌ Position size too small: ${position_value:.2f}")
# Test different confidence levels
logger.info("2. Testing different confidence levels:")
for conf in [0.2, 0.5, 0.8, 1.0]:
pos_val = trading_executor._calculate_position_size(conf, current_price)
qty = pos_val / current_price
logger.info(f" Confidence {conf}: ${pos_val:.2f} ({qty:.6f} ETH)")
def test_eth_only_restriction():
"""Test that only ETH trades are allowed"""
logger.info("=" * 60)
logger.info("TESTING ETH-ONLY TRADING RESTRICTION")
logger.info("=" * 60)
trading_executor = TradingExecutor()
# Test ETH trade (should be allowed)
logger.info("1. Testing ETH/USDT trade (should be allowed):")
eth_allowed = trading_executor._check_safety_conditions('ETH/USDT', 'BUY')
logger.info(f" ETH/USDT allowed: {'✅ YES' if eth_allowed else '❌ NO'}")
# Test BTC trade (should be blocked)
logger.info("2. Testing BTC/USDT trade (should be blocked):")
btc_allowed = trading_executor._check_safety_conditions('BTC/USDT', 'BUY')
logger.info(f" BTC/USDT allowed: {'❌ YES (ERROR!)' if btc_allowed else '✅ NO (CORRECT)'}")
def test_win_rate_calculation():
"""Test that win rate calculations are correct"""
logger.info("=" * 60)
logger.info("TESTING WIN RATE CALCULATIONS")
logger.info("=" * 60)
trading_executor = TradingExecutor()
# Get statistics from existing trades
stats = trading_executor.get_daily_stats()
logger.info("1. Current trading statistics:")
logger.info(f" Total trades: {stats['total_trades']}")
logger.info(f" Winning trades: {stats['winning_trades']}")
logger.info(f" Losing trades: {stats['losing_trades']}")
logger.info(f" Win rate: {stats['win_rate']*100:.1f}%")
logger.info(f" Avg winning trade: ${stats['avg_winning_trade']:.2f}")
logger.info(f" Avg losing trade: ${stats['avg_losing_trade']:.2f}")
logger.info(f" Total P&L: ${stats['total_pnl']:.2f}")
# If no trades, we can't verify calculations
if stats['total_trades'] == 0:
logger.info("2. No trades found - cannot verify calculations")
logger.info(" Run the system and execute real trades to test statistics")
return False
# Basic sanity checks on existing data
logger.info("2. Basic validation:")
win_rate_ok = 0.0 <= stats['win_rate'] <= 1.0
avg_win_ok = stats['avg_winning_trade'] >= 0 if stats['winning_trades'] > 0 else True
avg_loss_ok = stats['avg_losing_trade'] <= 0 if stats['losing_trades'] > 0 else True
logger.info(f" Win rate in valid range [0,1]: {'✅' if win_rate_ok else '❌'}")
logger.info(f" Avg win is positive when winning trades exist: {'✅' if avg_win_ok else '❌'}")
logger.info(f" Avg loss is negative when losing trades exist: {'✅' if avg_loss_ok else '❌'}")
return win_rate_ok and avg_win_ok and avg_loss_ok
def test_new_features():
"""Test new features: hold time, leverage, percentage-based sizing"""
logger.info("=" * 60)
logger.info("TESTING NEW FEATURES")
logger.info("=" * 60)
trading_executor = TradingExecutor()
# Test account info
account_info = trading_executor.get_account_info()
logger.info(f"1. Account Information:")
logger.info(f" Account Balance: ${account_info['account_balance']:.2f}")
logger.info(f" Leverage: {account_info['leverage']:.0f}x")
logger.info(f" Trading Mode: {account_info['trading_mode']}")
logger.info(f" Position Sizing: {account_info['position_sizing']['base_percent']:.1f}% base")
# Test leverage setting
logger.info("2. Testing leverage control:")
old_leverage = trading_executor.get_leverage()
logger.info(f" Current leverage: {old_leverage:.0f}x")
success = trading_executor.set_leverage(100.0)
new_leverage = trading_executor.get_leverage()
logger.info(f" Set to 100x: {'✅ SUCCESS' if success and new_leverage == 100.0 else '❌ FAILED'}")
# Reset leverage
trading_executor.set_leverage(old_leverage)
# Test percentage-based position sizing
logger.info("3. Testing percentage-based position sizing:")
confidence = 0.8
eth_price = 2500.0
position_value = trading_executor._calculate_position_size(confidence, eth_price)
account_balance = trading_executor._get_account_balance_for_sizing()
base_percent = trading_executor.mexc_config.get('base_position_percent', 5.0)
leverage = trading_executor.get_leverage()
expected_base = account_balance * (base_percent / 100.0) * confidence
expected_leveraged = expected_base * leverage
logger.info(f" Account: ${account_balance:.2f}")
logger.info(f" Base %: {base_percent:.1f}%")
logger.info(f" Confidence: {confidence:.1f}")
logger.info(f" Leverage: {leverage:.0f}x")
logger.info(f" Expected base: ${expected_base:.2f}")
logger.info(f" Expected leveraged: ${expected_leveraged:.2f}")
logger.info(f" Actual: ${position_value:.2f}")
sizing_ok = abs(position_value - expected_leveraged) < 0.01
logger.info(f" Percentage sizing: {'✅ CORRECT' if sizing_ok else '❌ INCORRECT'}")
return sizing_ok
def main():
"""Run all tests"""
logger.info("🚀 TESTING TRADING FIXES AND NEW FEATURES")
logger.info("Testing position sizing, ETH-only trading, win rate calculations, and new features")
# Test position sizing
test_position_sizing()
# Test ETH-only restriction
test_eth_only_restriction()
# Test win rate calculation
calculation_success = test_win_rate_calculation()
# Test new features
features_success = test_new_features()
logger.info("=" * 60)
logger.info("TEST SUMMARY")
logger.info("=" * 60)
logger.info(f"Position Sizing: ✅ Updated with percentage-based leverage")
logger.info(f"ETH-Only Trading: ✅ Configured in config")
logger.info(f"Win Rate Calculation: {'✅ FIXED' if calculation_success else '❌ STILL BROKEN'}")
logger.info(f"New Features: {'✅ WORKING' if features_success else '❌ ISSUES FOUND'}")
if calculation_success and features_success:
logger.info("🎉 ALL FEATURES WORKING! Now you should see:")
logger.info(" - Percentage-based position sizing (2-20% of account)")
logger.info(" - 50x leverage (adjustable in UI)")
logger.info(" - Hold time in seconds for each trade")
logger.info(" - Total fees in trading statistics")
logger.info(" - Only ETH/USDT trades")
logger.info(" - Correct win rate calculations")
else:
logger.error("❌ Some issues remain. Check the logs above for details.")
if __name__ == "__main__":
main()