| Overall Statistics |
|
Total Orders 1540 Average Win 2.10% Average Loss -1.36% Compounding Annual Return 49.425% Drawdown 30.200% Expectancy 0.566 Start Equity 10000 End Equity 2415294.53 Net Profit 24052.945% Sharpe Ratio 1.495 Sortino Ratio 1.626 Probabilistic Sharpe Ratio 94.276% Loss Rate 38% Win Rate 62% Profit-Loss Ratio 1.54 Alpha 0.242 Beta 1.091 Annual Standard Deviation 0.225 Annual Variance 0.051 Information Ratio 1.527 Tracking Error 0.163 Treynor Ratio 0.308 Total Fees $24019.22 Estimated Strategy Capacity $2000000.00 Lowest Capacity Asset UVXY V0H08FY38ZFP Portfolio Turnover 12.98% |
"""
**
* TQQQ_OG_ganesh v2 https://app.composer.trade/symphony/aPKwOIvIgAVB8q0NUSj3/details
*
*
* Description: This Strategy rebalances ETF's based on various Indicators
**
"""
from AlgorithmImports import *
from custom_sma import Intraday_Updating_SMA
from custom_cumulative_return import Intraday_Updating_Cumulative_Return
from custom_rsi import Intraday_Updating_RSI
from custom_drawdown import CustomDrawdown
from custom_return_ma import CustomReturnMA
from custom_return_stdev import CustomReturnStdev
from custom_ema import CustomEMA
from symboldata import SymbolData
from create_lists import *
import config
# from hedged_lev_bonds_stocks import *
# from hedgefundie_refined import *
class ETF_Rebalancing(QCAlgorithm):
def Initialize(self):
self.SetStartDate(config.BACKTEST_START_YEAR, config.BACKTEST_START_MONTH, config.BACKTEST_START_DAY)
self.SetEndDate(config.BACKTEST_END_YEAR, config.BACKTEST_END_MONTH, config.BACKTEST_END_DAY)
self.SetCash(config.BACKTEST_ACCOUNT_CASH)
self.Rebalance_Threshold = config.REBALANCE_THRESHOLD / 100
self.UniverseSettings.Leverage = 4
# Initialize ETFs as None
etf_symbols = [
"TECL", "SOXL", "FAS", "TQQQ", "UPRO", "TMF", "USDO", "SQQQ", "TBF", "BIL", "PHDG", "TMV", "UDOW", "MOAT",
"BRKB", "USMV", "SPY", "QQQ", "SPXL", "SGOV", "DBA", "ICSH", "TYD", "URTY", "XLU", "NUGT", "TYO", "VIXM",
"IEF", "SOXS", "BND", "VTI", "SHY", "USDU", "TLT", "PSQ", "VIXY", "BSV", "SPHB", "USD", "SPXU", "XLF",
"MVV", "UCO", "UUP", "QLD", "GLD", "YCS", "TECS", "SPXS", "IJS", "EPI", "TNA", "XLP", "AGG", "KRE", "IJS",
"UVXY", "EFA", "EEM", "SH", "SDS", "HBIL"
]
for symbol in etf_symbols:
setattr(self, symbol, None)
#self.hedged_lev_bnd_outer_alloation = config.hedged_lev_bnd_outer_alloation
self.lev_sec_mkt_fwork_outer_allocation = config.lev_sec_mkt_fwork_outer_allocation
#self.Minimal_BB_outer_allocation = config.Minimal_BB_outer_allocation
self.Sub_4_List = []
self.Symbol_List = []
self.ETFs = config.ETFS
self.Trade_Decision_Time = config.TRADE_DECISION_TIME
self.Trade_Decision_Time_1 = config.TRADE_DECISION_TIME_1
self.Order_Delay = config.ORDER_DELAY # Enable this for Delayed orders
self.Update_Intraday = False
self.Trade_Decision = False
for etf in self.ETFs:
try:
self.Symbol_List.append(self.AddEquity(etf, Resolution.Minute, dataNormalizationMode=DataNormalizationMode.Adjusted).Symbol)
except:
self.Debug(f"Unable to add stock {etf} to the algorithm")
self.Symbol_Dictionary = {}
for symbol in self.Symbol_List:
self.Symbol_Dictionary[symbol] = SymbolData(self, symbol)
self.Schedule.On(self.DateRules.EveryDay(), self.TimeRules.BeforeMarketClose("SPY", self.Trade_Decision_Time), self.Set_Update_Intraday)
self.Schedule.On(self.DateRules.EveryDay(), self.TimeRules.BeforeMarketClose("SPY", self.Trade_Decision_Time - self.Order_Delay), self.Delayed_Orders)
# self.Schedule.On(self.DateRules.EveryDay(), self.TimeRules.BeforeMarketClose("SPY", self.Trade_Decision_Time_1), self.Set_Update_Intraday)
# self.Schedule.On(self.DateRules.EveryDay(), self.TimeRules.BeforeMarketClose("SPY", self.Trade_Decision_Time_1 - self.Order_Delay), self.Delayed_Orders)
# self.Schedule.On(self.DateRules.EveryDay("SPY"), self.TimeRules.BeforeMarketClose("SPY", self.Trade_Decision_Time_1), self.ClosePositions)
# def ClosePositions(self):
# if self.Portfolio.Invested: # it does not hurt to check that but in fact, if you are not invested, Liquidate() will simply do nothing
# self.Liquidate()
# self.Schedule.On(self.DateRules.EveryDay(), self.TimeRules.BeforeMarketClose("SPY", self.Trade_Decision_Time_1), self.Set_Update_Intraday)
# self.Schedule.On(self.DateRules.EveryDay(), self.TimeRules.BeforeMarketClose("SPY", self.Trade_Decision_Time_1 - self.Order_Delay), self.Delayed_Orders)
def Set_Update_Intraday(self):
self.Update_Intraday = True
self.Trade_Decision = True
def Orders(self):
for symbol in self.Symbol_Dictionary.keys():
Symbol_Object = self.Symbol_Dictionary[symbol]
if Symbol_Object.Current_Position < (Symbol_Object.Counter - self.Rebalance_Threshold) or Symbol_Object.Current_Position > (Symbol_Object.Counter + self.Rebalance_Threshold):
if Symbol_Object.Counter <= 0:
self.Liquidate(symbol)
if not config.USE_ORDER_DELAY:
for symbol in self.Symbol_Dictionary.keys():
Symbol_Object = self.Symbol_Dictionary[symbol]
if Symbol_Object.Current_Position < (Symbol_Object.Counter - self.Rebalance_Threshold) or Symbol_Object.Current_Position > (Symbol_Object.Counter + self.Rebalance_Threshold):
if Symbol_Object.Counter >= 0:
self.SetHoldings(symbol, Symbol_Object.Counter, tag=f"{Symbol_Object.Function}") # Disable this for Delayed orders
elif not self.Portfolio[symbol].Invested and Symbol_Object.Current_Position == 0 and Symbol_Object.Counter > 0:
self.SetHoldings(symbol, Symbol_Object.Counter, tag=f"{Symbol_Object.Function}")
# Enable this for Delayed orders
def Delayed_Orders(self):
if config.USE_ORDER_DELAY:
for symbol in self.Symbol_Dictionary.keys():
Symbol_Object = self.Symbol_Dictionary[symbol]
if Symbol_Object.Current_Position < (Symbol_Object.Counter - self.Rebalance_Threshold) or Symbol_Object.Current_Position > (Symbol_Object.Counter + self.Rebalance_Threshold):
if Symbol_Object.Counter >= 0:
self.SetHoldings(symbol, Symbol_Object.Counter, tag=f"{Symbol_Object.Function}")
elif not self.Portfolio[symbol].Invested and Symbol_Object.Current_Position == 0 and Symbol_Object.Counter > 0:
self.SetHoldings(symbol, Symbol_Object.Counter, tag=f"{Symbol_Object.Function}")
# def Main_Strategy(self):
# #self.SPY_FOR_LONG_TERM(0.33)
# self.OG_v1_2_Risk_On_Off_Hedgefund(0.16)
# self.Hedged_Leveraged_Bonds_Stocks_V2(0.145)
# self.BlackSwan_MeanRev_BondSignal(0.145)
# self.Leveraged_Secular_Market_Framework(0.5)
# self.Minimal_BB(0.05)
def Main_Strategy(self):
#self.Cautious_Fund_Surfing(0.34)
#self.OG_v1_2_Risk_On_Off_Hedgefund(1)
#self.BlackSwan_MeanRev_BondSignal(1)
# self.Hedged_Leveraged_Bonds_Stocks_V2(0.10)
# self.Minimal_BB(0.10)
# self.TQQQ_FTLT_V2(0.10)
# self.Fund_Surfing(1)
self.Leveraged_Secular_Market_Framework(1)
# self.mega_mix_bull()
# self.BuyDips_Strategy(1)
# self.BEAT_THE_MARKET_QLD(0.20)
def mega_mix_bb(self):
self.Hedged_Leveraged_Bonds_Stocks_V2(0.10)
self.OG_v1_2_Risk_On_Off_Hedgefund(0.125)
self.BlackSwan_MeanRev_BondSignal(0.125)
self.Minimal_BB(0.125)
self.Fund_Surfing(0.125)
def mega_mix_bb_0_40(self):
self.Hedged_Leveraged_Bonds_Stocks_V2(0.06)
self.OG_v1_2_Risk_On_Off_Hedgefund(0.09)
self.BlackSwan_MeanRev_BondSignal(0.09)
self.Minimal_BB(0.08)
self.Fund_Surfing(0.08)
#self.TEST_DRAWDOWN(1)
#self.Cautious_Fund_Surfing(1)
#############################################
#self.OG_v1_2_Risk_On_Off_Hedgefund(0.16 * 2)
#self.Hedged_Leveraged_Bonds_Stocks_V2(0.145 * 2)
#self.BlackSwan_MeanRev_BondSignal(0.145 * 2)
#self.Minimal_BB(1)
def mega_mix_bull(self):
self.OG_v1_2_Risk_On_Off_Hedgefund(0.17)
self.Hedged_Leveraged_Bonds_Stocks_V2(0.165)
self.BlackSwan_MeanRev_BondSignal(0.165)
######################################################################################
def Cautious_Fund_Surfing(self, outer_allocation):
timeframes = [14, 21, 28, 35, 42]
stdev_thresholds = [0.01, 0.015, 0.02]
pairs = [(self.SPY, self.TQQQ, self.SGOV, self.SHY)] # Added self.SHY
for pair in pairs:
index_etf, leveraged_etf, bond_etf, rsi_etf = pair
allocation = outer_allocation / (len(pairs) * len(timeframes) * len(stdev_thresholds)) - (
config.CASH_BUFFER * outer_allocation / (len(pairs) * len(timeframes) * len(stdev_thresholds)))
for stdev_threshold in stdev_thresholds:
for timeframe in timeframes:
if getattr(index_etf, f"Return_STDEV_{timeframe}").Current_Value < stdev_threshold:
rsi_list = [(leveraged_etf, getattr(leveraged_etf, f"Rsi_{timeframe}").Current_Value),
(rsi_etf, getattr(rsi_etf, f"Rsi_{timeframe}").Current_Value)] # Replaced bond_etf with rsi_etf
sorted_rsi_list = sorted(rsi_list, key=lambda x: x[1], reverse=False)
symbol, symbol_return = sorted_rsi_list[0]
if symbol == rsi_etf: # If SHY has the lowest RSI, invest in SGOV
bond_etf.Counter += allocation
bond_etf.Function = f'Cautious_Fund_Surfing: invested in {bond_etf} because {symbol} had the lowest RSI'
else: # Otherwise invest in the ETF with the lowest RSI
symbol.Counter += allocation
symbol.Function = (f'Cautious_Fund_Surfing {index_etf}.Return_STDEV_{timeframe}.Current_Value < {stdev_threshold} '
f'{index_etf}_STDEV_{timeframe} = {round(getattr(index_etf, f"Return_STDEV_{timeframe}").Current_Value, 4)}')
else:
bond_etf.Counter += allocation # The investment still goes to bond_etf i.e. SGOV
bond_etf.Function = (f'Cautious_Fund_Surfing {index_etf}.Return_STDEV_{timeframe}.Current_Value >= {stdev_threshold} '
f'{index_etf}_STDEV_{timeframe} = {round(getattr(index_etf, f"Return_STDEV_{timeframe}").Current_Value, 4)}')
# #Call BuyDips_Strategy instead of investing in SHY
#self.BuyDips_Strategy(allocation)
# self.BEAT_THE_MARKET_QLD(allocation)
def BuyDips_Strategy(self, outer_allocation ):
if self.SPY.Drawdown_252.Current_Value > 0.10:
if self.QQQ.Return_5.Current_Value < -0.05:
if self.TQQQ.Return_1.Current_Value > 0.05:
if self.SPY.Return_5.Current_Value < -0.05:
if self.UPRO.Return_1.Current_Value > 0.05:
self.BIL.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
else:
self.UPRO.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
else:
self.BIL.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
else:
self.TQQQ.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
else:
if self.SPY.Return_5.Current_Value < -0.05:
if self.UPRO.Return_1.Current_Value > 0.05:
self.BIL.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
else:
self.UPRO.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
else:
self.BIL.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
else:
#HFEA-REFINED
if self.SPY.Drawdown_10.Current_Value < 0.05:
#RISK ON
self.UPRO.Counter += (outer_allocation * 0.275) - (config.CASH_BUFFER * (outer_allocation * 0.275 ))
self.TQQQ.Counter += (outer_allocation * 0.275) - (config.CASH_BUFFER * (outer_allocation * 0.275 ))
self.TMF.Counter += (outer_allocation * 0.45) - (config.CASH_BUFFER * (outer_allocation * 0.45 ))
else:
#RISK OFF
self.BIL.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
######################################################################################
def BEAT_THE_MARKET_QLD(self, outer_allocation):
if self.SPY.SMA_21.Current_Value > self.SPY.SMA_210.Current_Value:
self.QQQ.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
else:
if self.QQQ.Rsi_10.Current_Value < 30:
self.QLD.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
elif self.Securities["SPY"].Price > self.SPY.SMA_31.Current_Value:
self.QQQ.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
else:
self.SHY.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
######################################################################################
def TQQQ_FTLT_V2(self, allocation):
if self.Securities["SPY"].Price > self.SPY.SMA_200.Current_Value:
if self.TQQQ.Rsi_10.Current_Value > 79:
self.UVXY.Counter += allocation - (config.CASH_BUFFER * allocation)
else:
if self.SPXL.Rsi_10.Current_Value > 80:
self.UVXY.Counter += allocation - (config.CASH_BUFFER * allocation)
else:
self.TQQQ.Counter += allocation - (config.CASH_BUFFER * allocation)
else:
if self.TQQQ.Rsi_10.Current_Value < 31:
self.TECL.Counter += allocation - (config.CASH_BUFFER * allocation)
else:
if self.SPY.Rsi_10.Current_Value < 30:
self.UPRO.Counter += allocation - (config.CASH_BUFFER * allocation)
else:
if self.UVXY.Rsi_10.Current_Value > 74:
if self.UVXY.Rsi_10.Current_Value > 84:
if self.Securities["TQQQ"].Price > self.TQQQ.SMA_20.Current_Value:
self.TQQQ.Counter += allocation - (config.CASH_BUFFER * allocation)
else:
if self.SQQQ.Rsi_10.Current_Value > self.BSV.Rsi_10.Current_Value:
self.SQQQ.Counter += allocation - (config.CASH_BUFFER * allocation)
else:
self.BSV.Counter += allocation - (config.CASH_BUFFER * allocation)
self.UVXY.Counter += allocation - (config.CASH_BUFFER * allocation)
else:
if self.Securities["TQQQ"].Price > self.TQQQ.SMA_20.Current_Value:
self.TQQQ.Counter += allocation - (config.CASH_BUFFER * allocation)
else:
if self.SQQQ.Rsi_10.Current_Value > self.BSV.Rsi_10.Current_Value:
self.SQQQ.Counter += allocation - (config.CASH_BUFFER * allocation)
else:
self.BSV.Counter += allocation - (config.CASH_BUFFER * allocation)
######################################################################################
def Buy_The_Dip_SPXL_TQQQ_UVXY(self, allocation):
if self.SPY.Rsi_10.Current_Value < 30:
self.SPXL.Counter += allocation - (config.CASH_BUFFER * allocation)
self.SPXL.Function = "Buy_The_Dip SPY.Rsi_10 < 30"
else:
if self.QQQ.Rsi_10.Current_Value < 31:
self.TECL.Counter += allocation - (config.CASH_BUFFER * allocation)
self.TECL.Function = "Buy_The_Dip QQQ.Rsi_10 < 31"
else:
if self.QQQ.Rsi_10.Current_Value > 79:
self.UVXY.Counter += allocation - (config.CASH_BUFFER * allocation)
self.UVXY.Function = "Buy_The_Dip QQQ.Rsi_10 > 79"
else:
if self.SPXL.Rsi_10.Current_Value > 80:
self.UVXY.Counter += allocation - (config.CASH_BUFFER * allocation)
self.UVXY.Function = "Buy_The_Dip SPXL.Rsi_10 > 80"
else:
allocation_minus_buffer = allocation - (config.CASH_BUFFER * allocation)
self.SHY.Counter += allocation_minus_buffer / 3
self.XLP.Counter += allocation_minus_buffer / 3
self.SPY.Counter += allocation_minus_buffer / 3
self.SHY.Function = "Buy_The_Dip Remaining Allocation"
self.XLP.Function = "Buy_The_Dip Remaining Allocation"
self.SPY.Function = "Buy_The_Dip Remaining Allocation"
######################################################################################
def Fund_Surfing(self,outer_allocation):
if self.SPY.Return_STDEV_21.Current_Value < 0.01:
rsi_list = [(self.UPRO, self.UPRO.Rsi_21.Current_Value),
(self.TQQQ, self.TQQQ.Rsi_21.Current_Value),
(self.SHY, self.SHY.Rsi_21.Current_Value),
]
sorted_rsi_list = sorted(rsi_list, key=lambda x: x[1], reverse=False)
counter_ = 0
for symbol, symbol_return in sorted_rsi_list:
if counter_ >= 1:
break
symbol.Counter += outer_allocation/2 - (config.CASH_BUFFER * (outer_allocation/2))
symbol.Function = (f'Fund_Surfing SPY.Return_STDEV_21.Current_Value > 0.01 SPY_STDEV_21 = {round(self.SPY.Return_STDEV_21.Current_Value,4)}')
counter_ += 1
else:
self.SHY.Counter += outer_allocation/2 - (config.CASH_BUFFER * outer_allocation/2)
self.SHY.Function = (f'Fund_Surfing SPY.Return_STDEV_21.Current_Value < 0.01 SPY_STDEV_21 = {round(self.SPY.Return_STDEV_21.Current_Value,4)}')
if self.SPY.Return_STDEV_21.Current_Value < 0.02:
rsi_list = [(self.UPRO, self.UPRO.Rsi_21.Current_Value),
(self.TQQQ, self.TQQQ.Rsi_21.Current_Value),
(self.SHY, self.SHY.Rsi_21.Current_Value),
]
sorted_rsi_list = sorted(rsi_list, key=lambda x: x[1], reverse=False)
counter_ = 0
for symbol, symbol_return in sorted_rsi_list:
if counter_ >= 1:
break
symbol.Counter += outer_allocation/2 - (config.CASH_BUFFER * (outer_allocation/2))
symbol.Function = (f'Fund_Surfing SPY.Return_STDEV_21.Current_Value > 0.02 SPY_STDEV_21 = {round(self.SPY.Return_STDEV_21.Current_Value,4)}')
counter_ += 1
else:
self.SHY.Counter += outer_allocation/2 - (config.CASH_BUFFER * outer_allocation/2)
self.SHY.Function = (f'Fund_Surfing SPY.Return_STDEV_21.Current_Value < 0.02 SPY_STDEV_21 = {round(self.SPY.Return_STDEV_21.Current_Value,4)}')
# ######################################################################################
# def TEST_DRAWDOWN(self,outer_allocation):
# if self.QQQ.Drawdown_10.Current_Value > 0.06:
# self.BIL.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation * 0 )
# self.BIL.Function = (f'TEST_DRAWDOWN QQQ.Drawdown_10.Current_Value > 0.06 QQQ = {round(self.QQQ.Drawdown_10.Current_Value,4)}')
# else:
# self.QQQ.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
# self.QQQ.Function = (f'TEST_DRAWDOWN QQQ.Drawdown_10.Current_Value < 0.06 QQQ = {round(self.QQQ.Drawdown_10.Current_Value,4)}')
######################################################################################
def Leveraged_Secular_Market_Framework(self, allocation):
def update_counters(func_desc, symbols, allocs):
for symbol, alloc in zip(symbols, allocs):
symbol.Counter += alloc - (config.CASH_BUFFER * alloc)
symbol.Function = func_desc
def sort_return_list(return_list):
return sorted(return_list, key=lambda x: x[1], reverse=True)
golden_cross = self.SPY.SMA_50.Current_Value > self.SPY.SMA_200.Current_Value
SPY_above_200 = self.Securities["SPY"].Price > self.SPY.SMA_200.Current_Value
TLT_above_150 = self.Securities["TLT"].Price > self.TLT.SMA_150.Current_Value
TLT_below_23 = self.Securities["TLT"].Price < self.TLT.SMA_23.Current_Value
QQQ_Rsi_below_30 = self.QQQ.Rsi_10.Current_Value < 30
SPY_Rsi_above_60 = self.SPY.Rsi_60.Current_Value > 60
SPY_SMA_200_above_1000 = self.SPY.SMA_200.Current_Value > self.SPY.SMA_1000.Current_Value
if golden_cross and SPY_above_200:
if SPY_SMA_200_above_1000:
if SPY_Rsi_above_60:
update_counters("SPY Overbrought", [self.SPY, self.TMF], [allocation * 0.55, allocation * 0.45])
else:
quarter_alloc = allocation / 4
if TLT_above_150:
update_counters("TLT.Price > TLT.SMA_150", [self.UPRO, self.TQQQ, self.SOXL, self.TMF],
[quarter_alloc] * 4)
elif TLT_below_23:
update_counters("TLT.Price < TLT.SMA_23", [self.UPRO, self.TQQQ, self.SOXL], [quarter_alloc] * 3)
return_list = [(self.TMV, self.TMV.Return_5.Current_Value),
(self.UDOW, self.UDOW.Return_5.Current_Value),
(self.BIL, self.BIL.Return_5.Current_Value)]
sorted_return_list = sort_return_list(return_list)
first_symbol, _ = sorted_return_list[0]
update_counters("TLT.Price < TLT.SMA_23", [first_symbol], [quarter_alloc])
else:
update_counters("TLT.Price > TLT.SMA_23", [self.UPRO, self.TQQQ, self.SOXL, self.TMF],
[quarter_alloc] * 4)
else:
self.mega_mix_bull()
elif QQQ_Rsi_below_30:
self.TECL.Counter += allocation - (config.CASH_BUFFER * allocation)
else:
self.mega_mix_bull()
if not SPY_SMA_200_above_1000:
if QQQ_Rsi_below_30:
self.TECL.Counter += allocation - (config.CASH_BUFFER * allocation)
else:
if golden_cross and SPY_above_200:
quarter_alloc = allocation / 4
if TLT_above_150:
update_counters("TLT.Price > TLT.SMA_150", [self.UPRO, self.TQQQ, self.SOXL, self.TMF],
[quarter_alloc] * 4)
elif TLT_below_23:
update_counters
######################################################################################################
def Minimal_BB(self,Minimal_BB_outer_allocation):
if self.BIL.Rsi_5.Current_Value < self.IEF.Rsi_7.Current_Value:
if self.SPY.Rsi_6.Current_Value > 75:
#Overbought S&P. Sell the rip. Buy volatility.
if self.UVXY.Rsi_13.Current_Value < self.VIXY.Rsi_13.Current_Value:
self.UVXY.Counter += Minimal_BB_outer_allocation - (config.CASH_BUFFER * Minimal_BB_outer_allocation)
self.UVXY.Function = "Minimal_BB SPY.Rsi_6 > 75 & UVXY.Rsi_13 < VIXY.Rsi_13"
else:
self.VIXY.Counter += Minimal_BB_outer_allocation - (config.CASH_BUFFER * Minimal_BB_outer_allocation)
self.VIXY.Function = "Minimal_BB SPY.Rsi_6 > 75 & UVXY.Rsi_13 > VIXY.Rsi_13"
else:
self.SOXL.Counter += Minimal_BB_outer_allocation - (config.CASH_BUFFER * Minimal_BB_outer_allocation)
self.SOXL.Function = "Minimal_BB SPY.Rsi_6 < 75"
else:
#Extremely oversold S&P (low RSI). Double check with bond mkt before going long
if self.SHY.Rsi_10.Current_Value < self.TQQQ.Rsi_10.Current_Value:
if self.SOXS.Rsi_7.Current_Value < self.SQQQ.Rsi_7.Current_Value:
self.SOXS.Counter += Minimal_BB_outer_allocation - (config.CASH_BUFFER * Minimal_BB_outer_allocation)
self.SOXS.Function = "Minimal_BB SHY.Rsi_10 < TQQQ.Rsi_10 & SOXS.Rsi_7 < self.SQQQ.Rsi_7"
else:
self.SQQQ.Counter += Minimal_BB_outer_allocation - (config.CASH_BUFFER * Minimal_BB_outer_allocation)
self.SQQQ.Function = "Minimal_BB SHY.Rsi_10 < TQQQ.Rsi_10 & SOXS.Rsi_7 > self.SQQQ.Rsi_7"
else:
if self.SOXL.Rsi_7.Current_Value < self.TECL.Rsi_7.Current_Value:
self.SOXL.Counter += Minimal_BB_outer_allocation - (config.CASH_BUFFER * Minimal_BB_outer_allocation)
self.SOXL.Function = "Minimal_BB SHY.Rsi_10 > TQQQ.Rsi_10 & SOXL.Rsi_7 < self.TECL.Rsi_7"
else:
self.TECL.Counter += Minimal_BB_outer_allocation - (config.CASH_BUFFER * Minimal_BB_outer_allocation)
self.TECL.Function = "Minimal_BB SHY.Rsi_10 > TQQQ.Rsi_10 & SOXL.Rsi_7 > self.TECL.Rsi_7"
######################################################################################################
def BlackSwan_MeanRev_BondSignal(self,outer_allocation):
if self.TQQQ.Rsi_10.Current_Value > 79:
self.UVXY.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
self.UVXY.Function = "BMB TQQQ.Rsi_10.Current_Value > 79"
else:
#BlackSwan_Huge_Volatility
if self.TQQQ.Return_6.Current_Value < -0.12:
if self.TQQQ.Return_1.Current_Value > 0.05:
self.UVXY.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
self.UVXY.Function = "BMB TQQQ.Return_1.Current_Value > 0.05"
else:
#BlackSwan_MEAN_REVISION
if self.TQQQ.Rsi_10.Current_Value < 32:
self.TQQQ.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
self.TQQQ.Function = "BMB TQQQ.Rsi_10.Current_Value < 32"
else:
if self.TMF.Drawdown_10.Current_Value < 0.07:
self.TQQQ.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
self.TQQQ.Function = (f'BMB TMF.Drawdown_10.Current_Value < 0.07, TMF_10 = {round(self.TMF.Drawdown_10.Current_Value,4) * 100} , TMF_5 = {round(self.TMF.Drawdown_5.Current_Value,4) * 100 } , TMF_8 = {round(self.TMF.Drawdown_8.Current_Value,4) * 100}')
else:
self.SGOV.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
self.SGOV.Function = (f'BMB TMF.Drawdown_10.Current_Value > 0.07, TMF_10 = {round(self.TMF.Drawdown_10.Current_Value,4) * 100} , TMF_5 = {round(self.TMF.Drawdown_5.Current_Value,4) * 100 } , TMF_8 = {round(self.TMF.Drawdown_8.Current_Value,4) * 100}')
else:
#BlackSwan_NORMAL_MARKET
if self.QQQ.Drawdown_10.Current_Value > 0.06:
self.SGOV.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
self.SGOV.Function = (f'BMB QQQ.Drawdown_10.Current_Value > 0.06, QQQ_10 = {round(self.QQQ.Drawdown_10.Current_Value,4) * 100} , QQQ_5 = {round(self.QQQ.Drawdown_5.Current_Value,4) * 100} , QQQ_8 = {round(self.QQQ.Drawdown_8.Current_Value,4) * 100}')
else:
if self.TMF.Drawdown_10.Current_Value > 0.07:
self.SGOV.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
self.SGOV.Function = (f'BMB QQQ.Drawdown_10.Current_Value < 0.06 && TMF.Drawdown_10.Current_Value > 0.07, QQQ_10 = {round(self.QQQ.Drawdown_10.Current_Value,4) * 100} , QQQ_5 = {round(self.QQQ.Drawdown_5.Current_Value,4) * 100}, QQQ_8 = {round(self.QQQ.Drawdown_8.Current_Value,4) * 100} , TMF_10 = {round(self.TMF.Drawdown_10.Current_Value,4) * 100} , TMF_5 = {round(self.TMF.Drawdown_5.Current_Value,4) * 100 } , TMF_8 = {round(self.TMF.Drawdown_8.Current_Value,4) * 100}')
else:
if self.Securities["QQQ"].Price > self.QQQ.SMA_25.Current_Value:
self.TQQQ.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
self.TQQQ.Function = (f'BMB QQQ.Price > self.QQQ.SMA_25.Current_Value , QQQ_Price = {round(self.Securities["QQQ"].Price)}, QQQ_SMA25 = {round(self.QQQ.SMA_25.Current_Value)} , QQQ_10 = {round(self.QQQ.Drawdown_10.Current_Value,4) * 100} , QQQ_5 = {round(self.QQQ.Drawdown_5.Current_Value,4) * 100} , QQQ_8 = {round(self.QQQ.Drawdown_8.Current_Value,4) * 100}')
else:
if self.SPY.Rsi_60.Current_Value > 50:
#BlackSwan BOND > STOCK
if self.BND.Rsi_45.Current_Value > self.SPY.Rsi_45.Current_Value:
self.TQQQ.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
self.TQQQ.Function = "BMB BND.Rsi_45.Current_Value > self.SPY.Rsi_45.Current_Value"
else:
self.SGOV.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
self.SGOV.Function = "BMB BND.Rsi_45.Current_Value < self.SPY.Rsi_45.Current_Value"
else:
#BlackSwan BOND MID_TERM < LONG_TERM
if self.IEF.Rsi_200.Current_Value < self.TLT.Rsi_200.Current_Value:
if self.BND.Rsi_45.Current_Value > self.SPY.Rsi_45.Current_Value:
self.TQQQ.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
self.TQQQ.Function = "BMB BND.Rsi_45.Current_Value > self.SPY.Rsi_45.Current_Value"
else:
self.SGOV.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
self.SGOV.Function = "BMB BND.Rsi_45.Current_Value < self.SPY.Rsi_45.Current_Value"
else:
self.SGOV.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
self.SGOV.Function = "BMB IEF.Rsi_200.Current_Value > self.TLT.Rsi_200.Current_Value"
###################################################################################################################
def OG_v1_2_Risk_On_Off_Hedgefund(self, outer_allocation):
if self.VIXM.Rsi_40.Current_Value > 69:
self.Risk_Off_Market_Crash(outer_allocation)
else:
if self.BND.Return_60.Current_Value > self.BIL.Return_60.Current_Value:
self.Risk_On_Normal_Market_Conditions(outer_allocation)
else:
if self.TLT.Return_20.Current_Value < self.BIL.Return_20.Current_Value:
self.Risk_Off_Rising_Rates(outer_allocation)
else:
self.Risk_On_Falling_Rates_HFEA(outer_allocation)
def Risk_Off_Market_Crash(self, outer_allocation):
self.SHY.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
def Risk_On_Normal_Market_Conditions(self, outer_allocation):
self.Sub_Strategy_1(outer_allocation)
#self.TMF.Counter += (outer_allocation * 0.45) - (config.CASH_BUFFER * (outer_allocation * 0.45))
def Sub_Strategy_1(self, outer_allocation):
rsi_list = [(self.TECL, self.TECL.Rsi_10.Current_Value),
(self.SOXL, self.SOXL.Rsi_10.Current_Value),
(self.TQQQ, self.TQQQ.Rsi_10.Current_Value),
(self.UPRO, self.UPRO.Rsi_10.Current_Value),
(self.TMF, self.TMF.Rsi_10.Current_Value),
(self.FAS, self.FAS.Rsi_10.Current_Value),
(self.TNA, self.TNA.Rsi_10.Current_Value),
]
sorted_rsi_list = sorted(rsi_list, key=lambda x: x[1], reverse=False)
counter_ = 0
for symbol, symbol_return in sorted_rsi_list:
if counter_ >= 3:
break
symbol.Counter += outer_allocation/3 - (config.CASH_BUFFER * (outer_allocation/3))
counter_ += 1
def Risk_Off_Rising_Rates(self, outer_allocation):
self.UUP.Counter += outer_allocation * 0.5 - (config.CASH_BUFFER * (outer_allocation * 0.5))
self.Sub_Strategy_2(0.5*outer_allocation)
def Sub_Strategy_2(self, outer_allocation):
if self.SQQQ.Rsi_20.Current_Value < self.TBF.Rsi_20.Current_Value:
self.SQQQ.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
else:
self.TBF.Counter += outer_allocation- (config.CASH_BUFFER * outer_allocation)
def Risk_On_Falling_Rates_HFEA(self, outer_allocation):
if self.SPY.Drawdown_10.Current_Value < 0.05:
self.HFEA_Refined_Risk_On(outer_allocation)
else:
self.HFEA_Refined_Risk_Off(outer_allocation)
def HFEA_Refined_Risk_On(self, outer_allocation):
self.UPRO.Counter += 0.55*outer_allocation - (config.CASH_BUFFER * (0.55*outer_allocation))
self.TMF.Counter += 0.45*outer_allocation - (config.CASH_BUFFER * (0.45*outer_allocation))
def HFEA_Refined_Risk_Off(self, outer_allocation):
self.BIL.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
###################################################################################################################
def Hedged_Leveraged_Bonds_Stocks_V2(self, outer_allocation):
if self.Securities["TLT"].Price > self.TLT.SMA_150.Current_Value:
#self.Debug(f"TLT_Price & TLT.SMA_150 {self.Securities['TLT'].Price} & {self.TLT.SMA_150.Current_Value}")
self.UPRO.Counter += outer_allocation * 0.55 - (config.CASH_BUFFER * (outer_allocation * 0.55))
self.UPRO.Function = "Hedged_Leveraged_Bonds_Stocks_V2 TLT > TLT_150_SMA"
self.TMF.Counter += outer_allocation * 0.45 - (config.CASH_BUFFER * (outer_allocation * 0.45))
self.TMF.Function = "Hedged_Leveraged_Bonds_Stocks_V2 TLT > TLT_150_SMA"
# self.PHDG.Counter += outer_allocation/3 - (config.CASH_BUFFER/3 * (outer_allocation/3))
# self.PHDG.Function = "Hedged_Leveraged_Bonds_Stocks_V2 TLT > TLT_150_SMA"
else:
if self.Securities["TLT"].Price < self.TLT.SMA_23.Current_Value:
#self.Debug(f"TLT_Price & TLT.SMA_23 {self.Securities['TLT'].Price} & {self.TLT.SMA_23.Current_Value}")
return_list = [(self.TMV, self.TMV.Return_5.Current_Value),
(self.UDOW, self.UDOW.Return_5.Current_Value),
(self.BIL, self.BIL.Return_5.Current_Value),
]
sorted_return_list = sorted(return_list, key=lambda x: x[1], reverse=True)
counter_ = 0
for symbol, symbol_return in sorted_return_list:
if counter_ >= 2:
break
symbol.Counter += outer_allocation/2 - (config.CASH_BUFFER * (outer_allocation/2))
symbol.Function = "Hedged_Leveraged_Bonds_Stocks_V2 TLT > TLT_23_SMA"
counter_ += 1
else:
return_list = [(self.TMF, self.TMF.Return_30.Current_Value),
(self.UPRO, self.UPRO.Return_30.Current_Value),
(self.TMV, self.TMV.Return_30.Current_Value),
(self.MOAT, self.MOAT.Return_30.Current_Value),
(self.BRKB, self.BRKB.Return_30.Current_Value), # Ganesh - Updated self.B with self.BRKB
(self.USMV, self.USMV.Return_30.Current_Value)
]
sorted_return_list = sorted(return_list, key=lambda x: x[1], reverse=True)
counter_ = 0
for symbol, symbol_return in sorted_return_list:
if counter_ >= 1:
break
symbol.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
symbol.Function = "Hedged_Leveraged_Bonds_Stocks_V2 TLT < TLT_23_SMA"
counter_ += 1
###################################################################################################################
def Clear_Weightings(self):
portfolio_value = self.Portfolio.TotalPortfolioValue
for symbol in self.Symbol_Dictionary.keys():
Symbol_Object = self.Symbol_Dictionary[symbol]
Symbol_Object.Counter = 0
symbol_holding = self.Portfolio[symbol].AbsoluteHoldingsValue
allocation_per = symbol_holding / portfolio_value
Symbol_Object.Current_Position = allocation_per
def OnData(self, data: Slice):
for symbol in self.Symbol_Dictionary.keys():
Symbol_Object = self.Symbol_Dictionary[symbol]
if Symbol_Object is None:continue
if self.SHY is None and symbol == "SHY":
self.SHY = Symbol_Object
if self.TECL is None and symbol == "TECL":
self.TECL = Symbol_Object
if self.SOXL is None and symbol == "SOXL":
self.SOXL = Symbol_Object
if self.TQQQ is None and symbol == "TQQQ":
self.TQQQ = Symbol_Object
if self.UPRO is None and symbol == "UPRO":
self.UPRO = Symbol_Object
if self.TMF is None and symbol == "TMF":
self.TMF = Symbol_Object
if self.USDU is None and symbol == "USDU":
self.USDU = Symbol_Object
if self.SQQQ is None and symbol == "SQQQ":
self.SQQQ = Symbol_Object
if self.TBF is None and symbol == "TBF":
self.TBF = Symbol_Object
if self.BIL is None and symbol == "BIL":
self.BIL = Symbol_Object
if self.PHDG is None and symbol == "PHDG":
self.PHDG = Symbol_Object
if self.TMV is None and symbol == "TMV":
self.TMV = Symbol_Object
if self.UDOW is None and symbol == "UDOW":
self.UDOW = Symbol_Object
if self.MOAT is None and symbol == "MOAT":
self.MOAT = Symbol_Object
if self.BRKB is None and symbol == "BRK.B":
self.BRKB = Symbol_Object
if self.USMV is None and symbol == "USMV":
self.USMV = Symbol_Object
if self.SPY is None and symbol == "SPY":
self.SPY = Symbol_Object
if self.QQQ is None and symbol == "QQQ":
self.QQQ = Symbol_Object
if self.SPXL is None and symbol == "SPXL":
self.SPXL = Symbol_Object
if self.SGOV is None and symbol == "SGOV":
self.SGOV = Symbol_Object
if self.DBA is None and symbol == "DBA":
self.DBA = Symbol_Object
if self.ICSH is None and symbol == "ICSH":
self.ICSH = Symbol_Object
if self.TYD is None and symbol == "TYD":
self.TYD = Symbol_Object
if self.URTY is None and symbol == "URTY":
self.URTY = Symbol_Object
if self.XLU is None and symbol == "XLU":
self.XLU = Symbol_Object
if self.NUGT is None and symbol == "NUGT":
self.NUGT = Symbol_Object
if self.TYO is None and symbol == "TYO":
self.TYO = Symbol_Object
if self.VIXM is None and symbol == "VIXM":
self.VIXM = Symbol_Object
if self.IEF is None and symbol == "IEF":
self.IEF = Symbol_Object
if self.SOXS is None and symbol == "SOXS":
self.SOXS = Symbol_Object
if self.BND is None and symbol == "BND":
self.BND = Symbol_Object
if self.VTI is None and symbol == "VTI":
self.VTI = Symbol_Object
if self.FAS is None and symbol == "FAS":
self.FAS = Symbol_Object
if self.TLT is None and symbol == "TLT":
self.TLT = Symbol_Object
if self.UVXY is None and symbol == "UVXY":
self.UVXY = Symbol_Object
if self.PSQ is None and symbol == "PSQ":
self.PSQ = Symbol_Object
if self.VIXY is None and symbol == "VIXY":
self.VIXY = Symbol_Object
if self.BSV is None and symbol == "BSV":
self.BSV = Symbol_Object
if self.SPHB is None and symbol == "SPHB":
self.SPHB = Symbol_Object
if self.USD is None and symbol == "USD":
self.USD = Symbol_Object
if self.SPXU is None and symbol == "SPXU":
self.SPXU = Symbol_Object
if self.XLF is None and symbol == "XLF":
self.XLF = Symbol_Object
if self.MVV is None and symbol == "MVV":
self.MVV = Symbol_Object
if self.UCO is None and symbol == "UCO":
self.UCO = Symbol_Object
if self.UUP is None and symbol == "UUP":
self.UUP = Symbol_Object
if self.QLD is None and symbol == "QLD":
self.QLD = Symbol_Object
if self.GLD is None and symbol == "GLD":
self.GLD = Symbol_Object
if self.YCS is None and symbol == "YCS":
self.YCS = Symbol_Object
if self.TECS is None and symbol == "TECS":
self.TECS = Symbol_Object
if self.SPXS is None and symbol == "SPXS":
self.SPXS = Symbol_Object
if self.IJS is None and symbol == "IJS":
self.IJS = Symbol_Object
if self.EPI is None and symbol == "EPI":
self.EPI = Symbol_Object
if self.TNA is None and symbol == "TNA":
self.TNA = Symbol_Object
if self.XLP is None and symbol == "XLP":
self.XLP = Symbol_Object
if self.AGG is None and symbol == "AGG":
self.AGG = Symbol_Object
if self.KRE is None and symbol == "KRE":
self.KRE = Symbol_Object
if self.IJS is None and symbol == "IJS":
self.IJS = Symbol_Object
if self.EFA is None and symbol == "EFA":
self.EFA = Symbol_Object
if self.EEM is None and symbol == "EEM":
self.EEM = Symbol_Object
if self.SH is None and symbol == "SH":
self.SH = Symbol_Object
if self.SDS is None and symbol == "SDS":
self.SDS = Symbol_Object
if self.HBIL is None and symbol == "HBIL":
self.HBIL = Symbol_Object
if self.Update_Intraday:
if self.SHY is not None:
self.SHY.Update_With_Intraday_Bar(self.Securities["SHY"].Close)
if self.TECL is not None:
self.TECL.Update_With_Intraday_Bar(self.Securities["TECL"].Close)
if self.SOXL is not None:
self.SOXL.Update_With_Intraday_Bar(self.Securities["SOXL"].Close)
if self.FAS is not None:
self.FAS.Update_With_Intraday_Bar(self.Securities["FAS"].Close)
if self.TQQQ is not None:
self.TQQQ.Update_With_Intraday_Bar(self.Securities["TQQQ"].Close)
if self.UPRO is not None:
self.UPRO.Update_With_Intraday_Bar(self.Securities["UPRO"].Close)
if self.TMF is not None:
self.TMF.Update_With_Intraday_Bar(self.Securities["TMF"].Close)
if self.USDU is not None:
self.USDU.Update_With_Intraday_Bar(self.Securities["USDU"].Close)
if self.SQQQ is not None:
self.SQQQ.Update_With_Intraday_Bar(self.Securities["SQQQ"].Close)
if self.TBF is not None:
self.TBF.Update_With_Intraday_Bar(self.Securities["TBF"].Close)
if self.BIL is not None:
self.BIL.Update_With_Intraday_Bar(self.Securities["BIL"].Close)
if self.TMV is not None:
self.TMV.Update_With_Intraday_Bar(self.Securities["TMV"].Close)
if self.UDOW is not None:
self.UDOW.Update_With_Intraday_Bar(self.Securities["UDOW"].Close)
if self.MOAT is not None:
self.MOAT.Update_With_Intraday_Bar(self.Securities["MOAT"].Close)
if self.BRKB is not None:
self.BRKB.Update_With_Intraday_Bar(self.Securities["BRK.B"].Close)
if self.USMV is not None:
self.USMV.Update_With_Intraday_Bar(self.Securities["USMV"].Close)
if self.SPY is not None:
self.SPY.Update_With_Intraday_Bar(self.Securities["SPY"].Close)
if self.QQQ is not None:
self.QQQ.Update_With_Intraday_Bar(self.Securities["QQQ"].Close)
if self.SPXL is not None:
self.SPXL.Update_With_Intraday_Bar(self.Securities["SPXL"].Close)
if self.SGOV is not None:
self.SGOV.Update_With_Intraday_Bar(self.Securities["SGOV"].Close)
if self.DBA is not None:
self.DBA.Update_With_Intraday_Bar(self.Securities["DBA"].Close)
if self.ICSH is not None:
self.ICSH.Update_With_Intraday_Bar(self.Securities["ICSH"].Close)
if self.TYD is not None:
self.TYD.Update_With_Intraday_Bar(self.Securities["TYD"].Close)
if self.URTY is not None:
self.URTY.Update_With_Intraday_Bar(self.Securities["URTY"].Close)
if self.XLU is not None:
self.XLU.Update_With_Intraday_Bar(self.Securities["XLU"].Close)
if self.NUGT is not None:
self.NUGT.Update_With_Intraday_Bar(self.Securities["NUGT"].Close)
if self.TYO is not None:
self.TYO.Update_With_Intraday_Bar(self.Securities["TYO"].Close)
if self.VIXM is not None:
self.VIXM.Update_With_Intraday_Bar(self.Securities["VIXM"].Close)
if self.IEF is not None:
self.IEF.Update_With_Intraday_Bar(self.Securities["IEF"].Close)
if self.SOXS is not None:
self.SOXS.Update_With_Intraday_Bar(self.Securities["SOXS"].Close)
if self.BND is not None:
self.BND.Update_With_Intraday_Bar(self.Securities["BND"].Close)
if self.VTI is not None:
self.VTI.Update_With_Intraday_Bar(self.Securities["VTI"].Close)
if self.TLT is not None:
self.TLT.Update_With_Intraday_Bar(self.Securities["TLT"].Close)
if self.UVXY is not None:
self.UVXY.Update_With_Intraday_Bar(self.Securities["UVXY"].Close)
if self.PSQ is not None:
self.PSQ.Update_With_Intraday_Bar(self.Securities["PSQ"].Close)
if self.VIXY is not None:
self.VIXY.Update_With_Intraday_Bar(self.Securities["VIXY"].Close)
if self.BSV is not None:
self.BSV.Update_With_Intraday_Bar(self.Securities["BSV"].Close)
if self.SPHB is not None:
self.SPHB.Update_With_Intraday_Bar(self.Securities["SPHB"].Close)
if self.USD is not None:
self.USD.Update_With_Intraday_Bar(self.Securities["USD"].Close)
if self.SPXU is not None:
self.SPXU.Update_With_Intraday_Bar(self.Securities["SPXU"].Close)
if self.XLF is not None:
self.XLF.Update_With_Intraday_Bar(self.Securities["XLF"].Close)
if self.MVV is not None:
self.MVV.Update_With_Intraday_Bar(self.Securities["MVV"].Close)
if self.UCO is not None:
self.UCO.Update_With_Intraday_Bar(self.Securities["UCO"].Close)
if self.UUP is not None:
self.UUP.Update_With_Intraday_Bar(self.Securities["UUP"].Close)
if self.QLD is not None:
self.QLD.Update_With_Intraday_Bar(self.Securities["QLD"].Close)
if self.GLD is not None:
self.GLD.Update_With_Intraday_Bar(self.Securities["GLD"].Close)
if self.YCS is not None:
self.YCS.Update_With_Intraday_Bar(self.Securities["YCS"].Close)
if self.TECS is not None:
self.TECS.Update_With_Intraday_Bar(self.Securities["TECS"].Close)
if self.SPXS is not None:
self.SPXS.Update_With_Intraday_Bar(self.Securities["SPXS"].Close)
if self.IJS is not None:
self.IJS.Update_With_Intraday_Bar(self.Securities["IJS"].Close)
if self.EPI is not None:
self.EPI.Update_With_Intraday_Bar(self.Securities["EPI"].Close)
if self.TNA is not None:
self.TNA.Update_With_Intraday_Bar(self.Securities["TNA"].Close)
if self.XLP is not None:
self.XLP.Update_With_Intraday_Bar(self.Securities["XLP"].Close)
if self.AGG is not None:
self.AGG.Update_With_Intraday_Bar(self.Securities["AGG"].Close)
if self.KRE is not None:
self.KRE.Update_With_Intraday_Bar(self.Securities["KRE"].Close)
if self.IJS is not None:
self.IJS.Update_With_Intraday_Bar(self.Securities["IJS"].Close)
if self.EFA is not None:
self.EFA.Update_With_Intraday_Bar(self.Securities["EFA"].Close)
if self.EEM is not None:
self.EEM.Update_With_Intraday_Bar(self.Securities["EEM"].Close)
if self.SH is not None:
self.SH.Update_With_Intraday_Bar(self.Securities["SH"].Close)
if self.SDS is not None:
self.SDS.Update_With_Intraday_Bar(self.Securities["SDS"].Close)
if self.HBIL is not None:
self.HBIL.Update_With_Intraday_Bar(self.Securities["HBIL"].Close)
if self.SHY is None or self.TECL is None or self.SOXL is None or self.FAS is None or self.TQQQ is None or self.UPRO is None or self.TMF is None or self.USDU is None or self.SQQQ is None or self.TBF is None or self.BIL is None or self.PHDG is None or self.TMV is None or self.UDOW is None or self.MOAT is None or self.BRKB is None or self.USMV is None or self.SPY is None or self.QQQ is None or self.SPXL is None or self.SGOV is None or self.DBA is None or self.ICSH is None or self.TYD is None or self.URTY is None or self.XLU is None or self.NUGT is None or self.TYO is None or self.VIXM is None or self.IEF is None or self.SOXS is None or self.BND is None or self.VTI is None or self.TLT is None or self.UVXY is None or self.PSQ is None or self.VIXY is None or self.BSV is None or self.SPHB is None or self.USD is None or self.SPXU is None or self.XLF is None or self.MVV is None or self.UCO is None or self.QLD is None or self.GLD is None or self.YCS is None or self.TECS is None or self.SPXS is None or self.IJS is None or self.EPI is None or self.TNA is None or self.XLP is None or self.AGG is None or self.KRE is None or self.IJS is None or self.EFA is None or self.EEM is None or self.HBIL is None:
return
self.Update_Intraday = False
if self.Trade_Decision:
self.Clear_Weightings()
self.Main_Strategy()
self.Orders()
self.Trade_Decision = False
#region imports
from AlgorithmImports import *
#endregion
"""
"""
BACKTEST_START_YEAR = 2011 # Set start Year of the Backtest
BACKTEST_START_MONTH = 1 # Set start Month of the Backtest
BACKTEST_START_DAY = 1 # Set start Day of the Backtest
BACKTEST_END_YEAR = 2024 # Set end Year of the Backtest
BACKTEST_END_MONTH = 12 # Set end Month of the Backtest
BACKTEST_END_DAY = 31 # Set end Day of the Backtest
BACKTEST_ACCOUNT_CASH = 10000 # Set Backtest Strategy Cash
# List of ETF's that the algorithm will trade,
# !!! Changing these will break the code without the adequate changes in the main file
# If you need help in changing these please contact me
ETFS = [
"QQQ", "UVXY", "BIL", "QLD", "SPY", "BND",
"IEF", "TLT", "TQQQ", "SOXL", "UPRO", "QQEW",
"VTV", "VOX", "TECL", "VOOG", "VOOV", "XLP",
"XLY", "FAS", "SSO"
]
REBALANCE_THRESHOLD = 2
# Cash Buffer in Percent, 0.05 = 5%
CASH_BUFFER = 0 #0.05
# # Cash allocation for each Stratagey
#hedged_lev_bnd_outer_alloation = 0.145
# hfea_outer_allocation = 0.16
# spy_flt_outer_allocation = 0.2
#black_swan_outer_allocation = 0.145
lev_sec_mkt_fwork_outer_allocation = 0.5
#Minimal_BB_outer_allocation = 0.10
# In minutes before market close
TRADE_DECISION_TIME = 2
TRADE_DECISION_TIME_1 = 5
USE_ORDER_DELAY = False
ORDER_DELAY = 1
# In minutes after original order
# If scheduled call is set to BeforeMarketClose keep the minus in the main file
# If scheduled call is set to AfterMarketOpen change the minus to a plus
# E.g. self.Schedule.On(self.DateRules.EveryDay(), self.TimeRules.BeforeMarketClose("SPY", self.Trade_Decision_Time - self.Order_Delay), self.Delayed_Orders)
# E.g. self.Schedule.On(self.DateRules.EveryDay(), self.TimeRules.AfterMarketOpen("SPY", self.Trade_Decision_Time + self.Order_Delay), self.Delayed_Orders)
# ORDER_DELAY = 1
# Period for the Daily RSI
RSI_2_PERIOD = 2
RSI_5_PERIOD = 5
RSI_7_PERIOD = 7
RSI_8_PERIOD = 8
RSI_10_PERIOD = 10
RSI_11_PERIOD = 11
RSI_12_PERIOD = 12
RSI_13_PERIOD = 13
RSI_14_PERIOD = 14
RSI_15_PERIOD = 15
RSI_16_PERIOD = 16
RSI_17_PERIOD = 17
RSI_18_PERIOD = 18
RSI_20_PERIOD = 20
RSI_21_PERIOD = 21
RSI_28_PERIOD = 28
RSI_35_PERIOD = 35
RSI_40_PERIOD = 40
RSI_42_PERIOD = 42
RSI_45_PERIOD = 45
RSI_60_PERIOD = 60
RSI_70_PERIOD = 70
RSI_200_PERIOD = 200
# Period for the Daily Cumulative Return
RETURN_1_PERIOD = 1
RETURN_2_PERIOD = 2
RETURN_3_PERIOD = 3
RETURN_4_PERIOD = 4
RETURN_5_PERIOD = 5
RETURN_6_PERIOD = 6
RETURN_10_PERIOD = 10
RETURN_15_PERIOD = 15
RETURN_20_PERIOD = 20
RETURN_30_PERIOD = 30
RETURN_60_PERIOD = 60
RETURN_70_PERIOD = 70
RETURN_200_PERIOD = 200
# Period for the Daily Return MA
RETURN_MA_3_PERIOD = 3
RETURN_MA_5_PERIOD = 5
RETURN_MA_7_PERIOD = 7
RETURN_MA_12_PERIOD = 12
RETURN_MA_20_PERIOD = 20
RETURN_MA_22_PERIOD = 22
RETURN_MA_210_PERIOD = 210
RETURN_MA_360_PERIOD = 360
# Period for the Daily EMA
EMA_5_PERIOD = 5
EMA_8_PERIOD = 8
EMA_21_PERIOD = 21
EMA_50_PERIOD = 50
EMA_360_PERIOD = 360
# Period for the Standard Deviation of Return
STDEV_RETURN_5_PERIOD = 5
STDEV_RETURN_10_PERIOD = 10
STDEV_RETURN_14_PERIOD = 14
STDEV_RETURN_15_PERIOD = 15
STDEV_RETURN_21_PERIOD = 21
STDEV_RETURN_28_PERIOD = 28
STDEV_RETURN_35_PERIOD = 35
STDEV_RETURN_42_PERIOD = 42
# Period for the Daily SMA
SMA_2_PERIOD = 2
SMA_5_PERIOD = 5
SMA_12_PERIOD = 12
SMA_15_PERIOD = 15
SMA_20_PERIOD = 20
SMA_21_PERIOD = 21
SMA_23_PERIOD = 23
SMA_25_PERIOD = 25
SMA_30_PERIOD = 30
SMA_31_PERIOD = 31
SMA_50_PERIOD = 50
SMA_150_PERIOD = 150
SMA_200_PERIOD = 200
SMA_210_PERIOD = 210
SMA_100_PERIOD = 100
SMA_1000_PERIOD = 1000
CUSTOM_DRAWDOWN_1_PERIOD = 1
CUSTOM_DRAWDOWN_2_PERIOD = 2
CUSTOM_DRAWDOWN_5_PERIOD = 5
CUSTOM_DRAWDOWN_8_PERIOD = 8
CUSTOM_DRAWDOWN_10_PERIOD = 10
CUSTOM_DRAWDOWN_30_PERIOD = 30
CUSTOM_DRAWDOWN_200_PERIOD = 200
CUSTOM_DRAWDOWN_252_PERIOD = 252from AlgorithmImports import *
import config
def Create_Return_List(self, symbols, indicator, sorting_order, threshold, inner_allocation, outer_allocation):
return_list = []
for symbol in symbols:
return_list.append((symbol, getattr(symbol,indicator).Current_Value))
sorted_return_list = sorted(return_list, key=lambda x: x[1], reverse=sorting_order)
counter_ = 0
for symbol, symbol_return in sorted_return_list:
if counter_ >= 1:
break
symbol.Counter += inner_allocation*outer_allocation - (config.CASH_BUFFER * 1)
counter_ += 1
def Create_Return_MA_List(self, symbols, indicator, sorting_order, threshold, inner_allocation, outer_allocation):
return_ma_list = []
for symbol in symbols:
return_ma_list.append((symbol, getattr(symbol,indicator).Current_Value))
sorted_return_ma_list = sorted(return_ma_list, key=lambda x: x[1], reverse=sorting_order)
counter_ = 0
for symbol, symbol_return_ma in sorted_return_ma_list:
if counter_ >= 1:
break
symbol.Counter += inner_allocation*outer_allocation - (config.CASH_BUFFER * 1)
counter_ += 1
def Create_RSI_List(self, symbols, indicator, sorting_order, threshold, inner_allocation, outer_allocation):
rsi_list = []
for symbol in symbols:
rsi_list.append((symbol, getattr(symbol,indicator).Current_Value))
sorted_rsi_list = sorted(rsi_list, key=lambda x: x[1], reverse=sorting_order)
counter_ = 0
for symbol, symbol_rsi in sorted_rsi_list:
if counter_ >= 1:
break
symbol.Counter += inner_allocation*outer_allocation - (config.CASH_BUFFER * 1)
counter_ += 1
from AlgorithmImports import *
from collections import deque
class Intraday_Updating_Cumulative_Return():
def __init__(self, algorithm, return_period):
self.algorithm = algorithm
self.return_period = return_period +1
self.Bar_Queue = deque(maxlen=self.return_period)
self.Current_Value = None
self.First_Intraday_Update_Of_Day = True
self.Last_Main_Bar = None
self.New_Main_Bar = True
self.WarmUP = True
self.Updated_Today = False
def Receive_Main_Bar(self, bar):
if not self.First_Intraday_Update_Of_Day:
del self.Bar_Queue[0]
self.New_Main_Bar = True
self.Bar_Queue.appendleft(bar.Close)
if len(self.Bar_Queue) == self.return_period:
self.Calculate_Cumulative_Return()
def Receive_Sub_Bar(self, bar):
if bar is not None:
if len(self.Bar_Queue) == self.return_period:
if self.First_Intraday_Update_Of_Day:
self.Last_Main_Bar = self.Bar_Queue[0]
self.Bar_Queue.appendleft(bar)
self.First_Intraday_Update_Of_Day = False
else:
del self.Bar_Queue[0]
self.Bar_Queue.appendleft(bar)
self.Calculate_Cumulative_Return()
def Calculate_Cumulative_Return(self):
if len(self.Bar_Queue) == self.return_period:
self.Current_Value = (self.Bar_Queue[0] - self.Bar_Queue[self.return_period-1]) / self.Bar_Queue[self.return_period-1]
if self.New_Main_Bar:
self.First_Intraday_Update_Of_Day = True
self.New_Main_Bar = False
from AlgorithmImports import *
from collections import deque
class CustomDrawdown():
def __init__(self, algorithm, symbol, drawdown_period):
self.algorithm = algorithm
self.drawdown_period = drawdown_period + 1
self.close_queue = deque(maxlen=self.drawdown_period)
self.symbol = symbol
self.Current_Value = None
self.First_Intraday_Update_Of_Day = True
self.Last_Main_Bar = None
self.New_Main_Bar = True
self.WarmUP = True
self.Updated_Today = False
def Receive_Main_Bar(self, bar):
if not self.First_Intraday_Update_Of_Day:
del self.close_queue[-1]
self.New_Main_Bar = True
self.close_queue.append(bar.Close)
if len(self.close_queue) == self.drawdown_period:
self.Calculate_Drawdown()
def Receive_Sub_Bar(self, close):
if close is not None:
if len(self.close_queue) == self.drawdown_period:
if self.First_Intraday_Update_Of_Day:
self.Last_Main_High = self.close_queue[-1]
if close is not None:
self.close_queue.append(close)
self.First_Intraday_Update_Of_Day = False
else:
del self.close_queue[-1]
if close is not None:
self.close_queue.append(close)
self.Calculate_Drawdown()
def Calculate_Drawdown(self):
if len(self.close_queue) == self.drawdown_period:
max_value = 0
max_drawdown = 0
for i in range(len(self.close_queue)):
#if self.symbol == "QQQ" and self.algorithm.Time.day == 20 and self.drawdown_period == 11:
#self.algorithm.Debug(self.close_queue[i])
if self.close_queue[i] > max_value:
max_value = self.close_queue[i]
else:
drawdown = abs((self.close_queue[i] - max_value) / max_value)
if drawdown > max_drawdown:
max_drawdown = drawdown
self.Current_Value = max_drawdown
# if self.symbol == "QQQ" and self.algorithm.Time.day == 15:
# self.algorithm.Debug(f"{self.symbol} {self.close_queue} {self.Current_Value}")
if self.New_Main_Bar:
self.First_Intraday_Update_Of_Day = True
self.New_Main_Bar = False
from AlgorithmImports import *
from collections import deque
class CustomEMA():
def __init__(self, algorithm, ema_period):
self.algorithm = algorithm
self.ema_period = ema_period
self.Bar_Queue = deque(maxlen=self.ema_period)
self.IsFirst_Value = True
self.Current_Value = None
self.First_Intraday_Update_Of_Day = True
self.Last_Main_Bar = None
self.Updated_Today = False
self.New_Main_Bar = True
self.WarmUP = True
def Receive_Main_Bar(self, bar):
if not self.First_Intraday_Update_Of_Day:
del self.Bar_Queue[0]
self.New_Main_Bar = True
self.Bar_Queue.appendleft(bar.Close)
if len(self.Bar_Queue) == self.ema_period:
self.Calculate_EMA()
def Receive_Sub_Bar(self, bar):
if bar is not None:
if len(self.Bar_Queue) == self.ema_period:
if self.First_Intraday_Update_Of_Day:
self.Last_Main_Bar = self.Bar_Queue[0]
self.Bar_Queue.appendleft(bar)
self.First_Intraday_Update_Of_Day = False
else:
del self.Bar_Queue[0]
self.Bar_Queue.appendleft(bar)
self.Calculate_EMA()
def Calculate_EMA(self):
if len(self.Bar_Queue) == self.ema_period:
if self.IsFirst_Value:
self.Current_Value = sum(self.Bar_Queue) / len(self.Bar_Queue)
self.IsFirst_Value = False
return
k = 2 / (self.ema_period + 1)
self.Current_Value = self.Bar_Queue[0] * k + self.Current_Value * (1-k)
if self.New_Main_Bar:
self.First_Intraday_Update_Of_Day = True
self.New_Main_Bar = False
from AlgorithmImports import *
from collections import deque
class CustomReturnMA():
def __init__(self, algorithm, symbol, return_ma_period):
self.algorithm = algorithm
self.symbol = symbol
self.return_ma_period = return_ma_period + 1
self.Return_Queue = deque(maxlen=self.return_ma_period)
self.Current_Value = None
self.First_Intraday_Update_Of_Day = True
self.Last_Main_Return = None
self.New_Main_Bar = True
self.WarmUP = True
self.Updated_Today = False
def Receive_Main_Bar(self, bar):
if not self.First_Intraday_Update_Of_Day:
del self.Return_Queue[0]
self.New_Main_Bar = True
return_ = (bar.Close - bar.Open) / bar.Open
self.Return_Queue.appendleft(return_)
if len(self.Return_Queue) == self.return_ma_period:
self.Calculate_Return_MA()
def Receive_Sub_Bar(self, open_, close):
if open_ is not None and close is not None:
if len(self.Return_Queue) == self.return_ma_period:
if self.First_Intraday_Update_Of_Day:
self.Last_Main_Return = self.Return_Queue[0]
return_ = (close - open_) / open_
self.Return_Queue.appendleft(return_)
self.First_Intraday_Update_Of_Day = False
else:
del self.Return_Queue[0]
return_ = (close - open_) / open_
self.Return_Queue.appendleft(return_)
self.Calculate_Return_MA()
def Calculate_Return_MA(self):
#Drawdown needs to check that the LOW occurs AFTER the high! LOL
if len(self.Return_Queue) == self.return_ma_period:
self.Current_Value = sum(self.Return_Queue) / len(self.Return_Queue)
if self.New_Main_Bar:
self.First_Intraday_Update_Of_Day = True
self.New_Main_Bar = False
from AlgorithmImports import *
from collections import deque
import statistics as stats
class CustomReturnStdev():
def __init__(self, algorithm, symbol, return_stdev_period):
self.algorithm = algorithm
self.symbol = symbol
self.return_stdev_period = return_stdev_period + 1
self.Return_Queue = deque(maxlen=self.return_stdev_period)
self.Current_Value = None
self.First_Intraday_Update_Of_Day = True
self.Last_Main_Return = None
self.New_Main_Bar = True
self.WarmUP = True
self.Updated_Today = False
def Receive_Main_Bar(self, bar):
if not self.First_Intraday_Update_Of_Day:
del self.Return_Queue[0]
self.New_Main_Bar = True
return_ = (bar.Close - bar.Open) / bar.Open
self.Return_Queue.appendleft(return_)
if len(self.Return_Queue) == self.return_stdev_period:
self.Calculate_Return_Stdev()
def Receive_Sub_Bar(self, open_, close):
if open_ is not None and close is not None:
if len(self.Return_Queue) == self.return_stdev_period:
if self.First_Intraday_Update_Of_Day:
self.Last_Main_Return = self.Return_Queue[0]
return_ = (close - open_) / open_
self.Return_Queue.appendleft(return_)
self.First_Intraday_Update_Of_Day = False
else:
del self.Return_Queue[0]
return_ = (close - open_) / open_
self.Return_Queue.appendleft(return_)
self.Calculate_Return_Stdev()
def Calculate_Return_Stdev(self):
#Drawdown needs to check that the LOW occurs AFTER the high! LOL
if len(self.Return_Queue) == self.return_stdev_period:
self.Current_Value = stats.stdev(self.Return_Queue)
if self.New_Main_Bar:
self.First_Intraday_Update_Of_Day = True
self.New_Main_Bar = False
from AlgorithmImports import *
from collections import deque
class Intraday_Updating_RSI():
def __init__(self, algorithm, rsi_period):
self.algorithm = algorithm
self.rsi_period = rsi_period
self.Bar_Queue = deque(maxlen=2)
self.Average_Gain_Queue = deque(maxlen=self.rsi_period)
self.Average_Gain = None
self.Average_Loss_Queue = deque(maxlen=self.rsi_period)
self.Average_Loss = None
self.Change = None
self.Relative_Strength = None
self.Current_Value = None
self.Alpha = None
self.Sum_Gain = 0
self.Sum_Loss = 0
self.First_Intraday_Update_Of_Day = True
self.Last_Main_Bar = None
self.Last_Sum_Gain = None
self.Last_Sum_Loss = None
self.New_Main_Bar = True
self.WarmUP = True
self.Previous_Value = None
self.Updated_Today = False
def Receive_Main_Bar(self, bar):
if not self.First_Intraday_Update_Of_Day:
del self.Bar_Queue[0]
self.New_Main_Bar = True
self.Bar_Queue.appendleft(bar.Close)
if len(self.Bar_Queue) == 2:
self.Calculate_Change()
def Receive_Sub_Bar(self, bar):
if bar is not None:
if len(self.Bar_Queue) == 2:
if self.First_Intraday_Update_Of_Day:
self.Last_Main_Bar = self.Bar_Queue[1]
self.Last_Sum_Gain = self.Sum_Gain
self.Last_Sum_Loss = self.Sum_Loss
self.Bar_Queue.appendleft(bar)
self.First_Intraday_Update_Of_Day = False
else:
del self.Bar_Queue[0]
self.Bar_Queue.appendleft(bar)
self.Calculate_Change()
def Calculate_Change(self):
self.Change = self.Bar_Queue[0] - self.Bar_Queue[1]
self.Calculate_Average_Gain_Loss()
def Calculate_Average_Gain_Loss(self):
if self.Change >= 0:
gain = self.Change
else:
gain = 0
if self.Change < 0:
loss = abs(self.Change)
else:
loss = 0
self.Average_Gain_Queue.appendleft(gain)
self.Average_Loss_Queue.appendleft(loss)
if len(self.Average_Gain_Queue) == self.rsi_period and len(self.Average_Loss_Queue) == self.rsi_period:
self.Alpha = 1/self.rsi_period
self.Average_Gain = sum(self.Average_Gain_Queue) / len(self.Average_Gain_Queue)
self.Average_Loss = sum(self.Average_Loss_Queue) / len(self.Average_Loss_Queue)
if self.First_Intraday_Update_Of_Day:
if self.Sum_Gain == 0:
if self.WarmUP:
self.Sum_Gain = self.Average_Gain
else:
self.Sum_Gain = self.Last_Sum_Gain
else:
self.Sum_Gain = self.Alpha * gain + (1-self.Alpha) * self.Sum_Gain
if self.Sum_Loss == 0:
if self.WarmUP:
self.Sum_Loss = self.Average_Loss
else:
self.Sum_Loss = self.Last_Sum_Loss
else:
self.Sum_Loss = self.Alpha * loss + (1-self.Alpha) * self.Sum_Loss
else:
if self.Sum_Gain == 0:
self.Sum_Gain = self.Average_Gain
else:
self.Sum_Gain = self.Alpha * gain + (1-self.Alpha) * self.Last_Sum_Gain
if self.Sum_Loss == 0:
self.Sum_Loss = self.Average_Loss
else:
self.Sum_Loss = self.Alpha * loss + (1-self.Alpha) * self.Last_Sum_Loss
if self.New_Main_Bar:
self.First_Intraday_Update_Of_Day = True
self.Calculate_Relative_Strength()
def Calculate_Relative_Strength(self):
if self.Sum_Gain != 0 and self.Sum_Loss != 0:
self.Relative_Strength = self.Sum_Gain / self.Sum_Loss
if self.Relative_Strength is not None:
self.Current_Value = 100 - (100 / (1 + self.Relative_Strength))
if self.Sum_Gain == 0:
self.Current_Value = 0
elif self.Sum_Loss == 0:
self.Current_Value = 100
self.New_Main_Bar = False
from AlgorithmImports import *
from collections import deque
class Intraday_Updating_SMA():
def __init__(self, algorithm, sma_period):
self.algorithm = algorithm
self.sma_period = sma_period
self.Bar_Queue = deque(maxlen=self.sma_period)
self.Current_Value = None
self.First_Intraday_Update_Of_Day = True
self.Last_Main_Bar = None
self.Updated_Today = False
self.New_Main_Bar = True
self.WarmUP = True
def Receive_Main_Bar(self, bar):
if not self.First_Intraday_Update_Of_Day:
del self.Bar_Queue[0]
self.New_Main_Bar = True
self.Bar_Queue.appendleft(bar.Close)
if len(self.Bar_Queue) == self.sma_period:
self.Calculate_SMA()
def Receive_Sub_Bar(self, bar):
if bar is not None:
if len(self.Bar_Queue) == self.sma_period:
if self.First_Intraday_Update_Of_Day:
self.Last_Main_Bar = self.Bar_Queue[0]
self.Bar_Queue.appendleft(bar)
self.First_Intraday_Update_Of_Day = False
else:
del self.Bar_Queue[0]
self.Bar_Queue.appendleft(bar)
self.Calculate_SMA()
def Calculate_SMA(self):
if len(self.Bar_Queue) == self.sma_period:
self.Current_Value = sum(self.Bar_Queue) / len(self.Bar_Queue)
if self.New_Main_Bar:
self.First_Intraday_Update_Of_Day = True
self.New_Main_Bar = False
from AlgorithmImports import *
from custom_sma import Intraday_Updating_SMA
from custom_cumulative_return import Intraday_Updating_Cumulative_Return
from custom_rsi import Intraday_Updating_RSI
from custom_drawdown import CustomDrawdown
from custom_return_ma import CustomReturnMA
from custom_return_stdev import CustomReturnStdev
from custom_ema import CustomEMA
from symboldata import SymbolData
from create_lists import *
import config
from strategies.blackswan_strategy_TQQQ import *
from strategies.blackswan_strategy_QQQ import *
from qqq_mean_revision import qqq_mean_revision
from spy_mean_revision import spy_mean_revision
class ETF_Rebalancing(QCAlgorithm):
def Initialize(self):
self.SetStartDate(config.BACKTEST_START_YEAR, config.BACKTEST_START_MONTH, config.BACKTEST_START_DAY)
self.SetEndDate(config.BACKTEST_END_YEAR, config.BACKTEST_END_MONTH, config.BACKTEST_END_DAY)
self.SetCash(config.BACKTEST_ACCOUNT_CASH)
#self.SetBrokerageModel(BrokerageName.TDAmeritrade, AccountType.Margin)
self.Rebalance_Threshold = config.REBALANCE_THRESHOLD / 100
self.UniverseSettings.Leverage = 4
# Initialize ETFs as None
etf_symbols = {etf: None for etf in config.ETFS }
for symbol in etf_symbols:
setattr(self, symbol, None)
self.lev_sec_mkt_fwork_outer_allocation = config.lev_sec_mkt_fwork_outer_allocation
self.Sub_4_List = []
self.Symbol_List = []
self.ETFs = config.ETFS
self.Trade_Decision_Time = config.TRADE_DECISION_TIME
self.Trade_Decision_Time_1 = config.TRADE_DECISION_TIME_1
self.Order_Delay = config.ORDER_DELAY # Enable this for Delayed orders
self.Update_Intraday = False
self.Trade_Decision = False
for etf in self.ETFs:
try:
self.Symbol_List.append(self.AddEquity(etf, Resolution.Minute, dataNormalizationMode=DataNormalizationMode.Adjusted).Symbol)
except:
self.Debug(f"Unable to add stock {etf} to the algorithm")
self.Symbol_Dictionary = {}
for symbol in self.Symbol_List:
self.Symbol_Dictionary[symbol] = SymbolData(self, symbol)
self.Schedule.On(self.DateRules.EveryDay(), self.TimeRules.BeforeMarketClose("SPY", self.Trade_Decision_Time), self.Set_Update_Intraday)
self.Schedule.On(self.DateRules.EveryDay(), self.TimeRules.BeforeMarketClose("SPY", self.Trade_Decision_Time - self.Order_Delay), self.Delayed_Orders)
def Set_Update_Intraday(self):
self.Update_Intraday = True
self.Trade_Decision = True
def Orders(self):
for symbol in self.Symbol_Dictionary.keys():
Symbol_Object = self.Symbol_Dictionary[symbol]
if Symbol_Object.Current_Position < (Symbol_Object.Counter - self.Rebalance_Threshold) or Symbol_Object.Current_Position > (Symbol_Object.Counter + self.Rebalance_Threshold):
if Symbol_Object.Counter <= 0:
self.Liquidate(symbol)
if not config.USE_ORDER_DELAY:
for symbol in self.Symbol_Dictionary.keys():
Symbol_Object = self.Symbol_Dictionary[symbol]
if Symbol_Object.Current_Position < (Symbol_Object.Counter - self.Rebalance_Threshold) or Symbol_Object.Current_Position > (Symbol_Object.Counter + self.Rebalance_Threshold):
if Symbol_Object.Counter >= 0:
self.SetHoldings(symbol, Symbol_Object.Counter, tag=f"{Symbol_Object.Function}") # Disable this for Delayed orders
elif not self.Portfolio[symbol].Invested and Symbol_Object.Current_Position == 0 and Symbol_Object.Counter > 0:
self.SetHoldings(symbol, Symbol_Object.Counter, tag=f"{Symbol_Object.Function}")
# Enable this for Delayed orders
def Delayed_Orders(self):
if config.USE_ORDER_DELAY:
for symbol in self.Symbol_Dictionary.keys():
Symbol_Object = self.Symbol_Dictionary[symbol]
if Symbol_Object.Current_Position < (Symbol_Object.Counter - self.Rebalance_Threshold) or Symbol_Object.Current_Position > (Symbol_Object.Counter + self.Rebalance_Threshold):
if Symbol_Object.Counter >= 0:
self.SetHoldings(symbol, Symbol_Object.Counter, tag=f"{Symbol_Object.Function}")
elif not self.Portfolio[symbol].Invested and Symbol_Object.Current_Position == 0 and Symbol_Object.Counter > 0:
self.SetHoldings(symbol, Symbol_Object.Counter, tag=f"{Symbol_Object.Function}")
def Main_Strategy(self):
#BlackSwan_MeanRev_BondSignal_TQQQ_TONED_DOWN(self, 1)
#BlackSwan_MeanRev_BondSignal_QQQ_TONED_DOWN(self, 1)
qqq_mean_revision(self, 1)
#spy_mean_revision(self, 1)
################################################################################################################
def Clear_Weightings(self):
portfolio_value = self.Portfolio.TotalPortfolioValue
for symbol in self.Symbol_Dictionary.keys():
Symbol_Object = self.Symbol_Dictionary[symbol]
Symbol_Object.Counter = 0
symbol_holding = self.Portfolio[symbol].AbsoluteHoldingsValue
allocation_per = symbol_holding / portfolio_value
Symbol_Object.Current_Position = allocation_per
def OnData(self, data: Slice):
for symbol in self.Symbol_Dictionary.keys():
Symbol_Object = self.Symbol_Dictionary[symbol]
if Symbol_Object is None:continue
symbols_to_check = config.ETFS
for symbol_name in symbols_to_check:
if getattr(self, symbol_name) is None and symbol == symbol_name:
setattr(self, symbol_name, Symbol_Object)
if self.Update_Intraday:
securities_to_update = config.ETFS
for sec in securities_to_update:
security_obj = getattr(self, sec, None)
if security_obj is not None:
security_obj.Update_With_Intraday_Bar(self.Securities[sec].Close)
attributes = config.ETFS
if any(getattr(self, attr) is None for attr in attributes):
return
self.Update_Intraday = False
if self.Trade_Decision:
self.Clear_Weightings()
self.Main_Strategy()
self.Orders()
self.Trade_Decision = False
# region imports from AlgorithmImports import * # endregion # Your New Python File
# region imports
from AlgorithmImports import *
# endregion
def BlackSwan_MeanRev_BondSignal_QQQ_TONED_DOWN(algo, outer_allocation):
if algo.QQQ.Rsi_10.Current_Value > 80:
algo.UVXY.Counter += outer_allocation * 0.25
algo.UVXY.Function = "UVXY_1, Rsi_10 > 79"
algo.BIL.Counter += outer_allocation * 0.75
elif algo.QQQ.Rsi_10.Current_Value < 32:
algo.QLD.Counter += outer_allocation * 1
algo.QLD.Function = "QQQ_1, Rsi_10 < 32"
elif (algo.QQQ.SMA_50.Current_Value > algo.QQQ.SMA_150.Current_Value and
algo.Securities["SPY"].Price > algo.SPY.SMA_200.Current_Value):
if algo.SPY.Rsi_60.Current_Value > 60:
algo.QQQ.Counter += outer_allocation
else:
algo.QQQ.Counter += outer_allocation * 1
algo.QQQ.Function = "QQQ_2, SMA_50 > SMA_150 & SPY price > SMA_200"
elif algo.SPY.Rsi_60.Current_Value > 50:
if algo.BND.Rsi_45.Current_Value > algo.SPY.Rsi_45.Current_Value: # High-Hitrate-80%
algo.QQQ.Counter += outer_allocation
algo.QQQ.Function = "QQQ_3, BMB BND.Rsi_45.Current_Value > algo.SPY.Rsi_45.Current_Value"
else:
algo.BIL.Counter += outer_allocation
algo.BIL.Function = "BIL_2"
elif algo.IEF.Rsi_200.Current_Value < algo.TLT.Rsi_200.Current_Value:
if algo.BND.Rsi_45.Current_Value > algo.SPY.Rsi_45.Current_Value: # High-Hitrate-75%
algo.QQQ.Counter += outer_allocation
algo.QQQ.Function = "QQQ_4, BMB BND.Rsi_45.Current_Value > algo.SPY.Rsi_45.Current_Value"
else:
algo.BIL.Counter += outer_allocation
algo.BIL.Function = "BIL_3"# region imports
from AlgorithmImports import *
import config
# endregion
def BlackSwan_MeanRev_BondSignal_TQQQ_TONED_DOWN(algo, outer_allocation):
if algo.TQQQ.Rsi_10.Current_Value > 79:
algo.UVXY.Counter += outer_allocation * 0.25
algo.UVXY.Function = "BMB TQQQ.Rsi_10.Current_Value > 79" # High-Hitrate-99%
algo.BIL.Counter += outer_allocation * 0.75
elif algo.TQQQ.Rsi_10.Current_Value < 32:
algo.TQQQ.Counter += outer_allocation
algo.TQQQ.Function = "BMB TQQQ.Rsi_10.Current_Value < 32" # High-Hitrate-99%
elif (algo.TQQQ.SMA_50.Current_Value > algo.TQQQ.SMA_150.Current_Value and
(algo.Securities["SPY"].Price > algo.SPY.SMA_200.Current_Value) or (algo.Securities["QQQ"].Price > algo.QQQ.SMA_200.Current_Value)):
if algo.SPY.SMA_200.Current_Value > algo.SPY.SMA_1000.Current_Value:
if algo.SPY.Rsi_60.Current_Value > 60:
algo.QQQ.Counter += outer_allocation
else:
algo.TQQQ.Counter += outer_allocation
algo.TQQQ.Function = "TQQQ 50 > 150 & SPY.SMA_200 < SPY.SMA_1000"
elif algo.SPY.Rsi_60.Current_Value > 50:
if algo.BND.Rsi_45.Current_Value > algo.SPY.Rsi_45.Current_Value: # High-Hitrate-80%
algo.QLD.Counter += outer_allocation * 1
algo.QLD.Function = "BMB BND.Rsi_45.Current_Value > algo.SPY.Rsi_45.Current_Value"
else:
algo.BIL.Counter += outer_allocation * 1
algo.BIL.Function = "BMB BND.Rsi_45.Current_Value < algo.SPY.Rsi_45.Current_Value"
elif algo.IEF.Rsi_200.Current_Value < algo.TLT.Rsi_200.Current_Value:
if algo.BND.Rsi_45.Current_Value > algo.SPY.Rsi_45.Current_Value: # High-Hitrate-75%
algo.QLD.Counter += outer_allocation* 1
algo.QLD.Function = "BMB BND.Rsi_45.Current_Value > algo.SPY.Rsi_45.Current_Value"
else:
algo.BIL.Counter += outer_allocation * 1
algo.BIL.Function = "BMB BND.Rsi_45.Current_Value < algo.SPY.Rsi_45.Current_Value"
else:
algo.BIL.Counter += outer_allocation * 1
algo.BIL.Function = "BMB IEF.Rsi_200.Current_Value > algo.TLT.Rsi_200.Current_Value"# region imports
from AlgorithmImports import *
# endregion
# Function to split allocation between two strategies
def qqq_mean_revision(algo, total_allocation):
# Split the total allocation
allocation_BlackSwan = total_allocation * 0.75
allocation_oversold = total_allocation * 0.25
# Execute strategies with respective allocations
BlackSwan_MeanRev_BondSignal_QQQ(algo, allocation_BlackSwan)
oversold_overbrought(algo, allocation_oversold)
# Your New Python File
def BlackSwan_MeanRev_BondSignal_QQQ(algo, outer_allocation):
# Check if the 10-day RSI of QQQ is greater than 80
if algo.QQQ.Rsi_10.Current_Value > 80:
algo.UVXY.Counter += outer_allocation * 0
algo.UVXY.Function = "UVXY_1, Rsi_10 > 79"
algo.BIL.Counter += outer_allocation
# Check if the 10-day RSI of QQQ is less than 30
elif algo.QQQ.Rsi_10.Current_Value < 32:
algo.QLD.Counter += outer_allocation
algo.QLD.Function = "QQQ_1, Rsi_10 < 32"
# Check if QQQ's 50-day SMA is greater than its 150-day SMA and SPY's price is above its 200-day SMA
elif (algo.QQQ.SMA_50.Current_Value > algo.QQQ.SMA_150.Current_Value and
algo.Securities["SPY"].Price > algo.SPY.SMA_200.Current_Value):
#algo.TQQQ.Counter += outer_allocation * 0.3333
algo.QQQ.Counter += outer_allocation
# Check if SPY's 60-day RSI is greater than 50
elif algo.SPY.Rsi_60.Current_Value > 50:
# Nested condition to compare RSI values of BND and SPY
if algo.BND.Rsi_45.Current_Value > algo.SPY.Rsi_45.Current_Value:
algo.QQQ.Counter += outer_allocation
algo.QQQ.Function = "QQQ_3, BMB BND.Rsi_45 > SPY.Rsi_45"
else:
algo.BIL.Counter += outer_allocation
algo.BIL.Function = "BIL_2, BND.Rsi_45 ≤ SPY.Rsi_45"
# Check if IEF's 200-day RSI is less than TLT's 200-day RSI
elif algo.IEF.Rsi_200.Current_Value < algo.TLT.Rsi_200.Current_Value:
# Nested condition to compare RSI values of BND and SPY
if algo.BND.Rsi_45.Current_Value > algo.SPY.Rsi_45.Current_Value:
algo.QQQ.Counter += outer_allocation
algo.QQQ.Function = "QQQ_4, BMB BND.Rsi_45 > SPY.Rsi_45"
else:
algo.BIL.Counter += outer_allocation
algo.BIL.Function = "BIL_3, BND.Rsi_45 ≤ SPY.Rsi_45"
def oversold_overbrought(algo, outer_allocation):
if algo.SOXL.Rsi_10.Current_Value < 30:
algo.SOXL.Counter += outer_allocation
algo.SOXL.Function = "SOXL, Rsi_10 > 30"
elif algo.UPRO.Rsi_10.Current_Value < 30:
algo.UPRO.Counter += outer_allocation
algo.UPRO.Function = "UPRO, Rsi_10 < 30"
elif algo.TQQQ.Rsi_10.Current_Value < 32:
algo.TQQQ.Counter += outer_allocation
algo.TQQQ.Function = "TQQQ, Rsi_10 < 32"
else:
if (
algo.QQEW.Rsi_10.Current_Value > 79 or
algo.VTV.Rsi_10.Current_Value > 79 or
algo.VOX.Rsi_10.Current_Value > 79 or
algo.TECL.Rsi_10.Current_Value > 79 or
algo.VOOG.Rsi_10.Current_Value > 79 or
algo.VOOV.Rsi_10.Current_Value > 79 or
algo.XLP.Rsi_10.Current_Value > 75 or
algo.TQQQ.Rsi_10.Current_Value > 79 or
algo.XLY.Rsi_10.Current_Value > 80 or
algo.FAS.Rsi_10.Current_Value > 80 or
algo.SPY.Rsi_10.Current_Value > 80 or
algo.QQQ.Rsi_10.Current_Value > 80
):
algo.UVXY.Counter += outer_allocation
else:
#algo.SVXY.Counter += outer_allocation
BlackSwan_MeanRev_BondSignal_TQQQ(algo,outer_allocation)
def BlackSwan_MeanRev_BondSignal_TQQQ(algo, outer_allocation):
# Check if QQQ's 50-day SMA is greater than its 150-day SMA and SPY's price is above its 200-day SMA
if (algo.QQQ.SMA_50.Current_Value > algo.QQQ.SMA_150.Current_Value and
algo.Securities["SPY"].Price > algo.SPY.SMA_200.Current_Value):
algo.TQQQ.Counter += outer_allocation
algo.TQQQ.Function = "QQQ_2, SMA_50 > SMA_150 & SPY price > SMA_200"
# Check if SPY's 60-day RSI is greater than 50
elif algo.SPY.Rsi_60.Current_Value > 50:
# Nested condition to compare RSI values of BND and SPY
if algo.BND.Rsi_45.Current_Value > algo.SPY.Rsi_45.Current_Value:
algo.TQQQ.Counter += outer_allocation
algo.TQQQ.Function = "QQQ_3, BMB BND.Rsi_45 > SPY.Rsi_45"
else:
algo.BIL.Counter += outer_allocation
algo.BIL.Function = "BIL_2, BND.Rsi_45 ≤ SPY.Rsi_45"
# Check if IEF's 200-day RSI is less than TLT's 200-day RSI
elif algo.IEF.Rsi_200.Current_Value < algo.TLT.Rsi_200.Current_Value:
# Nested condition to compare RSI values of BND and SPY
if algo.BND.Rsi_45.Current_Value > algo.SPY.Rsi_45.Current_Value:
algo.TQQQ.Counter += outer_allocation
algo.TQQQ.Function = "QQQ_4, BMB BND.Rsi_45 > SPY.Rsi_45"
else:
algo.BIL.Counter += outer_allocation
algo.BIL.Function = "BIL_3, BND.Rsi_45 ≤ SPY.Rsi_45"# region imports
from AlgorithmImports import *
# endregion
# Function to split allocation between two strategies
def spy_mean_revision(algo, total_allocation):
# Split the total allocation
allocation_BlackSwan = total_allocation * 0.75
allocation_oversold = total_allocation * 0.25
# Execute strategies with respective allocations
BlackSwan_MeanRev_BondSignal_SPY(algo, allocation_BlackSwan)
oversold_overbrought(algo, allocation_oversold)
# Your New Python File
def BlackSwan_MeanRev_BondSignal_SPY(algo, outer_allocation):
# Check if the 10-day RSI of SPY is greater than 80
if algo.SPY.Rsi_10.Current_Value > 80:
algo.UVXY.Counter += outer_allocation * 0
algo.UVXY.Function = "UVXY_1, Rsi_10 > 79"
algo.BIL.Counter += outer_allocation
# Check if the 10-day RSI of SPY is less than 30
elif algo.SPY.Rsi_10.Current_Value < 32:
algo.SSO.Counter += outer_allocation
algo.SSO.Function = "SPY_1, Rsi_10 < 32"
# Check if SPY's 50-day SMA is greater than its 150-day SMA and SPY's price is above its 200-day SMA
elif (algo.SPY.SMA_50.Current_Value > algo.SPY.SMA_150.Current_Value and
algo.Securities["SPY"].Price > algo.SPY.SMA_200.Current_Value):
#algo.UPRO.Counter += outer_allocation * 0.3333
algo.SSO.Counter += outer_allocation
# algo.SPY.Function = "SPY_2, SMA_50 > SMA_150 & SPY price > SMA_200"
#Sub_Strategy_1(algo,outer_allocation)
# Check if SPY's 60-day RSI is greater than 50
elif algo.SPY.Rsi_60.Current_Value > 50:
# Nested condition to compare RSI values of BND and SPY
if algo.BND.Rsi_45.Current_Value > algo.SPY.Rsi_45.Current_Value:
algo.SPY.Counter += outer_allocation
algo.SPY.Function = "SPY_3, BMB BND.Rsi_45 > SPY.Rsi_45"
else:
algo.BIL.Counter += outer_allocation
algo.BIL.Function = "BIL_2, BND.Rsi_45 ≤ SPY.Rsi_45"
# Check if IEF's 200-day RSI is less than TLT's 200-day RSI
elif algo.IEF.Rsi_200.Current_Value < algo.TLT.Rsi_200.Current_Value:
# Nested condition to compare RSI values of BND and SPY
if algo.BND.Rsi_45.Current_Value > algo.SPY.Rsi_45.Current_Value:
algo.SPY.Counter += outer_allocation
algo.SPY.Function = "SPY_4, BMB BND.Rsi_45 > SPY.Rsi_45"
else:
algo.BIL.Counter += outer_allocation
algo.BIL.Function = "BIL_3, BND.Rsi_45 ≤ SPY.Rsi_45"
def Sub_Strategy_1(algo, outer_allocation):
# Create a list of tuples containing each asset and its 10-day RSI value
rsi_list = [
(algo.SPY, algo.SPY.Rsi_10.Current_Value),
(algo.XLP, algo.XLP.Rsi_10.Current_Value)
]
# Sort the list by RSI value in descending order to get the highest RSI first
sorted_rsi_list = sorted(rsi_list, key=lambda x: x[1], reverse=True)
# Select the asset with the highest RSI and allocate the full amount
top_asset, _ = sorted_rsi_list[0] # Get the asset with the highest RSI
top_asset.Counter += outer_allocation # Allocate the full outer_allocation
def oversold_overbrought(algo, outer_allocation):
if algo.SOXL.Rsi_10.Current_Value < 30:
algo.SOXL.Counter += outer_allocation * 1
algo.SOXL.Function = "SOXL, Rsi_10 > 30"
elif algo.UPRO.Rsi_10.Current_Value < 30:
algo.UPRO.Counter += outer_allocation * 1
algo.UPRO.Function = "UPRO, Rsi_10 < 30"
elif algo.TQQQ.Rsi_10.Current_Value < 32:
algo.TQQQ.Counter += outer_allocation * 1
algo.TQQQ.Function = "UPRO, Rsi_10 < 32"
else:
if (
algo.QQEW.Rsi_10.Current_Value > 79 or
algo.VTV.Rsi_10.Current_Value > 79 or
algo.VOX.Rsi_10.Current_Value > 79 or
algo.TECL.Rsi_10.Current_Value > 79 or
algo.VOOG.Rsi_10.Current_Value > 79 or
algo.VOOV.Rsi_10.Current_Value > 79 or
algo.XLP.Rsi_10.Current_Value > 75 or
algo.UPRO.Rsi_10.Current_Value > 79 or
algo.XLY.Rsi_10.Current_Value > 80 or
algo.FAS.Rsi_10.Current_Value > 80 or
algo.SPY.Rsi_10.Current_Value > 80 or
algo.SPY.Rsi_10.Current_Value > 80
):
algo.UVXY.Counter += outer_allocation * 1
else:
BlackSwan_MeanRev_BondSignal_TQQQ(algo,outer_allocation)
def BlackSwan_MeanRev_BondSignal_TQQQ(algo, outer_allocation):
# Check if SPY's 50-day SMA is greater than its 150-day SMA and SPY's price is above its 200-day SMA
if (algo.SPY.SMA_50.Current_Value > algo.SPY.SMA_150.Current_Value and
algo.Securities["SPY"].Price > algo.SPY.SMA_200.Current_Value):
algo.UPRO.Counter += outer_allocation
algo.UPRO.Function = "SPY_2, SMA_50 > SMA_150 & SPY price > SMA_200"
# Check if SPY's 60-day RSI is greater than 50
elif algo.SPY.Rsi_60.Current_Value > 50:
# Nested condition to compare RSI values of BND and SPY
if algo.BND.Rsi_45.Current_Value > algo.SPY.Rsi_45.Current_Value:
algo.UPRO.Counter += outer_allocation
algo.UPRO.Function = "SPY_3, BMB BND.Rsi_45 > SPY.Rsi_45"
else:
algo.BIL.Counter += outer_allocation
algo.BIL.Function = "BIL_2, BND.Rsi_45 ≤ SPY.Rsi_45"
# Check if IEF's 200-day RSI is less than TLT's 200-day RSI
elif algo.IEF.Rsi_200.Current_Value < algo.TLT.Rsi_200.Current_Value:
# Nested condition to compare RSI values of BND and SPY
if algo.BND.Rsi_45.Current_Value > algo.SPY.Rsi_45.Current_Value:
algo.UPRO.Counter += outer_allocation
algo.UPRO.Function = "SPY_4, BMB BND.Rsi_45 > SPY.Rsi_45"
else:
algo.BIL.Counter += outer_allocation
algo.BIL.Function = "BIL_3, BND.Rsi_45 ≤ SPY.Rsi_45"from AlgorithmImports import *
from custom_sma import Intraday_Updating_SMA
from custom_cumulative_return import Intraday_Updating_Cumulative_Return
from custom_rsi import Intraday_Updating_RSI
from custom_drawdown import CustomDrawdown
from custom_return_ma import CustomReturnMA
from custom_return_stdev import CustomReturnStdev
from custom_ema import CustomEMA
import config
class SymbolData():
def __init__(self, algorithm, symbol):
self.algorithm = algorithm
self.symbol = symbol
self.Daily_Open = None
self.Daily_High = None
self.Daily_Low = None
self.Counter = 0
self.Rsi_2_Period = config.RSI_2_PERIOD
self.Rsi_5_Period = config.RSI_5_PERIOD
self.Rsi_7_Period = config.RSI_7_PERIOD
self.Rsi_8_Period = config.RSI_8_PERIOD
self.Rsi_10_Period = config.RSI_10_PERIOD
self.Rsi_11_Period = config.RSI_11_PERIOD
self.Rsi_12_Period = config.RSI_12_PERIOD
self.Rsi_13_Period = config.RSI_13_PERIOD
self.Rsi_14_Period = config.RSI_14_PERIOD
self.Rsi_15_Period = config.RSI_15_PERIOD
self.Rsi_16_Period = config.RSI_16_PERIOD
self.Rsi_17_Period = config.RSI_17_PERIOD
self.Rsi_18_Period = config.RSI_18_PERIOD
self.Rsi_20_Period = config.RSI_20_PERIOD
self.Rsi_21_Period = config.RSI_21_PERIOD
self.Rsi_28_Period = config.RSI_28_PERIOD
self.Rsi_35_Period = config.RSI_35_PERIOD
self.Rsi_40_Period = config.RSI_40_PERIOD
self.Rsi_42_Period = config.RSI_42_PERIOD
self.Rsi_45_Period = config.RSI_45_PERIOD
self.Rsi_60_Period = config.RSI_60_PERIOD
self.Rsi_70_Period = config.RSI_70_PERIOD
self.Rsi_200_Period = config.RSI_200_PERIOD
self.Return_1_Period = config.RETURN_1_PERIOD
self.Return_2_Period = config.RETURN_2_PERIOD
self.Return_3_Period = config.RETURN_3_PERIOD
self.Return_4_Period = config.RETURN_4_PERIOD
self.Return_5_Period = config.RETURN_5_PERIOD
self.Return_6_Period = config.RETURN_6_PERIOD
self.Return_10_Period = config.RETURN_10_PERIOD
self.Return_15_Period = config.RETURN_15_PERIOD
self.Return_20_Period = config.RETURN_20_PERIOD
self.Return_30_Period = config.RETURN_30_PERIOD
self.Return_60_Period = config.RETURN_60_PERIOD
self.Return_70_Period = config.RETURN_70_PERIOD
self.Return_200_Period = config.RETURN_200_PERIOD
self.Return_MA_3_Period = config.RETURN_MA_3_PERIOD
self.Return_MA_5_Period = config.RETURN_MA_5_PERIOD
self.Return_MA_7_Period = config.RETURN_MA_7_PERIOD
self.Return_MA_12_Period = config.RETURN_MA_12_PERIOD
self.Return_MA_20_Period = config.RETURN_MA_20_PERIOD
self.Return_MA_22_Period = config.RETURN_MA_22_PERIOD
self.Return_MA_210_Period = config.RETURN_MA_210_PERIOD
self.Return_MA_360_Period = config.RETURN_MA_360_PERIOD
self.STDEV_Return_5_Period = config.STDEV_RETURN_5_PERIOD
self.STDEV_Return_10_Period = config.STDEV_RETURN_10_PERIOD
self.STDEV_Return_14_Period = config.STDEV_RETURN_14_PERIOD
self.STDEV_Return_15_Period = config.STDEV_RETURN_15_PERIOD
self.STDEV_Return_21_Period = config.STDEV_RETURN_21_PERIOD
self.STDEV_Return_28_Period = config.STDEV_RETURN_28_PERIOD
self.STDEV_Return_35_Period = config.STDEV_RETURN_35_PERIOD
self.STDEV_Return_42_Period = config.STDEV_RETURN_42_PERIOD
self.EMA_5_Period = config.EMA_5_PERIOD
self.EMA_8_Period = config.EMA_8_PERIOD
self.EMA_21_Period = config.EMA_21_PERIOD
self.EMA_50_Period = config.EMA_50_PERIOD
self.EMA_360_Period = config.EMA_360_PERIOD
self.SMA_2_Period = config.SMA_2_PERIOD
self.SMA_5_Period = config.SMA_5_PERIOD
self.SMA_12_Period = config.SMA_12_PERIOD
self.SMA_15_Period = config.SMA_15_PERIOD
self.SMA_20_Period = config.SMA_20_PERIOD
self.SMA_21_Period = config.SMA_21_PERIOD
self.SMA_23_Period = config.SMA_23_PERIOD
self.SMA_25_Period = config.SMA_25_PERIOD
self.SMA_30_Period = config.SMA_30_PERIOD
self.SMA_31_Period = config.SMA_31_PERIOD
self.SMA_50_Period = config.SMA_50_PERIOD
self.SMA_150_Period = config.SMA_150_PERIOD
self.SMA_200_Period = config.SMA_200_PERIOD
self.SMA_210_Period = config.SMA_210_PERIOD
self.SMA_100_Period = config.SMA_100_PERIOD
self.SMA_1000_Period = config.SMA_1000_PERIOD
self.Custom_Drawdown_1_Period = config.CUSTOM_DRAWDOWN_1_PERIOD
self.Custom_Drawdown_2_Period = config.CUSTOM_DRAWDOWN_2_PERIOD
self.Custom_Drawdown_5_Period = config.CUSTOM_DRAWDOWN_5_PERIOD
self.Custom_Drawdown_8_Period = config.CUSTOM_DRAWDOWN_8_PERIOD
self.Custom_Drawdown_10_Period = config.CUSTOM_DRAWDOWN_10_PERIOD
self.Custom_Drawdown_30_Period = config.CUSTOM_DRAWDOWN_30_PERIOD
self.Custom_Drawdown_200_Period = config.CUSTOM_DRAWDOWN_200_PERIOD
self.Custom_Drawdown_252_Period = config.CUSTOM_DRAWDOWN_252_PERIOD
self.Function = ""
self.Current_Position = 0
self.Rsi_2 = Intraday_Updating_RSI(algorithm, self.Rsi_2_Period)
self.Rsi_5 = Intraday_Updating_RSI(algorithm, self.Rsi_5_Period)
self.Rsi_7 = Intraday_Updating_RSI(algorithm, self.Rsi_7_Period)
self.Rsi_8 = Intraday_Updating_RSI(algorithm, self.Rsi_8_Period)
self.Rsi_10 = Intraday_Updating_RSI(algorithm, self.Rsi_10_Period)
self.Rsi_11 = Intraday_Updating_RSI(algorithm, self.Rsi_11_Period)
self.Rsi_12 = Intraday_Updating_RSI(algorithm, self.Rsi_12_Period)
self.Rsi_13 = Intraday_Updating_RSI(algorithm, self.Rsi_13_Period)
self.Rsi_14 = Intraday_Updating_RSI(algorithm, self.Rsi_14_Period)
self.Rsi_15 = Intraday_Updating_RSI(algorithm, self.Rsi_15_Period)
self.Rsi_16 = Intraday_Updating_RSI(algorithm, self.Rsi_16_Period)
self.Rsi_17 = Intraday_Updating_RSI(algorithm, self.Rsi_17_Period)
self.Rsi_18 = Intraday_Updating_RSI(algorithm, self.Rsi_18_Period)
self.Rsi_20 = Intraday_Updating_RSI(algorithm, self.Rsi_20_Period)
self.Rsi_21 = Intraday_Updating_RSI(algorithm, self.Rsi_21_Period)
self.Rsi_28 = Intraday_Updating_RSI(algorithm, self.Rsi_28_Period)
self.Rsi_35 = Intraday_Updating_RSI(algorithm, self.Rsi_35_Period)
self.Rsi_40 = Intraday_Updating_RSI(algorithm, self.Rsi_40_Period)
self.Rsi_42 = Intraday_Updating_RSI(algorithm, self.Rsi_42_Period)
self.Rsi_45 = Intraday_Updating_RSI(algorithm, self.Rsi_45_Period)
self.Rsi_60 = Intraday_Updating_RSI(algorithm, self.Rsi_60_Period)
self.Rsi_70 = Intraday_Updating_RSI(algorithm, self.Rsi_70_Period)
self.Rsi_200 = Intraday_Updating_RSI(algorithm, self.Rsi_200_Period)
self.Return_1 = Intraday_Updating_Cumulative_Return(algorithm, self.Return_1_Period)
self.Return_2 = Intraday_Updating_Cumulative_Return(algorithm, self.Return_2_Period)
self.Return_3 = Intraday_Updating_Cumulative_Return(algorithm, self.Return_3_Period)
self.Return_4 = Intraday_Updating_Cumulative_Return(algorithm, self.Return_4_Period)
self.Return_5 = Intraday_Updating_Cumulative_Return(algorithm, self.Return_5_Period)
self.Return_6 = Intraday_Updating_Cumulative_Return(algorithm, self.Return_6_Period)
self.Return_10 = Intraday_Updating_Cumulative_Return(algorithm, self.Return_10_Period)
self.Return_15 = Intraday_Updating_Cumulative_Return(algorithm, self.Return_15_Period)
self.Return_20 = Intraday_Updating_Cumulative_Return(algorithm, self.Return_20_Period)
self.Return_30 = Intraday_Updating_Cumulative_Return(algorithm, self.Return_30_Period)
self.Return_60 = Intraday_Updating_Cumulative_Return(algorithm, self.Return_60_Period)
self.Return_70 = Intraday_Updating_Cumulative_Return(algorithm, self.Return_70_Period)
self.Return_200 = Intraday_Updating_Cumulative_Return(algorithm, self.Return_200_Period)
self.SMA_2 = Intraday_Updating_SMA(algorithm, self.SMA_2_Period)
self.SMA_5 = Intraday_Updating_SMA(algorithm, self.SMA_5_Period)
self.SMA_12 = Intraday_Updating_SMA(algorithm, self.SMA_12_Period)
self.SMA_15 = Intraday_Updating_SMA(algorithm, self.SMA_15_Period)
self.SMA_20 = Intraday_Updating_SMA(algorithm, self.SMA_20_Period)
self.SMA_21 = Intraday_Updating_SMA(algorithm, self.SMA_21_Period)
self.SMA_23 = Intraday_Updating_SMA(algorithm, self.SMA_23_Period)
self.SMA_25 = Intraday_Updating_SMA(algorithm, self.SMA_25_Period)
self.SMA_30 = Intraday_Updating_SMA(algorithm, self.SMA_30_Period)
self.SMA_31 = Intraday_Updating_SMA(algorithm, self.SMA_31_Period)
self.SMA_50 = Intraday_Updating_SMA(algorithm, self.SMA_50_Period)
self.SMA_150 = Intraday_Updating_SMA(algorithm, self.SMA_150_Period)
self.SMA_200 = Intraday_Updating_SMA(algorithm, self.SMA_200_Period)
self.SMA_210 = Intraday_Updating_SMA(algorithm, self.SMA_210_Period)
self.SMA_100 = Intraday_Updating_SMA(algorithm, self.SMA_100_Period)
self.SMA_1000 = Intraday_Updating_SMA(algorithm, self.SMA_1000_Period)
self.Drawdown_1 = CustomDrawdown(algorithm, symbol, self.Custom_Drawdown_1_Period)
self.Drawdown_2 = CustomDrawdown(algorithm, symbol, self.Custom_Drawdown_2_Period)
self.Drawdown_5 = CustomDrawdown(algorithm, symbol, self.Custom_Drawdown_5_Period)
self.Drawdown_8 = CustomDrawdown(algorithm, symbol, self.Custom_Drawdown_8_Period)
self.Drawdown_10 = CustomDrawdown(algorithm, symbol, self.Custom_Drawdown_10_Period)
self.Drawdown_30 = CustomDrawdown(algorithm, symbol, self.Custom_Drawdown_30_Period)
self.Drawdown_200 = CustomDrawdown(algorithm, symbol, self.Custom_Drawdown_200_Period)
self.Drawdown_252 = CustomDrawdown(algorithm, symbol, self.Custom_Drawdown_252_Period)
self.Return_MA_3 = CustomReturnMA(algorithm, symbol, self.Return_MA_3_Period)
self.Return_MA_5 = CustomReturnMA(algorithm, symbol, self.Return_MA_5_Period)
self.Return_MA_7 = CustomReturnMA(algorithm, symbol, self.Return_MA_7_Period)
self.Return_MA_12 = CustomReturnMA(algorithm, symbol, self.Return_MA_12_Period)
self.Return_MA_20 = CustomReturnMA(algorithm, symbol, self.Return_MA_20_Period)
self.Return_MA_22 = CustomReturnMA(algorithm, symbol, self.Return_MA_22_Period)
self.Return_MA_210 = CustomReturnMA(algorithm, symbol, self.Return_MA_210_Period)
self.Return_MA_360 = CustomReturnMA(algorithm, symbol, self.Return_MA_360_Period)
self.Return_STDEV_5 = CustomReturnStdev(algorithm, symbol, self.STDEV_Return_5_Period)
self.Return_STDEV_10 = CustomReturnStdev(algorithm, symbol, self.STDEV_Return_10_Period)
self.Return_STDEV_14 = CustomReturnStdev(algorithm, symbol, self.STDEV_Return_14_Period)
self.Return_STDEV_15 = CustomReturnStdev(algorithm, symbol, self.STDEV_Return_15_Period)
self.Return_STDEV_21 = CustomReturnStdev(algorithm, symbol, self.STDEV_Return_21_Period)
self.Return_STDEV_28 = CustomReturnStdev(algorithm, symbol, self.STDEV_Return_28_Period)
self.Return_STDEV_35 = CustomReturnStdev(algorithm, symbol, self.STDEV_Return_35_Period)
self.Return_STDEV_42 = CustomReturnStdev(algorithm, symbol, self.STDEV_Return_42_Period)
self.EMA_5 = CustomEMA(algorithm, self.EMA_5_Period)
self.EMA_8 = CustomEMA(algorithm, self.EMA_8_Period)
self.EMA_21 = CustomEMA(algorithm, self.EMA_21_Period)
self.EMA_50 = CustomEMA(algorithm, self.EMA_50_Period)
self.EMA_360 = CustomEMA(algorithm, self.EMA_360_Period)
self.WarmUp = True
self.Daily_Bar_Consolidator = TradeBarConsolidator(timedelta(days=1))
self.algorithm.SubscriptionManager.AddConsolidator(self.symbol, self.Daily_Bar_Consolidator)
self.Daily_Bar_Consolidator.DataConsolidated += self.OnDataConsolidated
history = self.algorithm.History[TradeBar](self.symbol, 1000, Resolution.Daily)
for bar in history:
self.Daily_Bar_Consolidator.Update(bar)
self.WarmUp = False
self.Minute_Bar_Consolidator = TradeBarConsolidator(timedelta(minutes=1))
self.algorithm.SubscriptionManager.AddConsolidator(self.symbol, self.Minute_Bar_Consolidator)
self.Minute_Bar_Consolidator.DataConsolidated += self.OnMinuteConsolidated
self.algorithm.Schedule.On(self.algorithm.DateRules.EveryDay(), self.algorithm.TimeRules.AfterMarketOpen(self.symbol, -10), self.Reset_HL)
def Reset_HL(self):
self.Daily_Open = None
self.Daily_High = None
self.Daily_Low = None
def OnMinuteConsolidated(self, sender, bar):
if self.Daily_Open is None:
self.Daily_Open = bar.Open
if self.Daily_High is None:
self.Daily_High = bar.High
if self.Daily_Low is None:
self.Daily_Low = bar.Low
if self.Daily_High is not None and bar.High > self.Daily_High:
self.Daily_High = bar.High
if self.Daily_Low is not None and bar.Low < self.Daily_Low:
self.Daily_Low = bar.Low
def OnDataConsolidated(self, sender, bar):
self.Rsi_2.Receive_Main_Bar(bar)
self.Rsi_5.Receive_Main_Bar(bar)
self.Rsi_7.Receive_Main_Bar(bar)
self.Rsi_8.Receive_Main_Bar(bar)
self.Rsi_10.Receive_Main_Bar(bar)
self.Rsi_11.Receive_Main_Bar(bar)
self.Rsi_12.Receive_Main_Bar(bar)
self.Rsi_13.Receive_Main_Bar(bar)
self.Rsi_14.Receive_Main_Bar(bar)
self.Rsi_15.Receive_Main_Bar(bar)
self.Rsi_16.Receive_Main_Bar(bar)
self.Rsi_17.Receive_Main_Bar(bar)
self.Rsi_18.Receive_Main_Bar(bar)
self.Rsi_20.Receive_Main_Bar(bar)
self.Rsi_21.Receive_Main_Bar(bar)
self.Rsi_28.Receive_Main_Bar(bar)
self.Rsi_35.Receive_Main_Bar(bar)
self.Rsi_40.Receive_Main_Bar(bar)
self.Rsi_42.Receive_Main_Bar(bar)
self.Rsi_45.Receive_Main_Bar(bar)
self.Rsi_60.Receive_Main_Bar(bar)
self.Rsi_70.Receive_Main_Bar(bar)
self.Rsi_200.Receive_Main_Bar(bar)
self.Return_1.Receive_Main_Bar(bar)
self.Return_2.Receive_Main_Bar(bar)
self.Return_3.Receive_Main_Bar(bar)
self.Return_4.Receive_Main_Bar(bar)
self.Return_5.Receive_Main_Bar(bar)
self.Return_6.Receive_Main_Bar(bar)
self.Return_10.Receive_Main_Bar(bar)
self.Return_15.Receive_Main_Bar(bar)
self.Return_20.Receive_Main_Bar(bar)
self.Return_30.Receive_Main_Bar(bar)
self.Return_60.Receive_Main_Bar(bar)
self.Return_70.Receive_Main_Bar(bar)
self.Return_200.Receive_Main_Bar(bar)
self.SMA_2.Receive_Main_Bar(bar)
self.SMA_5.Receive_Main_Bar(bar)
self.SMA_12.Receive_Main_Bar(bar)
self.SMA_15.Receive_Main_Bar(bar)
self.SMA_20.Receive_Main_Bar(bar)
self.SMA_21.Receive_Main_Bar(bar)
self.SMA_23.Receive_Main_Bar(bar)
self.SMA_25.Receive_Main_Bar(bar)
self.SMA_30.Receive_Main_Bar(bar)
self.SMA_31.Receive_Main_Bar(bar)
self.SMA_50.Receive_Main_Bar(bar)
self.SMA_150.Receive_Main_Bar(bar)
self.SMA_200.Receive_Main_Bar(bar)
self.SMA_210.Receive_Main_Bar(bar)
self.SMA_100.Receive_Main_Bar(bar)
self.SMA_1000.Receive_Main_Bar(bar)
self.Drawdown_1.Receive_Main_Bar(bar)
self.Drawdown_2.Receive_Main_Bar(bar)
self.Drawdown_5.Receive_Main_Bar(bar)
self.Drawdown_8.Receive_Main_Bar(bar)
self.Drawdown_10.Receive_Main_Bar(bar)
self.Drawdown_30.Receive_Main_Bar(bar)
self.Drawdown_200.Receive_Main_Bar(bar)
self.Drawdown_252.Receive_Main_Bar(bar)
self.Return_MA_3.Receive_Main_Bar(bar)
self.Return_MA_5.Receive_Main_Bar(bar)
self.Return_MA_7.Receive_Main_Bar(bar)
self.Return_MA_12.Receive_Main_Bar(bar)
self.Return_MA_20.Receive_Main_Bar(bar)
self.Return_MA_22.Receive_Main_Bar(bar)
self.Return_MA_210.Receive_Main_Bar(bar)
self.Return_MA_360.Receive_Main_Bar(bar)
self.Return_STDEV_5.Receive_Main_Bar(bar)
self.Return_STDEV_10.Receive_Main_Bar(bar)
self.Return_STDEV_14.Receive_Main_Bar(bar)
self.Return_STDEV_15.Receive_Main_Bar(bar)
self.Return_STDEV_21.Receive_Main_Bar(bar)
self.Return_STDEV_28.Receive_Main_Bar(bar)
self.Return_STDEV_35.Receive_Main_Bar(bar)
self.Return_STDEV_42.Receive_Main_Bar(bar)
self.EMA_5.Receive_Main_Bar(bar)
self.EMA_8.Receive_Main_Bar(bar)
self.EMA_21.Receive_Main_Bar(bar)
self.EMA_50.Receive_Main_Bar(bar)
self.EMA_360.Receive_Main_Bar(bar)
self.Rsi_2.Updated_Today = True
self.Rsi_5.Updated_Today = True
self.Rsi_7.Updated_Today = True
self.Rsi_8.Updated_Today = True
self.Rsi_10.Updated_Today = True
self.Rsi_11.Updated_Today = True
self.Rsi_12.Updated_Today = True
self.Rsi_13.Updated_Today = True
self.Rsi_14.Updated_Today = True
self.Rsi_15.Updated_Today = True
self.Rsi_16.Updated_Today = True
self.Rsi_17.Updated_Today = True
self.Rsi_18.Updated_Today = True
self.Rsi_20.Updated_Today = True
self.Rsi_21.Updated_Today = True
self.Rsi_28.Updated_Today = True
self.Rsi_35.Updated_Today = True
self.Rsi_40.Updated_Today = True
self.Rsi_42.Updated_Today = True
self.Rsi_45.Updated_Today = True
self.Rsi_60.Updated_Today = True
self.Rsi_70.Updated_Today = True
self.Rsi_200.Updated_Today = True
self.Return_1.Updated_Today = True
self.Return_2.Updated_Today = True
self.Return_3.Updated_Today = True
self.Return_4.Updated_Today = True
self.Return_5.Updated_Today = True
self.Return_6.Updated_Today = True
self.Return_10.Updated_Today = True
self.Return_15.Updated_Today = True
self.Return_20.Updated_Today = True
self.Return_30.Updated_Today = True
self.Return_60.Updated_Today = True
self.Return_70.Updated_Today = True
self.Return_200.Updated_Today = True
self.SMA_2.Updated_Today = True
self.SMA_5.Updated_Today = True
self.SMA_12.Updated_Today = True
self.SMA_15.Updated_Today = True
self.SMA_20.Updated_Today = True
self.SMA_21.Updated_Today = True
self.SMA_23.Updated_Today = True
self.SMA_25.Updated_Today = True
self.SMA_30.Updated_Today = True
self.SMA_31.Updated_Today = True
self.SMA_50.Updated_Today = True
self.SMA_150.Updated_Today = True
self.SMA_200.Updated_Today = True
self.SMA_210.Updated_Today = True
self.SMA_100.Updated_Today = True
self.SMA_1000.Updated_Today = True
self.Drawdown_1.Updated_Today = True
self.Drawdown_2.Updated_Today = True
self.Drawdown_5.Updated_Today = True
self.Drawdown_8.Updated_Today = True
self.Drawdown_10.Updated_Today = True
self.Drawdown_30.Updated_Today = True
self.Drawdown_200.Updated_Today = True
self.Drawdown_252.Updated_Today = True
self.Return_MA_3.Updated_Today = True
self.Return_MA_5.Updated_Today = True
self.Return_MA_7.Updated_Today = True
self.Return_MA_12.Updated_Today = True
self.Return_MA_20.Updated_Today = True
self.Return_MA_22.Updated_Today = True
self.Return_MA_210.Updated_Today = True
self.Return_MA_360.Updated_Today = True
self.Return_STDEV_5.Updated_Today = True
self.Return_STDEV_10.Updated_Today = True
self.Return_STDEV_14.Updated_Today = True
self.Return_STDEV_15.Updated_Today = True
self.Return_STDEV_21.Updated_Today = True
self.Return_STDEV_28.Updated_Today = True
self.Return_STDEV_35.Updated_Today = True
self.Return_STDEV_42.Updated_Today = True
self.EMA_5.Updated_Today = True
self.EMA_8.Updated_Today = True
self.EMA_21.Updated_Today = True
self.EMA_50.Updated_Today = True
self.EMA_360.Updated_Today = True
def Update_With_Intraday_Bar(self, price):
if not self.WarmUp:
if self.Rsi_2.Updated_Today:
self.Rsi_2.Receive_Sub_Bar(price)
if self.Rsi_5.Updated_Today:
self.Rsi_5.Receive_Sub_Bar(price)
if self.Rsi_7.Updated_Today:
self.Rsi_7.Receive_Sub_Bar(price)
if self.Rsi_8.Updated_Today:
self.Rsi_8.Receive_Sub_Bar(price)
if self.Rsi_10.Updated_Today:
self.Rsi_10.Receive_Sub_Bar(price)
if self.Rsi_11.Updated_Today:
self.Rsi_11.Receive_Sub_Bar(price)
if self.Rsi_12.Updated_Today:
self.Rsi_12.Receive_Sub_Bar(price)
if self.Rsi_13.Updated_Today:
self.Rsi_13.Receive_Sub_Bar(price)
if self.Rsi_14.Updated_Today:
self.Rsi_14.Receive_Sub_Bar(price)
if self.Rsi_15.Updated_Today:
self.Rsi_15.Receive_Sub_Bar(price)
if self.Rsi_16.Updated_Today:
self.Rsi_16.Receive_Sub_Bar(price)
if self.Rsi_17.Updated_Today:
self.Rsi_17.Receive_Sub_Bar(price)
if self.Rsi_18.Updated_Today:
self.Rsi_18.Receive_Sub_Bar(price)
if self.Rsi_20.Updated_Today:
self.Rsi_20.Receive_Sub_Bar(price)
if self.Rsi_21.Updated_Today:
self.Rsi_21.Receive_Sub_Bar(price)
if self.Rsi_28.Updated_Today:
self.Rsi_28.Receive_Sub_Bar(price)
if self.Rsi_35.Updated_Today:
self.Rsi_35.Receive_Sub_Bar(price)
if self.Rsi_40.Updated_Today:
self.Rsi_40.Receive_Sub_Bar(price)
if self.Rsi_42.Updated_Today:
self.Rsi_42.Receive_Sub_Bar(price)
if self.Rsi_45.Updated_Today:
self.Rsi_45.Receive_Sub_Bar(price)
if self.Rsi_60.Updated_Today:
self.Rsi_60.Receive_Sub_Bar(price)
if self.Rsi_70.Updated_Today:
self.Rsi_70.Receive_Sub_Bar(price)
if self.Rsi_200.Updated_Today:
self.Rsi_200.Receive_Sub_Bar(price)
if self.Return_1.Updated_Today:
self.Return_1.Receive_Sub_Bar(price)
if self.Return_2.Updated_Today:
self.Return_2.Receive_Sub_Bar(price)
if self.Return_3.Updated_Today:
self.Return_3.Receive_Sub_Bar(price)
if self.Return_4.Updated_Today:
self.Return_4.Receive_Sub_Bar(price)
if self.Return_5.Updated_Today:
self.Return_5.Receive_Sub_Bar(price)
if self.Return_6.Updated_Today:
self.Return_6.Receive_Sub_Bar(price)
if self.Return_10.Updated_Today:
self.Return_10.Receive_Sub_Bar(price)
if self.Return_15.Updated_Today:
self.Return_15.Receive_Sub_Bar(price)
if self.Return_20.Updated_Today:
self.Return_20.Receive_Sub_Bar(price)
if self.Return_30.Updated_Today:
self.Return_30.Receive_Sub_Bar(price)
if self.Return_60.Updated_Today:
self.Return_60.Receive_Sub_Bar(price)
if self.Return_70.Updated_Today:
self.Return_70.Receive_Sub_Bar(price)
if self.Return_200.Updated_Today:
self.Return_200.Receive_Sub_Bar(price)
if self.SMA_2.Updated_Today:
self.SMA_2.Receive_Sub_Bar(price)
if self.SMA_5.Updated_Today:
self.SMA_5.Receive_Sub_Bar(price)
if self.SMA_12.Updated_Today:
self.SMA_12.Receive_Sub_Bar(price)
if self.SMA_15.Updated_Today:
self.SMA_15.Receive_Sub_Bar(price)
if self.SMA_20.Updated_Today:
self.SMA_20.Receive_Sub_Bar(price)
if self.SMA_21.Updated_Today:
self.SMA_21.Receive_Sub_Bar(price)
if self.SMA_23.Updated_Today:
self.SMA_23.Receive_Sub_Bar(price)
if self.SMA_25.Updated_Today:
self.SMA_25.Receive_Sub_Bar(price)
if self.SMA_30.Updated_Today:
self.SMA_30.Receive_Sub_Bar(price)
if self.SMA_31.Updated_Today:
self.SMA_31.Receive_Sub_Bar(price)
if self.SMA_50.Updated_Today:
self.SMA_50.Receive_Sub_Bar(price)
if self.SMA_150.Updated_Today:
self.SMA_150.Receive_Sub_Bar(price)
if self.SMA_200.Updated_Today:
self.SMA_200.Receive_Sub_Bar(price)
if self.SMA_210.Updated_Today:
self.SMA_210.Receive_Sub_Bar(price)
if self.SMA_100.Updated_Today:
self.SMA_100.Receive_Sub_Bar(price)
if self.SMA_1000.Updated_Today:
self.SMA_1000.Receive_Sub_Bar(price)
if self.Drawdown_1.Updated_Today:
self.Drawdown_1.Receive_Sub_Bar(price)
if self.Drawdown_2.Updated_Today:
self.Drawdown_2.Receive_Sub_Bar(price)
if self.Drawdown_5.Updated_Today:
self.Drawdown_5.Receive_Sub_Bar(price)
if self.Drawdown_8.Updated_Today:
self.Drawdown_8.Receive_Sub_Bar(price)
if self.Drawdown_10.Updated_Today:
self.Drawdown_10.Receive_Sub_Bar(price)
if self.Drawdown_30.Updated_Today:
self.Drawdown_30.Receive_Sub_Bar(price)
if self.Drawdown_200.Updated_Today:
self.Drawdown_200.Receive_Sub_Bar(price)
if self.Drawdown_252.Updated_Today:
self.Drawdown_252.Receive_Sub_Bar(price)
if self.Return_MA_3.Updated_Today:
self.Return_MA_3.Receive_Sub_Bar(self.Daily_Open, price)
if self.Return_MA_5.Updated_Today:
self.Return_MA_5.Receive_Sub_Bar(self.Daily_Open, price)
if self.Return_MA_7.Updated_Today:
self.Return_MA_7.Receive_Sub_Bar(self.Daily_Open, price)
if self.Return_MA_12.Updated_Today:
self.Return_MA_12.Receive_Sub_Bar(self.Daily_Open, price)
if self.Return_MA_20.Updated_Today:
self.Return_MA_20.Receive_Sub_Bar(self.Daily_Open, price)
if self.Return_MA_22.Updated_Today:
self.Return_MA_22.Receive_Sub_Bar(self.Daily_Open, price)
if self.Return_MA_210.Updated_Today:
self.Return_MA_210.Receive_Sub_Bar(self.Daily_Open, price)
if self.Return_MA_360.Updated_Today:
self.Return_MA_360.Receive_Sub_Bar(self.Daily_Open, price)
if self.Return_STDEV_5.Updated_Today:
self.Return_STDEV_5.Receive_Sub_Bar(self.Daily_Open, price)
if self.Return_STDEV_10.Updated_Today:
self.Return_STDEV_10.Receive_Sub_Bar(self.Daily_Open, price)
if self.Return_STDEV_14.Updated_Today:
self.Return_STDEV_14.Receive_Sub_Bar(self.Daily_Open, price)
if self.Return_STDEV_15.Updated_Today:
self.Return_STDEV_15.Receive_Sub_Bar(self.Daily_Open, price)
if self.Return_STDEV_21.Updated_Today:
self.Return_STDEV_21.Receive_Sub_Bar(self.Daily_Open, price)
if self.Return_STDEV_28.Updated_Today:
self.Return_STDEV_28.Receive_Sub_Bar(self.Daily_Open, price)
if self.Return_STDEV_35.Updated_Today:
self.Return_STDEV_35.Receive_Sub_Bar(self.Daily_Open, price)
if self.Return_STDEV_42.Updated_Today:
self.Return_STDEV_42.Receive_Sub_Bar(self.Daily_Open, price)
if self.EMA_5.Updated_Today:
self.EMA_5.Receive_Sub_Bar(price)
if self.EMA_8.Updated_Today:
self.EMA_8.Receive_Sub_Bar(price)
if self.EMA_21.Updated_Today:
self.EMA_21.Receive_Sub_Bar(price)
if self.EMA_50.Updated_Today:
self.EMA_50.Receive_Sub_Bar(price)
if self.EMA_360.Updated_Today:
self.EMA_360.Receive_Sub_Bar(price)
def Reset(self):
self.Rsi_2.Updated_Today = False
self.Rsi_5.Updated_Today = False
self.Rsi_7.Updated_Today = False
self.Rsi_8.Updated_Today = False
self.Rsi_10.Updated_Today = False
self.Rsi_11.Updated_Today = False
self.Rsi_12.Updated_Today = False
self.Rsi_13.Updated_Today = False
self.Rsi_14.Updated_Today = False
self.Rsi_15.Updated_Today = False
self.Rsi_16.Updated_Today = False
self.Rsi_17.Updated_Today = False
self.Rsi_18.Updated_Today = False
self.Rsi_20.Updated_Today = False
self.Rsi_21.Updated_Today = False
self.Rsi_28.Updated_Today = False
self.Rsi_35.Updated_Today = False
self.Rsi_40.Updated_Today = False
self.Rsi_42.Updated_Today = False
self.Rsi_45.Updated_Today = False
self.Rsi_60.Updated_Today = False
self.Rsi_70.Updated_Today = False
self.Rsi_200.Updated_Today = False
self.Return_1.Updated_Today = False
self.Return_2.Updated_Today = False
self.Return_3.Updated_Today = False
self.Return_4.Updated_Today = False
self.Return_5.Updated_Today = False
self.Return_6.Updated_Today = False
self.Return_10.Updated_Today = False
self.Return_15.Updated_Today = False
self.Return_20.Updated_Today = False
self.Return_30.Updated_Today = False
self.Return_60.Updated_Today = False
self.Return_70.Updated_Today = False
self.Return_200.Updated_Today = False
self.SMA_2.Updated_Today = False
self.SMA_5.Updated_Today = False
self.SMA_12.Updated_Today = False
self.SMA_15.Updated_Today = False
self.SMA_20.Updated_Today = False
self.SMA_21.Updated_Today = False
self.SMA_23.Updated_Today = False
self.SMA_25.Updated_Today = False
self.SMA_30.Updated_Today = False
self.SMA_31.Updated_Today = False
self.SMA_50.Updated_Today = False
self.SMA_150.Updated_Today = False
self.SMA_200.Updated_Today = False
self.SMA_210.Updated_Today = False
self.SMA_100.Updated_Today = False
self.SMA_1000.Updated_Today = False
self.Drawdown_1.Updated_Today = False
self.Drawdown_2.Updated_Today = False
self.Drawdown_5.Updated_Today = False
self.Drawdown_8.Updated_Today = False
self.Drawdown_10.Updated_Today = False
self.Drawdown_30.Updated_Today = False
self.Drawdown_200.Updated_Today = False
self.Drawdown_252.Updated_Today = False
self.Return_MA_3.Updated_Today = False
self.Return_MA_5.Updated_Today = False
self.Return_MA_7.Updated_Today = False
self.Return_MA_12.Updated_Today = False
self.Return_MA_20.Updated_Today = False
self.Return_MA_22.Updated_Today = False
self.Return_MA_210.Updated_Today = False
self.Return_MA_360.Updated_Today = False
self.Return_STDEV_5.Updated_Today = False
self.Return_STDEV_10.Updated_Today = False
self.Return_STDEV_14.Updated_Today = False
self.Return_STDEV_15.Updated_Today = False
self.Return_STDEV_21.Updated_Today = False
self.Return_STDEV_28.Updated_Today = False
self.Return_STDEV_35.Updated_Today = False
self.Return_STDEV_42.Updated_Today = False
self.EMA_5.Updated_Today = False
self.EMA_8.Updated_Today = False
self.EMA_21.Updated_Today = False
self.EMA_50.Updated_Today = False
self.EMA_360.Updated_Today = False