Universes

// Add daily Equity Option data for the SPY.
AddOption("SPY", resolution: Resolution.Daily);

# Add daily Equity Option data for the SPY.
self.add_option("SPY", resolution=Resolution.DAILY)

// Assign 2x leverage for all securities in the universe. 
UniverseSettings.Leverage = 2.0m;
// Add a universe of the 50 most liquid US Equities.
AddUniverse(Universe.DollarVolume.Top(50));

# Assign 2x leverage for all securities in the universe.  
self.universe_settings.leverage = 2.0
# Add a universe of the 50 most liquid US Equities.
self.add_universe(self.universe.dollar_volume.top(50))

// Disable fill-forward data before creating the universe (it's enabled by default). 
UniverseSettings.FillForward = false;
// Add the 50 Equities to the universe that have the most dollar trading volume.
AddUniverse(Universe.DollarVolume.Top(50));

# Disable fill-forward data before creating the universe (it's enabled by default).
self.universe_settings.fill_forward = False
# Add the 50 Equities to the universe that have the most dollar trading volume.
self.add_universe(self.universe.dollar_volume.top(50))

// Disable fill-forward in the VIX Index Option universe.
AddIndexOption("VIX", fillForward: false);

# Disable fill-forward in the VIX Index Option universe.
self.add_index_option("VIX", fill_forward=False)

// Enable pre- and post-market hours data for assets in the universe. 
UniverseSettings.ExtendedMarketHours = true;
// Add the 50 Equities to the universe that have the most dollar trading volume.
AddUniverse(Universe.DollarVolume.Top(50));

# Enable pre- and post-market hours data for assets in the universe.
self.universe_settings.extended_market_hours = True
# Add the 50 Equities to the universe that have the most dollar trading volume.
self.add_universe(self.universe.dollar_volume.top(50))

// Request pre- and post-market hours data for a Futures universe.
AddFuture(Futures.Currencies.BTC, extendedMarketHours: true);

# Request pre- and post-market hours data for a Futures universe.
self.add_future(Futures.Currencies.BTC, extended_market_hours=True)

// Keep each security in the universe for a minimum of 7 days.
UniverseSettings.MinimumTimeInUniverse = TimeSpan.FromDays(7);
// Add the top 50 most liquid Equities to the universe.
AddUniverse(Universe.DollarVolume.Top(50));

# Keep each security in the universe for a minimum of 7 days.
self.universe_settings.minimum_time_in_universe = timedelta(7)
# Add the top 50 most liquid Equities to the universe.
self.add_universe(self.universe.dollar_volume.top(50))

// Pipe raw price data (unadjusted for splits and dividends) into the algorithm. 
// Equity Options require raw data and it improves the accuracy of modeling historical periods. 
UniverseSettings.DataNormalizationMode = DataNormalizationMode.Raw;
// Add a universe of the 50 most liquid US Equities.
AddUniverse(Universe.DollarVolume.Top(50));

# Pipe raw price data (unadjusted for splits and dividends) into the algorithm. 
# Equity Options require raw data and it improves the accuracy of modeling historical periods. 
self.universe_settings.data_normalization_mode = DataNormalizationMode.RAW
# Add a universe of the 50 most liquid US Equities.
self.add_universe(self.universe.dollar_volume.top(50))

// Set a specific data normalization mode for the continuous contract 
// with the dataNormalizationMode parameter of the AddFuture method.
AddFuture(Futures.Currencies.BTC, dataNormalizationMode: DataNormalizationMode.BackwardsRatio);

# Set a specific data normalization mode for the continuous contract 
# with the data_normalization_mode parameter of the add_future method.
self.add_future(Futures.Currencies.BTC, data_normalization_mode=DataNormalizationMode.BACKWARDS_RATIO)

// To adjust the contract depth offset to the second back month contract, 
// pass the value 3 to the contractDepthOffset argument in the AddFuture method.
AddFuture(Futures.Currencies.BTC, contractDepthOffset: 3);

# To adjust the contract depth offset to the second back month contract, 
# pass the value 3 to the contract_depth_offset argument in the add_future method.
self.add_future(Futures.Currencies.BTC, contract_depth_offset=3)

// To speed up algorithm performance, enable asynchronous universe selection. 
// Only use this when the code is self-contained and stateless.
UniverseSettings.Asynchronous = true;
AddUniverse(Universe.DollarVolume.Top(50));

# To speed up algorithm performance, enable asynchronous universe selection. 
// Only use this when the code is self-contained and stateless.
self.universe_settings.asynchronous = True
self.add_universe(self.universe.dollar_volume.top(50))

