Beispiel #1
0
def run_strategy(context, data):

    # Get the data for the previous 900 minutes
    stock_data = data.history(context.stock, ["close"], 900, "1m")
    for stock in context.stock:
        # aggregate 15 minutes, all OHLCV columns
        stock_data["close"][stock] = (stock_data["close"][stock]).resample("15T", label="right", closed="right").last()

    stock_data["close"].dropna(inplace=True)

    # Calculate the SMAs
    for stock in context.stock:
        # Get the last 20 close prices
        last_20_prices = stock_data["close"][stock].iloc[-context.length_small_sma:]

        # Calculate the 20 SMA
        sma_20 = last_20_prices.mean()

        # Get the last 50 close prices
        last_50_prices = stock_data["close"][stock].iloc[-context.length_long_sma:]

        # Calculate the 50 SMA
        sma_50 = last_50_prices.mean()

        # Placing orders
        # Long Entry
        if ((sma_20 > sma_50) & (context.portfolio.positions[stock].amount == 0)):
            print("{} Going long on {}".format(get_datetime(), stock))
            order_target_percent(stock, 0.5)

        # Exiting Long entry
        elif ((sma_20 < sma_50) & (context.portfolio.positions[stock].amount != 0)):
            print("{} Exiting {}".format(get_datetime(), stock))
            order_target_percent(stock, 0)
Beispiel #2
0
def handle_data(context, data):
    print context
    #raw_input()

    #输出每天持仓情况

    if not context.has_ordered:
        for stock in data:
            #openprice=history(3, '1d', 'open')
            closeprice = history(5, '1d', 'close')
            #-2:昨天,-3 前天.-4 大前天
            print get_datetime(), closeprice[sid(stock)][0], closeprice[sid(
                stock)][1], closeprice[sid(stock)][2], closeprice[sid(
                    stock)][3], closeprice[sid(stock)][4]
            #print closeprice,closeprice[sid(stock)][1]
            if closeprice[sid(stock)][-2] > closeprice[sid(
                    stock)][-3] and closeprice[sid(stock)][-3] > closeprice[
                        sid(stock)][-4]:
                print "buy", get_datetime()
                order(stock, 300)
            elif closeprice[sid(stock)][-2] < closeprice[sid(
                    stock)][-3] and closeprice[sid(stock)][-3] < closeprice[
                        sid(stock)][-4]:
                print "sell", get_datetime()
                order(stock, -300)
Beispiel #3
0
    def _update_portfolio_metrics(self, context, data, s):
        strategy_price = 0
        for p_no, p in enumerate(s.portfolios):
            price = np.sum([
                context.portfolio.positions[a].amount *
                data.current(a, 'price') for a in p.all_assets
            ]) * s.weights[p_no]
            p.metrics.prices[get_datetime()] = price
            strategy_price += price
            try:
                calculate_SR = context.calculate_SR
                nominal_price = np.sum([
                    p.allocation_model.weights[i] *
                    data.current(security, 'price')
                    for i, security in enumerate(p.securities)
                ])
                p.metrics.nominal_prices[get_datetime()] = nominal_price
            except:
                calculate_SR = False

            if calculate_SR:
                try:
                    context.SR_lookback = context.SR_lookback
                    context.SD_factor = context.SD_factor
                except:
                    raise ValueError(
                        'context.SR_lookback and/or context.SR_factor missing')
                    return

                p.metrics.rolling_n_day_SR[
                    get_datetime()] = self._calculate_SR(context, data, p)

        return strategy_price
Beispiel #4
0
def get_sea(context, data):
    largecap_ret1w = context.pipeline_data.loc[symbol('000016.SH'), 'wrets']
    smallcap_ret1w = context.pipeline_data.loc[symbol('000905.SH'), 'wrets']

    vol = get_atr(context, data)
    print('atr', vol, context.seavol)
    dispersion = largecap_ret1w - smallcap_ret1w
    first_w_of_m = testday(context, data)
    last_week_return = context.pipeline_data.loc[symbol('000300.SH'), 'wrets']
    last_3m_return = context.pipeline_data.loc[symbol('000300.SH'),
                                               'returns_5M']
    eq_idx_dret = context.pipeline_data.loc[symbol('000300.SH'), 'drets']
    eq_idx_wvol = context.pipeline_data.loc[symbol('000300.SH'),
                                            'volatility'] / sqrt(
                                                242)  #beat context.seavol
    bondid = 'H11077.SH'  #'H00140.SH' `
    yld_wvol = context.pipeline_data.loc[symbol(bondid),
                                         'volatility'] / sqrt(242) * sqrt(5)
    yld_wret = context.pipeline_data.loc[symbol(bondid), 'wrets']
    rb_wret = context.pipeline_data.loc[symbol('CFRBPA.JZ'), 'wrets']
    au_wret = context.pipeline_data.loc[symbol('CFAUPA.JZ'), 'wrets']
    print('seatest', get_datetime())
    for asset in context.pipeline_data.index:
        context.seadf.loc[
            asset,
            'vol'] = 1 if vol > context.seavol else -1  # .22 (a11), .88(1+0),
        context.seadf.loc[asset, 'bond'] = np.sign(yld_wret)  #0.2sr
        context.seadf.loc[
            asset, 'mom'] = 1 if last_3m_return > 0 else -1  # .88 (a11),
        context.seadf.loc[asset, 'sea'] = first_w_of_m  #.26sr
        context.seadf.loc[asset, 'com'] = 1 if rb_wret < au_wret else -1
        context.seadf.loc[
            asset,
            'dis'] = 1 if dispersion > .005 else -1  # 0. 87(000300), 1.4(+1) -0.08 (-1)
        context.seadf.loc[asset, 'check'] = (
            np.sign(eq_idx_dret)
        ) if abs(eq_idx_dret) > eq_idx_wvol else 0  # -1 120180814 •
    sea_score = context.seadf.sum(axis=1)
    print('vol:', vol, context.seavol)
    print('bond:', yld_wret, yld_wvol)
    print('mom:', last_3m_return)
    print('com:', rb_wret, au_wret)
    print('dis1D:', context.pipeline_data.loc[symbol('000016.SH'), 'drets'],
          context.pipeline_data.loc[symbol('000905.SH'), 'drets'])
    print('dis6D:', context.pipeline_data.loc[symbol('000016.SH'),
                                              'returns_6D'],
          context.pipeline_data.loc[symbol('000905.SH'), 'returns_6D'])
    print('dis1W:', context.pipeline_data.loc[symbol('000016.SH'), 'wrets'],
          context.pipeline_data.loc[symbol('000905.SH'), 'wrets'])
    print('get_returns', largecap_ret1w, smallcap_ret1w)
    print('seaoverall:',
          get_datetime().strftime('%Y-%m-%d'), ',',
          sea_score.loc[symbol('000300.SH')], '\n',
          context.seadf.loc[symbol('000300.SH')])
    #test_dis = context.seadf.loc[symbol('000300.SH'), 'dis' ]
    toggle = 1  #if (sea score. loc[symbol('000300.SH')) - test_dis)*test_dis > 0 else .5
    return (np.sign(sea_score), toggle)
