`from System import *`

from QuantConnect import *

from QuantConnect.Algorithm import *

from QuantConnect.Python import PythonQuandl

from datetime import timedelta, datetime

from Selection.FundamentalUniverseSelectionModel import FundamentalUniverseSelectionModel

class SMAPairsTrading(QCAlgorithm):

def Initialize(self):

self.SetStartDate(2000, 1, 1)

self.SetEndDate(2010,3,16)# Set Start Date

self.SetCash(100000) # Set Strategy Cash

self.SetUniverseSelection(AllUniverse())

self.UniverseSettings.Resolution = Resolution.Daily

self.UniverseSettings.DataNormalizationMode = DataNormalizationMode.Raw

self.AddAlpha(Smaalphamodel())

self.SetPortfolioConstruction(EqualWeightingPortfolioConstructionModel())

self.SetRiskManagement(MaximumDrawdownPercentPerSecurity(0.05))

self.SetExecution(ImmediateExecutionModel())

self.SetBenchmark("SPY")

self.SetSecurityInitializer(self.CustomSecurityInitializer)

def OnEndOfDay(self, symbol):

self.Log("Taking a position of " + str(self.Portfolio[symbol].Quantity) + " units of symbol " + str(symbol))

def CustomSecurityInitializer(self, security):

security.SetLeverage(1)

class Smaalphamodel(AlphaModel):

def __init__(self):

self.Symbols = [ ]

self.SMALT = SimpleMovingAverage(200)

self.SMAMT = SimpleMovingAverage(50)

self.SMAST = SimpleMovingAverage(20)

self.period = timedelta(days=2)

def Update(self, algorithm, data):

Appd = []

Prices={}

for i in range(len(List)):

Price[i] = self.Symbols[i].Price

List=[x.Symbol for x in self.Symbols]

self.SMALT.Update(algorithm.Time,[x for x in Prices])

self.SMAMT.Update(algorithm.Time,[x for x in Prices])

self.SMAST.Update(algorithm.Time,[x for x in Prices])

for i in List:

if self.Symbols[i].Price > self.SMAL[i].Current.Value > self.SMAMT[i].Current.Value>self.SMAST[i].Current.Value :

Appd.append(Insight.Price(i, self.period, InsightDirection.Up))

elif self.Symbols[i].Price < self.SMAL[i].Current.Value < self.SMAMT[i].Current.Value < self.SMAST[i].Current.Value :

Appd.append(Insight.Price(i, self.period, InsightDirection.Down))

else:

Appd.append(Insight.Price(i, self.period, InsightDirection.Flat))

return Insight.Group([ x for x in Appd])

def OnSecuritiesChanged(self, algorithm, changes):

self.Symbols = [x for x in changes.AddedSecurities]

#1. Call for 500 bars of history data for each symbol in the pair and save to the variable history

history = algorithm.History([x.Symbol for x in self.Symbols], 200)

#2. Unstack the Pandas data frame to reduce it to the history close price

history = history.close.unstack(level=0)

for tuple in history.itertuples():

self.SMALT.Update(tuple[0],[tuple[i] for i in range(len(self.Symbols))])

self.SMAMT.Update(tuple[0],[tuple[i] for i in range(len(self.Symbols))])

self.SMAST.Update(tuple[0],[tuple[i] for i in range(len(self.Symbols))])

class AllUniverse(FundamentalUniverseSelectionModel):

'''

This module selects the most liquid stocks listed on the New York Stock Exchange.

'''

def __init__(self, filterFineData = True, universeSettings = None, securityInitializer = None):

'''Initializes a new default instance of the TechnologyUniverseModule'''

super().__init__(filterFineData, universeSettings, securityInitializer)

self.numberOfSymbolsCoarse = 1000

self.numberOfSymbolsFine = 500

self.dollarVolumeBySymbol = {}

self.lastMonth = -1

def SelectCoarse(self, algorithm, coarse):

'''

Performs a coarse selection:

-The stock must have fundamental data

-The stock must have positive previous-day close price

-The stock must have positive volume on the previous trading day

'''

if algorithm.Time.month == self.lastMonth:

return Universe.Unchanged

sortedByDollarVolume = sorted([x for x in coarse if x.HasFundamentalData and x.Volume > 0 and x.Price > 5],

key = lambda x: x.DollarVolume, reverse=True)[:self.numberOfSymbolsCoarse]

self.dollarVolumeBySymbol = {x.Symbol:x.DollarVolume for x in sortedByDollarVolume}

# If no security has met the QC500 criteria, the universe is unchanged.

if len(self.dollarVolumeBySymbol) == 0:

return Universe.Unchanged

return list(self.dollarVolumeBySymbol.keys())

def SelectFine(self, algorithm, fine):

'''

Performs a fine selection:

-The company's headquarter must in the U.S.

-The stock must be traded on the NASDAQ stock exchange

-The stock must be in the Industry Template Code catagory N

-At least half a year since its initial public offering

'''

# Filter stocks and sort on dollar volume

sortedByDollarVolume = sorted([x for x in fine if x.CompanyReference.CountryId == "USA"

and x.CompanyReference.PrimaryExchangeID == "NYS"

and (algorithm.Time - x.SecurityReference.IPODate).days > 180],

key = lambda x: self.dollarVolumeBySymbol[x.Symbol], reverse=True)

if len(sortedByDollarVolume) == 0:

return Universe.Unchanged

self.lastMonth = algorithm.Time.month

return [x.Symbol for x in sortedByDollarVolume[:self.numberOfSymbolsFine]]

Hello , I want to create an alpha model using technical analysis but unfortunately I couldn't update the historical datas in the SimpleMovingAverage function.Does anyone know how to fix this problem?

Thank you