Backtest not showing Data

This is my backtest btw 

From the code you've shared, there are a few potential issues that might be causing your backtests to show no data:

1. In your OnData method, you're checking if self.symbol is in self.Portfolio.Keys before placing any trades. However, self.symbol will always be in self.Portfolio.Keys because you've added it to your algorithm in the Initialize method. This means that your trading logic might never be executed. You might want to check if you have any open positions for self.symbol instead. You can do this with self.Portfolio[self.symbol].Invested.

2. In your CheckCandle method, you're calling CheckBull and CheckBear without the self keyword, which will cause a NameError because Python will think that CheckBull and CheckBear are global functions, not methods of your algorithm class. You should call these methods as self.CheckBull and self.CheckBear.

3. Similarly, in your CheckCandle method, you're calling RollCandleStates without the self keyword. You should call it as self.RollCandleStates.

4. In your CheckCandle method, you're checking if 'Engulfing' is in self.candle_states[0]. However, self.candle_states[0] is a string, not a list, so this check will always return False unless self.candle_states[0] is exactly 'Engulfing'. If you want to check if any of the strings in self.candle_states contain 'Engulfing', you should iterate over self.candle_states and check each string individually.

5. Finally, you're not doing anything with the size variable in the last line of your CheckCandle method. If you're not using this variable elsewhere in your code, you can remove this line.

Here's how you can fix these issues:

class MaccaDacca(QCAlgorithm):
    # ... (rest of your code) ...

    def OnData(self, data: Slice):
        # ... (rest of your code) ...
        if not self.Portfolio[self.symbol].Invested:  # Check if you have any open positions for self.symbol
            # ... (rest of your code) ...

    def CheckCandle(self, recent_candle, middle_candle, oldest_candle):
        if self.CheckBull(recent_candle) and self.CheckBear(middle_candle):  # Use self.CheckBull and self.CheckBear
            # ... (rest of your code) ...
        # ... (rest of your code) ...
        if any('Engulfing' in state for state in self.candle_states):  # Check if 'Engulfing' is in any string in self.candle_states
            # ... (rest of your code) ...

I hope this helps! Let me know if you have any other questions.

from AlgorithmImports import *
from collections import deque