// Run universe selection on a monthly basis.
UniverseSettings.Schedule.On(DateRules.MonthStart());
AddUniverse(Universe.DollarVolume.Top(50));

# Run universe selection on a monthly basis.
self.universe_settings.schedule.on(self.date_rules.month_start())
self.add_universe(self.universe.dollar_volume.top(50))

// Create a date rule that specifies the 10th day of each month.
var dateRule = new FuncDateRule(
    name: "10th_day_of_the_month",
    getDatesFunction: (start, end) => Enumerable.Range(start.Year, end.Year - start.Year + 1)
        .SelectMany(year => Enumerable.Range(1, 12).Select(month => new DateTime(year, month, 10)))
);

# Create a date rule that specifies the 10th day of each month.
date_rule = FuncDateRule(
    name="10th_day_of_the_month", 
    get_dates_function=lambda start, end: [
        datetime(year, month, 10) 
        for year in range(start.year, end.year) for month in range(1,12)
    ]
) 

// A custom security initializer can override default models such as 
// setting new fee and fill models for the security.
SetSecurityInitializer(CustomSecurityInitializer);

private void CustomSecurityInitializer(Security security)
{
    security.SetFeeModel(new ConstantFeeModel(0, "USD"));
}

# A custom security initializer can override default models such as
# setting new fee and fill models for the security.
self.set_security_initializer(self._custom_security_initializer)

def _custom_security_initializer(self, security: Security) -> None:
    security.set_fee_model(ConstantFeeModel(0, "USD"))

// Disable the trading fees for each security by passing a functional 
// implementation for the SetSecurityInitializer argument.
SetSecurityInitializer(security => security.SetFeeModel(new ConstantFeeModel(0, "USD")));

# Disable the trading fees for each security by using lambda function 
# for the set_security_initializer argument.
self.set_security_initializer(lambda security: security.set_fee_model(ConstantFeeModel(0, "USD")))

// Gather the last 3 days of security prices by using GetLastKnowPrice as the seed in Initialize.
var seeder = new FuncSecuritySeeder(GetLastKnownPrices);
SetSecurityInitializer(security => seeder.SeedSecurity(security));

# Gather the last 3 days of security prices by using get_last_known_prices as the seed in initialize.
seeder = FuncSecuritySeeder(self.get_last_known_prices)
self.set_security_initializer(lambda security: seeder.seed_security(security))

public class BrokerageModelExampleAlgorithm : QCAlgorithm
{
    public override void Initialize()
    {
        // In the Initialize method, set the security initializer to seed initial the prices and models of assets.
        SetSecurityInitializer(new MySecurityInitializer(BrokerageModel, new FuncSecuritySeeder(GetLastKnownPrices)));
    }
}

public class MySecurityInitializer : BrokerageModelSecurityInitializer
{
    public MySecurityInitializer(IBrokerageModel brokerageModel, ISecuritySeeder securitySeeder)
        : base(brokerageModel, securitySeeder) {}    
    public override void Initialize(Security security)
    {
        // First, call the superclass definition.
        // This method sets the reality models of each security using the default reality models of the brokerage model.
        base.Initialize(security);

        // Next, overwrite some of the reality models
        security.SetFeeModel(new ConstantFeeModel(0, "USD"));    }
}

class BrokerageModelExampleAlgorithm(QCAlgorithm):
    def initialize(self) -> None:
        # In the Initialize method, set the security initializer to seed initial the prices and models of assets.
        self.set_security_initializer(MySecurityInitializer(self.brokerage_model, FuncSecuritySeeder(self.get_last_known_prices)))

# Outside of the algorithm class
class MySecurityInitializer(BrokerageModelSecurityInitializer):

    def __init__(self, brokerage_model: IBrokerageModel, security_seeder: ISecuritySeeder) -> None:
        super().__init__(brokerage_model, security_seeder)    
    def initialize(self, security: Security) -> None:
        # First, call the superclass definition.
        # This method sets the reality models of each security using the default reality models of the brokerage model.
        super().initialize(security)

        # Next, overwrite some of the reality models
        security.set_fee_model(ConstantFeeModel(0, "USD"))

var seeder = new FuncSecuritySeeder(GetLastKnownPrices);
SetSecurityInitializer(new BrokerageModelSecurityInitializer(BrokerageModel, seeder));

seeder = FuncSecuritySeeder(self.get_last_known_prices)
self.set_security_initializer(BrokerageModelSecurityInitializer(self.brokerage_model, seeder))

