| Overall Statistics |
|
Total Orders 807 Average Win 0.87% Average Loss -0.28% Compounding Annual Return 85.548% Drawdown 20.900% Expectancy 1.950 Start Equity 10000 End Equity 79427.72 Net Profit 694.277% Sharpe Ratio 2.637 Sortino Ratio 3.257 Probabilistic Sharpe Ratio 99.844% Loss Rate 28% Win Rate 72% Profit-Loss Ratio 3.12 Alpha 0.486 Beta 0.806 Annual Standard Deviation 0.203 Annual Variance 0.041 Information Ratio 2.776 Tracking Error 0.171 Treynor Ratio 0.666 Total Fees $1021.71 Estimated Strategy Capacity $3100000.00 Lowest Capacity Asset QLD TJNNZWL5I4IT Portfolio Turnover 13.85% |
from AlgorithmImports import *
from collections import deque
from custom_ema import CustomEMA
class CustomMACD():
def __init__(self, algorithm, short_period, long_period, signal_period):
self.algorithm = algorithm
self.short_period = short_period
self.long_period = long_period
self.signal_period = signal_period
self.short_ema = CustomEMA(algorithm, short_period)
self.long_ema = CustomEMA(algorithm, long_period)
self.signal_ema = CustomEMA(algorithm, signal_period)
def Receive_Main_Bar(self, bar):
self.short_ema.Receive_Main_Bar(bar)
self.long_ema.Receive_Main_Bar(bar)
if self.short_ema.Current_Value is not None and self.long_ema.Current_Value is not None:
macd = self.short_ema.Current_Value - self.long_ema.Current_Value
self.signal_ema.Receive_Main_Bar(TradeBar(bar.EndTime, bar.Symbol, 0, 0, 0, macd, 0))
def Receive_Sub_Bar(self, bar):
self.short_ema.Receive_Sub_Bar(bar)
self.long_ema.Receive_Sub_Bar(bar)
if self.short_ema.Current_Value is not None and self.long_ema.Current_Value is not None:
macd = self.short_ema.Current_Value - self.long_ema.Current_Value
self.signal_ema.Receive_Sub_Bar(TradeBar(bar.EndTime, bar.Symbol, 0, 0, 0, macd, 0))
@property
def Current_Value(self):
if self.short_ema.Current_Value is not None and self.long_ema.Current_Value is not None and self.signal_ema.Current_Value is not None:
return self.short_ema.Current_Value - self.long_ema.Current_Value, self.signal_ema.Current_Value
else:
return None"""
**
* 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) # Set Backtest Start Date
self.SetEndDate(config.BACKTEST_END_YEAR, config.BACKTEST_END_MONTH, config.BACKTEST_END_DAY) # Set Backtest End Date
self.SetCash(config.BACKTEST_ACCOUNT_CASH) # Set Backtest Strategy Cash
self.Rebalance_Threshold = config.REBALANCE_THRESHOLD/100
self.UniverseSettings.Leverage = 4
self.TECL = None
self.SOXL = None
self.FAS = None
self.TQQQ = None
self.UPRO = None
self.TMF = None
self.USDO = None
self.SQQQ = None
self.TBF = None
self.BIL = None
self.PHDG = None
self.TMV = None
self.UDOW = None
self.MOAT = None
self.BRKB = None
self.USMV = None
self.SPY = None
self.QQQ = None
self.SPXL = None
self.DBC = None
self.DBA = None
self.ICSH = None
self.TYD = None
self.URTY = None
self.XLU = None
self.NUGT = None
self.TYO = None
self.VIXM = None
self.IEF = None
self.SOXS = None
self.BND = None
self.VTI = None
self.SHY = None
self.USDU = None
self.TLT = None
self.PSQ = None
self.VIXY = None
self.BSV = None
self.SPHB = None
self.USD = None
self.SPXU = None
self.EWZ = None
self.MVV = None
self.UCO = None
self.UUP = None
self.QLD = None
self.GLD = None
self.YCS = None
self.TECS = None
self.SPXS = None
self.ERX = None
self.EPI = None
self.TNA = None
self.EUO = None
self.AGG = None
self.PUI = None
self.ERX = None
self.UVXY = None
self.EFA = None
self.EEM = None
self.Sub_4_List = []
self.Symbol_List = []
self.ETFs = config.ETFS
self.Trade_Decision_Time = config.TRADE_DECISION_TIME
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):
self.OG_v1_2_Risk_On_Off_Hedgefund(0.6)
Hedged_Leveraged_Bonds_Stocks_V2(self,0.4)
self.Proposal_BetaBaller_TCCC(0.2)
def Proposal_BetaBaller_TCCC(self, outer_allocation):
if self.BIL.Rsi_42.Current_Value < self.IEF.Rsi_70.Current_Value: # Ganesh Change IEF RSI from 42 to 70
if self.SPY.Rsi_7.Current_Value > 75:
self.OverBought_S_P_Sell_Rip(0.2)
else:
if self.Securities["SOXL"].Price > self.SOXL.SMA_2.Current_Value:
if self.SOXL.Return_MA_12.Current_Value >= self.UPRO.Return_MA_12.Current_Value:
self.SOXL.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
else:
self.UPRO.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
else:
if self.SOXS.Return_MA_12.Current_Value >= self.PSQ.Return_MA_12.Current_Value:
self.SOXS.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
else:
self.PSQ.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
else:
if self.SPY.Rsi_6.Current_Value < 27:
self.Extremely_Oversold_S_P(0.2)
else:
self.VO_TCCC_Stop_The_Bleed(0.2)
def OverBought_S_P_Sell_Rip(self, outer_allocation):
if self.UVXY.Rsi_12.Current_Value <= self.VIXY.Rsi_12.Current.Value:
self.UVXY.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
else:
self.VIXY.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
def Extremely_Oversold_S_P(self, outer_allocation):
if self.BSV.Rsi_8.Current_Value < self.SPHB.Rsi_8.Current_Value:
if self.SOXS.Rsi_7.Current_Value <= self.SQQQ.Rsi_7.Current_Value:
self.SOXS.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
else:
self.SQQQ.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
else:
symbols = [ self.SOXL,
self.SPXL,
self.TECL,
self.TMF,
self.UPRO,
self.USD,
self.TQQQ
]
Create_RSI_List(self, symbols, "Rsi_18", False, 1, 1, 1) # Ganesh change RSI_7 to RSI_18
def VO_TCCC_Stop_The_Bleed(self, outer_allocation):
if self.SPY.Rsi_10.Current_Value < 30:
self.Five_And_Below_LETFS(0.2)
else:
if self.UVXY.Rsi_10.Current_Value > 74:
if self.UVXY.Rsi_10.Current_Value > 84:
self.Bear_Stock_Market(0.2)
else:
self.UVXY.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
else:
self.Bear_Stock_Market_2(0.2)
def Five_And_Below_LETFS(self, outer_allocation):
symbols = [ self.SOXL,
self.TECL,
self.TMF,
self.UPRO
]
Create_RSI_List(self, symbols, "Rsi_17", False, 1, 1, 1)
def Bear_Stock_Market(self, outer_allocation):
if self.Securities["TLT"].Price > self.TLT.SMA_200.Current_Value:
self.AB_Medium_Term_TLT_OverBought(0.2)
else:
self.B_Long_Term_TLT_Down(0.2)
def AB_Medium_Term_TLT_OverBought(self, outer_allocation):
if self.TLT.Return_MA_20.Current_Value < 0:
self.ABBA_Risk_Off_Rising_Rates(0.2)
else:
self.ABBB_Risk_Off_Falling_Rates(0.2)
def ABBA_Risk_Off_Rising_Rates(self, outer_allocation):
if self.SPY.EMA_210.Current_Value <= self.SPY.SMA_360.Current_Value:
if self.TQQQ.Rsi_10.Current_Value < 30:
symbols = [ self.SOXL,
self.TECL,
self.TQQQ,
self.UPRO
]
Create_Return_MA_List(self, symbols, "Return_MA_5", False, 1, 1, 1)
else:
if self.SPXU.Return_6.Current_Value >= self.UPRO.Return_3.Current_Value:
symbols = [ self.SQQQ,
self.EUO,
self.YCS,
]
Create_Return_List(self, symbols, "Return_5", True, 1, 1, 1)
else:
symbols = [ self.SOXL,
self.TECL,
self.TQQQ,
self.CURE # Ganesh CURE missing in ETF list
]
Create_Return_MA_List(self, symbols, "Return_MA_5", False, 1, 1, 1)
else:
if self.TQQQ.Rsi_11 > 77:
self.UVXY.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
else:
symbols = [ self.SOXL,
self.TECL,
self.TQQQ,
self.UPRO,
self.TMV
]
Create_Return_MA_List(self, symbols, "Return_MA_5", False, 1, 1, 1)
def ABBB_Risk_Off_Falling_Rates(self, outer_allocation):
if self.SPY.EMA_210.Current_Value <= self.SPY.SMA_360.Current_Value:
if self.TQQQ.Rsi_10.Current_Value < 30:
symbols = [ self.SOXL,
self.TECL,
self.TQQQ
]
Create_Return_MA_List(self, symbols, "Return_MA_5", False, 1, 1, 1)
else:
if self.SPY.Return_2.Current_Value < -0.02:
symbols = [ self.SQQQ,
self.TECS,
self.SOXS
]
Create_Return_List(self, symbols, "Return_5", True, 1, 1, 1)
else:
if self.SPXU.Return_6.Current_Value >= self.UPRO.Return_3.Current_Value:
symbols = [ self.ERX,
self.EUO,
self.YCS
]
Create_Return_List(self, symbols, "Return_5", True, 1, 1, 1)
else:
symbols = [ self.SOXL,
self.EWZ,
self.MVV,
self.USD
]
Create_Return_MA_List(self, symbols, "Return_MA_5", False, 1, 1, 1)
else:
if self.SPY.Return_MA_210.Current_Value > self.DBC.Return_MA_360.Current_Value:
if self.TQQQ.Rsi_11.Current_Value > 77:
self.UVXY.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
else:
if self.TQQQ.Return_6.Current_Value < -0.1:
if self.TQQQ.Return_1.Current_Value > 0.055:
self.UVXY.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
else:
if self.BIL.Rsi_7.Current_Value < self.IEF.Rsi_7.Current_Value:
self.SOXL.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
else:
symbols = [ self.EWZ,
self.UUP,
self.TMF,
self.UCO
]
Create_Return_List(self, symbols, "Return_5", True, 1, 1, outer_allocation)
else:
if self.BIL.Rsi_7.Current_Value < self.IEF.Rsi_7.Current_Value:
symbols = [ self.TECL,
self.TQQQ,
self.SPXL,
self.QLD,
self.USD
]
Create_Return_MA_List(self, symbols, "Return_MA_5", False, 1, 1, outer_allocation)
else:
symbols = [ self.EWZ,
self.UUP,
self.TMF
]
Create_Return_List(self, symbols, "Return_5", True, 1, 1, outer_allocation)
else:
self.Defense_Modified(0.2)
def Defense_Modified(self, outer_allocation):
if self.DBC.Return_STDEV_20.Current_Value > self.SPY.Return_STDEV_20.Current_Value: # Ganesh Added self.SPY
symbols = [ self.SHY,
self.EWZ,
self.GLD,
self.SPXS,
self.TECS,
self.SOXS,
self.UCO,
self.YCS
]
Create_RSI_List(self, symbols, "Rsi_5", False, 1, 1, outer_allocation)
else:
if self.BIL.Rsi_7.Current_Value < self.IEF.Rsi_7.Current_Value:
symbols = [ self.SOXL,
self.TMF,
self.USD
]
Create_Return_MA_List(self, symbols, "Return_MA_5", False, 1, 1, outer_allocation)
else:
symbols = [ self.EWZ,
self.SPXS,
self.SOXS,
self.UCO,
self.YCS
]
Create_Return_List(self, symbols, "Return_5", True, 1, 1, outer_allocation)
def B_Long_Term_TLT_Down(self, outer_allocation):
if self.TLT.Return_MA_20.Current_Value < 0:
self.BAA_Risk_Off_Rising_Rates_Left(0.2)
else:
self.BAB_Risk_Off_Falling_Rates_Left(0.2)
def BAA_Risk_Off_Rising_Rates_Left(self, outer_allocation):
#if self.SPY.Return_MA_210.Current_Value < self.DBC.Return_MA_360.Current_Value: # Ganesh this is wrong
if self.SPY.EMA_210.Current_Value <= self.SPY.SMA_360.Current_Value: # Ganesh updated new if condition
if self.TQQQ.Rsi_10.Current_Value < 30:
symbols = [ self.TQQQ,
self.SOXL,
self.UPRO
]
Create_Return_MA_List(self, symbols, "Return_MA_5", True, 1, 1, outer_allocation)
else:
if self.UUP.Return_2.Current_Value > 0.01:
symbols = [ self.TECS,
self.SPXS,
self.SOXS,
self.SQQQ,
self.ERX
]
Create_Return_List(self, symbols, "Return_5", False, 1, 1, outer_allocation)
else:
if self.SPXU.Return_5.Current_Value > self.UPRO.Return_4.Current_Value:
symbols = [ self.SQQQ,
self.EPI,
self.SOXS
]
Create_Return_List(self, symbols, "Return_5", True, 1, 1, outer_allocation)
else:
if self.BIL.Return_3.Current_Value > self.TMV.Return_3.Current_Value:
symbols = [ self.TECL,
self.SOXL,
self.TNA,
self.UPRO
]
Create_Return_MA_List(self, symbols, "Return_MA_5", False, 1, 1, outer_allocation)
else:
symbols = [ self.TECL, # Ganesh changed return_ma_list to symbols
self.SOXL,
self.TMV
]
Create_Return_MA_List(self, symbols, "Return_MA_5", False, 1, 1, outer_allocation)
else:
if self.SPY.Return_MA_210.Current_Value > self.DBC.Return_MA_360.Current_Value:
if self.TQQQ.Rsi_11.Current_Value > 77:
self.UVXY.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
else:
if self.TQQQ.Return_6.Current_Value < -0.1:
if self.TQQQ.Return_1.Current_Value > 0.055:
self.UVXY.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
else:
if self.SOXL.Return_MA_5.Current_Value <= self.TMV.Return_MA_5.Current_Value:
self.SOXL.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
else:
self.TMV.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
else:
if self.BIL.Rsi_7.Current_Value < self.IEF.Rsi_7.Current_Value:
symbols = [ self.TECL,
self.SOXL,
self.TMV,
self.TQQQ,
self.UPRO
]
Create_Return_MA_List(self, symbols, "Return_MA_5", True, 1, 1, outer_allocation)
else:
if self.SOXL.Return_MA_22.Current_Value < self.UPRO.Return_MA_22.Current_Value:
self.SOXL.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
else:
self.UPRO.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
else:
self.Defense_Modified_2(0.2)
def Defense_Modified_2(self, outer_allocation):
if self.DBC.Return_STDEV_20.Current_Value > self.SPY.Return_STDEV_20.Current_Value:
if self.DBC.Return_STDEV_10.Current_Value > 0.03:
if self.TMV.Return_STDEV_5.Current_Value <= self.DBC.Return_STDEV_5.Current_Value:
self.TMV.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
else:
self.DBC.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
else:
if self.BIL.Rsi_7.Current_Value < self.IEF.Rsi_7.Current_Value:
symbols = [ self.SPXU,
self.SOXS,
self.TMV
]
Create_Return_MA_List(self, symbols, "Return_MA_5", True, 1, 1, outer_allocation)
else:
symbols = [ self.EFA,
self.EEM,
self.SPXS,
self.SOXS,
self.UCO,
self.TMV
]
Create_Return_List(self, symbols, "Return_5", False, 1, 1, outer_allocation)
else:
if self.BIL.Rsi_7.Current_Value < self.IEF.Rsi_7.Current_Value:
symbols = [ self.SOXL,
self.EPI,
self.UPRO
]
Create_Return_MA_List(self, symbols, "Return_MA_5", False, 1, 1, outer_allocation)
else:
symbols = [ self.EWZ,
self.TECS,
self.EUO,
self.SOXS,
self.YCS,
self.TMV
]
Create_Return_List(self, symbols, "Return_5", True, 1, 1, outer_allocation)
def BAB_Risk_Off_Falling_Rates_Left(self, outer_allocation):
if self.SPY.EMA_210.Current_Value <= self.SPY.SMA_360.Current_Value:
if self.SPY.Return_2.Current_Value < -0.02:
symbols = [ self.SPXS,
self.TECS,
self.SQQQ,
self.SOXS
]
Create_Return_List(self, symbols, "Return_5", True, 1, 1, outer_allocation)
else:
if self.SPXU.Return_6.Current_Value >= self.UPRO.Return_3.Current_Value:
symbols = [ self.BIL,
self.AGG,
self.TMF
]
Create_Return_List(self, symbols, "Return_5", False, 1, 1, outer_allocation)
else:
symbols = [ self.TECL,
self.SOXL,
self.TMF,
self.TQQQ,
self.EWZ
]
Create_Return_MA_List(self, symbols, "Return_MA_5", False, 1, 1, outer_allocation)
else:
if self.SPY.Return_MA_210.Current_Value > self.DBC.Return_MA_360.Current_Value:
if self.SPY.EMA_210.Current_Value > self.SPY.EMA_360.Current_Value: # Ganesh Changed to >
if self.TQQQ.Rsi_11.Current_Value > 77:
self.UVXY.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
else:
if self.TQQQ.Return_6.Current_Value < -0.1:
if self.TQQQ.Return_1.Current_Value > 0.055:
self.UVXY.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
else:
symbols = [ self.TECL,
self.TQQQ,
self.SPXL,
self.EPI,
self.SOXL,
self.UPRO,
self.QLD,
self.EWZ,
self.MVV,
self.PUI,
self.USD,
self.TMF
]
Create_Return_MA_List(self, symbols, "Return_MA_7", False, 1, 1, outer_allocation)
else:
if self.BIL.Rsi_7.Current_Value < self.IEF.Rsi_7.Current_Value:
symbols = [ self.TECL,
self.SPXL,
self.EPI,
self.SOXL,
self.UPRO,
self.MVV
]
Create_Return_MA_List(self, symbols, "Return_MA_7", False, 1, 1, outer_allocation)
else:
symbols = [self.SOXS, self.TMF]
Create_Return_List(self, symbols, "Return_5", True, 1, 1, outer_allocation)
else:
symbols = [self.SPXS, self.SQQQ, self.TECS, self.SOXS]
Create_RSI_List(self, symbols, "Rsi_5", False, 1, 1, outer_allocation)
else:
self.Defense_Modified_3(0.2)
def Defense_Modified_3(self, outer_allocation):
if self.DBC.Return_STDEV_20.Current_Value > self.SPY.Return_STDEV_20.Current_Value:
symbols = [self.SPXS, self.EPI, self.TECS, self.SOXS, self.SQQQ]
Create_RSI_List(self, symbols, "Rsi_5", False, 1, 1, outer_allocation)
else:
symbols = [self.TECL, self.TQQQ, self.SOXL, self.TMF]
Create_Return_MA_List(self, symbols, "Return_MA_5", True, 1, 1, outer_allocation)
def Bear_Stock_Market_2(self, outer_allocation):
if self.Securities["TLT"].Price > self.TLT.SMA_200.Current_Value:
self.AB_Medium_Term_TLT_OverBought_2(0.2)
else:
self.B_Long_Term_TLT_Down_2(0.2)
def AB_Medium_Term_TLT_OverBought_2(self, outer_allocation):
if self.TLT.Return_MA_20.Current_Value < 0:
self.ABBA_Risk_Off_Rising_Rates_2(0.2)
else:
self.ABBB_Risk_Off_Falling_Rates_2(0.2)
def ABBA_Risk_Off_Rising_Rates_2(self, outer_allocation):
if self.SPY.EMA_210.Current_Value <= self.SPY.SMA_360.Current_Value:
if self.TQQQ.Rsi_10.Current_Value < 30:
symbols = [self.TECL, self.TQQQ, self.SOXL, self.UPRO]
Create_Return_MA_List(self, symbols, "Return_MA_5", False, 1, 1, outer_allocation)
else:
if self.SPXU.Return_6.Current_Value <= self.UPRO.Return_3.Current_Value:
symbols = [self.SQQQ, self.EUO, self.YCS]
Create_Return_List(self, symbols, "Return_5", True, 1, 1, outer_allocation)
else:
symbols = [self.TECL, self.TQQQ, self.SOXL, self.CURE]
Create_Return_MA_List(self, symbols, "Return_MA_5", False, 1, 1, outer_allocation)
else:
if self.TQQQ.Rsi_11.Current_Value > 77:
self.UVXY.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
else:
symbols = [self.TECL, self.TQQQ, self.SOXL, self.UPRO, self.TMV]
Create_Return_MA_List(self, symbols, "Return_MA_5", False, 1, 1, outer_allocation)
def ABBB_Risk_Off_Falling_Rates_2(self, outer_allocation):
if self.SPY.EMA_210.Current_Value <= self.SPY.SMA_360.Current_Value:
if self.TQQQ.Rsi_10.Current_Value < 30:
symbols = [self.TECL, self.TQQQ, self.SOXL]
Create_Return_MA_List(self, symbols, "Return_MA_5", False, 1, 1, outer_allocation)
else:
if self.UUP.Return_2.Current_Value >= 0.01:
symbols = [self.TECS, self.SOXS, self.SQQQ]
Create_Return_List(self, symbols, "Return_5", True, 1, 1, outer_allocation)
else:
if self.SPXU.Return_5.Current_Value > self.UPRO.Return_4.Current_Value:
symbols = [self.ERX, self.EUO, self.YCS]
Create_Return_List(self, symbols, "Return_5", True, 1, 1, outer_allocation)
else:
symbols = [self.SOXL, self.EWZ, self.MVV, self.USD]
Create_Return_MA_List(self, symbols, "Return_MA_5", False, 1, 1, outer_allocation)
else:
if self.SPY.Return_MA_210.Current_Value > self.DBC.Return_MA_360.Current_Value:
if self.TQQQ.Rsi_11.Current_Value > 77:
self.UVXY.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
else:
if self.TQQQ.Return_6.Current_Value < -0.1:
if self.TQQQ.Return_1.Current_Value > 0.055:
self.UVXY.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
else:
if self.BIL.Rsi_7.Current_Value < self.IEF.Rsi_7.Current_Value:
self.SOXL.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
else:
symbols = [self.EWZ, self.UUP, self.TMF, self.UCO]
Create_Return_List(self, symbols, "Return_5", True, 1, 1, outer_allocation)
else:
if self.BIL.Rsi_7.Current_Value < self.IEF.Rsi_7.Current_Value:
symbols[self.TECL, self.TQQQ, self.SPXL, self.QLD, self.USD]
Create_Return_MA_List(self, symbols, "Return_MA_5", False, 1, 1, outer_allocation)
else:
symbols = [self.EWZ, self.UUP, self.TMF]
Create_Return_List(self, symbols, "Return_5", True, 1, 1, outer_allocation)
else:
self.Defense_Modified(0.2)
def B_Long_Term_TLT_Down_2(self, outer_allocation):
if self.TLT.Return_MA_20.Current_Value < 0:
self.BAA_Risk_Off_Rising_Rates_Left_2(0.2)
else:
self.BAB_Risk_Off_Falling_Rates_Left_2(0.2)
def BAA_Risk_Off_Rising_Rates_Left_2(self, outer_allocation):
if self.SPY.EMA_210.Current_Value < self.SPY.SMA_360.Current_Value:
if self.TQQQ.Rsi_10.Current_Value < 30:
symbols =[self.TQQQ, self.SOXL, self.UPRO]
Create_Return_MA_List(self, symbols, "Return_MA_5", True, 1, 1, outer_allocation)
else:
if self.UUP.Return_2.Current_Value > 0.01:
symbols = [self.SPXS, self.TECS, self.SOXS, self.SQQQ, self.ERX]
Create_Return_List(self, symbols, "Return_5", False, 1, 1, outer_allocation)
else:
if self.SPXU.Return_5.Current_Value >= self.UPRO.Return_4.Current_Value:
symbols = [self.SOXS, self.SQQQ, self.EPI]
Create_Return_List(self, symbols, "Return_5", True, 1, 1, outer_allocation)
else:
if self.BIL.Return_3.Current_Value >= self.TMV.Return_3.Current_Value:
symbols = [self.TECL, self.SOXL, self.TNA, self.UPRO] # Ganesh self.UPRO additional
Create_Return_MA_List(self, symbols, "Return_MA_5", False, 1, 1, outer_allocation)
else:
symbols = [self.TECL, self.SOXL, self.TMV]
Create_Return_MA_List(self, symbols, "Return_MA_3", False, 1, 1, outer_allocation)
else:
if self.SPY.Return_MA_210.Current_Value > self.DBC.Return_MA_360.Current_Value:
if self.TQQQ.Rsi_11.Current_Value > 77:
self.UVXY.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
else:
if self.TQQQ.Return_6.Current_Value < -0.1:
if self.TQQQ.Return_1.Current_Value > 0.055:
self.UVXY.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
else:
symbols = [self.SOXL, self.TMV]
Create_Return_MA_List(self, symbols, "Return_MA_5", False, 1, 1, outer_allocation)
else:
if self.BIL.Rsi_7.Current_Value < self.IEF.Rsi_7.Current_Value:
symbols = [self.TQQQ, self.SOXL, self.UPRO, self.TMV, self.TECL]
Create_Return_MA_List(self, symbols, "Return_MA_5", True, 1, 1, outer_allocation)
else:
symbols = [self.SOXL, self.UPRO]
Create_Return_MA_List(self, symbols, "Return_MA_22", False, 1, 1, outer_allocation)
else:
self.Defense_Modified_2(0.2)
def BAB_Risk_Off_Falling_Rates_Left_2(self, outer_allocation):
if self.SPY.EMA_210.Current_Value < self.SPY.SMA_360.Current_Value:
if self.SPY.Return_1.Current_Value < -0.02:
symbols = [self.SPXS, self.TECS, self.SOXS, self.SQQQ]
Create_Return_List(self, symbols, "Return_5", True, 1, 1, outer_allocation) # Ganesh changed to True
else:
if self.SPXU.Return_6.Current_Value > self.UPRO.Return_3.Current_Value:
symbols = [self.BIL, self.AGG, self.TMF]
Create_Return_List(self, symbols, "Return_5", False, 1, 1, outer_allocation)
else:
symbols = [self.TECL, self.TQQQ, self.SOXL, self.EWZ, self.TMF]
Create_Return_MA_List(self, symbols, "Return_MA_5", False, 1, 1, outer_allocation)
else:
if self.SPY.Return_MA_210.Current_Value > self.DBC.Return_MA_360.Current_Value:
if self.SPY.EMA_210.Current_Value > self.SPY.EMA_360.Current_Value:
if self.TQQQ.Rsi_11.Current_Value > 77:
self.UVXY.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
else:
if self.TQQQ.Return_6.Current_Value < -0.1:
if self.TQQQ.Return_1.Current_Value > 0.055:
self.UVXY.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
else:
symbols = [self.TECL, self.TQQQ, self.SPXL, self.EPI, self.SOXL, self.UPRO, self.QLD, self.EWZ,
self.MVV, self.PUI, self.USD, self.TMF
]
Create_Return_MA_List(self, symbols, "Return_MA_7", False, 1, 1, outer_allocation)
else:
if self.BIL.Rsi_7.Current_Value < self.IEF.Rsi_7.Current_Value:
symbols = [self.TECL, self.SPXL, self.EPI, self.SOXL, self.UPRO, self.MVV]
Create_Return_MA_List(self, symbols, "Return_MA_7", False, 1, 1, outer_allocation)
else:
symbols = [self.SOXS, self.TMF]
Create_Return_List(self, symbols, "Return_5", True, 1, 1, outer_allocation)
else:
symbols = [self.SPXS, self.SQQQ, self.TECS, self.SOXS]
Create_RSI_List(self, symbols, "Rsi_5", False, 1, 1, outer_allocation)
else:
self.Defense_Modified_3(0.2)
def OG_v1_2_Risk_On_Off_Hedgefund(self, outer_allocation):
if self.VIXM.Rsi_40.Current_Value > 69:
self.Risk_Off_Market_Crash(0.6)
else:
if self.BND.Return_60.Current_Value > self.BIL.Return_60.Current_Value:
self.Risk_On_Normal_Market_Conditions(0.6)
else:
if self.TLT.Return_20.Current_Value < self.BIL.Return_20.Current_Value:
self.Risk_Off_Rising_Rates(0.6)
else:
self.Risk_On_Falling_Rates_HFEA(0.6)
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(0.55*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.FAS, self.FAS.Rsi_10.Current_Value),
(self.TQQQ, self.TQQQ.Rsi_10.Current_Value),
(self.UPRO, self.UPRO.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.USDU.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/3 - (config.CASH_BUFFER * (outer_allocation/3))
# self.UPRO.Function = "Hedged_Leveraged_Bonds_Stocks_V2 TLT > TLT_150_SMA"
# self.TMF.Counter += outer_allocation/3 - (config.CASH_BUFFER/3 * (outer_allocation/3))
# 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.DBC is None and symbol == "DBC":
self.DBC = 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.EWZ is None and symbol == "EWZ":
self.EWZ = 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.ERX is None and symbol == "ERX":
self.ERX = 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.EUO is None and symbol == "EUO":
self.EUO = Symbol_Object
if self.AGG is None and symbol == "AGG":
self.AGG = Symbol_Object
if self.PUI is None and symbol == "PUI":
self.PUI = Symbol_Object
if self.ERX is None and symbol == "ERX":
self.ERX = 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.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.DBC is not None:
self.DBC.Update_With_Intraday_Bar(self.Securities["DBC"].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.EWZ is not None:
self.EWZ.Update_With_Intraday_Bar(self.Securities["EWZ"].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.ERX is not None:
self.ERX.Update_With_Intraday_Bar(self.Securities["ERX"].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.EUO is not None:
self.EUO.Update_With_Intraday_Bar(self.Securities["EUO"].Close)
if self.AGG is not None:
self.AGG.Update_With_Intraday_Bar(self.Securities["AGG"].Close)
if self.PUI is not None:
self.PUI.Update_With_Intraday_Bar(self.Securities["PUI"].Close)
if self.ERX is not None:
self.ERX.Update_With_Intraday_Bar(self.Securities["ERX"].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.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.DBC 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.EWZ 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.ERX is None or self.EPI is None or self.TNA is None or self.EUO is None or self.AGG is None or self.PUI is None or self.ERX is None or self.EFA is None or self.EEM is None:
return
self.Update_Intraday = False
if self.Trade_Decision:
self.Clear_Weightings()
self.Main_Strategy()
self.Orders()
self.Trade_Decision = 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
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 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 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 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 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 = {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)
# self.Schedule.On(self.DateRules.Every(DayOfWeek.Monday), self.TimeRules.BeforeMarketClose("SPY", self.Trade_Decision_Time), self.Set_Update_Intraday)
# self.Schedule.On(self.DateRules.Every(DayOfWeek.Monday), 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):
#self.SPY_2_DAY_RSI(1)
#self.XLP_EASY_MONEY(1)
#self.Cautious_Fund_Surfing_SMH(0.5)
#self.Cautious_Fund_Surfing_QQQ(1)
#self.QLD_LONG_TERM(0.40)
self.QQQ_RSI_32_79(0.20)
self.BIL_ETF(0.40)
self.tqqq_longterm_20d_BND_vs_60d_SH(0.40)
################################################################################################################################################
# def XLP_EASY_MONEY_RSI(self,outer_allocation):
# if self.QQQ.Rsi_10.Current_Value > 79:
# self.SH.Counter += outer_allocation * 1 - (config.CASH_BUFFER * outer_allocation)
# elif self.QQQ.Rsi_10.Current_Value < 32:
# self.QLD.Counter += outer_allocation * 1 - (config.CASH_BUFFER * outer_allocation)
# self.QLD.Function = "QQQ.Rsi_10.Current_Value < 32"
# #elif self.QQQ.Rsi_10.Current_Value > 70:
# elif self.XLP.EMA_8.Current_Value > self.XLP.EMA_50.Current_Value:
# self.XLP.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
# #self.XLP.Function = (f'XLP EMA 8 > 50, EMA8 = {round(self.XLP.EMA_8.Current_Value,4)}, EMA50= {round(self.XLP.EMA_50.Current_Value,4)}' )
# elif self.Securities["SPY"].Price > self.SPY.SMA_200.Current_Value:
# self.QQQ.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
# else:
# #self.Cautious_Fund_Surfing_SMH(outer_allocation/2)
# self.Cautious_Fund_Surfing_QQQ(outer_allocation)
def BIL_ETF(self,outer_allocation):
if self.TQQQ.Rsi_10.Current_Value > 79:
self.VIXY.Counter += outer_allocation * 1 - (config.CASH_BUFFER * outer_allocation * 1)
self.VIXY.Function = "TQQQ.Rsi_10.Current_Value > 79" #High-Hitrate-99%
elif self.QLD.Rsi_10.Current_Value < 32:
self.QLD.Counter += outer_allocation * 1 - (config.CASH_BUFFER * outer_allocation)
self.QLD.Function = "TQQQ.Rsi_10.Current_Value < 32" #High-Hitrate-99%
else:
self.BIL.Counter += outer_allocation * 1 - (config.CASH_BUFFER * outer_allocation)
################################################################################################################################################
def QLD_LONG_TERM(self,outer_allocation):
if self.TQQQ.Rsi_10.Current_Value > 79:
self.UVXY.Counter += outer_allocation * 1 - (config.CASH_BUFFER * outer_allocation)
self.UVXY.Function = "QQQ.Rsi_10.Current_Value > 79"
elif self.TQQQ.Rsi_10.Current_Value < 32:
self.TQQQ.Counter += outer_allocation * 1 - (config.CASH_BUFFER * outer_allocation)
self.TQQQ.Function = "QQQ.Rsi_10.Current_Value < 32"
elif (self.TQQQ.SMA_50.Current_Value > self.TQQQ.SMA_150.Current_Value) and (self.Securities["SPY"].Price > self.SPY.SMA_200.Current_Value):
self.TQQQ.Counter += outer_allocation * 1 - (config.CASH_BUFFER * outer_allocation)
self.TQQQ.Function = "QLD Sit Long"
else:
self.BIL.Counter += outer_allocation * 1 - (config.CASH_BUFFER * (outer_allocation * 1))
def tqqq_longterm_20d_BND_vs_60d_SH(self,outer_allocation):
if self.TQQQ.Rsi_10.Current_Value > 79:
self.VIXY.Counter += outer_allocation * 1
self.VIXY.Function = "TQQQ.Rsi_10 > 79"
elif self.TQQQ.Rsi_10.Current_Value < 32:
self.TQQQ.Counter += outer_allocation * 1
self.TQQQ.Function = "TQQQ.Rsi_10 < 32"
else:
if self.TQQQ.SMA_50.Current_Value > self.TQQQ.SMA_150.Current_Value and self.Securities["SPY"].Price > self.SPY.SMA_200.Current_Value:
# if self.SPY.Rsi_60.Current_Value > 61:
# self.SPY.Counter += outer_allocation * 1
# self.SPY.Function = "SPY60"
if self.BND.Rsi_20.Current_Value > self.SH.Rsi_60.Current_Value:
self.TQQQ.Counter += outer_allocation * 1
self.TQQQ.Function = "HOLD"
else:
self.BIL.Counter += outer_allocation * 1
else:
self.BIL.Counter += outer_allocation * 1
################################################################################################################################################
def XLP_EASY_MONEY(self,outer_allocation):
if self.XLP.EMA_8.Current_Value > self.XLP.EMA_50.Current_Value:
self.XLP.Counter += outer_allocation * 1 - (config.CASH_BUFFER * outer_allocation)
else:
if self.QQQ.Rsi_10.Current_Value < 30:
self.QLD.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
self.QLD.Function = "QQQ.Rsi_10.Current_Value < 30"
else:
if self.Securities["SPY"].Price > self.SPY.SMA_200.Current_Value:
self.QQQ.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
else:
self.BIL.Counter += outer_allocation * 0 - (config.CASH_BUFFER * outer_allocation)
################################################################################################################################################
def QQQ_RSI_32_79(self, outer_allocation):
if self.TQQQ.Rsi_10.Current_Value > 79:
self.UVXY.Counter += outer_allocation * 0.3 - (config.CASH_BUFFER * outer_allocation)
elif self.TQQQ.Rsi_10.Current_Value < 32:
self.TQQQ.Counter += outer_allocation * 1 - (config.CASH_BUFFER * outer_allocation)
self.TQQQ.Function = "QQQ.Rsi_10.Current_Value < 32"
else:
#self.Cautious_Fund_Surfing_TLT(outer_allocation/2)
self.Cautious_Fund_Surfing_QQQ(outer_allocation)
######################################
def Cautious_Fund_Surfing_QQQ(self, outer_allocation):
timeframes = [14, 21, 28, 35, 42]
stdev_thresholds = [0.01, 0.015, 0.02]
pairs = [(self.SPY, self.TQQQ, self.BIL, 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 BIL
bond_etf.Counter += allocation * 1
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 * 1# 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)}')
################################################################################################################################################
def SPY_RSI_32_79(self, outer_allocation):
if self.QQQ.Rsi_10.Current_Value > 79:
self.UVXY.Counter += outer_allocation * 0.3 - (config.CASH_BUFFER * outer_allocation)
elif self.SPY.Rsi_10.Current_Value < 32:
self.SSO.Counter += outer_allocation * 1 - (config.CASH_BUFFER * outer_allocation)
self.SSO.Function = "QQQ.Rsi_10.Current_Value < 32"
else:
#self.Cautious_Fund_Surfing_TLT(outer_allocation/2)
self.Cautious_Fund_Surfing_SPY(outer_allocation)
######################################
def Cautious_Fund_Surfing_SPY(self, outer_allocation):
timeframes = [14, 21, 28, 35, 42]
stdev_thresholds = [0.01, 0.015, 0.02]
pairs = [(self.SPY, self.SSO, self.BIL, 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 BIL
bond_etf.Counter += allocation * 1
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 * 1# 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)}')
################################################################################################################################################
def Cautious_Fund_Surfing_SMH(self, outer_allocation):
timeframes = [14, 21, 28, 35, 42]
stdev_thresholds = [0.01, 0.015, 0.02]
pairs = [(self.SPY, self.SMH, self.BIL, 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 BIL
bond_etf.Counter += allocation * 0
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 * 0# 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)}')
def XLP_EASY_MONEY_BACKUP_RSI(self,outer_allocation):
if self.TQQQ.Rsi_10.Current_Value > 79:
self.UVXY.Counter += outer_allocation * 1 - (config.CASH_BUFFER * outer_allocation)
self.UVXY.Function = "QQQ.Rsi_10.Current_Value > 79"
if self.TLT.SMA_20.Current_Value > self.TLT.SMA_50.Current_Value:
self.TMF.Counter += outer_allocation * 0.20 - (config.CASH_BUFFER * outer_allocation)
else:
self.SH.Counter += outer_allocation * 0.20 - (config.CASH_BUFFER * outer_allocation)
self.SH.Function = "QQQ.Rsi_10.Current_Value > 79"
elif self.QQQ.Rsi_10.Current_Value < 32:
self.QLD.Counter += outer_allocation * 0.8 - (config.CASH_BUFFER * outer_allocation)
self.QLD.Function = "QQQ.Rsi_10.Current_Value < 32"
if self.TLT.SMA_20.Current_Value > self.TLT.SMA_50.Current_Value:
self.TMF.Counter += outer_allocation * 0.20 - (config.CASH_BUFFER * outer_allocation)
else:
self.QLD.Counter += outer_allocation * 0.20 - (config.CASH_BUFFER * outer_allocation)
self.QLD.Function = "QQQ.Rsi_10.Current_Value < 32"
elif (self.QLD.SMA_50.Current_Value > self.QLD.SMA_150.Current_Value) and (self.Securities["SPY"].Price > self.SPY.SMA_200.Current_Value):
#self.QLD.Counter += outer_allocation * 0.75 - (config.CASH_BUFFER * (outer_allocation * 0.75 ))
self.QLD.Counter += outer_allocation * 0.80 - (config.CASH_BUFFER * outer_allocation)
self.QLD.Function = "QLD Sit Long"
if self.TLT.SMA_20.Current_Value > self.TLT.SMA_50.Current_Value:
self.TMF.Counter += outer_allocation * 0.20 - (config.CASH_BUFFER * outer_allocation)
elif self.QQQ.Rsi_10.Current_Value > 79:
self.SH.Counter += outer_allocation * 0.2 - (config.CASH_BUFFER * outer_allocation)
self.SH.Function = "QQQ.Rsi_10.Current_Value > 79"
elif self.QQQ.Rsi_10.Current_Value < 32:
self.QLD.Counter += outer_allocation * 0.2 - (config.CASH_BUFFER * outer_allocation)
self.QLD.Function = "QQQ.Rsi_10.Current_Value < 32"
else:
self.QLD.Counter += outer_allocation * 0.20 - (config.CASH_BUFFER * outer_allocation)
self.QLD.Function = "QLD Sit Long_during_TLT_down"
else:
self.SPY.Counter += outer_allocation * 0 - (config.CASH_BUFFER * (outer_allocation * 0 ))
################################################################################################################
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
"""
"""
BACKTEST_START_YEAR = 2021 # 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 = 6 # Set end Month of the Backtest
BACKTEST_END_DAY = 1 # 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 = ["XLP", "SPY", "BIL", "TLT" , "QQQ" , "QLD" , "SH", "SHY", "SSO" , "TQQQ" , "TMF", "UVXY" , "VIXY" , "PSQ" , "BND"]
REBALANCE_THRESHOLD = 1
# 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_6_PERIOD = 6
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_50_PERIOD = 50
EMA_210_PERIOD = 210
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_20_PERIOD = 20
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_8_PERIOD = 8
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_360_PERIOD = 360
SMA_1000_PERIOD = 1000
CUSTOM_DRAWDOWN_5_PERIOD = 5
CUSTOM_DRAWDOWN_8_PERIOD = 8
CUSTOM_DRAWDOWN_10_PERIOD = 10
CUSTOM_DRAWDOWN_252_PERIOD = 252
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 *
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 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_6_Period = config.RSI_6_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_20_Period = config.STDEV_RETURN_20_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_50_Period = config.EMA_50_PERIOD
self.EMA_210_Period = config.EMA_210_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_8_Period = config.SMA_8_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_360_Period = config.SMA_360_PERIOD
self.SMA_1000_Period = config.SMA_1000_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_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_6 = Intraday_Updating_RSI(algorithm, self.Rsi_6_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_8 = Intraday_Updating_SMA(algorithm, self.SMA_8_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_360 = Intraday_Updating_SMA(algorithm, self.SMA_360_Period)
self.SMA_1000 = Intraday_Updating_SMA(algorithm, self.SMA_1000_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_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_20 = CustomReturnStdev(algorithm, symbol, self.STDEV_Return_20_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_50 = CustomEMA(algorithm, self.EMA_50_Period)
self.EMA_210 = CustomEMA(algorithm, self.EMA_210_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_6.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_8.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_360.Receive_Main_Bar(bar)
self.SMA_1000.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_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_20.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_50.Receive_Main_Bar(bar)
self.EMA_210.Receive_Main_Bar(bar)
self.EMA_360.Receive_Main_Bar(bar)
self.Rsi_2.Updated_Today = True
self.Rsi_6.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_8.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_360.Updated_Today = True
self.SMA_1000.Updated_Today = True
self.Drawdown_5.Updated_Today = True
self.Drawdown_8.Updated_Today = True
self.Drawdown_10.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_20.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_50.Updated_Today = True
self.EMA_210.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_6.Updated_Today:
self.Rsi_6.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_8.Updated_Today:
self.SMA_8.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_360.Updated_Today:
self.SMA_360.Receive_Sub_Bar(price)
if self.SMA_1000.Updated_Today:
self.SMA_1000.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_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_20.Updated_Today:
self.Return_STDEV_20.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_50.Updated_Today:
self.EMA_50.Receive_Sub_Bar(price)
if self.EMA_210.Updated_Today:
self.EMA_210.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_6.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_8.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_360.Updated_Today = False
self.SMA_1000.Updated_Today = False
self.Drawdown_5.Updated_Today = False
self.Drawdown_8.Updated_Today = False
self.Drawdown_10.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_20.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_50.Updated_Today = False
self.EMA_210.Updated_Today = False
self.EMA_360.Updated_Today = 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
#region imports
from AlgorithmImports import *
#endregion
# 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_AMZN = self.AMZN.SMA_5.Current_Value > self.AMZN.SMA_20.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_AMZN 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
# update_counters("Go Long", [self.AMZN ], [quarter_alloc])
# else:
# self.SGOV.Counter += allocation - (config.CASH_BUFFER * allocation)
# elif QQQ_Rsi_below_30:
# self.TQQQ.Counter += allocation - (config.CASH_BUFFER * allocation)
# else:
# self.SGOV.Counter += allocation - (config.CASH_BUFFER * allocation)
# if not SPY_SMA_200_above_1000:
# if QQQ_Rsi_below_30:
# self.TECL.Counter += allocation - (config.CASH_BUFFER * allocation)
# else:
# if golden_cross_AMZN and SPY_above_200:
# quarter_alloc = allocation
# update_counters("Go Long", [self.AMZN],[quarter_alloc])
# else:
# self.SGOV.Counter += allocation - (config.CASH_BUFFER * quarter_alloc)
##############################################################################
# def Leveraged_Secular_Market_Framework_Equal_Weight(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_AMZN = self.AMZN.SMA_5.Current_Value > self.AMZN.SMA_20.Current_Value
# # golden_cross_GOOG = self.GOOG.SMA_5.Current_Value > self.GOOG.SMA_20.Current_Value
# # golden_cross_AAPL = self.AAPL.SMA_5.Current_Value > self.AAPL.SMA_20.Current_Value
# # golden_cross_META = self.META.SMA_5.Current_Value > self.META.SMA_20.Current_Value
# # golden_cross_TSLA = self.TSLA.SMA_5.Current_Value > self.TSLA.SMA_20.Current_Value
# # golden_cross_NVDA = self.NVDA.SMA_5.Current_Value > self.NVDA.SMA_20.Current_Value
# # golden_cross_MSFT = self.MSFT.SMA_5.Current_Value > self.MSFT.SMA_20.Current_Value
# # golden_cross_COST = self.COST.SMA_5.Current_Value > self.COST.SMA_20.Current_Value
# # golden_cross_PANW = self.PANW.SMA_5.Current_Value > self.PANW.SMA_20.Current_Value
# # golden_cross_ORCL = self.ORCL.SMA_5.Current_Value > self.ORCL.SMA_20.Current_Value
# # # golden_cross_ANET = self.ANET.SMA_5.Current_Value > self.ANET.SMA_20.Current_Value
# # # golden_cross_AMD = self.AMD.SMA_5.Current_Value > self.AMD.SMA_20.Current_Value
# # # golden_cross_TQQQ = self.TQQQ.SMA_5.Current_Value > self.TQQQ.SMA_20.Current_Value
# # # golden_cross_ADBE = self.ADBE.SMA_5.Current_Value > self.ADBE.SMA_20.Current_Value
# # golden_cross_NFLX = self.NFLX.SMA_5.Current_Value > self.NFLX.SMA_20.Current_Value
# # # golden_cross_MDB = self.MDB.SMA_5.Current_Value > self.MDB.SMA_20.Current_Value
# # # golden_cross_CRM = self.CRM.SMA_5.Current_Value > self.CRM.SMA_20.Current_Value
# # # golden_cross_XLF = self.XLF.SMA_5.Current_Value > self.XLF.SMA_20.Current_Value
# # # golden_cross_XLI = self.XLI.SMA_5.Current_Value > self.XLI.SMA_20.Current_Value
# # # golden_cross_XLK = self.XLK.SMA_5.Current_Value > self.XLK.SMA_20.Current_Value
# # # golden_cross_XLV = self.XLV.SMA_5.Current_Value > self.XLV.SMA_20.Current_Value
# # # golden_cross_XLY = self.XLY.SMA_5.Current_Value > self.XLY.SMA_20.Current_Value
# # # golden_cross_XLU = self.XLU.SMA_5.Current_Value > self.XLU.SMA_20.Current_Value
# # # golden_cross_XLP = self.XLP.SMA_5.Current_Value > self.XLP.SMA_20.Current_Value
# # golden_cross_SSO = self.SSO.SMA_5.Current_Value > self.SSO.SMA_20.Current_Value
# # golden_cross_QLD = self.QQQ.SMA_5.Current_Value > self.QQQ.SMA_20.Current_Value
# golden_cross_QQQ = self.QQQ.SMA_5.Current_Value > self.QQQ.SMA_20.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
# invest_stocks = []
# # if golden_cross_AMZN: invest_stocks.append(self.AMZN)
# # if golden_cross_GOOG: invest_stocks.append(self.GOOG)
# # if golden_cross_AAPL: invest_stocks.append(self.AAPL)
# # if golden_cross_META: invest_stocks.append(self.META)
# # if golden_cross_TSLA: invest_stocks.append(self.TSLA)
# # if golden_cross_NVDA: invest_stocks.append(self.NVDA)
# # if golden_cross_MSFT: invest_stocks.append(self.MSFT)
# # if golden_cross_COST: invest_stocks.append(self.COST)
# # if golden_cross_PANW: invest_stocks.append(self.PANW)
# # if golden_cross_ORCL: invest_stocks.append(self.ORCL)
# # if golden_cross_ANET: invest_stocks.append(self.ANET)
# # if golden_cross_AMD: invest_stocks.append(self.AMD)
# # if golden_cross_TQQQ: invest_stocks.append(self.TQQQ)
# # if golden_cross_ADBE: invest_stocks.append(self.ADBE)
# #if golden_cross_NFLX: invest_stocks.append(self.NFLX)
# # if golden_cross_XLU: invest_stocks.append(self.XLU)
# # if golden_cross_XLP: invest_stocks.append(self.XLP)
# # if golden_cross_MDB: invest_stocks.append(self.MDB)
# # if golden_cross_CRM: invest_stocks.append(self.CRM)
# # if golden_cross_XLF: invest_stocks.append(self.XLF)
# # if golden_cross_XLI: invest_stocks.append(self.XLI)
# # if golden_cross_XLK: invest_stocks.append(self.XLK)
# # if golden_cross_XLV: invest_stocks.append(self.XLV)
# # if golden_cross_XLY: invest_stocks.append(self.XLY)
# # if golden_cross_SSO: invest_stocks.append(self.SSO)
# # if golden_cross_QLD: invest_stocks.append(self.QLD)
# # if golden_cross_QQQ: invest_stocks.append(self.QQQ)
# # if invest_stocks and SPY_above_200:
# # if SPY_SMA_200_above_1000:
# # if SPY_Rsi_above_60:
# # update_counters("SPY Overbrought", [self.SPY, self.TLT], [allocation * 0.55, allocation * 0.45])
# # else:
# # quarter_alloc = allocation / len(invest_stocks)
# # update_counters("Go Long", invest_stocks, [quarter_alloc]*len(invest_stocks))
# # else:
# # self.SGOV.Counter += allocation * 0 - (config.CASH_BUFFER * allocation * 0)
# # elif QQQ_Rsi_below_30:
# # self.TQQQ.Counter += allocation - (config.CASH_BUFFER * allocation)
# # else:
# # self.SGOV.Counter += allocation * 0 - (config.CASH_BUFFER * allocation * 0)
# # if not SPY_SMA_200_above_1000:
# # if QQQ_Rsi_below_30:
# # self.TQQQ.Counter += allocation - (config.CASH_BUFFER * allocation)
# # else:
# # if invest_stocks and SPY_above_200:
# # quarter_alloc = allocation / len(invest_stocks)
# # update_counters("Go Long", invest_stocks, [quarter_alloc]*len(invest_stocks))
# # else:
# # self.SGOV.Counter += allocation * 0 - (config.CASH_BUFFER * allocation * 0)
# # collect stock returns in a list of tuples (stock, return)
# stock_returns = [(stock, stock.Rsi_10.Current_Value <= 90) for stock in invest_stocks]
# # sort the list by returns
# sorted_stock_returns = sorted(stock_returns, key=lambda x: x[1], reverse=False)
# # select the top 5 stocks
# top_stocks = sorted_stock_returns[:10]
# # now invest in these top 5 stocks
# if top_stocks and SPY_above_200:
# if SPY_SMA_200_above_1000:
# if SPY_Rsi_above_60:
# update_counters("SPY Overbrought", [self.SPY, self.TLT], [allocation * 0.55, allocation * 0.45])
# else:
# quarter_alloc = allocation / len(top_stocks)
# update_counters("Go Long", [stock for stock, _ in top_stocks], [quarter_alloc]*len(top_stocks))
# else:
# self.SGOV.Counter += allocation * 0 - (config.CASH_BUFFER * allocation * 0)
# elif QQQ_Rsi_below_30:
# self.QLD.Counter += allocation - (config.CASH_BUFFER * allocation)
# else:
# self.SGOV.Counter += allocation * 0 - (config.CASH_BUFFER * allocation * 0)#region imports
from AlgorithmImports import *
import config
#endregion
#
def OG_v1_2_Risk_On_Off_Hedgefund(self, outer_allocation):
if self.VIXM.Rsi_40.Current_Value > 69:
self.Risk_Off_Market_Crash(0.6)
else:
if self.BND.Return_60.Current_Value > self.BIL.Return_60.Current_Value:
self.Risk_On_Normal_Market_Conditions(0.6)
else:
if self.TLT.Return_20.Current_Value < self.BIL.Return_20.Current_Value:
self.Risk_Off_Rising_Rates(0.6)
else:
self.Risk_On_Falling_Rates_HFEA(0.6)
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(0.55*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.FAS, self.FAS.Rsi_10.Current_Value),
(self.TQQQ, self.TQQQ.Rsi_10.Current_Value),
(self.UPRO, self.UPRO.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.USDU.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)
"""
**
* 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