def initialize(context): """ Called once at the start of the algorithm. """ c = context c.etf_universe = StaticAssets( symbols('XLY', 'XLP', 'XLE', 'XLF', 'XLV', 'XLI', 'XLB', 'XLK', 'XLU')) c.alphas = pd.DataFrame() # Rebalance every day, 1 hour after market open. schedule_function( rebalance, date_rules.every_day(), time_rules.market_open(hours=1), ) # Record tracking variables at the end of each day. schedule_function( record_vars, date_rules.every_day(), time_rules.market_close(), ) # Create our dynamic stock selector. attach_pipeline(make_pipeline(context), 'pipeline') attach_pipeline(make_pipeinit(context), 'pipeinit') c.first_trading_day = True c.factor_name_list = make_factor().keys()
def initialize(context): """ Called once at the start of the algorithm. """ feature_num = 11 context.orders_submitted = False large_num = 9999999 least_num = 0 context.n_components = feature_num context.security = symbol(SYMBOL) # Trade SPY set_benchmark(symbol(SYMBOL)) # Set benchmarks context.model = SVC(kernel='rbf', tol=1e-3, random_state=0, gamma=0.2, C=10.0, verbose=True) # 8.05 for SVM model context.lookback = 350 # Look back 62 days context.history_range = 350 # Only consider the past 400 days' history context.threshold = 4.05 context.longprices = large_num context.shortprices = least_num set_long_only() # Generate a new model every week schedule_function(create_model, date_rules.week_end(), time_rules.market_close(minutes=10)) """ # Generate a new model every week schedule_function(create_model1, date_rules.week_end(), time_rules.market_close(minutes=10)) """ # Trade at the start of every day schedule_function(rebalance, date_rules.every_day(), time_rules.market_open(minutes=1))
def initialize(context): """ A function to define things to do at the start of the strategy """ # set the account currency, only valid for backtests set_account_currency("USD") # universe selection context.short_dollar_basket = { symbol('FXCM:AUD/USD'):1, symbol('FXCM:EUR/USD'):1, symbol('FXCM:GBP/USD'):1, symbol('FXCM:NZD/USD'):1, symbol('FXCM:USD/CAD'):-1, symbol('FXCM:USD/CHF'):-1, symbol('FXCM:USD/JPY'):-1, } # Call rebalance function on the first trading day of each month after 2.5 hours from market open schedule_function(rebalance, date_rules.month_start(days_offset=0), time_rules.market_close(hours=2, minutes=30)) # set trading cost and slippage to zero set_commission(fx=commission.PipsCost(cost=0.00)) set_slippage(fx=slippage.FixedSlippage(0.00))
def initialize(context): """ Called once at the start of a backtest, and once per day at the start of live trading. In live trading, the stored context will be loaded *after* this function is called. """ # Rebalance every day, 1 hour after market open. algo.schedule_function( rebalance, algo.date_rules.month_start(), algo.time_rules.market_open(hours=1), ) algo.schedule_function( bonds, algo.date_rules.month_start(days_offset=1), algo.time_rules.market_open(hours=1), ) algo.set_benchmark(algo.sid("FIBBG000BDTBL9")) # Create a pipeline to select stocks each day. algo.attach_pipeline(make_pipeline(), 'pipeline') # algo.set_min_leverage(0, datetime.timedelta(30)) # algo.set_max_leverage(1.2) context.trend_filter = False
def initialize(context): """ Called once at the start of the algorithm. """ feature_num = 11 context.orders_submitted = False large_num = 9999999 least_num = 0 context.n_components = feature_num context.security = symbol(SYMBOL) # Trade SPY set_benchmark(symbol(SYMBOL)) # Set benchmarks context.model = DecisionTreeClassifier(criterion='entropy', max_depth=feature_num, random_state=0) context.lookback = 350 # Look back 62 days context.history_range = 350 # Only consider the past 400 days' history context.threshold = 4.05 context.longprices = large_num context.shortprices = least_num set_long_only() # Generate a new model every week schedule_function(create_model, date_rules.week_end(), time_rules.market_close(minutes=10)) """ # Generate a new model every week schedule_function(create_model1, date_rules.week_end(), time_rules.market_close(minutes=10)) """ # Trade at the start of every day schedule_function(rebalance, date_rules.every_day(), time_rules.market_open(minutes=1))
def initialize(context): model = g_models[g_idx] print("hello world --- :",g_idx,model) attach_pipeline(make_pipeline(asset_finder=None,algo_mode=model), 'my_pipeline') schedule_function(rebalance, date_rules.week_start(days_offset=0), half_days=True) context.posset = {} context.rbcnt = 0
def initialize(context): # Schedule our rebalance function to run at the start of # each week, when the market opens. schedule_function(func=my_rebalance, date_rule=date_rules.every_day(), time_rule=time_rules.market_open())
def initialize(context): # Benchmark against the Dow Jones Industrial Average (DIA) api.set_benchmark(symbol('DIA')) # stop when trying to handle missing data api.set_nodata_policy(api.NoDataPolicy.EXCEPTION) # These are the default commission and slippage settings. Change them to fit your # brokerage fees. These settings only matter for backtesting. When you trade this # algorithm, they are moot - the brokerage and real market takes over. api.set_commission(api.commission.PerTrade(cost=0.03)) api.set_slippage(api.slippage.VolumeShareSlippage(volume_limit=0.25, price_impact=0.1)) # create an instance of the Dow30 class and set it within context context.dow30 = dow_constituents # next trade year context.year = 0 # set to True to trigger a rebalance context.trade = False # for tracking max leverage context.mx_lvrg = 0 # check for possible trades daily api.schedule_function(func=rebalance, date_rule=api.date_rules.every_day(), time_rule=api.time_rules.market_open(hours=1))
def initialize(context): """ Called once at the start of the algorithm. """ set_slippage(slippage.VolumeShareSlippage(volume_limit=0.025, price_impact=0.1)) set_commission(commission.PerShare(cost=0.01, min_trade_cost=1.00)) set_max_leverage(1.0) # Rebalance every day, 1 hour after market open. schedule_function( context.my_rebalance, date_rules.every_day(), time_rules.market_open(hours=1) ) # Close all positions every day, 30 minutes before market close. schedule_function( context.close_positions, date_rules.every_day(), time_rules.market_close(minutes=30) ) # Create risk manager context.risk_manager = RiskManager(context, daily_risk) # Create our dynamic stock selector. attach_pipeline(context.make_screener(), 'stock_screener')
def initialize(context): attach_pipeline(make_pipeline(), 'my_pipeline') # Rebalance each day. In daily mode, this is equivalent to putting # `rebalance` in our handle_data, but in minute mode, it's equivalent to # running at the start of the day each day. schedule_function(rebalance, date_rules.every_day())
def initialize(context): # Turn off the slippage model set_slippage(slippage.FixedSlippage(spread=0.0)) # Set the commission model set_commission(commission.PerShare(cost=0.01, min_trade_cost=1.0)) context.day = -1 # using zero-based counter for days context.set_benchmark(symbol('DIA')) context.assets = [] print('Setup investable assets...') for ticker in asset_tickers: #print(ticker) context.assets.append(symbol(ticker)) context.n_asset = len(context.assets) context.n_portfolio = 40 # num mean-variance efficient portfolios to compute context.today = None context.tau = None context.min_data_window = 756 # min of 3 yrs data for calculations context.first_rebal_date = None context.first_rebal_idx = None context.weights = None # Schedule dynamic allocation calcs to occur 1 day before month end - note that # actual trading will occur on the close on the last trading day of the month schedule_function(rebalance, date_rule=date_rules.month_end(days_offset=1), time_rule=time_rules.market_close()) # Record some stuff every day schedule_function(record_vars, date_rule=date_rules.every_day(), time_rule=time_rules.market_close())
def initialize(context): # Get continuous futures for Light Sweet Crude Oil... context.crude_oil = continuous_future('CL', roll='calendar') # ... and RBOB Gasoline context.gasoline = continuous_future('RB', roll='calendar') # If Zipline has trouble pulling the default benchmark, try setting the # benchmark to something already in your bundle set_benchmark(context.crude_oil) # Ignore commissions and slippage for now set_commission(us_futures=commission.PerTrade(cost=0)) set_slippage(us_futures=slippage.FixedSlippage(spread=0.0)) # Long and short moving average window lengths context.long_ma = 65 context.short_ma = 5 # True if we currently hold a long position on the spread context.currently_long_the_spread = False # True if we currently hold a short position on the spread context.currently_short_the_spread = False # Rebalance pairs every day, 30 minutes after market open schedule_function(func=rebalance_pairs, date_rule=date_rules.every_day(), time_rule=time_rules.market_open(minutes=30)) # Record Crude Oil and Gasoline Futures prices everyday schedule_function(record_price, date_rules.every_day(), time_rules.market_open())
def initialize(context): """ Initialization and trading logic """ # Set comission and slippage if enable_commission: comm_model = PerDollar(cost=commission_pct) else: comm_model = PerDollar(cost=0.0) set_commission(comm_model) if enable_slippage: slippage_model = VolumeShareSlippage( volume_limit=slippage_volume_limit, price_impact=slippage_impact) else: slippage_model = FixedSlippage(spread=0.0) # Used only for progress output context.last_month = initial_portfolio # Store index membership context.index_members = pd.read_csv('./data/sp500_members.csv', index_col=0, parse_dates=[0]) # Schedule rebalance monthly schedule_function(func=rebalance, date_rule=date_rules.month_start(), time_rule=time_rules.market_open())
def initialize(context): """ Called once at the start of the algorithm. """ feature_num = 11 context.orders_submitted = False large_num = 9999999 least_num = 0 context.n_components = 6 context.security = symbol(SYMBOL) # Trade SPY set_benchmark(symbol(SYMBOL)) # Set benchmarks context.model2 = SVC(kernel='rbf', tol=1e-3, random_state=0, gamma=0.2, C=10.0, verbose=True) # 8.05 for SVM model context.model3 = KNeighborsClassifier(n_neighbors=feature_num, p=3, metric='minkowski') # 7.05 for model context.model = DecisionTreeClassifier(criterion='entropy', max_depth=feature_num, random_state=0) context.model4 = RandomForestClassifier(criterion='entropy', n_estimators=feature_num, random_state=1, n_jobs=2) # 5.2 for randomforest context.model1 = LogisticRegression(random_state=0, solver='lbfgs', multi_class='multinomial') context.modellist = {'SVM':context.model2,'KNeighbors':context.model3,'DecisionTree':context.model,'RandomForest':context.model4,'LogisticRegression':context.model1} context.lookback = 350 # Look back 62 days context.history_range = 350 # Only consider the past 400 days' history context.threshold = 4.05 context.longprices = large_num context.shortprices = least_num context.time_series = 0 context.init = 0 set_long_only() # Generate a new model every week #schedule_function(create_model, date_rules.week_end(), time_rules.market_close(minutes=10)) """ # Generate a new model every week schedule_function(create_model1, date_rules.week_end(), time_rules.market_close(minutes=10)) """ # Trade at the start of every day schedule_function(rebalance, date_rules.every_day(), time_rules.market_open(minutes=1))
def initialize(self, context): if self.verbose: print("Starting the robo advisor") # Populate Portfolios self.all_portfolios = initialize_portfolio(self.verbose) # Set Commission model self.initialize_commission(country=self.country, platform=self.trading_platform) # Set Slippage model set_slippage(slippage.FixedSlippage(spread=0.0)) # assume spread of 0 # Schedule Rebalancing check rebalance_check_freq = date_rules.month_end() if (self.rebalance_freq == 'daily'): rebalance_check_freq = date_rules.every_day() elif (self.rebalance_freq == 'weekly'): rebalance_check_freq = date_rules.week_end() if self.verbose: print('Rebalance checks will be done %s' % self.rebalance_freq) schedule_function( func=self.before_trading_starts, date_rule=rebalance_check_freq, time_rule=time_rules.market_open(hours=1)) # record daily weights at the end of each day schedule_function( func=record_current_weights, date_rule=date_rules.every_day(), time_rule=time_rules.market_close() )
def initialize(context): """ Called once at the start of the algorithm. """ set_slippage(slippage.FixedSlippage(spread=0.00)) set_commission(commission.PerShare(cost=0, min_trade_cost=0)) schedule_function(rebalance, TRADE_FREQ, date_rules.every_day(), time_rules.market_open(hours=1, minutes=30), ) schedule_function(record_vars, date_rules.every_day(), time_rules.market_close()) ml_pipeline = make_ml_pipeline(universe, n_forward_days=N_FORWARD_DAYS, window_length=TRAINING_PERIOD) # Create our dynamic stock selector. attach_pipeline(ml_pipeline, 'ml_model') context.past_predictions = {} context.ic = 0 context.rmse = 0 context.mae = 0 context.returns_spread_bps = 0
def initialize(context): context.set_commission(commission.PerShare(cost=0.0, min_trade_cost=0)) set_benchmark(symbol('SPY')) context.asset = symbol('AAPL') context.has_ordered = False schedule_function(place_order, None, time_rules.market_open())
def initialize(context): # Set benchmark to short-term Treasury note ETF (SHY) since strategy is dollar neutral set_benchmark(symbol('AAPL')) # Schedule our rebalance function to run at the end of each day. # Modified the timing to 5 mins earlier than the market close to reduce the fail to book warnings # schedule_function(my_rebalance, date_rules.every_day(), time_rules.market_close(minutes=5)) # Try to change it to open and see what happened -- HY schedule_function(my_rebalance, date_rules.every_day(), time_rules.market_open(minutes=5)) # Record variables at the end of each day. # schedule_function(my_record_vars, date_rules.every_day(), time_rules.market_close()) # Get intraday prices today before the close if you are not skipping the most recent data # schedule_function(get_prices,date_rules.every_day(), time_rules.market_close(minutes=10)) # Try to get the price data when the market is opening -- HY # schedule_function(get_prices, date_rules.every_day(), time_rules.market_open(minutes=1)) # Set commissions and slippage to 0 to determine pure alpha set_commission(commission.PerShare(cost=0, min_trade_cost=0)) set_slippage(slippage.FixedSlippage(spread=0)) # Number of quantiles for sorting returns for mean reversion context.nq = 5 # Number of quantiles for sorting volatility over five-day mean reversion period context.nq_vol = 3 # Create our pipeline and attach it to our algorithm. my_pipe = make_pipeline() attach_pipeline(my_pipe, 'my_pipeline')
def initialize(context): # Ethereum contract #context.contract = ContractHandler() # Get blacklist of sectors which returns a list of codes #context.blacklist = context.contract.getBlacklist() # for testing purpose without Ethereum exclude Defense, Beer & Alcohol, Tabacco and Coal context.blacklist = [26.0, 4.0, 5.0, 29.0] # Only run get_fundamentals when necessary based on the rebalance function context.initial = True # Dictionary of stocks and their respective weights context.stock_weights = {} # Count of days before rebalancing context.days = 0 # Number of sectors to go long in context.sect_numb = 2 # Sector mappings context.sector_mappings = get_sectors(key='code') context.ticker_sector_dict = get_sector_code() # TODO: Update this accordingly (weekly?) # Rebalance monthly on the first day of the month at market open schedule_function(rebalance, date_rule=date_rules.month_start(), time_rule=time_rules.market_open())
def initialize(context): # Dictionary of stocks and their respective weights context.stock_weights = {} # Count of days before rebalancing context.days = 0 # Number of sectors to go long in context.sect_numb = 2 # Sector mappings context.sector_mappings = { 101.0: "Basic Materials", 102.0: "Consumer Cyclical", 103.0: "Financial Services", 104.0: "Real Estate", 205.0: "Consumer Defensive", 206.0: "Healthcare", 207.0: "Utilites", 308.0: "Communication Services", 309.0: "Energy", 310.0: "Industrials", 311.0: "Technology", } # Rebalance monthly on the first day of the month at market open schedule_function(rebalance, date_rule=date_rules.month_start(), time_rule=time_rules.market_open())
def initialize(context): set_commission(commission.PerDollar(cost=0.0055)) # context.strategy_name = "FOF_{mdd}" context.mdd = context.namespace["mdd"] context.fof_code = context.namespace["fof_code"] context.save2mysql = context.namespace.get("save_method", 0) context.i = 0 schedule_function(scheduled_rebalance, date_rules.month_start(days_offset=0), time_rules.market_open()) context.init_value = pd.Series() # 记录自最近一次调仓以来,组合内各基金所达到的最大净值 context.adjust_date = 0 # 记录距离最近一次季调的时间 context.stop_date = 0 # 记录距离最近一次止损的时间 # 基金池 stock = [ '000478.OF', '050002.OF', '110006.OF', '161120.OF', '000217.OF', "501018.OF", '000071.OF', '070031.OF', '000342.OF', 'B00.IPE', "HSCI.HI", '037.CS', "em_bond", "reit", "SPTAUUSDOZ.IDC", '096001.OF', 'SPX.GI', '000905.SH' ] context.stocks = [] for sym in stock: context.stocks.append(symbol(sym)) # 指数与基金的对应关系 fixed index = [ "HSCI.HI", '037.CS', "EM_BOND", "REIT", "SPTAUUSDOZ.IDC", "000905.SH", "B00.IPE", "NDX.GI", 'SPX.GI' ] index_etf = ["000071.OF","161120.OF","000342.OF",\ "070031.OF","000217.OF","000478.OF",\ "501018.OF","160213.OF",'096001.OF'] context.df_index = pd.DataFrame( data=index_etf, index=index, )
def initialize(context): print("{}:inside initialize".format(get_datetime())) schedule_function(rebalance, date_rule=date_rules.month_start(), time_rule=time_rules.market_open()) context.frequency = 120 context.loop_count = 0
def initialize(context): print("init") context.asset = symbol('IBM') context.cmo_window = 30 context.over_sell = -10 context.over_buy = 10 schedule_function(rebalance, date_rules.every_day(), time_rules.market_open())
def initialize(context): print("init") context.asset = symbol('IBM') context.natr_period = 10 context.long_multi = 0.2 context.short_multi = 0.2 context.pre_period = 1 schedule_function(rebalance, date_rules.every_day(), time_rules.market_open())
def initialize(context): context.assets = { 'a1': symbol('AAPL'), 'a2': symbol('GE'), 'a3': symbol('WMT') } schedule_function(cte_mix_handle, date_rules.every_day())
def initialize(context): print("init") context.asset = symbol('JD') context.bop_window = 20 context.over_buy = 0.5 context.over_sell = -0.5 schedule_function(rebalance, date_rules.every_day(), time_rules.market_open())
def initialize(context): context.begin = time.time() context.security = sid(118267) # ISHARES RUSSELL 3000 ETF context.small = 30 context.large = 70 schedule_function(rebalance, date_rules.week_start(), time_rules.market_open())
def initialize(context): print('初始化策略') context.asset = symbol('IBM') context.adx_buy_line = 40 context.adx_sell_line = 20 context.adx_window = 7 schedule_function(rebalance, date_rules.every_day(), time_rules.market_open())
def initialize(context): print("init") context.asset = symbol('IBM') context.adosc_window = 14 context.fast_period = 3 context.slow_period = 10 schedule_function(rebalance, date_rules.every_day(), time_rules.market_open())
def initialize(context): __build_deeplearn_strategy(context) attach_pipeline(make_pipeline(context), 'my_pipeline') schedule_function(rebalance, date_rules.every_day(), time_rules.every_minute()) # record my portfolio variables at the end of day print("initialize over") pass
def initialize(context): context.params = {'lookback':12, 'min_volume':1E7 } schedule_function(strategy, date_rules.every_day(), time_rules.market_open(minutes=30)) attach_pipeline(make_strategy_pipeline(context), name='strategy_pipeline')
def initialize(context): attach_pipeline(make_pipeline(), 'my_pipeline') # Rebalance each day. In daily mode, this is equivalent to putting # `rebalance` in our handle_data, but in minute mode, it's equivalent to # running at the start of the day each day. schedule_function(rebalance, date_rules.every_day()) # Explicitly set the commission to the "old" value until we can # rebuild example data. # github.com/quantopian/zipline/blob/master/tests/resources/ # rebuild_example_data#L105 context.set_commission(commission.PerShare(cost=.0075, min_trade_cost=1.0))
def initialize(context): context.has_ordered = False set_commission(commission.PerShare(cost=0.0, min_trade_cost=0.0)) set_slippage(slippage.FixedSlippage(spread=0.0)) schedule_function(func0, date_rules.week_end())
def initialize (context) : # Algorithm parameters are defined here if ENVIRONMENT == 'RESEARCH': context.benchmark = symbols('SPY') context.risk_free = symbols('SHY') context.cash_proxy = symbols('SHY') elif ENVIRONMENT == 'ZIPLINE' or ENVIRONMENT == 'IDE': context.benchmark = symbol('SPY') context.risk_free = symbol('SHY') context.cash_proxy = symbol('SHY') context.algo_transforms = [(['price'], ROCP, ['mom_63'], 62), (['price'], ROCP, ['mom_21'], 20), (['price'], average_historic_volatility, ['hvol_20'], 63, 20), (['price'], SMA, ['short_mavg'], 21), (['price'], SMA, ['long_mavg'], 63) ] if ENVIRONMENT == 'ZIPLINE' or ENVIRONMENT == 'IDE': context.strategies = { 'strategy1': { 'strat_wt' : 1.0, 'strat_type' : 'SIGNAL', 'alloc_type' : 'EQWT', 'portfolios' : [ symbols('VHT', 'VGT', 'VCR', 'IBB', 'EDV', 'VB', 'VAW', 'TLT') ], 'weights' : [1.0], 'n_top' : [1], 'zscore_data' : ['+mom_63', '+mom_21', '-hvol_20'], 'zscore_weights' : [0.7, 0.0, 0.3], # 'filter' : [lambda x,y: (x > y) & (x > 0), 'mom_21', ('mom_21', context.risk_free)] # 'filter' : [] 'filter' : [lambda x,y: x > y, 'mom_63', ('mom_63', context.risk_free)], 'buy_trigger' : [lambda x,y: (x > y) and (context.buy_flag==False), 'short_mavg', 'long_mavg'], 'sell_trigger' : [lambda x,y : (x < y) and (context.buy_flag==True), 'short_mavg', 'long_mavg'] } } elif ENVIRONMENT == 'RESEARCH': context.strategies = { 'strategy1': { 'strat_wt' : 1.0, 'strat_type' : 'SIGNAL', 'alloc_type' : 'EQWT', 'portfolios' : [ [symbols('VHT'), symbols('VGT'), symbols('VCR'), symbols('IBB'), symbols('EDV'), symbols('VB'), symbols('VAW'), symbols('TLT')] ], 'weights' : [1.0], 'n_top' : [1], 'zscore_data' : ['+mom_63', '+mom_21', '-hvol_20'], 'zscore_weights' : [0.7, 0.0, 0.3], # 'filter' : [lambda x,y: (x > y) & (x > 0), 'mom_21', # ('mom_21', context.risk_free)] # 'filter' : [] 'filter' : [lambda x,y: x > y, 'mom_63', ('mom_63', context.risk_free)], 'buy_trigger' : [lambda x,y: (x > y) and (context.buy_flag==False), 'short_mavg', 'long_mavg'], 'sell_trigger' : [lambda x,y : (x < y) and (context.buy_flag==True), 'short_mavg', 'long_mavg'] } } # have to set this manually 'til I figure how to generate it programmatically from above parameters context.max_lookback = 120 # need additional data for recursive indicators like EMA, historic_vol etc. # set the appropriate time_rule offsets (hours, minutes) for order processing context.order_time_rule = time_rules.market_close(hours=0, minutes=1) context.threshold = 0.0 # only BUY/SELL if asset QTY changes by threshold% set_commission(commission.PerTrade(cost=0.0)) set_slippage(slippage.FixedSlippage(spread=0)) ####################################################################################### # THE FOLLOWING MUST ALWAYS BE INCLUDED AND MUST PRECEDE ANY SCHEDULED FUNCTIONS! # include this check to make sure that the algo parameters are formatted as required check_algo_parameters (context) # create a set of all the symbols used by the algorithm create_symbol_list(context) initialize_strat_variables(context) if ENVIRONMENT != 'IDE': add_strat_history(context) ####################################################################################### schedule_function(generate_strat_data, # date_rule=date_rules.month_start(days_offset=0), date_rule=date_rules.month_start(days_offset=0), time_rule=time_rules.market_open(hours=0, minutes=1), half_days=True) # schedule_function_by_interval(context, test_signal, # date_rule=date_rules.every_day(), # time_rule=time_rules.market_open(hours=0, minutes=5), # half_days=True, # freq=1) # the 'freq' parameter is added to the norma schedule_function routine # to enable intervals of 'freq' periods - 1,2,3,..... months schedule_function_by_interval(context, rebalance, date_rule=date_rules.month_start(days_offset=0), time_rule=time_rules.market_open(hours=0, minutes=5), half_days=True, freq=1) schedule_function_by_interval(context, handle_orders, date_rule=date_rules.month_start(days_offset=0), time_rule=time_rules.market_close(hours=0, minutes=15), half_days=True, freq=1)
def initialize(context, date_limits, verbose, symbols): print "in initialize" start_time_initialize = time.time() context.verbose = verbose # Define rebalance frequency context.scheduler = SCHEDULER if context.scheduler == 'Daily': schedule_function(rebalance) if context.scheduler == 'Weekly': schedule_function(rebalance, date_rules.week_end()) elif context.scheduler == 'Monthly': schedule_function(rebalance, date_rules.month_end()) context.date_limits = date_limits # Set slippage model and commission model set_slippage(slippage.FixedSlippage(spread=SLIPPAGE_SPREAD)) set_commission(commission.PerShare(cost=COMMISSION_COST_PER_SHARE, min_trade_cost=COMMISSION_MIN_TRADE_COST)) context.symbols = symbols symbol_membership = utils.get_underlying(context.symbols, sep = ' / ') symbol_membership.index = context.symbols context.symbol_membership = symbol_membership if REFERENCE_GROUP_SYMBOL['Cash'] in context.symbol_membership.index: context.symbol_membership.loc[REFERENCE_GROUP_SYMBOL['Cash']] = 'Cash' asset_keys = utils.get_asset_keys_db() if RETS_READER is not None: returns = utils.get_returns_db(RETS_READER, context.symbols, asset_keys) else: returns = None if VOL_READER is not None and CORR_READER is not None: volatility = utils.get_volatilities_db(VOL_READER, context.symbols, asset_keys) correlations = utils.get_correlations_db(CORR_READER, context.symbols, asset_keys) else: volatility, correlations = [None]*2 data_dict = {'returns': returns, 'volatility': volatility, 'correlations': correlations} context.data_dict = data_dict #print returns #print '' #print '' #print volatility #print '' #print '' #print correlations #print asfasfasf # Group group = "Top" if len(sys.argv) >= 3 and 'ASSETTYPE=' in sys.argv[2]: group = sys.argv[2].split('=')[-1] params_dict = {} params_dict.update(data_dict) params_dict.update(PARAMS['params']) ag_name = 'Top' if group == 'Equity': ag_name = PARAMS['params']['group'] context.group = AbstractGroup(context.symbols, name = ag_name, start=START_DATE_BT_STR, end = END_DATE_BT_STR, verbose = verbose, strategy_id = ID, scheduler = SCHEDULER , **params_dict) #print "DEBUG [context.group.updated_symbols] : \n", context.group.updated_symbols context.round_weights = 4 context.ref_group_df = pd.DataFrame(pd.Series({v:k for k,v in REFERENCE_GROUP_SYMBOL.items()})) context.active_orders = [] if verbose: print "INFO: Initialize took %f s." % (time.time() - start_time_initialize)
def schedule_function_by_interval (context, func, date_rule, time_rule, half_days=True, freq=1): context.interval_counter[func] = {'freq':freq, 'count':freq, 'periods':freq} # print ('\n\nINTERVAL COUNTER\n{}'.format(context.interval_counter)) schedule_function (func, date_rule, time_rule, half_days) return