Overall Statistics
class CalibratedUncoupledCoreWave(QCAlgorithm):

def Initialize(self):
self.SetStartDate(2019,1, 1)  # Set Start Date
#self.SetEndDate(2016, 12, 12) # Set End Date
self.SetCash(100000)  # Set Strategy Cash
# Set the resolution of your data
self.UniverseSettings.Resolution = Resolution.Minute
# Liquidate all positions before the market close each day
self.Schedule.On(self.DateRules.Every(DayOfWeek.Monday, DayOfWeek.Tuesday,DayOfWeek.Wednesday, DayOfWeek.Thursday,DayOfWeek.Friday), self.TimeRules.At(15, 30), self.ClosePositions)
# Store yesterday's close in a dictionary for reference in the SelectFine Function
self.coarseclose={}
# Store yesterday's close on fine filtered stocks to reference them in the OnData function
self.fineclose={}
# Ensure only 1 trade per day per stock
# Ensure each level of profit taking is only executed once per stock per day
self.pt1={}
self.pt2={}
self.pt3={}
self.pt4={}
# Only enter a trade if today's price is above yesterday's close * self.targetentry
self.targetentry=2.00

def SelectCoarse(self, coarse):
# Penny Stock filter
myuniverse = [x for x in coarse if x.HasFundamentalData and x.DollarVolume > 1000000 \
and x.DollarVolume < 5000000 and x.Price > 0 and x.Price <= 5.0]
stocks = {x.Symbol: x for x in myuniverse}
# Clear the dictionary each day before re-populating it
self.coarseclose.clear()
# Load the dictionary with yesterday's close for each filtered stock
for c in myuniverse:
# Return filtered stocks for further filtering by the SelecFine function
return list(stocks.keys())

def SelectFine(self,fine):
'''
This function takes the stock of the CoarceFundamental function and narrow the list adding specific fundamental filters
Largely to ensure that only common stock is traded and not EG Preference Shares or ETFs
'''
fine_filter = [x.Symbol for x in fine if x.SecurityReference.IsPrimaryShare == 1 and x.SecurityReference.SecurityType == 'ST00000001' and x.CompanyReference.IsLimitedPartnership == 0 and
x.SecurityReference.IsDepositaryReceipt == 0 ]
self.fineclose.clear()
self.pt1.clear()
self.pt2.clear()
self.pt3.clear()
self.pt4.clear()
self.pt1={k: 0 for k in fine_filter}
self.pt2={k: 0 for k in fine_filter}
self.pt3={k: 0 for k in fine_filter}
self.pt4={k: 0 for k in fine_filter}
self.fineclose = {k: self.coarseclose[k] for k in fine_filter}
self.traded = {k: 0 for k in fine_filter}
return fine_filter

def OnData(self, data):
'''OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.
Arguments:
data: Slice object keyed by symbol containing the stock data
'''

for kvp in data.Bars:
symbol = kvp.Key
close = kvp.Value.Close
dollarvolume=kvp.Value.Close*kvp.Value.Volume
if kvp.Key in self.fineclose.keys():
target =self.fineclose[kvp.Key]*self.targetentry
if self.Portfolio[symbol].Quantity == 0.0:
if close>=target:
if self.Time.hour <= 10 and self.Time.minute <=29:
if dollarvolume >= 50000:
self.SetHoldings(symbol,0.01 )
if self.Portfolio[symbol].Invested:
cost = round(self.Portfolio[symbol].AveragePrice,3)
profittarget1 = cost * 1.05
profittarget2 = cost * 1.10
profittarget3 = cost * 1.15
profittarget4 = cost * 1.20
stoploss = cost * 0.95
quantity=self.Portfolio[symbol].Quantity
if self.Time.hour <= 15 and self.Time.minute <=29:
if close>= profittarget1 and self.pt1[symbol] == 0:
self.MarketOrder(symbol, -(quantity*0.25))
self.pt1[symbol] = 1
if close>= profittarget2 and self.pt2[symbol] == 0:
self.MarketOrder(symbol, -(quantity*0.33))
self.pt2[symbol] = 1
if close>= profittarget3 and self.pt3[symbol] == 0:
self.MarketOrder(symbol, -(quantity*0.50))
self.pt3[symbol] = 1
if close>= profittarget4 and self.pt4[symbol] == 0:
self.Liquidate()
self.pt4[symbol] = 1
if self.Time.hour <= 15 and self.Time.minute <=29:
if (close <= stoploss):self.Liquidate()

def ClosePositions(self):
if self.Portfolio.Invested:
self.Liquidate()