Algorithm Framework

// Use a hybrid approach by combining Framework Universe Selection Models with classic methods to leverage both the modular flexibility of Framework modules and the control of classic design. This allows for better universe selection, portfolio allocation, and risk management.
public override void Initialize()
{
    UniverseSettings.Asynchronous = true;
    SetUniverseSelection(new ManualUniverseSelectionModel(QuantConnect.Symbol.Create("SPY", SecurityType.Equity, Market.USA)));
    AddUniverseSelection(new ManualUniverseSelectionModel(QuantConnect.Symbol.Create("AAPL", SecurityType.Equity, Market.USA)));
    AddUniverse(Universe.DollarVolume.Top(5));
}

# Use a hybrid approach by combining Framework Universe Selection Models with classic methods to leverage both the modular flexibility of Framework modules and the control of classic design. This allows for better universe selection, portfolio allocation, and risk management.
def initialize(self):
    self.universe_settings.asynchronous = True       
    self.set_universe_selection(ManualUniverseSelectionModel([ Symbol.create("SPY", SecurityType.EQUITY, Market.USA) ]))
    self.add_universe_selection(ManualUniverseSelectionModel([ Symbol.create("AAPL", SecurityType.EQUITY, Market.USA) ]))
    self.add_universe(self.universe.dollar_volume.top(5))

// Add one or multiple Alpha models to a classic algorithm allowing for direct trading based on generated Insight objects, bypassing the need for a Portfolio Construction model. 
public override void Initialize()
{
    AddAlpha(new EmaCrossAlphaModel());
    // The InsightsGenerated event handler is used to receive and process the collection of insights, facilitating flexible and dynamic trading strategies.
    InsightsGenerated += OnInsightsGenerated;
}
private void OnInsightsGenerated(IAlgorithm algorithm, GeneratedInsightsCollection insightsCollection)
{
    var insights = insightsCollection.Insights;
}

# Add one or multiple Alpha models to a classic algorithm allowing for direct trading based on generated Insight objects, bypassing the need for a Portfolio Construction model. 
def initialize(self):
    self.add_alpha(EmaCrossAlphaModel())
    # The insights_generated event handler is used to receive and process the collection of insights, facilitating flexible and dynamic trading strategies.
    self.insights_generated += self.on_insights_generated

def on_insights_generated(self, algorithm: IAlgorithm, insights_collection: GeneratedInsightsCollection) -> None:
    insights = insights_collection.insights

// Add a Portfolio Construction model to place orders directly without relying on Alpha-generated insights.
public override void Initialize()
{
    SetPortfolioConstruction(new EqualWeightingPortfolioConstructionModel());
}
// Use the EmitInsights method in the OnData method to provide trading signals for executing trades, ensuring balanced investment with the chosen Portfolio Construction model.
public override void OnData(Slice slice)
{
	EmitInsights(new Insight("GOOG", TimeSpan.FromMinutes(20), InsightType.Price, InsightDirection.Up));
	EmitInsights(new []{
		new Insight("AAPL", TimeSpan.FromMinutes(20), InsightType.Price, InsightDirection.Up),
		new Insight("MSFT", TimeSpan.FromMinutes(20), InsightType.Price, InsightDirection.Up)
	});
}

# Add a Portfolio Construction model to place orders directly without relying on Alpha-generated insights.
def initialize(self):
    self.set_portfolio_construction(EqualWeightingPortfolioConstructionModel())

# Use the emit_insights method in the on_data method to provide trading signals for executing trades, ensuring balanced investment with the chosen Portfolio Construction model.
def on_data(self, slice):
	self.emit_insights(Insight("GOOG", TimeSpan.from_minutes(20), InsightType.PRICE, InsightDirection.UP))
	self.emit_insights([
		Insight("AAPL", TimeSpan.from_minutes(20), InsightType.PRICE, InsightDirection.UP),
		Insight("MSFT", TimeSpan.from_minutes(20), InsightType.PRICE, InsightDirection.UP)
	])

// Add Risk Management models to monitor portfolio risk directly, without needing PortfolioTargets from a Portfolio Construction model. These models can independently manage holdings and trigger liquidations as needed.
public override void Initialize()
{
    AddRiskManagement(new MaximumDrawdownPercentPerSecurity(0.05m));
    AddRiskManagement(new MaximumUnrealizedProfitPercentPerSecurity(0.1m));
}

# Add Risk Management models to monitor portfolio risk directly, without needing PortfolioTargets from a Portfolio Construction model. These models can independently manage holdings and trigger liquidations as needed.
def initialize(self):
    self.add_risk_management(MaximumDrawdownPercentPerSecurity(0.05))
    self.add_risk_management(MaximumUnrealizedProfitPercentPerSecurity(0.1))

// Use SetExecution to place orders via the Execution Model, which routes PortfolioTarget objects to its 
// execute method, instead of placing orders manually. This ensures automated and consistent order execution.
public override void Initialize()
{
    // Execute the market order imediately to fill the portfolio targets.
    SetExecution(new ImmediateExecutionModel());
}

# Use set_execution to place orders via the Execution Model, which routes PortfolioTarget objects to its 
# execute method, instead of placing orders manually. This ensures automated and consistent order execution.
def initialize(self):
    # Execute the market order imediately to fill the portfolio targets.
    self.set_execution(ImmediateExecutionModel())