Overall Statistics
Total Trades
4088
Average Win
0.63%
Average Loss
-0.33%
Compounding Annual Return
24.577%
Drawdown
21.100%
Expectancy
0.319
Net Profit
801.390%
Sharpe Ratio
1.291
Probabilistic Sharpe Ratio
72.018%
Loss Rate
54%
Win Rate
46%
Profit-Loss Ratio
1.87
Alpha
0.066
Beta
0.944
Annual Standard Deviation
0.167
Annual Variance
0.028
Information Ratio
0.736
Tracking Error
0.077
Treynor Ratio
0.228
Total Fees
$11626.67
# (c) Blash19

from Selection.FundamentalUniverseSelectionModel import FundamentalUniverseSelectionModel   # Help us Create.Symbols for manual universes
from config import parameters                                                               # List of parameters defining the algorithm
import universes                                                                            # Universe Selection classes
from universes import Uparam, ManualSymbolsLists, SymbolData
from operator import itemgetter

class BlashAlgorithm(QCAlgorithm):

    def Initialize(self):
        
        # Optimization Parameters
        parameters["GainSellPercent"] = float(self.GetParameter('GainSell'))
        parameters["LossSellPercent"] = float(self.GetParameter('LossSell'))
        parameters["SellCooldown"] = int(self.GetParameter('SellCooldown'))
        parameters["NumberLaggrardToSell"] = int(self.GetParameter('SellLaggards'))
        
        parameters["SmaGap"] = float(self.GetParameter('SMAGap'))
        parameters["PpoGap"] =  float(self.GetParameter('PPOGap'))
        parameters["RsiGap"] = float(self.GetParameter('RSIGap'))
        
        parameters["PpoSlowDays"] =  int(self.GetParameter('PPOSlow'))
        parameters["PpoFastDays"] =  int(self.GetParameter('PPOFast'))
        parameters["SmaDays"] = int(self.GetParameter('SMADays'))
        parameters["RsiDays"] = int(self.GetParameter('RSIDays'))
        
        parameters["start_date_year"] = int(self.GetParameter('StartYear'))
        parameters["end_date_year"] = int(self.GetParameter('EndYear'))
         
        # ------------------------------------ Initialization & setup ----------------------------------------
        
        self.SetTimeZone("America/New_York")
    
        # Back testing only
        self.SetStartDate(parameters["start_date_year"], parameters["start_date_month"], parameters["start_date_day"])  
        self.SetEndDate(parameters["end_date_year"], parameters["end_date_month"], parameters["end_date_day"])  
        
        self.AddEquity(parameters["Benchmark"],Resolution.Daily)
        self.SetBenchmark(parameters["Benchmark"]) 
        
        # In live trading actual cash will be set at the Brokerage level 
        self.SetCash(parameters["StartCash"])
        
        
        # ------------------------------------- Universe creation --------------------------------------------
    
        # self.UniverseSettings.DataNormalizationMode=DataNormalizationMode.Raw   ??? 
        self.UniverseSettings.Resolution = Resolution.Hour  # Universe list of symbols is refreshed Monthly but symbol data is updated Hourly 
        self.UniverseSettings.Leverage = 1
       
        if Uparam["SelectedUniverse"] == "":
            self.AddUniverseSelection(universes.QC500UniverseSelectionModel()) # Auto seleced Universe
        else: # Manual selected Universes
            SymbolsList = ManualSymbolsLists[Uparam["SelectedUniverse"]]
            finalSymbols = []
            for ticker in SymbolsList:
                symbol = Symbol.Create(ticker, SecurityType.Equity, Market.USA)    # ??? What if Market is not USA?
                finalSymbols.append(symbol)
            self.AddUniverseSelection(ManualUniverseSelectionModel(finalSymbols))
        
        # My "Internal" Universe.
        # Contains a list of Symbols and Indicators. ??? History? Fundamentals?
        self.TickerTable = {}
        # Actual max numbers of tickers to invest in
        self.MaxTickers = max(parameters["MaxNumberOfTickersToInvest"],1) # ???? 1 is placeholder should be len()
        # Free slots to invest in       
        self.ToInvest = self.MaxTickers
        # Track lost buys because not enough Cash in Portfolio to buy
        self.LostBuys=0
        # Track our buying ticketsize
        self.TicketSizeValue = parameters["StartCash"] / (self.MaxTickers+parameters["CashBufferNumber"])  #??? need to redibe the cash
        # track dates of last time a symbol was sold. Enables us to implement SellCooldown
        self.SoldSymbolDates = {}
    
    # ---------------------------------------- New Benchmark plot --------------------------------------------
        # Variable to hold the last calculated benchmark value
        self.lastBenchmarkValue = None
        # Our inital benchmark value scaled to match our portfolio
        self.BenchmarkPerformance = self.Portfolio.TotalPortfolioValue

        # a try to create a QQQ sentiment indicator
        self.MyQQQIndicator = 1
        self.QQQrsi = self.RSI("QQQ", 7)
    
        self.SetWarmUp(timedelta(days=30))
       
       # ----------------------------------------- Schedules ---------------------------------------------
       
        if parameters["NumberLaggrardToSell"] > 0:
            self.Schedule.On(self.DateRules.MonthStart(), self.TimeRules.At(9, 0), self.SellLaggardsFunction) # parameters["SellLaggardsFrequency"]
        self.Schedule.On(self.DateRules.EveryDay("QQQ"), self.TimeRules.At(8, 0), self.CalculateMyQQQIndicator)
        self.Schedule.On(self.DateRules.Every(parameters["SellFrequency"]), self.TimeRules.At(10, 0), self.SellFunction) # ??? Market might be closed
        self.Schedule.On(self.DateRules.Every(parameters["BuyFrequency"]), self.TimeRules.At(11, 0), self.BuyFunction)   # ??? Market might be closed
        self.Schedule.On(self.DateRules.EveryDay(), self.TimeRules.At(12,0), self.PlotStuff)
        
       # ----------------------------------------- Opening Log--------------------------------------------
        
        self.Debug(f"Blash18: {self.Time}")
        
        if self.LiveMode:
            self.Debug("Trading Live!")
        
        self.Log(f"Init:{self.Time} Cash:{self.Portfolio.Cash}")
        self.Log(f'Universe:{Uparam["SelectedUniverse"]} MaxInvested:{self.MaxTickers}')
        self.Log(f'SMAgap:{parameters["SmaGap"]} SellGain:{parameters["GainSellPercent"]} SellLoss:{parameters["LossSellPercent"]}') # ??? Add all
        self.Log("---")
    
    def CalculateMyQQQIndicator(self):
        
       
        if self.QQQrsi.Current.Value > 30:
            self.MyQQQIndicator = 1
        elif self.QQQrsi.Current.Value <= 30:
            self.MyQQQIndicator = 0
        
    # ------------------------------------------------------------------------------------------------------   
    # ---------------------------------------------- Buy loop ----------------------------------------------
    
    def BuyFunction(self):
        
        # if self.MyQQQIndicator == 1:
            
        # Calculate how many investments (Equities) we currently have 
        investedPortfolio = [x.Key.Value for x in self.Portfolio if x.Value.Invested]
        numberOfSymbolsInvested = len(investedPortfolio)
        
        # Find how many open positions to be invested before we reach our Max limit
        self.ToInvest = self.MaxTickers - numberOfSymbolsInvested 
        
        if self.ToInvest == 0:
            return
        
        # For Graph display
        self.TicketSizeValue = self.Portfolio.TotalPortfolioValue / (self.MaxTickers+parameters["CashBufferNumber"])
        
        # ---- check for Candidates
        self.SymbolCandidateList = self.CheckCandidates()
        # ---- sort candidates
        self.RankedSymbolCandidateList = self.RankCandidates(self.SymbolCandidateList)
        # ---- buy best candidates
        self.BuyCandidates(self.RankedSymbolCandidateList)
        
    # ------------------------------------------- Check Candidates ------------------------------------------
    
    def CheckCandidates(self):
        temp_candidate_list = []
        
        for security, symbolData in self.TickerTable.items():
            symbol = security.Symbol
            
            if not self.Portfolio[symbol].Invested or parameters["AllowMultipleBuysBeforeSell"]:
                
                # Check SellCooldown
                if symbol in self.SoldSymbolDates:
                    last_sale_time = self.SoldSymbolDates[symbol]
                    current_time = self.Time
                    if (current_time - last_sale_time).days < parameters["SellCooldown"]:
                        continue
                    
                # Indicators
                RSI = symbolData.rsi.Current.Value
                SMA = symbolData.sma.Current.Value
                PPO = symbolData.ppo.Current.Value
                BIG_Window = symbolData.smaLong.Current.Value
                SMALL_Window = symbolData.smaShort.Current.Value
                SLOPE = symbolData.rcShort.Slope.Current.Value
                # self.Debug(symbolData.smaShort.Current.Value)
                
                # Fundamentals
                # Bring Fundanetal data here
                
                # Strategy point: The algo for Candidate selection (based on indicators and fundamentals)
                if ( RSI <= parameters["RsiGap"]) and (PPO <= parameters["PpoGap"]) and (SMA > self.Securities[symbol].Price * parameters["SmaGap"]):
                ###if  BIG_Window > SMALL_Window and SLOPE > 0:
                    temp_candidate_list.append(security)
                
        return temp_candidate_list

    # ---------------------------------------- Rank (sort) Candidates ---------------------------------------

    def RankCandidates(self, SymbolCandidateList):
        temp_list = []
        
        for security in SymbolCandidateList:
            temp_list.append([security,
            self.TickerTable[security].rsi.Current.Value,
            self.TickerTable[security].sma.Current.Value,
            self.TickerTable[security].ppo.Current.Value])
        
        # Strategy point: The algo for Candidate sorting (based on indicators and fundamentals we collected)
        if parameters["SortCandidatesby"] == "RSI":
            RankedSymbolCandidateList = sorted(temp_list, key=itemgetter(1))[:self.ToInvest] # sort by RSI and return :ToInvest best results
        elif parameters["SortCandidatesby"] == "PPO":
            RankedSymbolCandidateList = sorted(temp_list, key=itemgetter(3))[:self.ToInvest] # sort by RSI and return :ToInvest best results
        elif parameters["SortCandidatesby"] == "PPO&RSI":
            RankedSymbolCandidateList = sorted(temp_list, key=itemgetter(3,1))[:self.ToInvest] # sort by RSI and return :ToInvest best results
        elif parameters["SortCandidatesby"] == "RSI&PPO":
            RankedSymbolCandidateList = sorted(temp_list, key=itemgetter(1,3))[:self.ToInvest] # sort by RSI and return :ToInvest best results                
        else:
            RankedSymbolCandidateList = temp_list[:self.ToInvest]
        
        return RankedSymbolCandidateList

    # ---------------------------------------- Buy winning Candidates ---------------------------------------

    def BuyCandidates(self, RankedSymbolCandidateList):        
        for record in self.RankedSymbolCandidateList:
            security = record[0]
            symbol = security.Symbol
    
            # collect for taagging Order only
            RSI = record[1]
            SMA = record[2]
            PPO = record[3]
            
            cash = self.Portfolio.MarginRemaining                                   # How much cash we have free
            portfolio_percentage = 1 / self.MaxTickers                              # What percent of the Portfolio we want to allocate
            quantity = self.CalculateOrderQuantity(symbol, portfolio_percentage)    # What is the quantity we need to buy
            close_price = self.Securities[symbol].Price                             # What is the current equity price
            
            cost_of_trade = close_price * quantity                                  # What is the cost of the expected order
            adj_cost_of_trade = cost_of_trade * (1 + parameters["CashTradeBuffer"]) # Cost or order adjusted to include a buffer
            
            if cash > adj_cost_of_trade:
                
                #self.Debug(f"margin: {cash} - cost: {adj_cost_of_trade}")
                #self.Debug(len([symbol for symbol in self.Portfolio.Keys if self.Portfolio[symbol].Invested]))
                #self.Debug([(symbol.Value, self.Portfolio[symbol].HoldingsValue) for symbol in self.Portfolio.Keys if self.Portfolio[symbol].Invested])
                
                self.SetHoldings(symbol, 1/ (self.MaxTickers+parameters["CashBufferNumber"]), False, "Buy: "+
                str(symbol)+ " SMA:"+str(round(SMA,2))+" RSI:"+str(round(RSI,2))+" PPO:"+str(round(PPO,2))+" Cash B4:"+str(round(self.Portfolio.Cash,2))+" ToInvest:"+str(self.ToInvest))
                
            else:
                self.LostBuys+=1    
        
    # ----------------------------------------- Sell loop -----------------------------------------
    def SellFunction(self):
        
        #if self.MyQQQIndicator == 1:
            
        investedPortfolio = [x.Key.Value for x in self.Portfolio if x.Value.Invested]
        numberOfSymbolsInvested = len(investedPortfolio)
        
        for security, symbolData in self.TickerTable.items():
            symbol = security.Symbol
            if self.Portfolio[symbol].Invested:
                if self.Portfolio[symbol].UnrealizedProfitPercent >= parameters["GainSellPercent"]:
                    self.Liquidate(symbol, "Profit: "+str(symbol)+":"+str(round(self.Portfolio[symbol].UnrealizedProfitPercent*100,2))+"%")
                    self.SoldSymbolDates[symbol]=self.Time
                elif self.Portfolio[symbol].UnrealizedProfitPercent <= -1 * parameters["LossSellPercent"]:
                    self.Liquidate(symbol, "Loss: "+str(symbol)+":"+str(round(self.Portfolio[symbol].UnrealizedProfitPercent*100,2))+"%")
                    self.SoldSymbolDates[symbol]=self.Time
                
        
    # ------------------------------------- Sell Laggards loop -------------------------------------
    def SellLaggardsFunction(self):
        
        #self.Debug(len([symbol for symbol in self.Portfolio.Keys if self.Portfolio[symbol].Invested]))
        #self.Debug([(symbol.Value, self.Portfolio[symbol].HoldingsValue) for symbol in self.Portfolio.Keys if self.Portfolio[symbol].Invested])
        
       
        #investedPortfolio = [[x.Key.Value,x.Value.UnrealizedProfitPercent] for x in self.Portfolio if x.Value.Invested]
        investedPortfolio = [[symbol,self.Portfolio[symbol].UnrealizedProfitPercent] for symbol in self.Portfolio.Keys if self.Portfolio[symbol].Invested]
        numberOfSymbolsInvested = len(investedPortfolio)
        
        if numberOfSymbolsInvested > 0:
            sortedInvestedPortfolio = sorted(investedPortfolio, key=itemgetter(1), reverse = False)
            
            # How many we need to clear?
            toLiquidate = min(self.MaxTickers-self.ToInvest-1, parameters["NumberLaggrardToSell"])

            if toLiquidate > 0:
                for i in range(0,toLiquidate):
                    if i<numberOfSymbolsInvested:
                        symbol= sortedInvestedPortfolio[i][0]
                        self.Liquidate(symbol, "Laggard: "+str(symbol)+" Unrealized:"+str(round(self.Portfolio[symbol].UnrealizedProfitPercent*100,2))+"%")
                        self.SoldSymbolDates[symbol]=self.Time
    
    
    # -------------------------------------- Plots and Graphs --------------------------------------
    def PlotStuff(self):
        self.Plot('Portfolio Cash', 'Cash', self.Portfolio.Cash)
        self.Plot('Lost buys', 'Lost', self.LostBuys)
        self.Plot('Margin Remaining', 'MarginRemaining', self.Portfolio.MarginRemaining)
        self.Plot('Ticket Size', 'Size', self.TicketSizeValue)
        self.Plot('To Invest','ToInvest', self.ToInvest)
        self.Plot('My QQQ Indicator','MyQQQIndicator', self.QQQrsi.Current.Value)
        bench = self.Securities[parameters["Benchmark"]].Close
        if self.lastBenchmarkValue is not  None:
           self.BenchmarkPerformance = self.BenchmarkPerformance * (bench/self.lastBenchmarkValue)
        # store today's benchmark close price for use tomorrow
        self.lastBenchmarkValue = bench
        # make our plots
        self.Plot(parameters["AlgoName"] + " vs Benchmark", "Portfolio", self.Portfolio.TotalPortfolioValue)
        self.Plot(parameters["AlgoName"] + " vs Benchmark", parameters["Benchmark"], self.BenchmarkPerformance)
        
    # ------------------------------------------  On Data  ------------------------------------------
    def OnData(self, data):
        for security, symbolData in self.TickerTable.items():
            if not data.ContainsKey(security.Symbol):
                return

        
    # -------------------------------------- On Securities Change ---------------------------------------
    def OnSecuritiesChanged(self, changes):
        self.changes = changes
        self.Log(f"OnSecuritiesChanged({self.Time}):: {changes}")
        
        for security in changes.RemovedSecurities:
            #self.Liquidate(security)
            self.TickerTable.pop(security, None)
        
        for security in changes.AddedSecurities:
            if security not in self.TickerTable: # and security.Symbol.Value != parameters["Benchmark"]:
                symbol = security.Symbol
                rsi = self.RSI(symbol, parameters["RsiDays"], Resolution.Daily)
                sma = self.SMA(symbol, parameters["SmaDays"], Resolution.Daily)
                smaLong = self.SMA(symbol, parameters["SmaLong"], Resolution.Daily)
                smaShort = self.SMA(symbol, parameters["SmaShort"], Resolution.Daily)
                rcShort = self.RC(symbol, parameters["SmaShort"], Resolution.Daily)
                ppo = self.PPO(symbol, parameters["PpoFastDays"], parameters["PpoSlowDays"], MovingAverageType.Simple, Resolution.Daily)
                
                symbolData = SymbolData(symbol, rsi, sma, smaLong, smaShort, rcShort, ppo)
                
                self.TickerTable[security] = symbolData
                
                
    # ------------------------------------------- On End --------------------------------------------
    def OnEndOfAlgorithm(self):
        self.Liquidate()
        
        self.Debug(len([symbol for symbol in self.Portfolio.Keys if self.Portfolio[symbol].Invested]))
        self.Debug([(symbol.Value, self.Portfolio[symbol].HoldingsValue) for symbol in self.Portfolio.Keys if self.Portfolio[symbol].Invested])
        
        self.Debug("Cash: "+str(self.Portfolio.Cash))
        self.Debug("Total Holdings Value: "+str(self.Portfolio.TotalHoldingsValue))
        self.Debug("Total Portfolio Value: "+str(self.Portfolio.TotalPortfolioValue))
        self.Debug("Lost buys: "+str(self.LostBuys))
