#!/usr/bin/env python3 """ Basic Usage Example for IncrementalTrader This example demonstrates the basic usage of the IncrementalTrader framework for testing trading strategies. """ import pandas as pd from IncrementalTrader import ( MetaTrendStrategy, BBRSStrategy, RandomStrategy, IncTrader, IncBacktester, BacktestConfig ) def basic_strategy_usage(): """Demonstrate basic strategy usage with live data processing.""" print("=== Basic Strategy Usage ===") # Create a strategy strategy = MetaTrendStrategy("metatrend", params={ "timeframe": "15min", "supertrend_periods": [10, 20, 30], "supertrend_multipliers": [2.0, 3.0, 4.0], "min_trend_agreement": 0.6 }) # Create trader trader = IncTrader( strategy=strategy, initial_usd=10000, stop_loss_pct=0.03, take_profit_pct=0.06, fee_pct=0.001 ) # Simulate some price data (in real usage, this would come from your data source) sample_data = [ (1640995200000, (46000, 46500, 45800, 46200, 1000)), # timestamp, (O,H,L,C,V) (1640995260000, (46200, 46800, 46100, 46600, 1200)), (1640995320000, (46600, 47000, 46400, 46800, 1100)), (1640995380000, (46800, 47200, 46700, 47000, 1300)), (1640995440000, (47000, 47400, 46900, 47200, 1150)), # Add more data points as needed... ] print(f"Processing {len(sample_data)} data points...") # Process data points for timestamp, ohlcv in sample_data: signal = trader.process_data_point(timestamp, ohlcv) # Log significant signals if signal.signal_type != 'HOLD': print(f"Signal: {signal.signal_type} at price {ohlcv[3]} (confidence: {signal.confidence:.2f})") # Get results results = trader.get_results() print(f"\nFinal Portfolio Value: ${results['final_portfolio_value']:.2f}") print(f"Total Return: {results['total_return_pct']:.2f}%") print(f"Number of Trades: {len(results['trades'])}") def basic_backtesting(): """Demonstrate basic backtesting functionality.""" print("\n=== Basic Backtesting ===") # Note: In real usage, you would have a CSV file with historical data # For this example, we'll create sample data create_sample_data_file() # Configure backtest config = BacktestConfig( initial_usd=10000, stop_loss_pct=0.03, take_profit_pct=0.06, start_date="2024-01-01", end_date="2024-01-31", fee_pct=0.001, slippage_pct=0.0005 ) # Create backtester backtester = IncBacktester() # Test MetaTrend strategy print("Testing MetaTrend Strategy...") results = backtester.run_single_strategy( strategy_class=MetaTrendStrategy, strategy_params={"timeframe": "15min"}, config=config, data_file="sample_data.csv" ) # Print results performance = results['performance_metrics'] print(f"Total Return: {performance['total_return_pct']:.2f}%") print(f"Sharpe Ratio: {performance['sharpe_ratio']:.2f}") print(f"Max Drawdown: {performance['max_drawdown_pct']:.2f}%") print(f"Win Rate: {performance['win_rate']:.2f}%") print(f"Total Trades: {performance['total_trades']}") def compare_strategies(): """Compare different strategies on the same data.""" print("\n=== Strategy Comparison ===") # Ensure we have sample data create_sample_data_file() # Configure backtest config = BacktestConfig( initial_usd=10000, start_date="2024-01-01", end_date="2024-01-31" ) # Strategies to compare strategies = [ (MetaTrendStrategy, {"timeframe": "15min"}, "MetaTrend"), (BBRSStrategy, {"timeframe": "15min"}, "BBRS"), (RandomStrategy, {"timeframe": "15min", "seed": 42}, "Random") ] backtester = IncBacktester() results_comparison = {} for strategy_class, params, name in strategies: print(f"Testing {name} strategy...") results = backtester.run_single_strategy( strategy_class=strategy_class, strategy_params=params, config=config, data_file="sample_data.csv" ) results_comparison[name] = results['performance_metrics'] # Print comparison print("\n--- Strategy Comparison Results ---") print(f"{'Strategy':<12} {'Return %':<10} {'Sharpe':<8} {'Max DD %':<10} {'Trades':<8}") print("-" * 50) for name, performance in results_comparison.items(): print(f"{name:<12} {performance['total_return_pct']:<10.2f} " f"{performance['sharpe_ratio']:<8.2f} {performance['max_drawdown_pct']:<10.2f} " f"{performance['total_trades']:<8}") def create_sample_data_file(): """Create a sample data file for backtesting examples.""" import numpy as np from datetime import datetime, timedelta # Generate sample OHLCV data start_date = datetime(2024, 1, 1) end_date = datetime(2024, 1, 31) # Generate timestamps (1-minute intervals) timestamps = [] current_time = start_date while current_time <= end_date: timestamps.append(int(current_time.timestamp() * 1000)) current_time += timedelta(minutes=1) # Generate realistic price data with some trend np.random.seed(42) # For reproducible results initial_price = 45000 prices = [initial_price] for i in range(1, len(timestamps)): # Add some trend and random walk trend = 0.0001 * i # Slight upward trend random_change = np.random.normal(0, 0.002) # 0.2% volatility new_price = prices[-1] * (1 + trend + random_change) prices.append(new_price) # Generate OHLCV data data = [] for i, (timestamp, close) in enumerate(zip(timestamps, prices)): # Generate realistic OHLC from close price volatility = close * 0.001 # 0.1% intrabar volatility high = close + np.random.uniform(0, volatility) low = close - np.random.uniform(0, volatility) open_price = low + np.random.uniform(0, high - low) # Ensure OHLC consistency high = max(high, open_price, close) low = min(low, open_price, close) volume = np.random.uniform(800, 1500) # Random volume data.append({ 'timestamp': timestamp, 'open': round(open_price, 2), 'high': round(high, 2), 'low': round(low, 2), 'close': round(close, 2), 'volume': round(volume, 2) }) # Save to CSV df = pd.DataFrame(data) df.to_csv("sample_data.csv", index=False) print(f"Created sample data file with {len(data)} data points") def indicator_usage_example(): """Demonstrate how to use indicators directly.""" print("\n=== Direct Indicator Usage ===") from IncrementalTrader.strategies.indicators import ( MovingAverageState, RSIState, SupertrendState, BollingerBandsState ) # Initialize indicators sma_20 = MovingAverageState(period=20) rsi_14 = RSIState(period=14) supertrend = SupertrendState(period=10, multiplier=3.0) bb = BollingerBandsState(period=20, std_dev=2.0) # Sample price data prices = [100, 101, 99, 102, 98, 103, 97, 104, 96, 105, 94, 106, 93, 107, 92, 108, 91, 109, 90, 110] print("Processing price data with indicators...") print(f"{'Price':<8} {'SMA20':<8} {'RSI14':<8} {'ST Signal':<10} {'BB %B':<8}") print("-" * 50) for i, price in enumerate(prices): # Update indicators sma_20.update(price) rsi_14.update(price) # For Supertrend, we need OHLC data (using price as close, with small spread) high = price * 1.001 low = price * 0.999 supertrend.update_ohlc(high, low, price) bb.update(price) # Print values when indicators are ready if i >= 19: # After warmup period sma_val = sma_20.get_value() if sma_20.is_ready() else "N/A" rsi_val = rsi_14.get_value() if rsi_14.is_ready() else "N/A" st_signal = supertrend.get_signal() if supertrend.is_ready() else "N/A" bb_percent_b = bb.get_percent_b(price) if bb.is_ready() else "N/A" print(f"{price:<8.2f} {sma_val:<8.2f} {rsi_val:<8.2f} " f"{st_signal:<10} {bb_percent_b:<8.2f}") if __name__ == "__main__": """Run all examples.""" print("IncrementalTrader - Basic Usage Examples") print("=" * 50) try: # Run examples basic_strategy_usage() basic_backtesting() compare_strategies() indicator_usage_example() print("\n" + "=" * 50) print("All examples completed successfully!") print("\nNext steps:") print("1. Replace sample data with your own historical data") print("2. Experiment with different strategy parameters") print("3. Create your own custom strategies") print("4. Use parameter optimization for better results") except Exception as e: print(f"Error running examples: {e}") print("Make sure you have the IncrementalTrader module properly installed.")