Writing Algorithms

public override void Initialize()
{
    // Call the BeforeMarketOpen method 10 minutes before open every day SPY is trading. 
    var symbol = QuantConnect.Symbol.Create("SPY", SecurityType.Equity, Market.USA);
    Schedule.On(
        DateRules.EveryDay(symbol),
        TimeRules.BeforeMarketOpen(symbol, 10),
        BeforeMarketOpen
    );
}

def initialize(self):
    # Call the _before_market_open method 10 minutes before open every day SPY is trading. 
    symbol = Symbol.create('SPY', SecurityType.EQUITY, Market.USA)
    self.schedule.on(
        self.date_rules.every_day(symbol),
        self.time_rules.before_market_open(symbol, 10),
        self._before_market_open
    )

public override void Initialize()
{
    // Call the Rebalance method 30 minutes before the end of the SPY trading week.
    var symbol = QuantConnect.Symbol.Create("SPY", SecurityType.Equity, Market.USA);
    Schedule.On(
        DateRules.WeekEnd(symbol),
        TimeRules.BeforeMarketClose(symbol, 30),
        Rebalance
    );
}

def initialize(self):
# Call the _rebalance method 30 minutes before the end of the SPY trading week.
    symbol = Symbol.create('SPY', SecurityType.EQUITY, Market.USA)
    self.schedule.on(
        self.date_rules.week_end(symbol),
        self.time_rules.before_market_close(symbol, 30),
        self._rebalance
    )

public override void Initialize()
{
    // Every day SPY is trading, call the 'SomeAction' method every 30 minutes.
    var symbol = QuantConnect.Symbol.Create("SPY", SecurityType.Equity, Market.USA);
    Schedule.On(
        DateRules.EveryDay(symbol),
        TimeRules.Every(TimeSpan.FromMinutes(30)),
        SomeAction
    );
}

def initialize(self):
    # Every day SPY is trading, call the '_some_action' method every 30 minutes.
    symbol = Symbol.create('SPY', SecurityType.EQUITY, Market.USA)
    self.schedule.on(
        self.date_rules.every_day(symbol),
        self.time_rules.every(timedelta(minutes=30)),
        self._some_action
    )

// 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)
    ]
) 

var timeRule = new FuncTimeRule(
    name: "CustomTimeRule",
    createUtcEventTimesFunction: dates => dates.Select(d => d.AddHours(10)));

time_rule = FuncTimeRule(
    name="CustomTimeRule", 
    create_utc_event_times_function=lambda dates: [d + timedelta(hours=10) for d in dates]
)

private ScheduledEvent _scheduledEvent;

public override void Initialize()
{
    // Remove a scheduled event by keeping a copy of the object on creation.
    var symbol = QuantConnect.Symbol.Create("SPY", SecurityType.Equity, Market.USA);
    _scheduledEvent = Schedule.On(
        DateRules.EveryDay(symbol),
        TimeRules.AfterMarketOpen(symbol, 10),
        TenMinutesAfterOpen
    )
};

// Remove the scheduled event using the object reference in any method
Schedule.Remove(_scheduledEvent);

def initialize(self):
    # Remove a scheduled event by keeping a copy of the object on creation.
    symbol = Symbol.create('SPY', SecurityType.EQUITY, Market.USA)
    self.scheduled_event = self.schedule.on(
        self.date_rules.every_day(symbol),
        self.time_rules.after_market_open(symbol, 10),       
        self._ten_minutes_after_open)

# Remove the scheduled event using the object reference in any method
self.schedule.remove(self.scheduled_event)