Beispiel #5
0
def generate_signals(context, data):
    try:
        results = pipeline_output('strategy_pipeline')
    except NoFurtherDataError:
        print('no data for {}'.format(get_datetime()))
    
    # use other columns to print other indicators scanning results
    rsi = results.rsi.sort_values(ascending=True)
    print('{}{}'.format(get_datetime(),'-'*30))
    print(rsi[:5])
    print(rsi[-5:])
Beispiel #6
0
def handle_data(context, data):
    # check if the spot is outside CI of MPP
    day_option_df = context.options[context.options['date'] == get_datetime()]
    call_sums = call_otm(day_option_df, 'FB', get_datetime())
    put_sums = put_otm(day_option_df, 'FB', get_datetime())

    add_to_window(context, 10, max_pain_strike(call_sums, put_sums), 'FB')
    ci = CI(context.window, 1)

    price = history(1, '1d', 'price').iloc[0, 0]
    if price < ci[0]: order_target_percent(symbol('FB'), 1)
    elif price > ci[1]: order_target_percent(symbol('FB'), 0)
Beispiel #7
0
def handle_data(context, data):
	# check if the spot is outside CI of MPP
	day_option_df = context.options[context.options['date'] == get_datetime()]
	call_sums = call_otm(day_option_df, 'FB', get_datetime())
	put_sums = put_otm(day_option_df, 'FB', get_datetime())
	
	add_to_window(context, 10, max_pain_strike(call_sums, put_sums), 'FB')
	ci = CI(context.window, 1)

	price = history(1, '1d', 'price').iloc[0,0]
	if price < ci[0]: order_target_percent(symbol('FB'), 1)
	elif price > ci[1]: order_target_percent(symbol('FB'), 0)
def trade(context, data):
    if not context.fired:
        context.rebalance_date = get_datetime()
        #print("build portfolio at " + str(context.rebalance_date))
        init_portfolio(context, data)
        context.fired = True
    else:
        now = get_datetime()
        if (need_rebalance(context, now)):
            #print("new rebalance arrivid:" + str(now))
            context.rebalance_date = now
            rebalance(context, data)
Beispiel #9
0
def handle_data(context, data):
    context.save2mysql = 0
    context.i += 1
    print str(get_datetime())
    record(weights=None)
    # 按照最大回撤值止损
    context.adjust_date += 1
    context.stop_date += 1
    weight = get_weight(context)
    # print  weight
    stocks = weight.keys()
    stop_loss_flag = True  # 记录本次是否

    # 更新最大净值
    for stock in stocks:
        current_price = data[stock]["price"]
        try:
            current_price > context.init_value[stock]
        except:
            assert (False)
        if current_price > context.init_value[stock]:
            context.init_value[stock] = current_price

    # 判断是否需要止损
    if context.adjust_date > 5 and context.adjust_date < 55 and \
            context.stop_date > 5:
        ben_loss = -0.05
        for stock in stocks:
            current_price = data[stock]["price"]
            returns = (current_price -
                       context.init_value[stock]) / context.init_value[stock]
            if returns < 0:
                # 分风险类别进行止损,激进组合止损不同
                if context.mdd < 0.07:
                    a = returns
                else:
                    a = returns * weight[stock] / (1 + returns)
                if a < ben_loss:
                    stop_loss(context, stock, data)
                    print "!!紧急调仓: " + str(get_datetime())
                    print stock, current_price, context.init_value[stock]
                    stop_loss_flag = False
            else:
                continue

    if stop_loss_flag:
        record(weights=None)
        record(rebalance_reason=None)
    else:
        context.stop_date = 0

    context.old_value = context.portfolio.portfolio_value
