| Overall Statistics |
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 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 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
"""
**
* 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.VXX = None
self.EFA = None
self.EEM = None
self.SH = None
self.SDS = None
self.UVXY = None
self.SMH = None
self.DIA = None
self.XLP = None
self.XLV = None
self.XLF = None
self.LABU = None
self.UTSL = None
self.DRN = None
self.hedged_lev_bnd_outer_alloation = config.hedged_lev_bnd_outer_alloation
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.34)
#self.Hedged_Leveraged_Bonds_Stocks_V2(0.33)
#self.SPY_FOR_LONG_TERM(0.33)
#self.BlackSwan_MeanRev_BondSignal(0.33)
self.TQQQFTLT()
#############################################################################################
def TQQQFTLT(self):
if self.Securities["SPY"].Price > self.SPY.SMA_200.Current_Value:
if self.TQQQ.Rsi_14.Current_Value > 75:
#self.Debug(f"TQQQ.Rsi_14 {self.TQQQ.Rsi_14.Current_Value}")
self.UVXY.Counter = 1 - (config.TQQQFTLT_CASH_BUFFER * 1)
#self.UVXY.Function = "Main_Strategy TQQQ.Rsi_14 > 75"
elif self.SPXL.Rsi_10.Current_Value > 80:
#self.Debug(f"SPXL.Rsi_10 {self.SPXL.Rsi_10.Current_Value}")
self.UVXY.Counter = 1 - (config.TQQQFTLT_CASH_BUFFER * 1)
#self.UVXY.Function = "Main_Strategy SPXL.Rsi_10 > 80"
elif self.QQQ.Return_5.Current_Value < -0.6:
if self.TQQQ.Return_1.Current_Value > 0.5:
#self.Debug(f"QQQ Return 5 {self.TQQQ.Return_5.Current_Value}")
#self.Debug(f"TQQQ Return 1 {self.TQQQ.Return_1.Current_Value}")
self.SQQQ.Counter = 1 - (config.TQQQFTLT_CASH_BUFFER * 1)
#self.SQQQ.Function = "Main_Strategy QQQ.Return_5 < 6% & TQQQ.Return_1 > 5%"
else:
if self.TQQQ.Rsi_10.Current_Value > 31:
self.SQQQ.Counter = 1 - (config.TQQQFTLT_CASH_BUFFER * 1)
else:
self.TQQQ.Counter = 1 - (config.TQQQFTLT_CASH_BUFFER * 1)
else:
if self.QQQ.Rsi_10.Current_Value > 80:
self.SQQQ.Counter = 1 - (config.TQQQFTLT_CASH_BUFFER * 1)
else:
if self.QQQ.Rsi_10.Current_Value < 31:
self.TQQQ.Counter = 1 - (config.TQQQFTLT_CASH_BUFFER * 1)
else:
return_list = [(self.TQQQ, self.TQQQ.Rsi_7.Current_Value),
(self.TECL, self.TECL.Rsi_7.Current_Value),
(self.ERX, self.ERX.Rsi_7.Current_Value),
(self.LABU, self.LABU.Rsi_7.Current_Value),
(self.UTSL, self.UTSL.Rsi_7.Current_Value),
(self.DRN, self.DRN.Rsi_7.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 += 1 - (config.TQQQFTLT_CASH_BUFFER * 1)
counter_ += 1
else:
# IF NO, use Sideways Market Mod Below the SPY 200d SMA | FINAL | DereckN
if self.TQQQ.Rsi_10.Current_Value < 31:
#self.Debug(f"TQQQ.Rsi_10 {self.TQQQ.Rsi_10.Current_Value}")
self.TECL.Counter = 1 - (config.TQQQFTLT_CASH_BUFFER * 1)
elif self.SMH.Rsi_10.Current_Value < 30:
#self.Debug(f"SMH.Rsi_10 {self.SMH.Rsi_10.Current_Value}")
self.SOXL.Counter = 1 - (config.TQQQFTLT_CASH_BUFFER * 1)
elif self.DIA.Rsi_10.Current_Value < 27:
#self.Debug(f"DIA.Rsi_10 {self.DIA.Rsi_10.Current_Value}")
self.UDOW.Counter = 1 - (config.TQQQFTLT_CASH_BUFFER * 1)
elif self.SPY.Rsi_14.Current_Value < 28:
self.UPRO.Counter = 1 - (config.TQQQFTLT_CASH_BUFFER * 1)
# IF NO : Weight these groups equally : Sub-strategy 1 & 4 (50%/50%)
else:
self.TQQQFTLT_Sub_Strategy_1()
self.TQQQFTLT_Sub_Strategy_4()
# For Sub-Strategy 1
# Ask whether the QQQ 200-day cumulative return is below −20%
def TQQQFTLT_Sub_Strategy_1(self):
if self.QQQ.Return_200.Current_Value < -0.2:
self.TQQQFTLT_Nasdaq_In_Crash_Territory()
else:
if self.Securities["QQQ"].Price < self.QQQ.SMA_20.Current_Value:
if self.TLT.Rsi_10.Current_Value > self.SQQQ.Rsi_10.Current_Value:
self.TQQQ.Counter += 0.50 - (config.TQQQFTLT_CASH_BUFFER * 0.50)
self.TQQQ.Function = "TQQQFTLT_Sub_Strategy_1 TLT.Rsi_10 > SQQQ_Rsi_10"
elif self.TLT.Rsi_10.Current_Value <= self.SQQQ.Rsi_10.Current_Value:
self.SQQQ.Counter += 0.50 - (config.TQQQFTLT_CASH_BUFFER * 0.50)
self.SQQQ.Function = "TQQQFTLT_Sub_Strategy_1 TLT_Rsi_10 < SQQQ_Rsi_10"
else:
if self.SQQQ.Rsi_10.Current_Value < 31:
self.SQQQ.Counter += 0.50 - (config.TQQQFTLT_CASH_BUFFER * 0.50)
self.SQQQ.Function = "TQQQFTLT_Sub_Strategy_1 SQQQ_Rsi_10 < 31"
elif self.QQQ.Return_10.Current_Value >= 0.055:
self.SQQQ.Counter += 0.50 - (config.TQQQFTLT_CASH_BUFFER * 0.50)
self.SQQQ.Function = "TQQQFTLT_Sub_Strategy_1 QQQ_RETRUN < 5.5"
else:
if self.TQQQ.Rsi_10.Current_Value > self.SOXL.Rsi_10.Current_Value:
self.TQQQ.Counter += 0.50 - (config.TQQQFTLT_CASH_BUFFER * 0.50)
self.TQQQ.Function = "TQQQFTLT_Sub_Strategy_1 TQQQ_Rsi_10 > SOXL_Rsi_10"
elif self.TQQQ.Rsi_10.Current_Value <= self.SOXL.Rsi_10.Current_Value:
self.SOXL.Counter += 0.50 - (config.TQQQFTLT_CASH_BUFFER * 0.50)
self.SOXL.Function = "TQQQFTLT_Sub_Strategy_1 TQQQ_Rsi_10 < SOXL_Rsi_10"
def TQQQFTLT_Nasdaq_In_Crash_Territory(self):
if self.Securities["QQQ"].Price < self.QQQ.SMA_20.Current_Value:
if self.QQQ.Return_60.Current_Value < -0.12:
self.Sideways_Market_Deleverage()
else:
if self.TLT.Rsi_10.Current_Value > self.SQQQ.Rsi_10.Current_Value:
self.TQQQ.Counter += 0.50 - (config.TQQQFTLT_CASH_BUFFER * 0.50)
self.TQQQ.Function = "TQQQFTLT_Nasdaq_In_Crash_Territory TLT.Rsi_10 > SQQQ.Rsi_10"
elif self.TLT.Rsi_10.Current_Value <= self.SQQQ.Rsi_10.Current_Value:
self.SQQQ.Counter += 0.50 - (config.TQQQFTLT_CASH_BUFFER * 0.50)
self.SQQQ.Function = "TQQQFTLT_Nasdaq_In_Crash_Territory TLT.Rsi_10 <= SQQQ.Rsi_10"
else:
if self.SQQQ.Rsi_10.Current_Value < 31:
self.PSQ.Counter += 0.50 - (config.TQQQFTLT_CASH_BUFFER * 0.50)
self.PSQ.Function = "TQQQFTLT_Nasdaq_In_Crash_Territory SQQQ.Rsi_10 < 31"
elif self.QQQ.Return_10.Current_Value >= 0.055:
self.PSQ.Counter += 0.50 - (config.TQQQFTLT_CASH_BUFFER * 0.50)
self.PSQ.Function = "TQQQFTLT_Nasdaq_In_Crash_Territory QQQ.Return_10_days > 5.5%"
else:
if self.QQQ.Rsi_10.Current_Value > self.SMH.Rsi_10.Current_Value:
self.QQQ.Counter += 0.50 - (config.TQQQFTLT_CASH_BUFFER * 0.50)
self.QQQ.Function = "TQQQFTLT_Nasdaq_In_Crash_Territory QQQ.Rsi_10 > SMH.Rsi_10"
elif self.QQQ.Rsi_10.Current_Value <= self.SMH.Rsi_10.Current_Value:
self.SMH.Counter += 0.50 - (config.TQQQFTLT_CASH_BUFFER * 0.50)
self.SMH.Function = "TQQQFTLT_Nasdaq_In_Crash_Territory QQQ.Rsi_10 <= SMH.Rsi_10"
def Sideways_Market_Deleverage(self):
self.TQQQFTLT_Sub_Strategy_2()
self.TQQQFTLT_Sub_Strategy_3()
def TQQQFTLT_Sub_Strategy_4(self):
if self.Securities["QQQ"].Price < self.QQQ.SMA_20.Current_Value:
if self.QQQ.Return_60.Current_Value < -0.12:
self.Sideways_Market_Deleverage()
else:
if self.TLT.Rsi_10.Current_Value > self.SQQQ.Rsi_10.Current_Value:
# Comment - TECL Missing here, should be fine
self.TQQQ.Counter += 0.50 - (config.TQQQFTLT_CASH_BUFFER * 0.50)
self.TQQQ.Function = "TQQQFTLT_Sub_Strategy_4 TLT.Rsi_10 > SQQQ.Rsi_10"
elif self.TLT.Rsi_10.Current_Value <= self.SQQQ.Rsi_10.Current_Value:
self.SQQQ.Counter += 0.50 - (0.50)
self.SQQQ.Function = "TQQQFTLT_Sub_Strategy_4 TLT.Rsi_10 <= SQQQ.Rsi_10"
else:
if self.SQQQ.Rsi_10.Current_Value < 31:
self.SQQQ.Counter += 0.50 - (config.TQQQFTLT_CASH_BUFFER * 0.50)
self.SQQQ.Function = "TQQQFTLT_Sub_Strategy_4 SQQQ.Rsi_10 < 31"
else:
if self.QQQ.Return_70.Current_Value < -0.15:
if self.TQQQ.Rsi_10.Current_Value > self.SOXL.Rsi_10.Current_Value:
self.TQQQ.Counter += 0.50 - (config.TQQQFTLT_CASH_BUFFER * 0.50)
self.TQQQ.Function = "TQQQFTLT_Sub_Strategy_4 TQQQ.Rsi_10 > SOXL.Rsi_10 & QQQ.Return_70_days < -15%"
elif self.TQQQ.Rsi_10.Current_Value <= self.SOXL.Rsi_10.Current_Value:
self.SOXL.Counter += 0.50 - (config.TQQQFTLT_CASH_BUFFER * 0.50)
self.SOXL.Function = "TQQQFTLT_Sub_Strategy_4 TQQQ.Rsi_10 <= SOXL.Rsi & QQQ.Return_70_days < -15%"
else:
return_list = [(self.SPY, self.SPY.Return_15.Current_Value),
(self.QQQ, self.QQQ.Return_15.Current_Value),
(self.DIA, self.DIA.Return_15.Current_Value),
(self.XLP, self.XLP.Return_15.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 += 0.25 - (config.TQQQFTLT_CASH_BUFFER * 0.25)
symbol.Function = "TQQQFTLT_Sub_Strategy_4_pick_2_1x_ETF's"
counter_ += 1
def TQQQFTLT_Sub_Strategy_2(self):
if self.Securities["SPY"].Price > self.SPY.SMA_20.Current_Value:
self.SPY.Counter += 0.25 - (config.TQQQFTLT_CASH_BUFFER * 0.25)
self.SPY.Function = "TQQQFTLT_Sub_Strategy_2 SPY_Price > SPY.SMA_20"
else:
if self.TLT.Rsi_10.Current_Value > self.SQQQ.Rsi_10.Current_Value:
self.QQQ.Counter += 0.25 - (config.TQQQFTLT_CASH_BUFFER * 0.25)
self.QQQ.Function = "TQQQFTLT_Sub_Strategy_2 TLT.Rsi_10 > SQQQ.Rsi_10"
elif self.TLT.Rsi_10.Current_Value <= self.SQQQ.Rsi_10.Current_Value:
self.PSQ.Counter += 0.25 - (config.TQQQFTLT_CASH_BUFFER * 0.25)
self.PSQ.Function = "TQQQFTLT_Sub_Strategy_2 TLT.Rsi_10 <= SQQQ.Rsi_10"
def TQQQFTLT_Sub_Strategy_3(self):
if self.TLT.Rsi_10.Current_Value > self.SQQQ.Rsi_10.Current_Value:
self.QQQ.Counter += 0.25 - (config.TQQQFTLT_CASH_BUFFER * 0.25)
self.QQQ.Function = "TQQQFTLT_Sub_Strategy_3 TLT.Rsi_10 > SQQQ.Rsi_10"
elif self.TLT.Rsi_10.Current_Value <= self.SQQQ.Rsi_10.Current_Value:
self.PSQ.Counter += 0.25 - (config.TQQQFTLT_CASH_BUFFER * 0.25)
self.PSQ.Function = "TQQQFTLT_Sub_Strategy_3 TLT.Rsi_10 <= SQQQ.Rsi_10"
#############################################################################################
def BlackSwan_MeanRev_BondSignal(self,outer_allocation):
if self.TQQQ.Rsi_10.Current_Value > 79:
self.VXX.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
else:
#BlackSwan_Huge_Volatility
if self.TQQQ.Return_6.Current_Value < -0.12:
if self.TQQQ.Return_1.Current_Value > 0.05:
self.VXX.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
else:
#BlackSwan_MEAN_REVISION
if self.TQQQ.Rsi_10.Current_Value < 32:
self.TQQQ.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
else:
if self.TMF.Drawdown_10.Current_Value < 0.07:
self.TQQQ.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
else:
self.BIL.Counter += outer_allocation * 0 - (config.CASH_BUFFER * outer_allocation * 0)
else:
#BlackSwan_NORMAL_MARKET
if self.QQQ.Drawdown_10.Current_Value > 0.06:
self.BIL.Counter += outer_allocation * 0 - (config.CASH_BUFFER * outer_allocation * 0 )
else:
if self.TMF.Drawdown_10.Current_Value > 0.07:
self.BIL.Counter += outer_allocation * 0 - (config.CASH_BUFFER * outer_allocation * 0)
else:
if self.Securities["QQQ"].Price > self.QQQ.SMA_25.Current_Value:
self.TQQQ.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
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)
else:
self.BIL.Counter += outer_allocation * 0 - (config.CASH_BUFFER * outer_allocation * 0)
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)
else:
self.BIL.Counter += outer_allocation * 0 - (config.CASH_BUFFER * outer_allocation * 0)
else:
self.BIL.Counter += outer_allocation * 0 - (config.CASH_BUFFER * outer_allocation * 0)
def SPY_FOR_LONG_TERM(self,outer_allocation):
if self.Securities["SPY"].Price > self.SPY.SMA_200.Current_Value:
if self.SPY.Rsi_10.Current_Value > 80:
self.TLT.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
#self.TLT.Function = f"SPY.Rsi_10.Current_Value > 80 / SPY_Price={self.Securities['SPY'].Price} > SPY_200_SMA={self.SPY.SMA_200.Current_Value} & SPY_10_RSI={self.SPY.Rsi_10.Current_Value}"
else:
if self.SPY.Rsi_60.Current_Value > 60:
self.TLT.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
#self.TLT.Function = f"self.SPY.Rsi_60.Current_Value > 60 / SPY_60_RSI={self.SPY.Rsi_60.Current_Value} > 60"
else:
self.SPY.Counter += (outer_allocation * 0.9) - (config.CASH_BUFFER * (outer_allocation * 0.9))
#self.SPY.Function = f"self.SPY.Rsi_60.Current_Value < 60 / SPY_60_RSI={self.SPY.Rsi_60.Current_Value} < 60"
self.UPRO.Counter += (outer_allocation * 0.1) - (config.CASH_BUFFER * (outer_allocation * 0.1))
#self.UPRO.Function = f"self.SPY.Rsi_60.Current_Value < 60 / SPY_60_RSI={self.SPY.Rsi_60.Current_Value} < 60"
else:
if self.QQQ.Rsi_10.Current_Value < 31:
self.TECL.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
#self.TECL.Function = f"self.QQQ.Rsi_10.Current_Value < 31 / QQQ_10_RSI={self.QQQ.Rsi_10.Current_Value} < 31"
else:
if self.Securities["SPY"].Price < self.SPY.SMA_30.Current_Value:
if self.SHY.Rsi_10.Current_Value > self.SDS.Rsi_10.Current_Value:
self.SPY.Counter += (outer_allocation * 0.5) - (config.CASH_BUFFER * (outer_allocation * 0.5))
#self.SPY.Function = f"SHY.Rsi_10 > SDS.Rsi_10 / SHY_10_RSI={self.SHY.Rsi_10.Current_Value} > SDS_10_RSI={self.SDS.Rsi_10.Current_Value}"
self.BND.Counter += (outer_allocation * 0.5) - (config.CASH_BUFFER * (outer_allocation * 0.5))
#self.BND.Function = f"SHY.Rsi_10 > SDS.Rsi_10 / SHY_10_RSI={self.SHY.Rsi_10.Current_Value} > SDS_10_RSI={self.SDS.Rsi_10.Current_Value}"
else:
self.SH.Counter += (outer_allocation * 0.5) - (config.CASH_BUFFER * (outer_allocation * 0.5))
#self.SH.Function = f"SHY.Rsi_10 < SDS.Rsi_10 / SHY_10_RSI={self.SHY.Rsi_10.Current_Value} < SDS_10_RSI={self.SDS.Rsi_10.Current_Value}"
self.BND.Counter += (outer_allocation * 0.5) - (config.CASH_BUFFER * (outer_allocation * 0.5))
#self.BND.Function = f"SHY.Rsi_10 < SDS.Rsi_10 / SHY_10_RSI={self.SHY.Rsi_10.Current_Value} < SDS_10_RSI={self.SDS.Rsi_10.Current_Value}"
else:
self.SPY.Counter += outer_allocation - (config.CASH_BUFFER * outer_allocation)
#self.SPY.Function = f"SPY.Price > SPY.SMA_30 / SPY_Price={self.Securities['SPY'].Price} > SPY_30_SMA={self.SPY.SMA_30.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(0.34)
else:
if self.BND.Return_60.Current_Value > self.BIL.Return_60.Current_Value:
self.Risk_On_Normal_Market_Conditions(0.34)
else:
if self.TLT.Return_20.Current_Value < self.BIL.Return_20.Current_Value:
self.Risk_Off_Rising_Rates(0.34)
else:
self.Risk_On_Falling_Rates_HFEA(0.34)
def Risk_Off_Market_Crash(self, outer_allocation):
self.SHY.Counter += outer_allocation * 0 - (config.CASH_BUFFER * outer_allocation * 0)
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_ >= 2:
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 * 0 - (config.CASH_BUFFER * outer_allocation * 0)
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 QS_Pop_Bot_LETF_AWP(self,outer_allocation):
# self.QQQ_Pop_Bot(0.5 * outer_allocation)
# self.SOXX_Pop_Bot(0.5 * outer_allocation)
# def QQQ_Pop_Bot(self,outer_allocation):
# if self.TQQQ.Rsi_16.Current_Value > 78:
# self.SQQQ.Counter += (outer_allocation * 0.5) - (config.CASH_BUFFER * (outer_allocation * 0.5))
# else:
# if self.TQQQ.Rsi_15.Current_Value < 25:
# self.TQQQ.Counter += (outer_allocation * 0.5) - (config.CASH_BUFFER * (outer_allocation * 0.5))
# else:
# self.Left_AWP(outer_allocation)
# def Left_AWP(self,outer_allocation):
# if self.VIXM.Rsi_10.Current_Value > 75:
# self.ICSH.Counter += (outer_allocation * 0.5) - (config.CASH_BUFFER * (outer_allocation * 0.5))
# else:
# if self.IEF.Rsi_200.Current_Value > self.TLT.Rsi_200.Current_Value:
# self.TMF_Bull(outer_allocation)
# else:
# if self.SPY.Rsi_60.Current_Value > 50:
# self.TMV_Bull(outer_allocation)
# else:
# self.TMV_Bear(outer_allocation)
# def TMF_Bull(self,outer_allocation): # Ganesh should be direct cash allocation, no RSI comparison required
# rsi_list = [(self.TMF, self.TMF.Rsi_5.Current_Value),
# (self.TYD, self.TYD.Rsi_5.Current_Value),
# (self.UPRO, self.UPRO.Rsi_5.Current_Value),
# (self.UDOW, self.UDOW.Rsi_5.Current_Value),
# (self.TQQQ, self.TQQQ.Rsi_5.Current_Value),
# (self.URTY, self.URTY.Rsi_5.Current_Value),
# (self.XLU, self.XLU.Rsi_5.Current_Value),
# (self.NUGT, self.NUGT.Rsi_5.Current_Value),
# (self.UPRO, self.UPRO.Rsi_5.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_ >= 9:
# break
# symbol.Counter += (outer_allocation * 0.055) - (config.CASH_BUFFER * (outer_allocation * 0.055))
# counter_ += 1
# def TMV_Bull(self,outer_allocation):
# self.TMV.Counter += (outer_allocation * 0.2) - (config.CASH_BUFFER * (outer_allocation * 0.5))
# self.USDU.Counter +=(outer_allocation * 0.5) - (config.CASH_BUFFER * (outer_allocation * 0.5))
# self.XLU.Counter += (outer_allocation * 0.1) - (config.CASH_BUFFER * (outer_allocation * 0.1))
# self.NUGT.Counter += (outer_allocation * 0.05) - (config.CASH_BUFFER * (outer_allocation * 0.05))
# self.TYO.Counter += (outer_allocation * 0.1) - (config.CASH_BUFFER * (outer_allocation * 0.1))
# def TMV_Bear(self,outer_allocation):
# self.TMV.Counter += (outer_allocation * 0.25) - (config.CASH_BUFFER * (outer_allocation * 0.25))
# self.USDU.Counter += (outer_allocation * 0.25) - (config.CASH_BUFFER * (outer_allocation * 0.25))
# def SOXX_Pop_Bot(self,outer_allocation):
# if self.SOXL.Rsi_15.Current_Value > 80:
# self.SOXS.Counter += (outer_allocation * 0.5) - (config.CASH_BUFFER * (outer_allocation * 0.5))
# else:
# if self.SOXL.Rsi_10.Current_Value < 30:
# self.SOXL.Counter += (outer_allocation * 0.5) - (config.CASH_BUFFER * (outer_allocation * 0.5))
# else:
# self.Left_AWP(outer_allocation)
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.VXX is None and symbol == "VXX":
self.VXX = 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.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.UVXY is None and symbol == "UVXY":
self.UVXY = Symbol_Object
if self.SMH is None and symbol == "SMH":
self.SMH = Symbol_Object
if self.DIA is None and symbol == "DIA":
self.DIA = Symbol_Object
if self.XLP is None and symbol == "XLP":
self.XLP = Symbol_Object
if self.XLV is None and symbol == "XLV":
self.XLV = Symbol_Object
if self.XLF is None and symbol == "XLF":
self.XLF = Symbol_Object
if self.LABU is None and symbol == "LABU":
self.LABU = Symbol_Object
if self.UTSL is None and symbol == "UTSL":
self.UTSL = Symbol_Object
if self.DRN is None and symbol == "DRN":
self.DRN = 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.VXX is not None:
self.VXX.Update_With_Intraday_Bar(self.Securities["VXX"].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.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.UVXY is not None:
self.UVXY.Update_With_Intraday_Bar(self.Securities["UVXY"].Close)
if self.LABU is not None:
self.LABU.Update_With_Intraday_Bar(self.Securities["LABU"].Close)
if self.UTSL is not None:
self.UTSL.Update_With_Intraday_Bar(self.Securities["UTSL"].Close)
if self.DRN is not None:
self.DRN.Update_With_Intraday_Bar(self.Securities["DRN"].Close)
if self.DIA is not None:
self.DIA.Update_With_Intraday_Bar(self.Securities["DIA"].Close)
if self.XLP is not None:
self.XLP.Update_With_Intraday_Bar(self.Securities["XLP"].Close)
if self.SMH is not None:
self.SMH.Update_With_Intraday_Bar(self.Securities["SMH"].Close)
if self.XLV is not None:
self.XLV.Update_With_Intraday_Bar(self.Securities["XLV"].Close)
if self.XLF is not None:
self.XLF.Update_With_Intraday_Bar(self.Securities["XLF"].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.VXX 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.EFA is None or self.EEM is None or self.SHY is None or self.UVXY is None or self.SDS is None or self.SH is None or self.SMH is None or self.DIA is None or self.XLP is None or self.XLV is None or self.XLF is None or self.LABU is None or self.UTSL is None or self.DRN is None:
return
self.Update_Intraday = False
if self.Trade_Decision:
self.Clear_Weightings()
self.Main_Strategy()
self.Orders()
self.Trade_Decision = False#region imports
from AlgorithmImports import *
#endregion
"""
"""
BACKTEST_START_YEAR = 2022 # Set start Year of the Backtest
BACKTEST_START_MONTH = 10 # Set start Month of the Backtest
BACKTEST_START_DAY = 14 # Set start Day of the Backtest
BACKTEST_END_YEAR = 2023 # Set end Year of the Backtest
BACKTEST_END_MONTH = 1 # Set end Month of the Backtest
BACKTEST_END_DAY = 11 # 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 = ['SHY', 'TECL', 'SOXL', 'FAS', 'TQQQ', 'UPRO', 'TMF', 'USDU', 'SQQQ', 'TBF', 'BIL', 'PHDG', 'TMV',
'UDOW', 'MOAT', 'BRK.B', 'USMV', 'SPY', 'QQQ', 'SPXL', 'DBC', 'DBA', 'ICSH', 'TYD', 'URTY', 'XLU', 'NUGT',
'TYO', 'VIXM', 'IEF', 'SOXS', 'BND', 'VTI', 'TLT', 'VXX', 'PSQ', 'VIXY', 'BSV', 'SPHB', 'USD', 'SPXU',
'EWZ', 'MVV', 'UCO', 'UUP', 'QLD', 'GLD', 'YCS', 'TECS', 'SPXS', 'ERX', 'EPI', 'TNA', 'EUO', 'AGG',
'PUI', 'EFA', 'EEM', 'SH', 'SDS', 'UVXY', 'SMH', 'DIA', 'XLP', 'XLV', 'XLF', 'LABU', 'UTSL', 'DRN']
REBALANCE_THRESHOLD = 5
# Cash Buffer in Percent, 0.05 = 5%
CASH_BUFFER = 0 #0.05
TQQQFTLT_CASH_BUFFER = 0
# # Cash allocation for each Stratagey
hedged_lev_bnd_outer_alloation = 0.35
# hfea_outer_allocation = 0.35
# spy_flt_outer_allocation = 0.2
# black_swan_outer_allocation = 0.1
# In minutes before market close
TRADE_DECISION_TIME = 2
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_5_PERIOD = 5
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_14_PERIOD = 14
RSI_15_PERIOD = 15
RSI_16_PERIOD = 16
RSI_17_PERIOD = 17
RSI_18_PERIOD = 18
RSI_20_PERIOD = 20
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_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_20_PERIOD = 20
# Period for the Daily SMA
SMA_2_PERIOD = 2
SMA_12_PERIOD = 12
SMA_20_PERIOD = 20
SMA_23_PERIOD = 23
SMA_25_PERIOD = 25
SMA_30_PERIOD = 30
SMA_150_PERIOD = 150
SMA_200_PERIOD = 200
SMA_360_PERIOD = 360
CUSTOM_DRAWDOWN_5_PERIOD = 5
CUSTOM_DRAWDOWN_8_PERIOD = 8
CUSTOM_DRAWDOWN_10_PERIOD = 10
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 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
"""
**
* 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 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 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
#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)
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_5_Period = config.RSI_5_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_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_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_20_Period = config.STDEV_RETURN_20_PERIOD
self.STDEV_Return_10_Period = config.STDEV_RETURN_10_PERIOD
self.STDEV_Return_5_Period = config.STDEV_RETURN_5_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_12_Period = config.SMA_12_PERIOD
self.SMA_20_Period = config.SMA_20_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_150_Period = config.SMA_150_PERIOD
self.SMA_200_Period = config.SMA_200_PERIOD
self.SMA_360_Period = config.SMA_360_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.Function = ""
self.Current_Position = 0
self.Rsi_5 = Intraday_Updating_RSI(algorithm, self.Rsi_5_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_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_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_12 = Intraday_Updating_SMA(algorithm, self.SMA_12_Period)
self.SMA_20 = Intraday_Updating_SMA(algorithm, self.SMA_20_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_150 = Intraday_Updating_SMA(algorithm, self.SMA_150_Period)
self.SMA_200 = Intraday_Updating_SMA(algorithm, self.SMA_200_Period)
self.SMA_360 = Intraday_Updating_SMA(algorithm, self.SMA_360_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.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_20 = CustomReturnStdev(algorithm, symbol, self.STDEV_Return_20_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, 400, 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_5.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_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_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_12.Receive_Main_Bar(bar)
self.SMA_20.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_150.Receive_Main_Bar(bar)
self.SMA_200.Receive_Main_Bar(bar)
self.SMA_360.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.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_20.Receive_Main_Bar(bar)
self.EMA_210.Receive_Main_Bar(bar)
self.EMA_360.Receive_Main_Bar(bar)
self.Rsi_5.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_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_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_12.Updated_Today = True
self.SMA_20.Updated_Today = True
self.SMA_23.Updated_Today = True
self.SMA_25.Updated_Today = True
self.SMA_30.Updated_Today = True
self.SMA_150.Updated_Today = True
self.SMA_200.Updated_Today = True
self.SMA_360.Updated_Today = True
self.Drawdown_5.Updated_Today = True
self.Drawdown_8.Updated_Today = True
self.Drawdown_10.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_20.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_5.Updated_Today:
self.Rsi_5.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_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_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_12.Updated_Today:
self.SMA_12.Receive_Sub_Bar(price)
if self.SMA_20.Updated_Today:
self.SMA_20.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_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_360.Updated_Today:
self.SMA_360.Receive_Sub_Bar(price)
if self.Drawdown_5.Updated_Today:
self.Drawdown_5.Receive_Sub_Bar(self.Daily_High, self.Daily_Low)
if self.Drawdown_8.Updated_Today:
self.Drawdown_8.Receive_Sub_Bar(self.Daily_High, self.Daily_Low)
if self.Drawdown_10.Updated_Today:
self.Drawdown_10.Receive_Sub_Bar(self.Daily_High, self.Daily_Low)
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_20.Updated_Today:
self.Return_STDEV_20.Receive_Sub_Bar(self.Daily_Open, 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_5.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_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_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_12.Updated_Today = False
self.SMA_20.Updated_Today = False
self.SMA_23.Updated_Today = False
self.SMA_25.Updated_Today = False
self.SMA_30.Updated_Today = False
self.SMA_150.Updated_Today = False
self.SMA_200.Updated_Today = False
self.SMA_360.Updated_Today = False
self.Drawdown_5.Updated_Today = False
self.Drawdown_8.Updated_Today = False
self.Drawdown_10.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_20.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 len(self.Return_Queue) == self.return_stdev_period:
if self.First_Intraday_Update_Of_Day:
self.Last_Main_Return = self.Return_Queue[0]
return_ = (close - open_) / open_
self.Return_Queue.appendleft(return_)
self.First_Intraday_Update_Of_Day = False
else:
del self.Return_Queue[0]
return_ = (close - open_) / open_
self.Return_Queue.appendleft(return_)
self.Calculate_Return_Stdev()
def Calculate_Return_Stdev(self):
#Drawdown needs to check that the LOW occurs AFTER the high! LOL
if len(self.Return_Queue) == self.return_stdev_period:
self.Current_Value = stats.stdev(self.Return_Queue)
if self.New_Main_Bar:
self.First_Intraday_Update_Of_Day = True
self.New_Main_Bar = False
from AlgorithmImports import *
from collections import deque
class CustomDrawdown():
def __init__(self, algorithm, symbol, drawdown_period):
self.algorithm = algorithm
self.drawdown_period = drawdown_period
self.High_Queue = deque(maxlen=self.drawdown_period)
self.Low_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.High_Queue[0]
del self.Low_Queue[0]
self.New_Main_Bar = True
self.High_Queue.appendleft(bar.High)
self.Low_Queue.appendleft(bar.Low)
if len(self.High_Queue) == self.drawdown_period and len(self.Low_Queue) == self.drawdown_period:
self.Calculate_Drawdown()
def Receive_Sub_Bar(self, high, low):
if len(self.High_Queue) == self.drawdown_period and len(self.Low_Queue) == self.drawdown_period:
if self.First_Intraday_Update_Of_Day:
self.Last_Main_High = self.High_Queue[0]
self.Last_Main_Low = self.Low_Queue[0]
self.High_Queue.appendleft(high)
self.Low_Queue.appendleft(low)
self.First_Intraday_Update_Of_Day = False
else:
del self.High_Queue[0]
del self.Low_Queue[0]
self.High_Queue.appendleft(high)
self.Low_Queue.appendleft(low)
self.Calculate_Drawdown()
def Calculate_Drawdown(self):
if len(self.High_Queue) == self.drawdown_period and len(self.Low_Queue) == self.drawdown_period:
high = 0
idx = None
for i in range(0, len(self.High_Queue)):
if self.High_Queue[i] > high:
high = self.High_Queue[i]
idx = i
low = 100000000
for i in range(0, idx+1):
if self.Low_Queue[i] < low:
low = self.Low_Queue[i]
hh = high
ll = low
self.Current_Value = abs((ll - hh) / hh)
if self.New_Main_Bar:
self.First_Intraday_Update_Of_Day = True
self.New_Main_Bar = False
from AlgorithmImports import *
from collections import deque
class CustomReturnMA():
def __init__(self, algorithm, symbol, return_ma_period):
self.algorithm = algorithm
self.symbol = symbol
self.return_ma_period = return_ma_period + 1
self.Return_Queue = deque(maxlen=self.return_ma_period)
self.Current_Value = None
self.First_Intraday_Update_Of_Day = True
self.Last_Main_Return = None
self.New_Main_Bar = True
self.WarmUP = True
self.Updated_Today = False
def Receive_Main_Bar(self, bar):
if not self.First_Intraday_Update_Of_Day:
del self.Return_Queue[0]
self.New_Main_Bar = True
return_ = (bar.Close - bar.Open) / bar.Open
self.Return_Queue.appendleft(return_)
if len(self.Return_Queue) == self.return_ma_period:
self.Calculate_Return_MA()
def Receive_Sub_Bar(self, open_, close):
if 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