public override void Initialize()
{
    var symbol = QuantConnect.Symbol.Create("SPY", SecurityType.Equity, Market.USA);

    // Schedule an event to fire at a specific date/time using inline callback function.
    Schedule.On(DateRules.On(2013, 10, 7),
                TimeRules.At(13, 0),
                () => Log($"SpecificTime: Fired at : {Time}"));

    // Schedule an event to fire every trading day for a security
    // The time rule here tells it to fire at 13:00:00 UTC
    Schedule.On(DateRules.EveryDay(symbol),
                TimeRules.At(13, 0, 0, TimeZones.Utc),
                () => Log($"EveryDay.SPY SpecificTime: Fired at: {Time}"));

    // Schedule an event to fire every trading day for a security
    // The time rule here tells it to fire 10 minutes before SPY's market open
    Schedule.On(DateRules.EveryDay(symbol),
                TimeRules.BeforeMarketOpen(symbol, 10),
                () => Log($"EveryDay.SPY 10 min before open: Fired at: {Time}"));

    // Schedule an event to fire every trading day for a security
    // The time rule here tells it to fire 10 minutes after SPY's market open
    Schedule.On(DateRules.EveryDay(symbol),
                TimeRules.AfterMarketOpen(symbol, 10),
                () => Log($"EveryDay.SPY 10 min after open: Fired at: {Time}"));

    // Schedule an event to fire every trading day for a security
    // The time rule here tells it to fire 10 minutes before SPY's market close
    Schedule.On(DateRules.EveryDay(symbol),
                TimeRules.BeforeMarketClose(symbol, 10),
                () => Log($"EveryDay.SPY 10 min before close: Fired at: {Time}"));

    // Schedule an event to fire every trading day for a security
    // The time rule here tells it to fire 10 minutes after SPY's market close
    Schedule.On(DateRules.EveryDay(symbol),
                TimeRules.AfterMarketClose(symbol, 10),
                () => Log($"EveryDay.SPY 10 min after close: Fired at: {Time}"));

    // Schedule an event to fire on certain days of the week
    Schedule.On(DateRules.Every(DayOfWeek.Monday, DayOfWeek.Friday),
                TimeRules.At(12, 0),
                () => Log($"Mon/Fri at 12pm: Fired at: {Time}"));

    // Schedule an event to fire once today at when this method is called (now)
    Schedule.On(DateRules.Today,
                TimeRules.Now,
                () => Log($"Now: Fired at: {Time}"));

    // Schedule an event to fire once tomorrow at midnight
    Schedule.On(DateRules.Tomorrow,
                TimeRules.Midnight,
                () => Log($"Tomorrow at midnight: Fired at: {Time}"));

    // Schedule an event to fire once today at noon
    Schedule.On(DateRules.Today,
                TimeRules.Noon,
                () => Log($"Today at noon: Fired at: {Time}"));

    // The scheduling methods return the ScheduledEvent object which can be used 
    // for other things here I set the event up to check the portfolio value every
    // 10 minutes, and liquidate if we have too many losses
    Schedule.On(DateRules.EveryDay(),
                TimeRules.Every(TimeSpan.FromMinutes(10)),
                LiquidateUnrealizedLosses);

    // Schedule an event to fire at the beginning of the month, the symbol is optional. 
    // If specified, it will fire the first trading day for that symbol of the month.
    // Otherwise, it will fire on the first day of the month.
    Schedule.On(DateRules.MonthStart(symbol),
                TimeRules.AfterMarketOpen(symbol),
                RebalancingCode);

    // Schedule an event to fire at the end of the month, the symbol is optional. 
    // If specified, it will fire the last trading day for that symbol of the month.
    // Otherwise, it will fire on the last day of the month.
    Schedule.On(DateRules.MonthEnd(symbol),
                TimeRules.BeforeMarketClose(symbol),
                RebalancingCode);

    // Schedule an event to fire at the beginning of the week, the symbol is optional. 
    // If specified, it will fire the first trading day for that symbol of the week.
    // Otherwise, it will fire on the first day of the week.
    Schedule.On(DateRules.WeekStart(symbol),
                TimeRules.AfterMarketOpen(symbol, 5),
                RebalancingCode);

    // Schedule an event to fire at the end of the week, the symbol is optional. 
    // If specified, it will fire the last trading day for that symbol of the week.
    // Otherwise, it will fire on the first day of the week.
    Schedule.On(DateRules.WeekEnd(symbol),
                TimeRules.BeforeMarketClose(symbol, 5),
                RebalancingCode);
    }

// The following methods are not defined in Initialize:
private void LiquidateUnrealizedLosses()
{
    // if we have over 1000 dollars in unrealized losses, liquidate
    if (Portfolio.TotalUnrealizedProfit < -1000)
    {
        Log($"Liquidated due to unrealized losses at: {Time}");
        Liquidate();
    }
}

private void RebalancingCode()
{
    // Good spot for rebalancing code?
}