Beispiel #10
0
def testday(context, data):
    from zipline.utils.tradingcalendar import trading_day
    from pandas import date_range

    tdate = get_datetime()
    tdate_mon = tdate.strftime('%m')

    week_later = tdate + relativedelta(weeks=+1)
    week_before = tdate + relativedelta(weeks=-1)
    print('week_later', week_later.strftime('%Y-%m'), context.last_reb_month)
    sdate = week_later.strftime('%Y-%m') + '-01'
    edate = week_later.strftime('%Y-%m') + '-15'
    next_month_days = date_range(sdate,
                                 edate,
                                 freq=trading_day,
                                 tz='Asia/Shanghai')
    d1 = pd.to_datetime(tdate.strftime("%Y-%m-%d"))
    d2 = pd.to_datetime(datetime.strftime(next_month_days[0], "%Y-%m-%d"))
    d_diff = pd.Timedelta(d2 - d1).days
    first_w_of_m = 0

    if (d_diff < 5 and
            d_diff > 0) or (context.last_reb_month != tdate.strftime('%Y-%m')):
        print('mend', tdate, next_month_days[0])
        print('mdiff', type(week_later), (next_month_days[0]))
        first_w_of_m = 1
    print('first_w_of_m', first_w_of_m, d_diff, d1, d2)

    return np.sign(first_w_of_m)
Beispiel #11
0
def initialize(context):
    """
    use our factors to add our pipes and screens.
    """
    pipe = Pipeline()
    attach_pipeline(pipe, 'ff_example')

    mkt_cap = MarketEquity()
    pipe.add(mkt_cap, 'market_cap')

    book_equity = BookEquity()
    # book equity over market equity
    bm = book_equity/mkt_cap
    pipe.add(bm, 'bm')

    # 营运能力
    op = OP()
    pipe.add(op, 'op')

    # 投资因子
    inv = INV()
    pipe.add(inv, 'inv')

    returns = Returns(window_length=2)
    pipe.add(returns, 'returns')
    
    dt = get_datetime().normalize()
    start_ = dt if dt > START_DATE else START_DATE
    context.result = result.loc[start_: , :]
Beispiel #12
0
    def wrapper(context, data):
        dt = get_datetime()
        if dt.date() != context.current_date:
            context.warmup -= 1
            context.mins_for_days.append(1)
            context.current_date = dt.date()
        else:
            context.mins_for_days[-1] += 1

        hist = context.history(2, '1d', 'close_price')
        for n in (1, 2, 3):
            if n in data:
                if data[n].dt == dt:
                    context.vol_bars[n].append(data[n].volume)
                else:
                    context.vol_bars[n].append(0)

                context.price_bars[n].append(data[n].price)
            else:
                context.price_bars[n].append(np.nan)
                context.vol_bars[n].append(0)

            context.last_close_prices[n] = hist[n][0]

        if context.warmup < 0:
            return f(context, data)
def rebalance(context, data):
    # Wait for 756 trading days (3 yrs) of historical prices before trading
    if context.day < context.min_data_window - 1:
        return
    # Get expanding window of past prices and compute returns
    context.today = get_datetime().date() 
    prices = data.history(context.assets, "price", context.day, "1d")
    if context.first_rebal_date is None:
        context.first_rebal_date = context.today
        context.first_rebal_idx = context.day
        print('Starting dynamic allocation simulation...')
    # Get investment horizon in days ie number of trading days next month
    context.tau = rnr.get_num_days_nxt_month(context.today.month, context.today.year)
    # Calculate HFP distribution
    asset_rets = np.array(prices.pct_change(context.tau).iloc[context.tau:, :])
    num_scenarios = len(asset_rets)
    # Set Flexible Probabilities Using Exponential Smoothing
    half_life_prjn = 252 * 2 # in days
    lambda_prjn = np.log(2) / half_life_prjn
    probs_prjn = np.exp(-lambda_prjn * (np.arange(0, num_scenarios)[::-1]))
    probs_prjn = probs_prjn / sum(probs_prjn)
    mu_pc, sigma2_pc = rnr.fp_mean_cov(asset_rets.T, probs_prjn)
    # Perform shrinkage to mitigate estimation risk
    mu_shrk, sigma2_shrk = rnr.simple_shrinkage(mu_pc, sigma2_pc)
    weights, _, _ = rnr.efficient_frontier_qp_rets(context.n_portfolio, 
                                                          sigma2_shrk, mu_shrk)
    print('Optimal weights calculated 1 day before month end on %s (day=%s)' \
        % (context.today, context.day))
    #print(weights)
    min_var_weights = weights[0,:]
    # Rebalance portfolio accordingly
    for stock, weight in zip(prices.columns, min_var_weights):
        order_target_percent(stock, np.asscalar(weight))
    context.weights = min_var_weights
Beispiel #14
0
    def rebalance(self, context, data):

        # make sure there's algo data
        if not isinstance(context.algo_data, dict):
            return
        elif not self.first_time:
            if self.rebalance_count != context.rebalance_interval:
                self.rebalance_count += 1
                return

        self.first_time = False

        self.rebalance_count = 1

        log.info('----------------------------------------------------------------------------')
        log.debug(get_datetime())

        self.allocations = pd.Series(0., index=self.all_assets)
        self.elligible = pd.Index(self.strategy_IDs)

        self.allocation_model.caller = self
        if self.regime == None:
            self._get_strategy_and_portfolio_allocations(context)
        else:
            self._check_for_regime_change_and_set_active(context)

        self.weights = self.allocation_model.get_weights(context)
        self.allocations = self._allocate_assets(context)

        self._execute_orders(context, data)

        return self.allocations