# (c) Blash19
# Confidential

parameters = {}

parameters["AlgoName"] = "BLASH19"                  
parameters["StartCash"] = 100000                    # First Cash deposit for the Algorithm
parameters["MaxNumberOfTickersToInvest"] = 20       # Max Number of Equities we will invest in
parameters["CashBufferNumber"] = 1                  # We we allocate investment (% of Holdings) we will allocate to ["MaxNumberOfTickersToInvest"] + ["CashBufferNumber"] so we don't risk too low cash
parameters["CashTradeBuffer"] = 0.01                # Each trade(order) cash buffer
parameters["AllowDebt"] = False                     # ------ To Be implemented

# Back testing dates
#parameters["start_date_year"] = 2020
parameters["start_date_month"] = 1
parameters["start_date_day"] = 1
#parameters["end_date_year"] = 2020
parameters["end_date_month"] = 12
parameters["end_date_day"] = 31

parameters["BuyFrequency"] = [DayOfWeek.Monday,DayOfWeek.Tuesday,DayOfWeek.Wednesday,DayOfWeek.Thursday,DayOfWeek.Friday]
parameters["SellFrequency"] = [DayOfWeek.Monday,DayOfWeek.Tuesday,DayOfWeek.Wednesday,DayOfWeek.Thursday,DayOfWeek.Friday]

