Bollinger Ausbruch DC2008

using System;
using System.Linq;
using System.Collections.Generic;
using Ecng.Common;
using Ecng.Collections;
using Ecng.Serialization;
using StockSharp.Algo.Indicators;
using StockSharp.Algo.Strategies;
using StockSharp.BusinessEntities;
using StockSharp.Messages;

namespace StockSharp.Samples.Strategies;



/// <summary>
/// Bollinger breakout strategy inspired by DC2008 implementation.
/// </summary>
public class BollingerBreakoutDc2008Strategy : Strategy
{
	public enum AppliedPriceTypes
	{
		Close,
		Open,
		High,
		Low,
		Median,
		Typical,
		Weighted,
		Average
	}

	private readonly StrategyParam<int> _bandsPeriod;
	private readonly StrategyParam<decimal> _bandsDeviation;
	private readonly StrategyParam<AppliedPriceTypes> _appliedPrice;
	private readonly StrategyParam<DataType> _candleType;

	private BollingerBands _bollinger;
	private decimal _entryPrice;

	public int BandsPeriod
	{
		get => _bandsPeriod.Value;
		set => _bandsPeriod.Value = value;
	}

	public decimal BandsDeviation
	{
		get => _bandsDeviation.Value;
		set => _bandsDeviation.Value = value;
	}

	public AppliedPriceTypes AppliedPrice
	{
		get => _appliedPrice.Value;
		set => _appliedPrice.Value = value;
	}

	public DataType CandleType
	{
		get => _candleType.Value;
		set => _candleType.Value = value;
	}

	public BollingerBreakoutDc2008Strategy()
	{
		_bandsPeriod = Param(nameof(BandsPeriod), 80)
			.SetDisplay("Bands Period", "Number of candles for Bollinger Bands", "Indicators")
			.SetGreaterThanZero()
			
			.SetOptimize(10, 200, 10);

		_bandsDeviation = Param(nameof(BandsDeviation), 3m)
			.SetDisplay("Deviation", "Standard deviation multiplier", "Indicators")
			.SetGreaterThanZero()
			
			.SetOptimize(1m, 5m, 0.5m);

		_appliedPrice = Param(nameof(AppliedPrice), AppliedPriceTypes.Close)
			.SetDisplay("Applied Price", "Candle price source for Bollinger Bands", "Indicators");

		_candleType = Param(nameof(CandleType), TimeSpan.FromMinutes(5).TimeFrame())
			.SetDisplay("Candle Type", "Type of candles to analyze", "General");
	}

	/// <inheritdoc />
	public override IEnumerable<(Security sec, DataType dt)> GetWorkingSecurities()
	{
		yield return (Security, CandleType);
	}

	/// <inheritdoc />
	protected override void OnReseted()
	{
		base.OnReseted();
		_bollinger = null;
		_entryPrice = 0m;
	}

	/// <inheritdoc />
	protected override void OnStarted2(DateTime time)
	{
		base.OnStarted2(time);

		// Create Bollinger Bands indicator with the configured parameters.
		_bollinger = new BollingerBands
		{
			Length = BandsPeriod,
			Width = BandsDeviation
		};

		var subscription = SubscribeCandles(CandleType);
		subscription
			.Bind(ProcessCandle)
			.Start();

		var area = CreateChartArea();
		if (area != null)
		{
			DrawCandles(area, subscription);
			DrawIndicator(area, _bollinger);
			DrawOwnTrades(area);
		}
	}

	private void ProcessCandle(ICandleMessage candle)
	{
		if (candle.State != CandleStates.Finished || _bollinger is null)
			return;

		// Calculate Bollinger Bands for the selected price source.
		var indicatorValue = _bollinger.Process(new DecimalIndicatorValue(_bollinger, GetAppliedPrice(candle), candle.OpenTime) { IsFinal = true });

		if (!indicatorValue.IsFinal)
			return;

		if (indicatorValue is not BollingerBandsValue bands)
			return;

		if (bands.UpBand is not decimal upper || bands.LowBand is not decimal lower || bands.MovingAverage is not decimal middle)
			return;

		var high = candle.HighPrice;
		var low = candle.LowPrice;
		var close = candle.ClosePrice;

		// Determine breakout conditions based on Bollinger structure.
		var buySignal = low < lower && high < middle;
		var sellSignal = high > upper && low > middle;

		if (!buySignal && !sellSignal)
			return;

		// Compute unrealized profit to mimic original position filter.
		var unrealizedPnL = Position == 0 ? 0m : Position * (close - _entryPrice);

		if (buySignal)
		{
			if (Position == 0)
			{
				// No position open, start a new long.
				BuyMarket();
				_entryPrice = close;
			}
			else
			{
				if (unrealizedPnL < 0m)
					return;

				if (Position < 0)
				{
					// Reverse from short to long while preserving target volume.
					BuyMarket();
					_entryPrice = close;
				}
			}

			return;
		}

		if (sellSignal)
		{
			if (Position == 0)
			{
				// No position open, start a new short.
				SellMarket();
				_entryPrice = close;
			}
			else
			{
				if (unrealizedPnL < 0m)
					return;

				if (Position > 0)
				{
					// Reverse from long to short while preserving target volume.
					SellMarket();
					_entryPrice = close;
				}
			}
		}
	}

