QuantConnect

from AlgorithmImports import *


class SpectralTickFlowSignalAlgorithm(QCAlgorithm):
    execution_score_threshold = 15

    def initialize(self) -> None:
        self.set_start_date(2024, 9, 1)
        self.set_end_date(2024, 12, 31)
        self.set_cash(100000)
        # AAPL is both the traded security and the equity the custom signal is linked to.
        self._aapl = self.add_equity("AAPL", Resolution.DAILY)
        self.dataset_symbol = self.add_data(SpectralTickFlowSignal, self._aapl).symbol

    def on_data(self, data: Slice) -> None:
        # Require current signal and equity data to avoid stale fills.
        if self.dataset_symbol not in data:
            return
        # Hold AAPL on strong algorithmic-execution intensity, otherwise stand aside.
        execution_score = data[self.dataset_symbol].execution_score
        target_holdings = 1 if execution_score > self.execution_score_threshold else 0
        if target_holdings != self.portfolio.invested:
            self.set_holdings(self._aapl, target_holdings)

public class SpectralTickFlowSignalAlgorithm : QCAlgorithm
{
    private Equity _aapl;
    private Symbol _datasetSymbol;
    private const decimal ExecutionScoreThreshold = 15m;

    public override void Initialize()
    {
        SetStartDate(2024, 9, 1);
        SetEndDate(2024, 12, 31);
        SetCash(100000);
        // AAPL is both the traded security and the equity the custom signal is linked to.
        _aapl = AddEquity("AAPL", Resolution.Daily);
        _datasetSymbol = AddData<SpectralTickFlowSignal>(_aapl.Symbol).Symbol;
    }

    public override void OnData(Slice slice)
    {
        // Require current signal and equity data to avoid stale fills.
        if (!slice.ContainsKey(_datasetSymbol))
        {
            return;
        }
        // Hold AAPL on strong algorithmic-execution intensity, otherwise stand aside.
        decimal executionScore = slice[_datasetSymbol].ExecutionScore;
        var targetHoldings = executionScore > ExecutionScoreThreshold ? 1 : 0;
        if (targetHoldings == 1 != Portfolio.Invested)
        {
            SetHoldings(_aapl.Symbol, targetHoldings);
        }
    }
}

from AlgorithmImports import *


class SpectralTickFlowSignalAlgorithm(QCAlgorithm):
    def initialize(self) -> None:
        self.set_start_date(2024, 9, 1)
        self.set_end_date(2024, 12, 31)
        self.set_cash(100000)
        self.settings.seed_initial_prices = True
        self.universe_settings.resolution = Resolution.DAILY
        # Filter to the confirmed execution signatures with the strongest intensity.
        self.add_universe(SpectralTickFlowSignalUniverse, self.universe_selection)
        self.add_alpha(SpectralTickFlowSignalAlphaModel())
        self.set_portfolio_construction(EqualWeightingPortfolioConstructionModel())
        self.add_risk_management(NullRiskManagementModel())
        self.set_execution(ImmediateExecutionModel())

    def universe_selection(self, alt_coarse: List[SpectralTickFlowSignalUniverse]) -> List[Symbol]:
        # Keep only confirmed execution signatures, ranked by intensity.
        confirmed = [d for d in alt_coarse if d.signature_count > 0]
        return [d.symbol for d in sorted(confirmed, key=lambda d: d.execution_score)[-50:]]


class SpectralTickFlowSignalAlphaModel(AlphaModel):
    def update(self, algorithm: QCAlgorithm, slice: Slice) -> List[Insight]:
        insights = []
        for dataset_symbol, data_point in slice.get(SpectralTickFlowSignal).items():
            security = algorithm.securities[dataset_symbol.underlying]
            # Buy names with a confirmed execution signature, liquidate otherwise.
            target_direction = InsightDirection.UP if data_point.signature_count > 0 else InsightDirection.FLAT
            if security.price and target_direction == InsightDirection.UP and not security.invested:
                insights.append(Insight.price(security, timedelta(7), target_direction))
        return insights

    def on_securities_changed(self, algorithm: QCAlgorithm, changes: SecurityChanges) -> None:
        for security in changes.added_securities:
            # Subscribe to the daily signal feed for the added equity.
            dataset = algorithm.add_data(SpectralTickFlowSignal, security, Resolution.DAILY)
            security.dataset_symbol = dataset.symbol
        for security in changes.removed_securities:
            # Unsubscribe from the Spectral Tick-Flow Signal feed.
            algorithm.remove_security(security.dataset_symbol)

public class SpectralTickFlowSignalAlgorithm : QCAlgorithm
{
    public override void Initialize()
    {
        SetStartDate(2024, 9, 1);
        SetEndDate(2024, 12, 31);
        SetCash(100000);
        Settings.SeedInitialPrices = true;
        UniverseSettings.Resolution = Resolution.Daily;
        // Filter to the confirmed execution signatures with the strongest intensity.
        AddUniverse<SpectralTickFlowSignalUniverse>(altCoarse => altCoarse
            .Select(d => d as SpectralTickFlowSignalUniverse)
            .Where(d => d.SignatureCount > 0)
            .OrderBy(d => d.ExecutionScore)
            .TakeLast(50)
            .Select(d => d.Symbol)
        );
        AddAlpha(new SpectralTickFlowSignalAlphaModel());
        SetPortfolioConstruction(new EqualWeightingPortfolioConstructionModel());
        AddRiskManagement(new NullRiskManagementModel());
        SetExecution(new ImmediateExecutionModel());
    }
}


public class SpectralTickFlowSignalAlphaModel : AlphaModel
{
    public override IEnumerable<Insight> Update(QCAlgorithm algorithm, Slice slice)
    {
        var insights = new List<Insight>();
        foreach (var (datasetSymbol, dataPoint) in slice.Get<SpectralTickFlowSignal>())
        {
            var security = algorithm.Securities[datasetSymbol.Underlying];
            // Buy names with a confirmed execution signature, liquidate otherwise.
            var targetDirection = dataPoint.SignatureCount > 0 ? InsightDirection.Up : InsightDirection.Flat;
            if (security.Price != 0 && targetDirection == InsightDirection.Up && !security.Holdings.Invested)
            {
                insights.Add(Insight.Price(security.Symbol, TimeSpan.FromDays(7), targetDirection));
            }
        }
        return insights;
    }

    public override void OnSecuritiesChanged(QCAlgorithm algorithm, SecurityChanges changes)
    {
        foreach (var security in changes.AddedSecurities)
        {
            // Subscribe to the daily signal feed for the added equity.
            var dataset = algorithm.AddData<SpectralTickFlowSignal>(security.Symbol, Resolution.Daily);
            security.Set("DatasetSymbol", dataset.Symbol);
        }
        foreach (var security in changes.RemovedSecurities)
        {
            // Unsubscribe from the Spectral Tick-Flow Signal feed.
            algorithm.RemoveSecurity(security.Get<Symbol>("DatasetSymbol"));
        }
    }
}