class MaccaDacca(QCAlgorithm):

    def Initialize(self):
        self.SetStartDate(2021, 1, 1)
        self.SetEndDate(2023, 11, 8)
        self.SetCash(3000)

        self.symbol = self.AddEquity('AAPL', Resolution.Hour).Symbol
        self.window = deque(maxlen=3)  # Use deque as a rolling window
        self.macd = self.MACD(self.symbol, 1, 2, 2, MovingAverageType.Exponential)
        self.candle_states = []
        self.SetBenchmark(self.symbol)

        # Pre-fill the window with historical data
        history_data = self.History(self.symbol, 3, Resolution.Hour)
        for index, row in history_data.iterrows():
            candle = TradeBar()
            candle.Open = row['open']
            candle.Close = row['close']
            candle.High = row['high']
            candle.Low = row['low']
            candle.Volume = row['volume']
            self.window.append(candle)

        self.Settings.FreePortfolioValuePercentage = 0.05


    def OnData(self, data: Slice):
        try:
            #if data.ContainsKey(self.symbol) and self.macd.IsReady: 
            #    self.window.append(data[self.symbol])

            if len(self.window) == 3:  # Check if the rolling window is ready
                    recent_candle = self.window[-1]
                    middle_candle = self.window[-2]
                    oldest_candle = self.window[-3]
                    self.CheckCandle(recent_candle, middle_candle, oldest_candle)

            self.macd_value = self.macd.Current.Value
            self.macd_indicator = self.CheckMACD(self.macd_value)

            # if you have yet to invest, open a long position 
            if not self.Portfolio[self.symbol].Invested and data[self.symbol] is not None: 
                quantity = (self.Portfolio.Cash / 2) / recent_candle.Close
                price = data[self.symbol].Price
                
                if self.candle_states:
                    # long positions
                    if self.macd_indicator == 'Bull' and self.candle_states[0] == 'Bullish Engulfing'\
                            or self.macd_indicator == 'Bull' and self.candle_states[0] == 'Bearish Doji'\
                            or self.macd_indicator == 'Bull' and self.candle_states[0] == 'Bullish Momentum'\
                            or self.macd_indicator == 'Bull' and self.candle_states[0] == 'Bullish Hammer':
                        self.MarketTicket = self.LimitOrder(self.symbol, quantity, price)
                        self.TrailingStop = self.TrailingStopOrder(self.symbol, quantity, price * 0.9, 1.2, False)

                    # short positions
                    elif self.macd_indicator == 'Bear' and self.candle_states[0] == 'Bearish Engulfing'\
                            or self.macd_indicator == 'Bear' and self.candle_states[0] == 'Bearish Doji'\
                            or self.macd_indicator == 'Bear' and self.candle_states[0] == 'Bearish Momentum'\
                            or self.macd_indicator == 'Bear' and self.candle_states[0] == 'Bearish Hammer':
                        self.MarketTicket = self.LimitOrder(self.symbol, -quantity, price)
                        self.TrailingStop = self.StopMarketOrder(self.symbol, -quantity, price * 1.1)

        except KeyError: 
            self.Debug('Might be an error with data')

        # if you already have an open position, hold until the trailing stop loss or indicator turns to 
        # a large red candle or a doji green candle 

    def CheckBull(self, data): 
        if data.Close > data.Open: 
            return True
        else: 
            return False

    def CheckBear(self, data):
        if data.Close < data.Open: 
            return True
        else: 
            return False


    def RollCandleStates(self, candle_states): 
        if len(candle_states) > 3:
            candle_states.pop()


    def CheckCandle(self, recent_candle, middle_candle, oldest_candle): 
        # Check for engulfing candles  
        if self.CheckBull(recent_candle) and self.CheckBear(middle_candle):
            if recent_candle.Close > middle_candle.Open and recent_candle.Open < middle_candle.Close:
                self.candle_states.insert(0, 'Bullish Engulfing')
                self.RollCandleStates(self.candle_states)

        if self.CheckBear(recent_candle) and self.CheckBull(middle_candle):
            if recent_candle.Close < middle_candle.Open and recent_candle.Open > middle_candle.Close: 
                self.candle_states.insert(0, 'Bearish Engulfing')
                self.RollCandleStates(self.candle_states)

        if self.CheckBear(recent_candle) and self.CheckBear(middle_candle):
            if recent_candle.Close < middle_candle.Close and recent_candle.Open > middle_candle.Open: 
                self.candle_states.insert(0, 'Bearish Engulfing')
                self.RollCandleStates(self.candle_states)

        elif self.CheckBull(recent_candle) and self.CheckBull(middle_candle):
            if recent_candle.Close > middle_candle.Close and recent_candle.Open < middle_candle.Open:
                self.candle_states.insert(0, 'Bullish Engulfing')
                self.RollCandleStates(self.candle_states)

        # Check for doji candles 
        if self.CheckBull(recent_candle) and recent_candle.Open * 1.1 < recent_candle.Close: 
            self.candle_states.insert(0, 'Bullish Doji')
            self.RollCandleStates(self.candle_states)

        elif self.CheckBear(recent_candle) and recent_candle.Close * 1.1 < recent_candle.Open: 
            self.candle_states.insert(0, 'Bearish Doji')
            self.RollCandleStates(self.candle_states)

        # Check for momentum candles (momentum candles)
        if self.CheckBull(recent_candle) and any('Engulfing' in state for state in self.candle_states):
            size = abs(recent_candle.Close - recent_candle.Open)
            previous_size = abs(middle_candle.Close - middle_candle.Open)
            if size >= previous_size:
                self.candle_states.insert(0, 'Bullish Momentum')
                self.RollCandleStates(self.candle_states)
                    
        elif self.CheckBear(recent_candle) and any('Engulfing' in state for state in self.candle_states):
            size = abs(recent_candle.Close - recent_candle.Open)
            previous_size = abs(middle_candle.Close - middle_candle.Open)
            if size >= previous_size:
                self.candle_states.insert(0, 'Bearish Momentum')
                self.RollCandleStates(self.candle_states)     
        
        # check for Maribozu candles 
        if self.CheckBull(recent_candle) and recent_candle.Open == recent_candle.Low and recent_candle.Close == recent_candle.High:
            self.candle_states.insert(0, 'Bullish Maribozu')
            self.RollCandleStates(self.candle_states)

        elif self.CheckBear(recent_candle) and recent_candle.Open == recent_candle.High and recent_candle.Close == recent_candle.Low:
            self.candle_states.insert(0, 'Bearish Maribozu') 
            self.RollCandleStates(self.candle_states)

        # check for hammer candle (wick is longer than body of candle)
        if self.CheckBull(recent_candle) and recent_candle.Open - recent_candle.Low > recent_candle.Close - recent_candle.Open: 
            self.candle_states.insert(0, 'Bullish Hammer')
            self.RollCandleStates(self.candle_states)

        elif self.CheckBear(recent_candle) and recent_candle.Close - recent_candle.Low > recent_candle.Open - recent_candle.Close: 
            self.candle_states.insert(0, 'Bearish Shooting Star')
            self.RollCandleStates(self.candle_states)


    def CheckMACD(self, macd_value):
        if macd_value > 0: 
            return 'Bull'
        else:
            return 'Bear'


    def OnOrderEvent(self, orderEvent): 
        if orderEvent.Status != OrderStatus.Filled: 
            return 
        
        elif orderEvent.Status == OrderStatus.Filled and self.Portfolio[self.symbol].IsLong:
            # Check if the order event was for a trailing stop order
            if orderEvent.OrderId == self.TrailingStop.OrderId:
                self.Liquidate(self.symbol)
        
        elif orderEvent.Status == OrderStatus.Filled and self.Portfolio[self.symbol].IsShort:
            # Check if the order event was for a trailing stop order
            if orderEvent.OrderId == self.TrailingStop.OrderId:
                self.Liquidate(self.symbol)