	private decimal GetAppliedPrice(ICandleMessage candle)
	{
		return AppliedPrice switch
		{
			AppliedPriceTypes.Close => candle.ClosePrice,
			AppliedPriceTypes.Open => candle.OpenPrice,
			AppliedPriceTypes.High => candle.HighPrice,
			AppliedPriceTypes.Low => candle.LowPrice,
			AppliedPriceTypes.Median => (candle.HighPrice + candle.LowPrice) / 2m,
			AppliedPriceTypes.Typical => (candle.HighPrice + candle.LowPrice + candle.ClosePrice) / 3m,
			AppliedPriceTypes.Weighted => (candle.HighPrice + candle.LowPrice + (2m * candle.ClosePrice)) / 4m,
			AppliedPriceTypes.Average => (candle.OpenPrice + candle.HighPrice + candle.LowPrice + candle.ClosePrice) / 4m,
			_ => candle.ClosePrice
		};
	}
}

import clr

clr.AddReference("StockSharp.Messages")
clr.AddReference("StockSharp.Algo")
clr.AddReference("StockSharp.Algo.Indicators")
clr.AddReference("StockSharp.Algo.Strategies")

from System import TimeSpan, Math
from StockSharp.Messages import DataType, CandleStates, Unit, UnitTypes
from StockSharp.Algo.Indicators import BollingerBands
from StockSharp.Algo.Strategies import Strategy
from indicator_extensions import *

PRICE_CLOSE = 0
PRICE_OPEN = 1
PRICE_HIGH = 2
PRICE_LOW = 3
PRICE_MEDIAN = 4
PRICE_TYPICAL = 5
PRICE_WEIGHTED = 6
PRICE_AVERAGE = 7

class bollinger_breakout_dc2008_strategy(Strategy):
    def __init__(self):
        super(bollinger_breakout_dc2008_strategy, self).__init__()

        self._bands_period = self.Param("BandsPeriod", 80)
        self._bands_deviation = self.Param("BandsDeviation", 3.0)
        self._applied_price = self.Param("AppliedPrice", PRICE_CLOSE)
        self._candle_type = self.Param("CandleType", DataType.TimeFrame(TimeSpan.FromMinutes(5)))

        self._entry_price = 0.0

    @property
    def BandsPeriod(self):
        return self._bands_period.Value

    @BandsPeriod.setter
    def BandsPeriod(self, value):
        self._bands_period.Value = value

    @property
    def BandsDeviation(self):
        return self._bands_deviation.Value

    @BandsDeviation.setter
    def BandsDeviation(self, value):
        self._bands_deviation.Value = value

    @property
    def AppliedPrice(self):
        return self._applied_price.Value

    @AppliedPrice.setter
    def AppliedPrice(self, value):
        self._applied_price.Value = value

    @property
    def CandleType(self):
        return self._candle_type.Value

    @CandleType.setter
    def CandleType(self, value):
        self._candle_type.Value = value

    def _get_applied_price(self, candle):
        ap = int(self.AppliedPrice)
        if ap == PRICE_OPEN:
            return candle.OpenPrice
        elif ap == PRICE_HIGH:
            return candle.HighPrice
        elif ap == PRICE_LOW:
            return candle.LowPrice
        elif ap == PRICE_MEDIAN:
            return (candle.HighPrice + candle.LowPrice) / 2
        elif ap == PRICE_TYPICAL:
            return (candle.HighPrice + candle.LowPrice + candle.ClosePrice) / 3
        elif ap == PRICE_WEIGHTED:
            return (candle.HighPrice + candle.LowPrice + 2 * candle.ClosePrice) / 4
        elif ap == PRICE_AVERAGE:
            return (candle.OpenPrice + candle.HighPrice + candle.LowPrice + candle.ClosePrice) / 4
        else:
            return candle.ClosePrice

    def OnStarted2(self, time):
        super(bollinger_breakout_dc2008_strategy, self).OnStarted2(time)

        self._bollinger = BollingerBands()
        self._bollinger.Length = self.BandsPeriod
        self._bollinger.Width = self.BandsDeviation

        self._entry_price = 0.0

        subscription = self.SubscribeCandles(self.CandleType)
        subscription.Bind(self.ProcessCandle).Start()

    def ProcessCandle(self, candle):
        if candle.State != CandleStates.Finished:
            return

        price_value = self._get_applied_price(candle)
        indicator_value = process_float(self._bollinger, price_value, candle.OpenTime, True)

        if not indicator_value.IsFinal:
            return

        up_band = indicator_value.UpBand
        low_band = indicator_value.LowBand
        moving_average = indicator_value.MovingAverage

        if up_band is None or low_band is None or moving_average is None:
            return

        upper = float(up_band)
        lower = float(low_band)
        middle = float(moving_average)

        high = float(candle.HighPrice)
        low = float(candle.LowPrice)
        close = float(candle.ClosePrice)

        buy_signal = low < lower and high < middle
        sell_signal = high > upper and low > middle

        if not buy_signal and not sell_signal:
            return

        unrealized_pnl = 0.0
        if self.Position != 0:
            unrealized_pnl = self.Position * (close - self._entry_price)

        if buy_signal:
            if self.Position == 0:
                self.BuyMarket()
                self._entry_price = close
            else:
                if unrealized_pnl < 0.0:
                    return
                if self.Position < 0:
                    self.BuyMarket()
                    self._entry_price = close
            return

        if sell_signal:
            if self.Position == 0:
                self.SellMarket()
                self._entry_price = close
            else:
                if unrealized_pnl < 0.0:
                    return
                if self.Position > 0:
                    self.SellMarket()
                    self._entry_price = close

    def OnReseted(self):
        super(bollinger_breakout_dc2008_strategy, self).OnReseted()
        self._entry_price = 0.0

    def CreateClone(self):
        return bollinger_breakout_dc2008_strategy()