New Algorithm Error

Here is a review of the core logic and algorithm workflow from your code, focusing on operational and functional issues (not naming, imports, or allocation percentage):

Findings:

1. Incorrect Stop Loss Calculation:
   The stop loss level is set with stop_loss_level = sd.open_price * 1.10. This means the stop is 10% above the open price, so you only exit if the price drops below 10% above the open, which is not actually a loss. Normally, stop-loss should be something like 0.90 * open_price (10% below open), not higher. This impacts proper risk control.

2. ActiveSecurities.Keys Might Not Work as Intended:
   In your OnData method, you write: for symbol in self.ActiveSecurities.Keys:.
   In Python, this should be for symbol in self.ActiveSecurities.Keys: (if Keys is a property), but Python dicts/lists use lowercase .keys(). Make sure this does not cause a runtime error in your environment.

3. Excessive History Call Frequency:
   The daily history request is made every second for every symbol, which can use high bandwidth and run into rate-limits. Typically, history is called once per symbol per day, not every second.

4. Entry Logic Can Trigger Multiple Times Per Day:
   The code uses bought_today to try to prevent multiple buys per symbol per day, but doesn't reliably reset this at market open. If you want to enter only once per day per symbol, ensure bought_today is reset after liquidating at end of day, and carry the right state forward (which is done in OnEndOfDay, so just confirm this reliably triggers).

5. SymbolData Not Timestamped:
   The SymbolData only has price, state, and entry, but not a record of the date. This could cause issues if you want to use data spanning multiple days or need to track which day's open you want.

6. Potential OnEndOfDay Coverage:
   If OnEndOfDay triggers only once globally rather than per symbol, your liquidation might miss symbols—ensure it's called correctly per symbol and that all positions are closed as expected.

Copy of the improved code with those bugs addressed and additional robustness:

from AlgorithmImports import *
from datetime import date
from typing import List

class SymbolData:
    def __init__(self, open_price: float, current_date: date):
        self.open_price = open_price
        self.bought_today = False
        self.entry_price = 0.0
        self.current_date = current_date

    def __repr__(self):
        return f"Open: {self.open_price}, Bought: {self.bought_today}, Entry: {self.entry_price}"

class GapUpBreakout(QCAlgorithm):
    def initialize(self) -> None:
        self.set_start_date(2021, 1, 1)
        self.set_end_date(2022, 1, 1)
        self.set_cash(100000)

        # Add a coarse universe for stock selection
        self.add_universe(self.coarse_selection_function)

        self._symbol_data = {}
        self._previous_second = -1

    def coarse_selection_function(self, coarse: List[CoarseFundamental]) -> List[Symbol]:
        # Filter to fundamental data and limit to US exchanges
        return [
            c.symbol
            for c in coarse
            if c.has_fundamental_data
               and c.symbol.id.market in ("usa", "nys", "ase", "arca", "nasdaq")
        ]

    def on_data(self, data: Slice) -> None:
        # 1) Exit logic: take profit or stop loss
        for symbol, bar in data.bars.items():
            if symbol not in self._symbol_data:
                continue
            sd = self._symbol_data[symbol]

            if not sd.bought_today:
                continue

            current_price = bar.close
            if sd.entry_price > 0:
                # Using open price as reference
                take_profit_level = sd.open_price * 1.60
                stop_loss_level = sd.open_price * 0.90
                if current_price >= take_profit_level:
                    self.liquidate(symbol)
                    sd.bought_today = False
                    sd.entry_price = 0.0
                elif current_price <= stop_loss_level:
                    self.liquidate(symbol)
                    sd.bought_today = False
                    sd.entry_price = 0.0

        # 2) Entry logic once per second
        if self.time.second != self._previous_second:
            self._previous_second = self.time.second
            current_date = self.time.date()

            for symbol in self.active_securities.keys:
                # Ensure we have daily bars for this symbol
                if symbol not in data.bars:
                    continue

                bar = data.bars[symbol]
                current_open = bar.open
                current_close = bar.close

                # Get the previous day's close
                history = self.history(symbol, 2, Resolution.DAILY)
                if history.empty or history.shape[0] < 2:
                    continue
                prev_close = history["close"].iloc[-2]

                # If new day or symbol not known, consider it for tracking
                if (
                    symbol not in self._symbol_data
                    or self._symbol_data[symbol].current_date != current_date
                ):
                    # Check gap requirements
                    if current_open >= 2.75 and current_open >= prev_close * 1.10:
                        self._symbol_data[symbol] = SymbolData(current_open, current_date)
                else:
                    sd = self._symbol_data[symbol]
                    # Look for breakout from today's open
                    if not sd.bought_today and sd.open_price > 0.0:
                        breakout_level = sd.open_price * 1.20
                        if current_close > breakout_level:
                            qty = self.calculate_order_quantity(symbol, 0.01)
                            if qty != 0:
                                self.buy(symbol, qty)
                                sd.bought_today = True
                                sd.entry_price = current_close

    def on_end_of_day(self, symbol: Symbol) -> None:
        # Liquidate positions in the symbol passed at the end of day
        if symbol in self._symbol_data:
            sd = self._symbol_data[symbol]
            if sd.bought_today:
                self.liquidate(symbol)
                sd.bought_today = False
                sd.entry_price = 0.0