Beispiel #15
0
    def wrapper(context, data):
        dt = get_datetime()
        if dt.date() != context.current_date:
            context.warmup -= 1
            context.mins_for_days.append(1)
            context.current_date = dt.date()
        else:
            context.mins_for_days[-1] += 1

        hist = context.history(2, "1d", "close_price")
        for n in (1, 2, 3):
            if n in data:
                if data[n].dt == dt:
                    context.vol_bars[n].append(data[n].volume)
                else:
                    context.vol_bars[n].append(0)

                context.price_bars[n].append(data[n].price)
            else:
                context.price_bars[n].append(np.nan)
                context.vol_bars[n].append(0)

            context.last_close_prices[n] = hist[n][0]

        if context.warmup < 0:
            return f(context, data)
def generate_signals(context, data):
    try:
        pipeline_results = pipeline_output('strategy_pipeline')
    except NoFurtherDataError:
        context.long_securities = []
        context.short_securities = []
        return

    p = context.params['percentile']
    pipeline_results = pipeline_results[pipeline_results.vol > 0].dropna()
    vol_threshold_hi = pipeline_results.vol.quantile(0.75)
    vol_threshold_lo = pipeline_results.vol.quantile(0.25)
    high_vol = pipeline_results[pipeline_results.vol > vol_threshold_hi]
    low_vol = pipeline_results[pipeline_results.vol < vol_threshold_lo]

    short_candidates = high_vol.sort_values('skew', ascending=False)
    long_candidates = low_vol.sort_values('skew', ascending=False)
    available = min(len(long_candidates), len(short_candidates))

    n = int(available * p)
    print('total candidates {}'.format(n))

    if n == 0:
        print("{}, no signals".format(get_datetime()))
        context.long_securities = []
        context.short_securities = []

    context.long_securities = long_candidates.index[:n]
    context.short_securities = short_candidates.index[:n]
def rebalance(context, data):
    log.info("rebalance) " + str(normalize_date(get_datetime())))
    # Pipeline data will be a dataframe with boolean columns named 'longs' and
    # 'shorts'.
    pipeline_data = context.pipeline_data.dropna()
    log.info(pipeline_data.head())

    all_assets = pipeline_data.index

    longs = all_assets[pipeline_data.longs]
    shorts = all_assets[pipeline_data.shorts]

    record(universe_size=len(all_assets))

    # Build a 2x-leveraged, equal-weight, long-short portfolio.
    one_third = 1.0 / 3.0
    for asset in longs:
        order_target_percent(asset, one_third)

    for asset in shorts:
        order_target_percent(asset, -one_third)

    # Remove any assets that should no longer be in our portfolio.
    portfolio_assets = longs | shorts
    positions = context.portfolio.positions
    for asset in viewkeys(positions) - set(portfolio_assets):
        # This will fail if the asset was removed from our portfolio because it
        # was delisted.
        if data.can_trade(asset):
            order_target_percent(asset, 0)
Beispiel #18
0
def handle_data(context, data):
    # 去除时间,保留日期
    dt = get_datetime().normalize()
    context.result.loc[dt, 'SMB'] = context.smb
    context.result.loc[dt, 'HML'] = context.hml
    context.result.loc[dt, 'RMW'] = context.rmw
    context.result.loc[dt, 'CMA'] = context.cma
Beispiel #19
0
def handle_data(context, data):
    # Skip first 300 days to get full windows

    date = get_datetime()
    context.i += 1
    if context.i < 10:
        return

    prices = history(25, '1d', 'price')

    for sym in data:
        upper, middle, lower = talib.BBANDS(
            np.array(prices[sym]),
            timeperiod=20,
            nbdevup=2,
            nbdevdn=2,
            matype=0
        )

        potential_buy = []

        buy = False
        sell = False
        if data[sym].price > upper[-1] and context.portfolio.positions[sym].amount == 0:
            # log.info('buy')
            # log.info(get_datetime())
            # log.info(data[sym].price)
            # log.info(upper[-1])
            order_target_percent(sym, 1.0, limit_price=data[sym].price)
        elif data[sym].price < middle[-1] and context.portfolio.positions[sym].amount > 0:
            # log.info('sell')
            # log.info(get_datetime())
            # log.info(data[sym].price)
            # log.info(middle[-1])
            order_target(sym, 0, limit_price=data[sym].price)
def rebalance(context, data):
    #print context.pipeline_data
    print("today 0 :", type(get_datetime()), get_datetime(),
          type(context.sim_params.end_session),
          context.sim_params.end_session.day)
    if (context.sim_params.end_session.day != get_datetime().day):
        return
    print("today 1 :", get_datetime())

    pipeline_data = context.pipeline_data
    pipeline_data.index = [index.symbol for index in pipeline_data.index]

    shorts, longs = context.strategy.compute_allocation(data, pipeline_data)
    print("to trade:", shorts, longs)
    context.strategy.trade(shorts, longs)
    pass