parameters["Benchmark"] = "QQQ"

parameters["AllowMultipleBuysBeforeSell"] = False   # Can you buy a ticker tou own before you sell it
parameters["SortCandidatesby"] = "PPO&RSI"  ##  this is a whitelist. only 'RSI', 'PPO', 'SMA', 'RSI&PPO', 'PPO&RSI' allowed. add here if new options

parameters["MonkeyBuyer"] = False
parameters["MonkeySeller"] = False

parameters["SmaLong"] = 30
parameters["SmaShort"] = 3
#
from Selection.FundamentalUniverseSelectionModel import FundamentalUniverseSelectionModel

Uparam = {}

Uparam["SelectedUniverse"]= "nasdaq100_A2Z" # if blank go for Automatic Universe selection
Uparam["CoarseUniverseSize"] = 3000
Uparam["FineUniverseSize"] =102
Uparam["UniverseMinMarketCap"] = 2e9
Uparam["PrimaryExchangeID"] = ["NAS"]
Uparam["UniverseSectors"] = [MorningstarSectorCode.BasicMaterials,
                            MorningstarSectorCode.ConsumerCyclical,
                            MorningstarSectorCode.FinancialServices,
                            MorningstarSectorCode.RealEstate,
                            MorningstarSectorCode.ConsumerDefensive,
                            MorningstarSectorCode.Healthcare,
                            MorningstarSectorCode.Utilities,
                            MorningstarSectorCode.CommunicationServices,
                            MorningstarSectorCode.Energy,
                            MorningstarSectorCode.Industrials,
                            MorningstarSectorCode.Technology]

