Problem with Debug Time to prevent day trades

You can just create some dictionary that indicates whether you sold the stock, then use a Scheduled Function at end of each day to reset it to False.

from datetime import datetime
from datetime import timedelta

class BasicTemplateAlgorithm(QCAlgorithm):

    def Initialize(self):
     
        self.SetStartDate(2022,2,20)
        self.SetCash(50000000)
        self.Data_Symbol = {}
        tickers = ["SPY", "AAPL", "MSFT", "AMZN", ]

        self.SetWarmUp(30, Resolution.Daily)                
                        
        for stock in tickers:
            symbol = self.AddEquity(stock, Resolution.Minute).Symbol
            self.Data_Symbol[symbol] = SymbolData(self, symbol)
            
        ## Dictionary for whether symbol was traded; we will reset this every day
        self.symbolTraded = { symbol: False for symbol in self.Data_Symbol.keys() }    
        
self.Schedule.On(self.DateRules.EveryDay("SPY"), self.TimeRules.BeforeMarketClose('SPY', 0), self.ResetSymbolTraded)
        


        self.Schedule.On(self.DateRules.EveryDay("SPY"), self.TimeRules.Every(timedelta(minutes=1)), self.EveryDayAfterMarketOpen)


        
    def EveryDayAfterMarketOpen(self):
        if self.IsWarmingUp: return
        
        for symbol, symbol_data in self.Data_Symbol.items():
            if not symbol_data.cci.IsReady: continue

            holdings = self.Portfolio[symbol]
            invested = holdings.Invested
            nowprice = holdings.Price
            aveprice = holdings.AveragePrice
            quantity = holdings.Quantity
            
            cci = symbol_data.cci.Current.Value
            
            ## Check whether the symbol was traded
            sold_today = self.symbolTraded[symbol]
            



            #Buy symbol only if if CCI < 100 and that symbol was not sold today
            if (not invested) and (not sold_today) and (cci < -100):
                self.MarketOrder(symbol, + mofactor)
                self.Debug (symbol)
                self.Debug (self.Time.date)
                
                what_to_buy = (symbol)
                when_to_buy = (self.Time.date)
                tobuy = what_to_buy and when_to_buy
                    
            if invested and (nowprice > aveprice * 1.01):
                self.MarketOrder (symbol, (-1 * quantity))
                self.Debug (symbol)
                self.Debug (self.Time.date)
                #sold_symbol = (symbol)
                when_sold = (self.Time.date)
                #sold_today = sold_symbol and when_sold
                
                ## Note: Assuming if this triggers you want to stop the buy signal?
                ## Then add a `self.symbolTraded[symbol] = True` here
        

    
    def ResetSymbolTraded(self):
        ## We reset this to False at end of each day
        self.symbolTraded = { symbol: False for symbol in self.Data_Symbol.keys() }    
         
class SymbolData:
    def __init__ (self,algo,symbol):
        self.algorithm = algo
        self.symbol = symbol
       
        #CCI Functions
        self.cci = algo.CCI(symbol, 14, MovingAverageType.Simple, Resolution.Daily)

@Adam, when I run the back test on your edit, the algo is re-buying the symbols 1-2 minutes after selling them. I tried playing around the False/True flag, but doesn't see to figure how to prevent the someday rebuying after selling

@Adam, when I run the back test on your edit, the algo is re-buying the symbols 1-2 minutes after selling them. I tried playing around the False/True flag, but doesn't see to figure how to prevent the someday rebuying after selling

See backtest below

Lemuel Mwangi   this code solves the ‘don’t buy the same day if you have sold that day' problem.  It does though still initiate a buy-on open for the next day.  Quite impressive 100% win rate, but this is negated by the fact that there is no stop-loss.  

Thanks

Lemuel Mwangi 

→ I am trying to improve this algorithm to NOT buy a stock if the same stock has been sold on that same day. 

You can use  self.Schedule.On() to trade once a day like in “Oversold CCI portfolio with Take Profit and Stop Loss”.

If you are satisfied with my answer, please accept it and don't forget to like it

Lemuel Mwangi 

    @Adam, when I run the back test on your edit, the algo is re-buying the symbols 1-2 minutes after selling them. I tried playing around the False/True     flag, but doesn't see to figure how to prevent the someday rebuying after selling

Try this instead. I'm running a backtest so can't check if this works, but it should.

from datetime import datetime
from datetime import timedelta

class BasicTemplateAlgorithm(QCAlgorithm):

    def Initialize(self):
     
        self.SetStartDate(2022,2,20)
        self.SetCash(50000000)
        self.Data_Symbol = {}
        tickers = ["SPY", "AAPL", "MSFT", "AMZN", ]

        self.SetWarmUp(30, Resolution.Daily)                
                        
        for stock in tickers:
            symbol = self.AddEquity(stock, Resolution.Minute).Symbol
            self.Data_Symbol[symbol] = SymbolData(self, symbol)
            
        ## Dictionary for whether we can trade this symbol; we will reset this at end of each day
        self.canTradeSymbol = { symbol: True for symbol in self.Data_Symbol.keys() }    
        
        self.Schedule.On(self.DateRules.EveryDay("SPY"), 
                         self.TimeRules.BeforeMarketClose('SPY', 0), 
                         self.canTradeSymbols)
 
        self.Schedule.On(self.DateRules.EveryDay("SPY"), 
                         self.TimeRules.Every(timedelta(minutes=1)), 
                         self.EveryDayAfterMarketOpen)


        
    def EveryDayAfterMarketOpen(self):
        if self.IsWarmingUp: return
        
        for symbol, symbol_data in self.Data_Symbol.items():
            if not symbol_data.cci.IsReady: continue

            holdings = self.Portfolio[symbol]
            invested = holdings.Invested
            nowprice = holdings.Price
            aveprice = holdings.AveragePrice
            quantity = holdings.Quantity
            
            cci = symbol_data.cci.Current.Value
            
            # Check whether we can trade this symbol
            can_trade = self.canTradeSymbol[symbol]
            if not can_trade:
                continue
                
            #Buy symbol if CCI < 100
            if (not invested) and (cci < -100):
                self.MarketOrder(symbol, 1)
                self.Debug(f'Bought {symbol} at {self.Time}')
                
            # Sell symbol        
            if invested and (nowprice > aveprice * 1.01):
                self.MarketOrder (symbol, (-1 * quantity))
                self.Debug(f'Liquidated {symbol} at {self.Time}.')
                
                # Now after a buy/sell, we prevent future buys for the rest of the day
                self.canTradeSymbol[symbol] = False

    def ResetSymbolTraded(self):
        ## We reset this to Trade at end of each day
        self.canTradeSymbol = { symbol: True for symbol in self.Data_Symbol.keys() }    
         
class SymbolData:
    def __init__ (self,algo,symbol):
        self.algorithm = algo
        self.symbol = symbol
       
        #CCI Functions
        self.cci = algo.CCI(symbol, 14, MovingAverageType.Simple, Resolution.Daily)