Suggestion about time method in Alpha Model

To create an Alpha Model that generates signals at specific times for different assets, you can follow these steps. This approach uses the AlphaModel class and the Insight.price method to generate insights based on time conditions.

Step-by-Step Implementation

1. Define the Alpha Model Class: Create a new class that inherits from AlphaModel. Initialize any necessary variables, such as the specific assets and the times for signal generation.

2. Implement the update Method: Override the update method to include logic for generating insights at market open and close for one asset, and on Monday morning and Friday before market close for another asset.

3. Use Time Checks: Within the update method, use time checks to determine if the current time matches the desired signal generation times, such as market open, market close, Monday morning, or Friday before market close.

4. Generate Insights: When the time conditions are met, generate insights using the Insight.price method for the specific assets, specifying the direction and expiry as needed.

5. Store and Manage Insights: Keep track of generated insights to ensure they are acted upon at the correct times, and manage their lifecycle to avoid duplicate signals.

6. Integrate with Algorithm: Set the custom Alpha Model in your algorithm using self.set_alpha() to ensure it is used for generating trading signals.

Here's an example of how you might implement this:

from AlgorithmImports import *

class CustomAlphaModel(AlphaModel):
    def __init__(self, asset1: Symbol, asset2: Symbol):
        self.asset1 = asset1
        self.asset2 = asset2
        self.last_open_insight_time = None
        self.last_close_insight_time = None
        self.last_monday_insight_time = None
        self.last_friday_insight_time = None

    def update(self, algorithm: QCAlgorithm, data: Slice) -> List[Insight]:
        insights = []
        current_time = algorithm.time

        # Market open and close signals for asset1
        if current_time.hour == 9 and current_time.minute == 30 and self.last_open_insight_time != current_time.date():
            insights.append(Insight.price(self.asset1, timedelta(hours=6.5), InsightDirection.UP))
            self.last_open_insight_time = current_time.date()

        if current_time.hour == 16 and current_time.minute == 0 and self.last_close_insight_time != current_time.date():
            insights.append(Insight.price(self.asset1, timedelta(days=1), InsightDirection.DOWN))
            self.last_close_insight_time = current_time.date()

        # Monday morning and Friday before market close signals for asset2
        if current_time.weekday() == 0 and current_time.hour == 9 and current_time.minute == 30 and self.last_monday_insight_time != current_time.date():
            insights.append(Insight.price(self.asset2, timedelta(days=4.5), InsightDirection.UP))
            self.last_monday_insight_time = current_time.date()

        if current_time.weekday() == 4 and current_time.hour == 15 and current_time.minute == 59 and self.last_friday_insight_time != current_time.date():
            insights.append(Insight.price(self.asset2, timedelta(minutes=1), InsightDirection.DOWN))
            self.last_friday_insight_time = current_time.date()

        return insights

class MyAlgorithm(QCAlgorithm):
    def initialize(self):
        self.set_start_date(2020, 1, 1)
        self.set_cash(100000)
        asset1 = self.add_equity("SPY", Resolution.MINUTE).symbol
        asset2 = self.add_equity("AAPL", Resolution.MINUTE).symbol
        self.set_alpha(CustomAlphaModel(asset1, asset2))
        self.set_portfolio_construction(EqualWeightingPortfolioConstructionModel())
        self.set_execution(ImmediateExecutionModel())

Explanation

• Market Open and Close: For asset1, insights are generated at 9:30 AM and 4:00 PM.
• Monday Morning and Friday Close: For asset2, insights are generated at 9:30 AM on Monday and 3:59 PM on Friday.
• Insight Expiry: The expiry for each insight is set according to the expected duration of the trade.

This model ensures that signals are generated only at the specified times without using the schedule.on method, adhering to your requirement of using the Alpha Model only.

Sources: Key Concepts - QuantConnect.com, Intraday Arbitrage Between Index ETFs, Vix Predicts Stock Index Returns, Add Alpha Model Algorithm, Hybrid Algorithms - QuantConnect.com