def initialize(self):
    symbol = Symbol.create('SPY', SecurityType.EQUITY, Market.USA)

    # Schedule an event to fire at a specific date/time using inline callback function.
    self.schedule.on(self.date_rules.on(2013, 10, 7), 
                    self.time_rules.at(13, 0), 
                    lambda: self.log(f"SpecificTime: Fired at : {self.time}"))

    # Schedule an event to fire every trading day for a security at 13:00:00 UTC.
    self.schedule.on(self.date_rules.every_day(symbol), 
                    self.time_rules.at(13, 0, 0, TimeZones.UTC),
                    lambda: self.log(f"EveryDay.SPY SpecificTime: Fired at: {self.time}"))

    # Schedule an event to fire every trading day for a security - 10 minutes before SPY's market open.
    self.schedule.on(self.date_rules.every_day(symbol), 
                    self.time_rules.before_market_open(symbol, 10),
                    lambda: self.log(f"EveryDay.SPY 10 min before open: Fired at: {self.time}"))

    # Schedule an event to fire every trading day for a security - 10 minutes after SPY's market open.
    self.schedule.on(self.date_rules.every_day(symbol), 
                    self.time_rules.after_market_open(symbol, 10),
                    lambda: self.log(f"EveryDay.SPY 10 min after open: Fired at: {self.time}"))

    # Schedule an event to fire every trading day for a security - 10 minutes before SPY's market close.
    self.schedule.on(self.date_rules.every_day(symbol),
                    self.time_rules.before_market_close(symbol, 10),
                    lambda: self.log(f"EveryDay.SPY 10 min before close: Fired at: {self.time}"))

    # Schedule an event to fire every trading day for a security - 10 minutes after SPY's market close.
    self.schedule.on(self.date_rules.every_day(symbol),
                    self.time_rules.after_market_close(symbol, 10),
                    lambda: self.log(f"EveryDay.SPY 10 min after close: Fired at: {self.time}"))

    # Schedule an event to fire on certain days of the week
    self.schedule.on(self.date_rules.every(DayOfWeek.MONDAY, DayOfWeek.FRIDAY),
                    self.time_rules.at(12, 0),
                    lambda: self.log(f"Mon/Fri at 12pm: Fired at: {self.time}"))

    # Schedule an event to fire once today at when this method is called (now)
    self.schedule.on(self.date_rules.today,
                    self.time_rules.now,
                    lambda: self.log(f"Now: Fired at: {self.time}"))

    # Schedule an event to fire once tomorrow at midnight
    self.schedule.on(self.date_rules.tomorrow,
                    self.time_rules.midnight,
                    lambda: self.log(f"Tomorrow at midnight: Fired at: {self.time}"))

    # Schedule an event to fire once today at noon
    self.schedule.on(self.date_rules.today,
                    self.time_rules.noon,
                    lambda: self.log(f"Today at noon: Fired at: {self.time}"))

    # Scan a method every ten minutes, every day. 
    self.schedule.on(self.date_rules.every_day(), 
                    self.time_rules.every(timedelta(minutes=10)),
                    self._liquidate_unrealized_losses)

    # Schedule an event to fire at the beginning of the month. 
    # The symbol is optional but if specified, it will fire the first trading day 
    # for that symbol of the month. Otherwise, it will fire on the first day of the month.
    self.schedule.on(self.date_rules.month_start(symbol),
                    self.time_rules.after_market_open(symbol),
                    self._rebalancing_code)

    # Schedule an event to fire at the end of the month, the symbol is optional. 
    # If specified, it will fire the last trading day for that symbol of the month.
    # Otherwise, it will fire on the last day of the month.
    self.schedule.on(self.date_rules.month_end(symbol),
                    self.time_rules.before_market_close(symbol),
                    self._rebalancing_code)

    # Schedule an event to fire at the beginning of the week, the symbol is optional. 
    # If specified, it will fire the first trading day for that symbol of the week.
    # Otherwise, it will fire on the first day of the week.
    self.schedule.on(self.date_rules.week_start(symbol),
                    self.time_rules.after_market_open(symbol, 5),
                    self._rebalancing_code)

    # Schedule an event to fire at the end of the week, the symbol is optional.
    # If specified, it will fire the last trading day for that symbol of the week.
    # Otherwise, it will fire on the last day of the week.
    self.schedule.on(self.date_rules.week_end(symbol),
                    self.time_rules.before_market_close(symbol, 5),
                    self._rebalancing_code)

# The following methods from examples above should be defined in the algorithm body.
def _liquidate_unrealized_losses(self) -> None:
    ''' if we have over 1000 dollars in unrealized losses, liquidate'''
    if self.portfolio.total_unrealized_profit < -1000:
        self.log(f"Liquidated due to unrealized losses at: {self.time}")
        self.liquidate()

def _rebalancing_code(self) -> None:
    ''' Good spot for rebalancing code?'''
    pass