def before_trading_start(context, data):
    dt = api.get_datetime()

    # rebalance at the beginning or at the beginning of a new year
    if context.year == 0 or context.year == dt.year or len(context.portfolio) != 10:
        context.trade = True
        context.year = dt.year + 1

        # get our dow 30 stocks
        members = get_dow(context.dow30)
        sids = [m.sid for m in members]

        # get fundamentals, save, and update universe
        # PROBLEM: this does not always sync up with Dow30
        # PROBLEM: example, returns "CAT"/1267 and "CAT_WI"/11740
        fundamentals_df = api.get_fundamentals(
            api
            .query(
                api.fundamentals.valuation_ratios.pe_ratio,
                api.fundamentals.valuation_ratios.dividend_yield,
            )
            .filter(api.fundamentals.share_class_reference.sid.in_(sids))
            .order_by(
                api.fundamentals.valuation_ratios.dividend_yield.desc()  # sort by highest to lowest dividend yield
            )
            .limit(10)  # take the top 10 highest paying dividend
        )

        context.fundamentals_df = fundamentals_df  # save to context to use during rebalance()
        api.update_universe(fundamentals_df.columns.values)
Beispiel #22
0
    def n_period_momentum(self, context):

        # percentage increase over n periods
        # arg[0] = no of periods
        # arg[1] = period : 'D'|'W'|'M' (day|week||month)

        h = context.dp[self.inputs[0]]

        lookback = self.kwargs['lookback']
        period = self.kwargs['period']

        if period in ['W', 'M']:
            if h.index[-1].date() == get_datetime().date():
                ds = h.resample('M', how='last').pct_change(lookback).iloc[-1]
            else:
                ds = h.resample('M', how='last').pct_change(lookback).iloc[-2]
        else:
            ds = h.pct_change(lookback).iloc[-1]

        df = pd.DataFrame(0, index=h.index, columns=h.columns)
        df.iloc[-1] = ds

        context.dp[self.outputs[0]] = df

        return context.dp
Beispiel #23
0
def handle_data(context, data):
    now = get_datetime()
    today = datetime(now.year, now.month, now.day, 0, 0)

    # Get current day's headlines
    current_headlines = []
    for i in range(0, len(context.headlines)):
        if (today == context.headlines.iloc[i]['date']):
            current_headlines.append((context.headlines.iloc[i]['ticker'],
                                      context.headlines.iloc[i]['text']))

    print current_headlines
    # Calculate sentiment
    sentiment = dict()
    for headline in current_headlines:
        ticker = headline[0]
        text = headline[1]
        #TODO: Get score from classifier
        score = -1
        if ticker in sentiment.keys():
            sentiment[ticker] += score
        else:
            sentiment[ticker] = score

    # Long/Short stocks based on sentiment
    for ticker in sentiment.keys():
        #TODO: Order stocks
        if sentiment[ticker] > context.long_thresh:
            #long stocks
            print "long " + ticker
        if sentiment[ticker] < context.short_thresh:
            #short stocks
            print "short " + ticker
    return
def scheduled_rebalance(context, data):
    month = get_datetime().month
    if month == scheduled_month:
        stocks = patch_fund(context, data)
        print(stocks)
        # print stocks
        rebalance(context, data, stocks)
Beispiel #25
0
def rebalance(context, data):

    if not interval_countdown(context, data, rebalance):
        return

    #generate_strat_data(context, data)

    print ('\nREBALANCE {}'.format(get_datetime()))

    context.new_weights = pd.Series(0., index=context.stocks)

    for strategy in context.strategies :
        for portfolio_no, assets in enumerate(context.strategies[strategy]['portfolios']):

            # rank portfolio assets according to zscore parameters
            ranks = rank_assets (context, strategy, assets, portfolio_no)        

            #elligible_pre portfolio assets are those with rank <= n_top
            elligible_pre = ranks.index[ranks<=context.strategies[strategy]['n_top']]
            # apply asset filter
            elligible_post = filter_assets(context, strategy, elligible_pre, context.strategies[strategy]['filter'])

            # asset allocation
            new_weights = allocate_assets(context, strategy, portfolio_no, elligible_pre, elligible_post)
            context.new_weights = context.new_weights + new_weights

    return
Beispiel #26
0
def show_positions (context, data):

    if context.order_placed == True :

        print ('\n{}'.format(get_datetime().date()))

        print ('\nPOSITIONS\n\n')
        for asset in context.stocks : 
            if context.portfolio.positions[asset].amount > 0 :
                print ( '{0} : QTY = {1}, COST BASIS {2:3.2f}, CASH = {3:7.2f}, POSITIONS VALUE = {4:7.2f}, TOTAL = {5:7.2f}'
                       .format(asset, context.portfolio.positions[asset].amount,
                               context.portfolio.positions[asset].cost_basis,
                               context.portfolio.cash, 
                               context.portfolio.positions[asset].amount * data[asset].price,
                               context.portfolio.portfolio_value))

        # retrieve all the open orders and log the total open amount  
        # for each order  
        open_orders = get_open_orders()  
        # open_orders is a dictionary keyed by sid, with values that are lists of orders.  
        if open_orders:  
            # iterate over the dictionary  
            for security, orders in open_orders.iteritems():  
                # iterate over the orders  
                for oo in orders:  
                    message = '\nOutstanding open order for {amount} shares in {stock}'  
                    message = message.format(amount=oo.amount, stock=security)  
                    print(message)
            return
        else:
            # wait until all orders filled before resetting this flag
            context.order_placed = False
    return
 def process_record(self, record):
     """
     use the date of the trading day for log purposes
     """
     super().process_record(record)
     if self.arena == 'live':
         send_mail(record.channel + " " + record.level_name, record.message)
     record.time = get_datetime()
