USING RETURNS FOR STRATEGY

Issue is this part here:

if symbol1 in data.Keys and symbol2 in data.Keys and data[symbol1] and data[symbol2]:
    x = data[symbol1].Price
    y = data[symbol2].Price
           
    price_1=x/x.shift(1)-1
    price_1=y/y.shift(1)-1

where `x` and `y` are floats but you run the (presumably pandas) `.shift()` on it. If you need to store the previous price, you can do something like

def Initialize(self):
    self.prevPrices = { symbol : None for symbol in self.symbols }

def OnData(self, data):
    # Check if not empty
    for symbol in self.symbols: 
        if self.prevPrices[symbol] is None:
            return
    # Check if data exists
    if not all([ data.ContainsKey(symbol) for symbol in self.symbols ]): return
    
    prices = { symbol : data[symbol] for symbol in self.symbols }
    
    # The change in prices (your `price_1` var)
    price_1 = { symbol : ( prices[symbol] / self.prevPrices[symbol] )-1. for symbol in self.symbols }
    
    # Do something
    
    # At end of OnData, update the price dicts with current value
    self.prevPrices.update( prices )

Thanks for the help! I think I made a mistake in the code I meant

if symbol1 in data.Keys and symbol2 in data.Keys and data[symbol1] and data[symbol2]:x = data[symbol1].Pricey = data[symbol2].Priceprice_1=x/x.shift(1)-1price_2=y/y.shift(1)-1

I try to run your algo but im not sure if iim having something wrong can you check it out? The code is not working

THANKS FOR THE HELP!!

class WTIBRENTSpread(QCAlgorithm):
   def Initialize(self):
       self.SetStartDate(2022, 1, 1)
       self.SetCash(10000)
       self.symbols = ["CDNS","SNPS"]
       self.prevPrices = { symbol : None for symbol in self.symbols }
       for symbol in self.symbols:
           data = self.AddEquity(symbol, Resolution.Hour)
           #data.SetLeverage(5)
       
   def OnData(self, data):
       symbol1 = self.Symbol(self.symbols[0])
       symbol2 = self.Symbol(self.symbols[1])
       
       
       for symbol in self.symbols: 
           if self.prevPrices[symbol] is None:
               return
       if not all([ data.ContainsKey(symbol) for symbol in self.symbols ]): return
   
       prices = { symbol : data[symbol] for symbol in self.symbols }
       
       price_1 = { symbol : ( prices[symbol1] / self.prevPrices[symbol1] )-1 for symbol in self.symbols }
       price_2 = { symbol : ( prices[symbol2] / self.prevPrices[symbol2] )-1 for symbol in self.symbols }
       
       self.prevPrices.update( prices )
           
       if price1 != 0 and price2 != 0:
           spread = price_1 - price_2
           self.spread.Add(spread)
       
       if self.spread.IsReady:
           if (self.Time.date() - self.Securities[symbol1].GetLastData().Time.date()).days < 5 and (self.Time.date() - self.Securities[symbol2].GetLastData().Time.date()).days < 5:
               
               current_spread = spreads[0]
               
               if current_spread > 0.01:
                   self.SetHoldings(symbol1, -1)
                   self.SetHoldings(symbol2, 1)
               elif current_spread < 0.01:
                   self.SetHoldings(symbol1, 1)
                   self.SetHoldings(symbol2, -1)
           else:
               self.Liquidate()

Be careful with this part here:

prices = { symbol : data[symbol] for symbol in self.symbols }
price_1 = { symbol : ( prices[symbol1] / self.prevPrices[symbol1] )-1 for symbol in self.symbols }
price_2 = { symbol : ( prices[symbol2] / self.prevPrices[symbol2] )-1 for symbol in self.symbols }

Here's a more complete example attached. Try to make sure you understand what each line of code is doing so far before adding the trading logic.

Reattaching backtest in case it didn't show up

Ro García G

Here is my attempt to implement your strategy with QC indicators.

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

Here is the code snippet of the attached backtest.

# Pair momentum spread

from AlgorithmImports import *

SYMBOLS = ["CDNS","SNPS"]; MOM = 2;

class WTIBRENTSpread(QCAlgorithm):
    def Initialize(self):
        self.SetStartDate(2021, 1, 1)
        self.SetCash(100000)
        self.symbols = [self.AddEquity(ticker, Resolution.Minute).Symbol for ticker in SYMBOLS]
        self.mom = {}
        for symbol in self.symbols:
             self.mom[symbol] = self.MOM(symbol, MOM, Resolution.Daily)
        self.SetWarmUp(MOM + 1, Resolution.Daily)  
       
       
    def OnData(self, data):
        if self.Time.time() != time(10, 31): return
        if self.IsWarmingUp: return
        if not (self.mom[self.symbols[0]].IsReady and self.mom[self.symbols[1]].IsReady): return
   
        spread = self.mom[self.symbols[0]].Current.Value - self.mom[self.symbols[1]].Current.Value
        self.Plot("spread", "spread", spread)
       
        if spread > 10:
            self.SetHoldings(self.symbols[0], -0.5)
            self.SetHoldings(self.symbols[1], 0.5)
        elif spread < -10:
            self.SetHoldings(self.symbols[0], 0.5)
            self.SetHoldings(self.symbols[1], -0.5)