Start New Discussion 
Back
Reward Discussion 
from datetime import timedelta
from QuantConnect.Data.UniverseSelection import *
from Selection.FundamentalUniverseSelectionModel import FundamentalUniverseSelectionModel
from Portfolio.EqualWeightingPortfolioConstructionModel import EqualWeightingPortfolioConstructionModel
class SectorBalancedPortfolioConstruction(QCAlgorithm):
def Initialize(self):
self.SetStartDate(2020, 7, 1)
self.SetEndDate(2021, 7, 1)
self.SetCash(100000)
self.UniverseSettings.Resolution = Resolution.Hour
# Set an instance of MyUniverseSelectionModel using self.SetUniverseSelection
self.SetUniverseSelection(MyUniverseSelectionModel())
self.SetAlpha(ConstantAlphaModel(InsightType.Price, InsightDirection.Up, timedelta(1), 0.025, None))
# Set an instance of the MySectorWeightingPortfolioConstructionModel using self.SetPortfolioConstruction
self.SetPortfolioConstruction(MySectorWeightingPortfolioConstructionModel()) #Default (Resolution.Daily))
self.SetExecution(ImmediateExecutionModel())
class MyUniverseSelectionModel(FundamentalUniverseSelectionModel):
def __init__(self):
super().__init__(True, None) #default: super().__init__(True, None)
def SelectCoarse(self, algorithm, coarse):
filtered = [x for x in coarse if x.HasFundamentalData and x.Price > 0]
sortedByDollarVolume = sorted(filtered, key=lambda x: x.DollarVolume, reverse=True)
return [x.Symbol for x in sortedByDollarVolume][:100]
def SelectFine(self, algorithm, fine):
# Save the top 3 securities sorted by MarketCap for the Technology sector to the variable self.technology
filtered = [f for f in fine if f.AssetClassification.MorningstarSectorCode == MorningstarSectorCode.Technology]
self.technology = sorted(filtered, key=lambda f: f.MarketCap, reverse=True)[:3]
# Save the top 2 securities sorted by MarketCap for the Financial Services sector to the variable self.financialServices
filtered = [f for f in fine if f.AssetClassification.MorningstarSectorCode == MorningstarSectorCode.FinancialServices]
self.financialServices = sorted(filtered, key=lambda f: f.MarketCap, reverse=True)[:3]
#4. Save the top 1 securities sorted by MarketCap for the Consumer Goods sector to the variable self.consumerDefensive
filtered = [f for f in fine if f.AssetClassification.MorningstarSectorCode == MorningstarSectorCode.ConsumerDefensive]
self.consumerDefensive = sorted(filtered, key=lambda f: f.MarketCap, reverse=True)[:0]
return [x.Symbol for x in self.technology + self.financialServices + self.consumerDefensive]
########################
class MySectorWeightingPortfolioConstructionModel(EqualWeightingPortfolioConstructionModel):
# In the constructor, pass in the rebalance parameter and set it to daily resolution
def __init__(self, rebalance = Resolution.Daily):
# Initialize the underlying class by passing it through
super().__init__(rebalance)
# Initialize an empty dictionary self.symbolBySectorCode to group the securities by sector code
self.symbolBySectorCode = dict()
self.result = dict()
def DetermineTargetPercent(self, activeInsights):
#1. Set the self.sectorBuyingPower before by dividing one by the length of self.symbolBySectorCode
self.sectorBuyingPower = 1 / len(self.symbolBySectorCode)
for sector, symbols in self.symbolBySectorCode.items():
#2. Search for the active insights in this sector. Save the variable self.insightsInSector
self.insightsInSector = [insight for insight in activeInsights if insight.Symbol in symbols]
#3. Divide the self.sectorBuyingPower by the length of self.insightsInSector to calculate the variable percent
# The percent is the weight we'll assign the direction of the insight
self.percent = self.sectorBuyingPower / len(self.insightsInSector)
#4. For each insight in self.insightsInSector, assign each insight an allocation.
# The allocation is calculated by multiplying the insight direction by the self.percent
for insight in self.insightsInSector:
self.result[insight] = insight.Direction * self.percent
return self.result
################################
def OnSecuritiesChanged(self, algorithm, changes):
for security in changes.AddedSecurities:
# When new assets are added to the universe, save the Morningstar sector code
# for each security to the variable sectorCode
sectorCode = security.Fundamentals.AssetClassification.MorningstarSectorCode
# If the sectorCode is not in the self.symbolBySectorCode dictionary, create a new list
if sectorCode not in self.symbolBySectorCode:
self.symbolBySectorCode[sectorCode] = list()
# and append the symbol to the list, keyed by sectorCode in the self.symbolBySectorCode dictionary
self.symbolBySectorCode[sectorCode].append(security.Symbol)
for security in changes.RemovedSecurities:
#3. For securities that are removed, save their Morningstar sector code to sectorCode
sectorCode = security.Fundamentals.AssetClassification.MorningstarSectorCode
#4. If the sectorCode is in the self.symbolBySectorCode dictionary
if sectorCode in self.symbolBySectorCode:
symbol = security.Symbol
# If the symbol is in the dictionary's sectorCode list;
if symbol in self.symbolBySectorCode[sectorCode]:
# Then remove the corresponding symbol from the dictionary
self.symbolBySectorCode[sectorCode].remove(symbol)
# We use the super() function to avoid using the base class name explicity
super().OnSecuritiesChanged(algorithm, changes)
Above Code is from the last of the bootcamps but it sends the error message below. What am I missing that causes this error?
Error Message
Runtime Error: AttributeError : 'NoneType' object has no attribute 'AssetClassification'
at OnSecuritiesChanged
sectorCode = security.Fundamentals.AssetClassification.MorningstarSectorCode
===
at Python.Runtime.PyObject.Invoke(PyTuple args in main.py:line 89
AttributeError : 'NoneType' object has no attribute 'AssetClassification'Stack Trace
AttributeError : 'NoneType' object has no attribute 'AssetClassification'
at OnSecuritiesChanged
sectorCode = security.Fundamentals.AssetClassification.MorningstarSectorCode
===
at Python.Runtime.PyObject.Invoke(PyTuple args in main.py:line 89
2
