Overall Statistics
Total Trades
324
Average Win
0.52%
Average Loss
-0.45%
Compounding Annual Return
24.213%
Drawdown
20.600%
Expectancy
0.265
Net Profit
91.762%
Sharpe Ratio
1.199
Probabilistic Sharpe Ratio
56.461%
Loss Rate
41%
Win Rate
59%
Profit-Loss Ratio
1.16
Alpha
0.227
Beta
-0.083
Annual Standard Deviation
0.179
Annual Variance
0.032
Information Ratio
0.297
Tracking Error
0.241
Treynor Ratio
-2.587
Total Fees
$459.33
from Selection.FundamentalUniverseSelectionModel import FundamentalUniverseSelectionModel

class TechnologyUniverseModule(FundamentalUniverseSelectionModel):
    '''
    This module selects the most liquid stocks listed on the Nasdaq 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 = 100
        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 > 0],
            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 == "NAS"
                                        and x.CompanyReference.IndustryTemplateCode == "N"
                                        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]]
from Selection.FundamentalUniverseSelectionModel import FundamentalUniverseSelectionModel

class NadionUncoupledPrism(QCAlgorithm):

    def Initialize(self):
        
        self.SetStartDate(2011, 1, 1)
        self.SetEndDate(2014, 1, 1)
        self.SetCash(100000)
        
        self.AddEquity("SPY", Resolution.Daily)
        self.AddEquity("TLT", Resolution.Daily)
        self.AddEquity("QQQ", Resolution.Daily)
        
        self.symbols = [Symbol.Create("SPY", SecurityType.Equity, Market.USA), \
        Symbol.Create("TLT", SecurityType.Equity, Market.USA), Symbol.Create("QQQ", SecurityType.Equity, Market.USA)]
        
        self.averages = {}
        
        self.AddUniverseSelection(TechnologyUniverseModule())
        self.AddRiskManagement(NullRiskManagementModel())
        self.SetPortfolioConstruction(NullPortfolioConstructionModel())
        self.SetExecution(ImmediateExecutionModel())

        self.UniverseSettings.Resolution = Resolution.Daily
        
        self.SetWarmUp(200)
        

    def OnData(self, data):

        if self.IsWarmingUp:
            
            return


        for security in self.changes.RemovedSecurities:
            
            if security.Invested:
                
                self.Liquidate(security.Symbol)
                
                
        for security in self.changes.AddedSecurities:
            
            if not security.Invested and security.Symbol not in self.symbols:
                
                self.SetHoldings(security.Symbol, 0.05)
                    
            
        else:
            
            return


    def OnSecuritiesChanged(self, changes):
        
        self.changes = changes


class TechnologyUniverseModule(FundamentalUniverseSelectionModel):
    
    #This module selects the most liquid stocks listed on the Nasdaq 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 = 100
        self.dollarVolumeBySymbol = {}
        self.lastMonth = -1


    def SelectCoarse(self, algorithm, coarse):

        if algorithm.Time.month == self.lastMonth: 
            return Universe.Unchanged
            

        coarse = sorted([x for x in coarse if x.HasFundamentalData and x.Price > 10],
                               key = lambda x: x.DollarVolume, reverse=True)[:self.numberOfSymbolsCoarse]
        

        for security in coarse:
            
            symbol = security.Symbol
            
            self.dollarVolumeBySymbol[symbol] = security.DollarVolume

       #self.dollarVolumeBySymbol = {x.Symbol:x.DollarVolume for x in coarse}
        
        
        # 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):

        sortedByDollarVolume =  sorted([x for x in fine if x.CompanyReference.CountryId == "USA" \
                                and x.CompanyReference.PrimaryExchangeID == "NAS" \
                                and x.CompanyReference.IndustryTemplateCode == "N" \
                                and (algorithm.Time - x.SecurityReference.IPODate).days > 180], \
            key = lambda x: self.dollarVolumeBySymbol[x.Symbol], reverse=True)

#Industry Template Codes: N=Normal (Manufacturing), M=Mining, U=Utility, T=Transportation, B=Bank, I=Insurance  


        if len(sortedByDollarVolume) == 0:
            
            return Universe.Unchanged
            
            
        self.lastMonth = algorithm.Time.month
        
        return [x.Symbol for x in sortedByDollarVolume[:20]]
        
        
class NullPortfolioConstructionModel(PortfolioConstructionModel):

    def CreateTargets(self, algorithm, insights):
        
        return []
        
        
class ImmediateExecutionModel(ExecutionModel):

    def __init__(self):
        
        self.targetsCollection = PortfolioTargetCollection()
        

    def Execute(self, algorithm, targets):

        # for performance we check count value, OrderByMarginImpact and ClearFulfilled are expensive to call
        self.targetsCollection.AddRange(targets)
        
        if self.targetsCollection.Count > 0:
            
            for target in self.targetsCollection.OrderByMarginImpact(algorithm):
                # calculate remaining quantity to be ordered
                
                quantity = OrderSizing.GetUnorderedQuantity(algorithm, target)
                
                if quantity != 0:
                    
                    algorithm.MarketOrder(target.Symbol, quantity)


            self.targetsCollection.ClearFulfilled(algorithm)