ManualSymbolsLists = {"nasdaq100_A2Z":["AAPL","ADBE","ADI","ADP","ADSK","AEP","ALGN","ALXN","AMAT","AMD","AMGN","AMZN","ANSS","ASML","ATVI","AVGO","BIDU","BIIB","BKNG","CDNS","CDW","CERN","CHKP","CHTR","CMCSA","COST","CPRT","CSCO","CSX","CTAS","CTSH","DLTR","DOCU","DXCM","EA","EBAY","EXC","FAST","FB","FISV","FOX","FOXA","GILD","GOOG","GOOGL","IDXX","ILMN","INCY","INTC","INTU","ISRG","JD","KDP","KHC","KLAC","LRCX","LULU","MAR","MCHP","MDLZ","MELI","MNST","MRNA","MRVL","MSFT","MTCH","MU","MXIM","NFLX","NTES","NVDA","NXPI","OKTA","ORLY","PAYX","PCAR","PDD","PEP","PTON","PYPL","QCOM","REGN","ROST","SBUX","SGEN","SIRI","SNPS","SPLK","SWKS","TCOM","TEAM","TMUS","TSLA","TXN","VRSK","VRSN","VRTX","WBA","WDAY","XEL","XLNX","ZM"],
                        
                        "nasdaq100_S2L":["FOX","FOXA","CHKP","CDW","TCOM","INCY","VRSN","CERN","MXIM","SIRI","DLTR","SWKS","CPRT","FAST","SPLK","PAYX","VRSK","ANSS","SGEN","ORLY","CTAS","OKTA",
                        "PCAR","XEL","ALXN","XLNX","MRVL","DXCM","MTCH","CDNS","EBAY","MAR","KHC","MCHP","ROST","AEP","WBA","SNPS","BIIB","EXC","IDXX","ALGN","EA","CTSH","KDP","LULU","MNST",
                        "PTON","KLAC","NXPI","DOCU","MRNA","WDAY","REGN","ADI","TEAM","ILMN","VRTX","ADSK","CSX","ADP","FISV","ATVI","NTES","MDLZ","LRCX","GILD","BKNG","BIDU","ISRG","MU","AMAT",
                        "MELI","INTU","AMD","ZM","SBUX","CHTR","JD","AMGN","TXN","COST","TMUS","QCOM","AVGO","CSCO","PEP","PDD","CMCSA","ADBE","INTC","ASML","NFLX","PYPL","NVDA","FB","TSLA",
                        "GOOGL","GOOG","AMZN","MSFT","AAPL"],

                        "nasdaq100_L2S":["AAPL","MSFT","AMZN","GOOG","GOOGL","TSLA","FB","NVDA","PYPL","NFLX","ASML","INTC","ADBE","CMCSA","PDD","PEP","CSCO","AVGO","QCOM","TMUS","COST","TXN","AMGN","JD","CHTR","SBUX","ZM","AMD","INTU","MELI","AMAT","MU","ISRG","BIDU","BKNG","GILD","LRCX","MDLZ","NTES","ATVI","FISV","ADP","CSX","ADSK","VRTX","ILMN","TEAM","ADI","REGN","WDAY","MRNA","DOCU","NXPI","KLAC","PTON","MNST","LULU","KDP","CTSH","EA","ALGN","IDXX","EXC","BIIB","SNPS","WBA","AEP","ROST","MCHP","KHC","MAR","EBAY","CDNS","MTCH","DXCM","MRVL","XLNX","ALXN","XEL","PCAR","OKTA","CTAS","ORLY","SGEN","ANSS","VRSK","PAYX","SPLK","FAST","CPRT","SWKS","DLTR","SIRI","MXIM","CERN","VRSN","INCY","TCOM","CDW","CHKP","FOXA","FOX"],

                        "Ten20":["nflx","dpz","meli","nvda","avgo","AMZN","CSGP","AAPL","FTNT","adbe","QDEL","UNH","CRM","adsk","HD","BLDP","nke","NKE","PAR","TMUS"],
                        
                        "debug_list":["MSFT"]
                        }

 # ------------------------------------- Symbol Data -----------------------------------------