Beispiel #28
0
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
Beispiel #29
0
def handle_data(context, data):
    sentiment = dict()
    now = get_datetime()
    today = datetime(now.year, now.month, now.day, 0, 0)
    print list(context.headlines['date'])[0]
    print today
    for headline in list(
            context.headlines[context.headlines['date'] == today]):
        print headline
def handle_data(context, data):

    context.i += 1
    print(get_datetime())

    record(weights=None)
    record(TRC=None)
    record(MRC=None)
    record(rebalance_reason=None)
Beispiel #31
0
def handle_data(context, data):
	day_option_df = context.options[context.options['date'] == get_datetime()]
	call_options = day_option_df[day_option_df['type'] == 'C']

	################################## classifier stuff happens somewhere here
	call_options_good = call_options # call_options_good is the classified call_options
	##################################

	# purchase the options that we think will end up in the money (could also modify this to give weight to it)
	for index, row in call_options_good.iterrows():
		context.bought_options = rbind(context.bought_options, row)
		cash -= row['price']

	# exercise expiring options that we've bought (assuming strike price is lower than expiration price)
	expiring_calls = context.bought_options[context.bought_options['expiration'] == get_datetime()]
	for index, row in expiring_calls.iterrows():
		price = history(symbol(row['ticker']), '1d', 'price').iloc[0,0]
        cash += 100*max(price - row['strike'], 0) # assuming 100:1 ratio equity:option
Beispiel #32
0
def handle_data(context, data):
    contract = data.current(context.my_cf, 'contract')
    log.info(contract)
    log.info(get_datetime())
    x = data.current(contract, 'price')
    log.info(x)
    # order_target(contract, 10)
    #order_target_value(contract, 100000)
    order_target_percent(contract, 1.0)
Beispiel #33
0
    def handle_data(context, data):
        """This function will be executed every minute to check
		if an order should be placed now, and place the order if so."""
        # quant = 0 if timestamp of now is not in context.trades
        quant = context.trades.get(get_datetime(), 0)
        if quant != 0:
            order(context.asset, quant)  # place an order
        # use "_asset" as a temporary placeholder col name for actual trading pair
        record(_asset=data.current(context.asset, 'price'))
def handle_data(context, data):
    # Get current date
    now = str(get_datetime('US/Eastern'))[0:11] + "00:00:00+0000"

    # Get current state
    state = gv.TP_matrixs.ix[now].values

    # Epsilon-greedy Algorithm
    # Choose an action to execute according to current state
    probab = random.random()
    if probab <= gv.epsilon:
        # Epsilon
        # Take random action
        action = gv.action_set[random.randint(0, 2)]
    else:
        # 1 - epsilon
        # Take the action of the highest Q-Value
        action_values = [gv.Q_function(state, gv.action_set[0]),
                         gv.Q_function(state, gv.action_set[1]),
                         gv.Q_function(state, gv.action_set[2])]
        action = gv.action_set[action_values.index(max(action_values))]

    # Execute chosen action
    if action == gv.action_set[0]:
        # Sell
        order(context.security, -gv.mu)
    elif action == gv.action_set[1]:
        # Buy
        order(context.security, gv.mu)
    elif action == gv.action_set[2]:
        # Hold
        pass

    # Construct labeled data
    global Q_data, Q_labels
    # Juage if it's the first day
    if context.action_prev != "":
        y = context.portfolio.portfolio_value - \
            context.portfolio_prev + gama * gv.Q_function(state, action)
        # Add new data
        if Q_data[context.action_prev].size == 0:
            Q_data[context.action_prev] = np.array(
                [gv.TP_matrixs.ix[context.date_prev].values.tolist()],
                dtype=np.float32)
        else:
            Q_data[context.action_prev] = np.vstack((
                Q_data[context.action_prev],
                [gv.TP_matrixs.ix[context.date_prev].values.tolist()]))
        # Add new label
        Q_labels[context.action_prev] = np.append(
            Q_labels[context.action_prev], y)

    # Update saved previous information
    context.date_prev = now
    context.action_prev = action
    context.portfolio_prev = context.portfolio.portfolio_value
