Quick Start Guide¶

"""
Simple Moving Average Crossover Strategy
Buy when fast MA crosses above slow MA, sell when it crosses below.
"""

import sys
sys.path.insert(0, 'src')

from backtesting import Backtest
from backtesting.strategy import BaseStrategy
from backtesting.indicators import sma
import numpy as np


class SMACrossover(BaseStrategy):
    """
    Simple Moving Average Crossover Strategy.

    Parameters:
        fast_period: Fast MA period (default: 10)
        slow_period: Slow MA period (default: 30)
    """

    # Strategy parameters
    fast_period = 10
    slow_period = 30

    def init(self):
        """Initialize indicators."""
        # Calculate moving averages on close prices
        close = np.array([c['close'] for c in self.data])
        self.fast_ma = sma(close, self.fast_period)
        self.slow_ma = sma(close, self.slow_period)

    def next(self):
        """Execute on each new candle."""
        # Need enough data for both MAs
        if len(self.data) < self.slow_period:
            return

        # Get current and previous MA values
        current_fast = self.fast_ma
        current_slow = self.slow_ma

        # Crossover logic
        if current_fast > current_slow:
            # Golden cross - buy signal
            if not self.position:
                self.buy()
        elif current_fast < current_slow:
            # Death cross - sell signal
            if self.position:
                self.sell()


if __name__ == '__main__':
    # Create backtest with sample data
    bt = Backtest(
        strategy=SMACrossover,
        cash=10000,  # Starting capital
        commission=0.001  # 0.1% commission
    )

    # Load sample data (will be replaced with real data later)
    # For now, create synthetic data
    from datetime import datetime, timedelta
    import random

    # Generate 180 days of hourly data
    data = []
    base_price = 50000
    start_time = datetime.now() - timedelta(days=180)

    for i in range(180 * 24):  # 180 days * 24 hours
        price_change = random.uniform(-0.01, 0.01)
        base_price *= (1 + price_change)

        data.append({
            'timestamp': start_time + timedelta(hours=i),
            'open': base_price * (1 + random.uniform(-0.002, 0.002)),
            'high': base_price * (1 + random.uniform(0, 0.005)),
            'low': base_price * (1 - random.uniform(0, 0.005)),
            'close': base_price,
            'volume': random.uniform(100, 1000)
        })

    # Run backtest
    print("Running backtest...")
    stats = bt.run(data)

    # Print results
    print("\n" + "="*60)
    print("BACKTEST RESULTS")
    print("="*60)
    print(f"Total Return: {stats['total_return']:.2%}")
    print(f"Sharpe Ratio: {stats['sharpe_ratio']:.2f}")
    print(f"Max Drawdown: {stats['max_drawdown']:.2%}")
    print(f"Win Rate: {stats['win_rate']:.2%}")
    print(f"Total Trades: {stats['num_trades']}")
    print("="*60)

from api.tasks.data_collection import collect_candlesticks
from datetime import datetime, timedelta

# Collect data
end_time = datetime.now()
start_time = end_time - timedelta(days=30)

collect_candlesticks(
    exchange='binance',
    symbol='BTCUSDT',
    interval='1h',
    start_time=start_time,
    end_time=end_time
)

print("Data collection complete!")

from api.models import Candlestick
from backtesting import Backtest
from my_first_strategy import SMACrossover

# Load data from database
candles = Candlestick.objects.filter(
    exchange='binance',
    symbol='BTCUSDT',
    interval='1h'
).order_by('timestamp').values(
    'timestamp', 'open_price', 'high_price', 
    'low_price', 'close_price', 'volume'
)

# Convert to backtest format
data = [{
    'timestamp': c['timestamp'],
    'open': float(c['open_price']),
    'high': float(c['high_price']),
    'low': float(c['low_price']),
    'close': float(c['close_price']),
    'volume': float(c['volume'])
} for c in candles]

# Run backtest
bt = Backtest(strategy=SMACrossover, cash=10000)
stats = bt.run(data)

print(f"Total Return: {stats['total_return']:.2%}")