public class UniverseSettingsAlgorithm : QCAlgorithm
{
    public override void Initialize()
    {
        SetStartDate(2021, 1, 1);
        SetEndDate(2021, 2, 1);
        
        // To avoid over-updating the universe, which causes insufficient time to earn the trend, update the universe weekly.
        UniverseSettings.Schedule.On(DateRules.WeekStart());
        UniverseSettings.MinimumTimeInUniverse = TimeSpan.FromDays(7);
        // Rebalancing frequency is daily, so we only need to subscribe to daily resolution.
        UniverseSettings.Resolution = Resolution.Daily;
        // To best simulate IB's margin requirement set the leverage to 50%.
        UniverseSettings.Leverage = 2;
        // Since we trade by market order, we cannot use extended market hours data to fill.
        UniverseSettings.ExtendedMarketHours = false;
        // We want to trade the EMA with raw price but not altered by splits.
        UniverseSettings.DataNormalizationMode = DataNormalizationMode.SplitAdjusted;

        // Only trade on the top 10 most traded stocks since they have the most popularity to drive trends.
        AddUniverse(Universe.DollarVolume.Top(10));
    }

    public override void OnData(Slice slice)
    {
        foreach (var (symbol, bar) in slice.Bars)
        {
            // Trade the trend by EMA crossing.
            var ema = (Securities[symbol] as dynamic).ema;
            if (bar.Close > ema)
            {
                SetHoldings(symbol, 0.05m);
            }
            else
            {
                SetHoldings(symbol, -0.05m);
            }
        }
    }

    public override void OnSecuritiesChanged(SecurityChanges changes)
    {
        foreach (var removed in changes.RemovedSecurities)
        {
            // Liquidate the ones leaving the universe since we will not trade their EMA anymore.
            Liquidate(removed.Symbol);
            // Deregister the EMA indicator to free resources
            DeregisterIndicator((removed as dynamic).ema as ExponentialMovingAverage);
        }

        foreach (var added in changes.AddedSecurities)
        {
            var security = added as dynamic;
            // Create EMA indicator for trend trading signals.
            security.ema = EMA(added.Symbol, 50, Resolution.Daily);
            // Warm up the EMA indicator to ensure its readiness for immediate use.
            WarmUpIndicator(added.Symbol, (ExponentialMovingAverage)security.ema, Resolution.Daily);
        }
    }
}

class UniverseSettingsAlgorithm(QCAlgorithm):
    def initialize(self) -> None:
        self.set_start_date(2021, 1, 1)
        self.set_end_date(2021, 2, 1)
        
        # To avoid over-updating the universe, which causes insufficient time to earn the trend, update the universe weekly.
        self.universe_settings.schedule.on(self.date_rules.week_start())
        self.universe_settings.minimum_time_in_universe = timedelta(7)
        # Rebalancing frequency is daily, so we only need to subscribe to daily resolution.
        self.universe_settings.resolution = Resolution.DAILY
        # To best simulate IB's margin requirement, set the leverage to 50%.
        self.universe_settings.leverage = 2
        # Since we trade by market order, we cannot use extended market hours data to fill.
        self.universe_settings.extended_market_hours = False
        # We want to trade the EMA with raw price but not altered by splits.
        self.universe_settings.data_normalization_mode = DataNormalizationMode.SPLIT_ADJUSTED

        # Only trade on the top 10 most traded stocks since they have the most popularity to drive trends.
        self.add_universe(self.universe.dollar_volume.top(10))

    def on_data(self, slice: Slice) -> None:
        for symbol, bar in slice.bars.items():
            # Trade the trend by EMA crossing.
            ema = self.securities[symbol].ema.current.value
            if bar.close > ema:
                self.set_holdings(symbol, 0.05)
            else:
                self.set_holdings(symbol, -0.05)

    def on_securities_changed(self, changes: SecurityChanges) -> None:
        for removed in changes.removed_securities:
            # Liquidate the ones leaving the universe since we will not trade their EMA anymore.
            self.liquidate(removed.symbol)
            # Deregister the EMA indicator to free resources
            self.deregister_indicator(removed.ema)

        for added in changes.added_securities:
            # Create EMA indicator for trend trading signals.
            added.ema = self.ema(added.symbol, 50, Resolution.DAILY)
            # Warm up the EMA indicator to ensure its readiness for immediate use.
            self.warm_up_indicator(added.symbol, added.ema, Resolution.DAILY)