Beispiel #35
0
    def view_status(self, context, data):

        if not self.actions is None:
            start_cash = float(self.param_dict["cash"]) / float(
                self.n_portfolios)
            today = str(get_datetime())[:-15]
            value = float(self.cash)
            returns = float(float(self.cash - start_cash) / start_cash * 100)
            #confidence = float(self.actions.confidence)
            n_long = int(len(self.longs))
            n_short = int(len(self.shorts))
            leverage = context.account.leverage

            date_str = "[{!s}]\t"
            ret_str = "total returns: {:03.2f}%\t"
            value_str = "value: ${:03,.2f}\t"
            s_str = "n short: {:n}\t"
            l_str = "n long: {:n}\t"
            conf_str = "confidence: {:03.2f}%"
            lev_str = "leverage: {:03.2f}"

            template = date_str + ret_str + value_str + s_str + l_str + lev_str  #+ conf_str
            template = template.format(today, returns, value, n_short, n_long,
                                       leverage)  #, confidence)

            # template = "[{!s}]\ttotal returns: {:03.2f}%\tvalue: ${:03,.2f}\tn short:{:n}\n long: {:n}\tconfidence:{:03.2f}%"\
            #     .format(today, returns, value, n_short, n_long, float(confidence))
            log.info(template)

            stocks_template = ""
            n_held = len(context.portfolio.positions)
            net_gain = 0

            for eq, pos in context.portfolio.positions.iteritems():

                ticker = eq.symbol
                n_shares = pos.amount
                current_val = pos.last_sale_price * n_shares
                paid_val = pos.cost_basis * n_shares
                net_gain += current_val - paid_val

            #   stock_template = "stock {!s}:\tnet gain: {:03.2f}\t".format(ticker, net_gain)
            #   stocks_template += stock_template
            # log.info(stocks_template)
            sign = "$" if net_gain >= 0 else "-$"
            log.info("n held: {:n}\t net gain: {!s}{:03.2f}\t".format(
                n_held, sign, abs(net_gain)))
            tickers = ""
            eqs = self.market.index.values.tolist()
            for i in xrange(min(len(eqs), 10)):

                tickers += "{!s} ".format(eqs[i].symbol)

            log.info("Market: " + tickers)

            return self.cash
 def handle_data(context, data):
     today = get_datetime()
     factors = data.factors
     for length, key in iteritems(vwap_keys):
         for asset in assets:
             computed = factors.loc[asset, key]
             expected = vwaps[length][asset].loc[today]
             # Only having two places of precision here is a bit
             # unfortunate.
             assert_almost_equal(computed, expected, decimal=2)
def handle_data(context, data):
    # 获取股票的收盘价
    close_data = history(12,'1d','close')
    # 取得过去五天的平均价格
    ma5 = close_data[-6:-2].mean()
    # 取得过去10天的平均价格
    ma10 = close_data[-11:-2].mean()
    # 取得当前的现金

    print get_datetime(),ma5,ma10
    cash = context.portfolio.cash
    
    #print ma5[sid(symbol(context.security))],ma10[sid(stock)],cash,symbol(context.security)
    #如果当前有余额,并且五日均线大于十日均线
    if ma5[sid(symbol(context.security))] > ma10[sid(symbol(context.security))]:
         order_value(symbol(context.security), cash)
    # 如果五日均线小于十日均线,并且目前有头寸
    elif ma5[sid(symbol(context.security))] < ma10[sid(symbol(context.security))]:
        # 全部卖出
        order_target(symbol(context.security), 0)
Beispiel #38
0
def handle_orders(context, data):

    if (context.new_weights == context.current_weights).all() :
        print ('\n{} ALLOCATION UNCHANGED\n'.format(get_datetime().date()))
        return

    for asset in context.new_weights.index:
        if abs(context.new_weights[asset] - context.current_weights[asset]) > context.threshold :
            print ('\n{} ORDER {} of {} @ {}'.format(get_datetime(), context.new_weights[asset],
                                                     asset, data[asset].close_price))
            order_target_percent(asset, context.new_weights[asset])

    context.current_weights = context.new_weights

    context.order_placed = True

#     print (context.strat_data['price'].ix[-1])
#     print ('\n\n', get_open_orders())

    return
Beispiel #39
0
 def handle_data(context, data):
     factors = data.factors
     date = get_datetime().normalize()
     for asset in self.assets:
         # Assets should appear iff they exist today and yesterday.
         exists_today = self.exists(date, asset)
         existed_yesterday = self.exists(date - trading_day, asset)
         if exists_today and existed_yesterday:
             latest = factors.loc[asset, 'close']
             self.assertEqual(latest, self.expected_close(date, asset))
         else:
             self.assertNotIn(asset, factors.index)
Beispiel #40
0
def handle_data(context, data):
    context.cur_time += 1
    month = get_datetime().date().month
    is_january = (month == 1)

    new_prices = np.array([data[symbol(symbol_name)].price for symbol_name in context.symbols], dtype='float32')
    record(Prices=new_prices)
    new_prices = new_prices.reshape((context.N_STOCKS, 1))
    #     print context.returns_history.shape
    #     print new_prices.shape
    #     print context.previous_prices.shape
    context.returns_history = np.concatenate([context.returns_history, new_prices / context.previous_prices], axis=1)
    context.previous_prices = new_prices

    if context.month != month:
        # Trading in the beginning of month
        context.month_sizes.append(context.day_of_month)
        context.day_of_month = 1
        context.count_month += 1
        context.month_sizes.append(context.day_of_month)
        context.day_of_month = 1
        if context.count_month > N_MONTHS:
            # Deleting too old returns
            if context.count_month > N_MONTHS + 1:
                context.returns_history = np.delete(context.returns_history, range(context.month_sizes[-14]), axis=1)

            model_input = preprocess_data_for_model(context.returns_history, context.month_sizes[-13:], context.scaler)
            is_january_column = np.array([is_january] * context.N_STOCKS).reshape((context.N_STOCKS, 1))
            model_input = np.concatenate([is_january_column, model_input], axis=1)
            #             print 'Input shape', model_input.shape
            predicted_proba = context.model.predict_proba(model_input)
            #             print predicted_proba

            '''
            half_trade = len(context.symbols) * 1 / 10
            args_sorted = np.argsort(predicted_proba[:, 0])
            buy_args = args_sorted[:half_trade]
            sell_args = args_sorted[-half_trade:]

            for arg in buy_args:
                order_target(symbol(context.symbols[arg]), 1)
            for arg in sell_args:
                order_target(symbol(context.symbols[arg]), -1)
            '''
            for i in range(context.N_STOCKS):
                if predicted_proba[i, 0] > 0.5:
                    order_target(symbol(context.symbols[i]), 1)
                else:
                    order_target(symbol(context.symbols[i]), -1)
    else:
        context.day_of_month += 1

    context.month = month