class SymbolData:
    def __init__(self, symbol, rsi, sma, smaLong, smaShort, rcShort,  ppo):
        self.Symbol = symbol
        self.rsi = rsi
        self.sma = sma
        self.smaLong = smaLong
        self.smaShort = smaShort
        self.rcShort = rcShort
        self.ppo = ppo

 
 # ------------------------------ QC500UniverseSelectionModel ---------------------------------

class QC500UniverseSelectionModel(FundamentalUniverseSelectionModel):
    '''Defines the QC500 universe as a universe selection model for framework algorithm
    For details: https://github.com/QuantConnect/Lean/pull/1663'''

    def __init__(self, filterFineData = True, universeSettings = None, securityInitializer = None):
        '''Initializes a new default instance of the QC500UniverseSelectionModel'''
        super().__init__(filterFineData, universeSettings, securityInitializer)
        self.numberOfSymbolsCoarse = Uparam["CoarseUniverseSize"]
        self.numberOfSymbolsFine = Uparam["FineUniverseSize"]
        self.sorted1BySymbol = {} 
        self.lastMonth = -1

    def SelectCoarse(self, algorithm, coarse):
        '''coarse selection
        Must have fundamental data
        Must have positive previous-day close price
        Must have positive volume on the previous trading day
        Sort by tarde Dollar Volume (previous day)
        '''
        
        if algorithm.Time.month == self.lastMonth:
            return Universe.Unchanged
        self.lastMonth = algorithm.Time.month
            
        sorted1 = 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.sorted1BySymbol = {x.Symbol:x.DollarVolume for x in sorted1}
        
        # If no security has met the QC500 criteria, the universe is unchanged.
        # A new selection will be attempted on the next trading day as self.lastMonth is not updated
        count = len(self.sorted1BySymbol)
        #algorithm.Debug("U coarse:"+str(count))
        if count == 0:
            return Universe.Unchanged

        # return the symbol objects our sorted collection
        return list(self.sorted1BySymbol.keys())

    def SelectFine(self, algorithm, fine):
        
        # fine is a list of FineFundamental objects
        # expects is to return a list of Symbol objects
        
        # Strategy point: Sorts our list
        sortedBySector = sorted([x for x in fine if x.CompanyReference.PrimaryExchangeID in Uparam["PrimaryExchangeID"]
                                        #and x.CompanyReference.CountryId == "USA"
                                        #and (algorithm.Time - x.SecurityReference.IPODate).days > 30
                                        #and x.ValuationRatios.ForwardPERatio > 0
                                        and x.AssetClassification.MorningstarSectorCode in Uparam["UniverseSectors"]
                                        and x.MarketCap <= Uparam["UniverseMinMarketCap"]
                                        and x.MarketCap >= 1e9],
                               key = lambda x: x.MarketCap, reverse = True)
                               

        count = len(sortedBySector)
        algorithm.Debug("U fine:"+str(count))
        if count == 0:
            return Universe.Unchanged
        
        # converts our list of fine to a list of Symbols 
        sortedBySectorSymbols = [f.Symbol for f in sortedBySector]
        
        # logging fine Universe ???
        #algorithm.Debug(str(algorithm.Time)+" " +str(len(sortedBySectorSymbols)))
        #counter = self.numberOfSymbolsFine
        #for security in sortedBySectorSymbols:
        #    algorithm.Debug(security)
        #    counter +=1
        #    if counter == self.numberOfSymbolsFine:
        #        break
       
        return sortedBySectorSymbols[:self.numberOfSymbolsFine]