Error with engulfing indicator, No trades taken in backest. Any thoughts?

Backtests show no trades taken, cant seem to get the engulfing pattern to work with my dynamic universe. 

Reviewing 'Luke's' Python code reveals a few potential issues that could affect the algorithm's performance or lead to runtime errors:

1. Missing Import Statement for Engulfing Pattern: The code uses the Engulfing class from QuantConnect.Indicators.CandlestickPatterns but does not include an import statement for it. This will result in a NameError when trying to instantiate Engulfing. To fix this, you should add the following import statement at the beginning of your code:

   from QuantConnect.Indicators.CandlestickPatterns import Engulfing
   

2. Incorrect Use of QuoteBarConsolidator for Engulfing Pattern: The Engulfing pattern indicator is designed to work with TradeBar objects, but the code is using a QuoteBarConsolidator. This mismatch can lead to unexpected behavior since QuoteBar and TradeBar have different properties. You should use TradeBarConsolidator instead:

   consolidator = TradeBarConsolidator(timedelta(minutes=1))
   

3. Potential Issue with Trade Logic Execution: The TradeLogic method checks if the symbol is invested and then attempts to set holdings. However, there's a logic block that seems to be intended for managing stop losses, but it's placed outside any conditional or loop structure, which could lead to syntax errors or unintended behavior. The indentation seems off, and the else statement is empty and not followed by any code. This part of the code needs to be structured properly to ensure the intended logic is executed correctly. A corrected structure might look like this:

   def TradeLogic(self, symbol):
       if not self.Portfolio[symbol].Invested:
           self.SetHoldings(symbol, 0.1)
       holding = self.Portfolio[symbol]
       if holding.Invested:
           current_price = self.Securities[symbol].Price
           stop_loss_price = holding.AveragePrice * 0.95
           trailing_stop_price = holding.AveragePrice * 0.9
           if current_price < stop_loss_price or current_price < trailing_stop_price:
               self.Liquidate(symbol)
   

   Ensure the logic for managing stop losses and trailing stops is correctly implemented and only executed when necessary.

4. Potential Issue with Historical Data Requests: The OnData method requests historical data every time it's called, which can be very inefficient and may lead to rate limits being hit or excessive delays. It's generally better to request historical data less frequently or to use other techniques to reduce the number of requests, such as caching the results or using scheduled events to update data at specific intervals.

5. Logging and Debugging Information: While not a bug, it's worth noting that extensive logging, such as logging every time an engulfing pattern is found, can slow down backtesting. Use logging judiciously to ensure that it provides value without significantly impacting performance.

These are the primary issues identified in the provided code. Addressing these should help improve the algorithm's correctness and efficiency.

If 'Luke' is experiencing issues with no trades being taken in backtests, especially related to the engulfing pattern not working with a dynamic universe, there are several potential areas to investigate and adjust:

1. Ensure Engulfing Pattern Indicator is Correctly Registered and Updated:

   • Verify that the Engulfing pattern indicator is correctly instantiated and registered for each symbol added to the universe. This seems to be correctly handled in the OnSecuritiesChanged method.
   • Ensure that the Engulfing pattern indicator is updated with new data as it arrives. This is typically done through consolidators, which you've set up, but ensure that the data type (QuoteBar vs. TradeBar) matches the expected input for the indicator.

2. Check the Consolidator Period:

   • The QuoteBarConsolidator(1) creates a consolidator with a period of 1 minute. Confirm that this period aligns with the expected timeframe for the engulfing pattern to form. If the engulfing pattern is expected to form over a different period, adjust the consolidator accordingly.

3. Verify the Engulfing Pattern Logic:

   • The logic within consolidation_handler checks if the Engulfing pattern's Current.Value is not 0, which indicates a pattern has been found. Ensure this logic correctly identifies the patterns you're interested in. Remember, an engulfing pattern value of 1 indicates a bullish engulfing, and -1 indicates a bearish engulfing.

4. Review the Trade Execution Conditions:

   • In the OnData method, trades are only executed if certain conditions related to volume ratio and percent change are met. Double-check these conditions to ensure they're not too restrictive, preventing trades from being executed.

5. Ensure Symbols are Tradable:

   • When symbols are added to or removed from the universe, ensure they are tradable (not delisted, have sufficient liquidity, etc.). Use security.IsTradable to check if a security is tradable before attempting to trade it.

6. Debugging and Logging:

   • Add more logging throughout the algorithm, especially before trade execution conditions and within the TradeLogic method. This can help identify where the algorithm might be failing to meet trade criteria or if there are issues with the data.
   • Consider logging the count of self.engulfingNOW and self.filtered_symbols to ensure that symbols are being correctly identified and added for trading.

7. Historical Data Requests:

   • Be cautious with historical data requests in the OnData method, as frequent requests can slow down your algorithm. Ensure that these requests are necessary for your trade logic and consider caching results if possible.

8. Warm-Up Period:

   • You've set a warm-up period of 2 days with Resolution.Daily. Ensure this is sufficient for your indicators to be ready and produce meaningful signals from the start of the algorithm.

If after reviewing and adjusting these areas the issue persists, it may be helpful to isolate parts of the algorithm (e.g., testing the engulfing pattern logic independently) to more easily identify where the problem lies.