Beispiel #41
0
 def handle_data(context, data):
     results = pipeline_output("test")
     date = get_datetime().normalize()
     for asset in self.assets:
         # Assets should appear iff they exist today and yesterday.
         exists_today = self.exists(date, asset)
         existed_yesterday = self.exists(date - self.trading_day, asset)
         if exists_today and existed_yesterday:
             latest = results.loc[asset, "close"]
             self.assertEqual(latest, self.expected_close(date, asset))
         else:
             self.assertNotIn(asset, results.index)
def handle_data(context, data):
    
    # context.i+=1
    # if context.i<=5:
    #     return
    # 循环每只股票

    closeprice= history(5,'1d','close')
    for security in context.stocks:
        vwap=(closeprice[symbol(security)][-2]+closeprice[symbol(security)][-3]+closeprice[symbol(security)][-4])/3
        price = closeprice[symbol(security)][-2]
        print get_datetime(),security,vwap,price
        # # 如果上一时间点价格小于三天平均价*0.995,并且持有该股票,卖出
        if price < vwap * 0.995:
            # 下入卖出单
            order(symbol(security),-300)
            print get_datetime(),("Selling %s" % (security))
            # 记录这次卖出
            #log.info("Selling %s" % (security))
        # 如果上一时间点价格大于三天平均价*1.005,并且有现金余额,买入
        elif price > vwap * 1.005:
            # 下入买入单
            order(symbol(security),300)
            # 记录这次买入
            print get_datetime(),("Buying %s" % (security))
Beispiel #43
0
def wait_for_data (context, data):
    if context.waiting_for_data :
        print ('\n{} WAITING FOR DATA...'.format(get_datetime().date()))
        # wait for history to fill
        max_lookback = context.max_lookback
        highs = history (max_lookback, '1d', 'high')

        if not highs.ix[0].sum() > 0 : 
            return

        else:
            context.waiting_for_data = False
            return
Beispiel #44
0
        def handle_data(context, data):
            today = normalize_date(get_datetime())
            results = pipeline_output("test")
            expect_over_300 = {AAPL: today < self.AAPL_split_date, MSFT: False, BRK_A: True}
            for asset in assets:
                should_pass_filter = expect_over_300[asset]
                if set_screen and not should_pass_filter:
                    self.assertNotIn(asset, results.index)
                    continue

                asset_results = results.loc[asset]
                self.assertEqual(asset_results["filter"], should_pass_filter)
                for length in vwaps:
                    computed = results.loc[asset, vwap_key(length)]
                    expected = vwaps[length][asset].loc[today]
                    # Only having two places of precision here is a bit
                    # unfortunate.
                    assert_almost_equal(computed, expected, decimal=2)
 def handle_data(context, data):
     closes = pipeline_output('test_close')
     volumes = pipeline_output('test_volume')
     date = get_datetime().normalize()
     for asset in self.assets:
         # Assets should appear iff they exist today and yesterday.
         exists_today = self.exists(date, asset)
         existed_yesterday = self.exists(date - self.trading_day, asset)
         if exists_today and existed_yesterday:
             self.assertEqual(
                 closes.loc[asset, 'close'],
                 self.expected_close(date, asset)
             )
             self.assertEqual(
                 volumes.loc[asset, 'volume'],
                 self.expected_volume(date, asset)
             )
         else:
             self.assertNotIn(asset, closes.index)
             self.assertNotIn(asset, volumes.index)
Beispiel #46
0
def generate_strat_data (context, data) :

    print ('\n{} GENERATING STRAT_DATA...'.format(get_datetime().date()))
    
#     if ENVIRONMENT != 'IDE':
#         wait_for_data(context, data)
#     if context.waiting_for_data :
#         return

    for item in ['high', 'open_price', 'low', 'close_price', 'volume', 'price']:
        context.strat_data[item] = history(context.max_lookback, '1d', item)

    # need to do this to keep talib happy
    context.strat_data['open'] = context.strat_data['open_price']
    context.strat_data['close'] = context.strat_data['close_price']

    # return a dataframe for each transform
    for transform in context.algo_transforms :       
        panel = apply_transform(context, transform)
        context.strat_data = {i: panel[i] for i in panel.items}
Beispiel #47
0
def rebalance(context, data):
    if context.trade == True:
        log.info('REBALANCING...')
        context.trade = False
        dt = get_datetime()
        members = context.dow30.get(dt)

        for s in members:
            if s not in data:
                log.error("NoTradeDataAvailableEvent for %s" % s.symbol)

        for s in data:
            if s in members and s in context.fundamentals_df.columns:
                log.info('ordering %s, price = %.2f, yield = %.2f' % (s.symbol,
                                                                      data[s].price,
                                                                      100 * context.fundamentals_df[s].dividend_yield))
                order_target_percent(s, .1)
            else:
                order_target_percent(s, 0)
        log.info('\n')