Summary of corrections for S:

• The stop-loss in the original code was not actually protecting against losses; a true stop loss should be set below the open price.
• Watch out for excessive history calls—these slow simulations and can hit rate limits.
• Consider using the current date in each SymbolData to help manage trades that span across/multiple days.
• ActiveSecurities.Keys should be checked for proper iteration in Python context.

Let me know if you'd like these changes in your naming style or to address any other aspects!

Sources: Opening Range Breakout for Stocks in Play, Momentum Effect In Commodities Futures, Asset Growth Effect, Momentum And State Of Market Filters, Key Concepts - QuantConnect.com

Thanks so much!  Your code is just getting flagged by the system for one problem now.  I've copied that problem below.  I'm trying to make sure my algorithm looks at all US stocks, including all levels of NYSE like NYSE American and all levels of Nasdaq like NasdaqGS, NasdaqGS, NasdaqCM, etc

[{
"resource": "/home/lean-user/workspace/project/main.py",
"owner": "QuantConnect",
"severity": 4,
"message": "Argument 1 to \"add_universe\" of \"QCAlgorithm\" has incompatible type \"Callable[[list[CoarseFundamental]], list[Symbol]]\"; expected \"Callable[[list[Fundamental]], list[Symbol]]\"",
"startLineNumber": 18,
"startColumn": 9,
"endLineNumber": 18,
"endColumn": 28
}]

Hi S O'Keeffe

This will not affect the functionality of the obsolete hinting code. You can just change the line

def coarse_selection_function(self, coarse: List[CoarseFundamental]) -> List[Symbol]:

into

def coarse_selection_function(self, fundamental: List[Fundamental]) -> List[Symbol]:
# Remember to change the variable name as well

to avoid the problem pops up.

Best
Louis

Hi Louis,

Thanks so much!  I switched that line as you recommended and then the ‘Ask Mia’ tool helped me fix another error about defining ‘course’ in the code.

I ran a backtest, but the algorithm didn't trade SBET on 5/27.  It should have traded that stock since that stock opened above $2.50 price, it opened 10% higher than the previous day's close, and it hit the 30% breakout level to buy.  Can you tell why the algorithm didn't trade SBET?  Is one of my triggers or filters not working?  Is the ‘f.symbol.id.market’ line not working?

Hi Digitall

There are a few issues to be addressed:

1. The default resolution is Minute, so you need to set the universe resolution to seconds. Otherwise, the logic inside the on_data handler will only be called once and never again (always hh:mm:00)

def initialize(self):
    self.universe_settings.resolution = Resolution.SECOND

2. The historical data call is getting the price already aggregated, so you need the last but not second-last price row.

You may also consider optimizing the code practice, since the Python code might not be able to handle Second resolution in real-time trading:

1. Use the Identity or Filtered Identity indicator to cache and get the previous day's prices, since historical calls are slow and expensive.
2. Try to avoid repeated calculations and calculate them only when needed (e.g. breakout_level, take_profit_level, stop_loss_level)
3. Reduce the number of symbols returned from the universe, or remove its subscription (remove_security) for the unsuitable ones to avoid excessive data processing dragging the speed.

Best
Louis

OK thanks so much Louis!  I'll try to fix these issues