help with adding moving averages to a fundamental screen

Back to Community

posted

I'm new to Python so this is all a little confusing to me as of now. I'm trying to create a list of stocks from four sectors (consumer cyclicals, tech, consumer defensives an industrials). I'm trying to combine all those stocks in a list and then rank them by return on invested capital (roic) and go long the top 50 and short the bottom 50, rebalanced monthly. I'm pretty sure the attached code does all this

I'm trying to add a wrinkle to it but can't seem to figure it out. I would like to only go long the high roic stocks if the sma 50 > sma 200 and only go short the bottom stocks if sma 200 < sma 50. I would like this new screen/filter to run daily. Any help would be very much appreciated.

Clone Algorithm

Backtest from to with initial capital

Cumulative performance:

Total Returns

Alpha

Beta

Sharpe

Sortino

Max Drawdown

Benchmark Returns

Volatility

Returns	1 Month	3 Month	6 Month	12 Month

Alpha	1 Month	3 Month	6 Month	12 Month

Beta	1 Month	3 Month	6 Month	12 Month

Sharpe	1 Month	3 Month	6 Month	12 Month

Sortino	1 Month	3 Month	6 Month	12 Month

Volatility	1 Month	3 Month	6 Month	12 Month

Max Drawdown	1 Month	3 Month	6 Month	12 Month

# Backtest ID: 5946d1263cceb4697b3d88c6

"""
Trading Strategy using Fundamental Data

1. Look at stocks in the Q1500US and staples, discretionary, tech and industrials.
2. Go long in the top 10? stocks by roic.
3. Go short in the bottom 100 stocks by roic.
4. Rebalance once a month at market open.
"""

from quantopian.algorithm import attach_pipeline, pipeline_output
from quantopian.pipeline import Pipeline
from quantopian.pipeline.data import morningstar
from quantopian.pipeline.filters.morningstar import Q1500US
from quantopian.pipeline.factors import BusinessDaysSincePreviousEvent
from quantopian.pipeline.classifiers.morningstar import Sector
from quantopian.pipeline.factors import SimpleMovingAverage


def initialize(context):
    
    # Rebalance monthly on the first day of the month at market open
    schedule_function(rebalance,
                      date_rule=date_rules.month_start(days_offset=1),
                      time_rule=time_rules.market_open())

    attach_pipeline(make_pipeline(), 'fundamentals_pipeline')

def make_pipeline():

    # Latest roic ratio.
    roic = morningstar.operation_ratios.roic.latest

    
    # Q1500US is a pre-defined universe of liquid securities. 
    # You can read more about it here: https://www.quantopian.com/posts/the-q500us-and-q1500us
    sector = Sector()  
    sector_filter = sector.eq((sector.CONSUMER_CYCLICAL) or (sector.TECHNOLOGY) or (sector.CONSUMER_DEFENSIVE) or (Sector.INDUSTRIALS))
    
    
    
    universe = Q1500US() & sector_filter

    # Top 50 and bottom 50 stocks ranked by roic
    top_roic_stocks = roic.top(50, mask=universe)
    bottom_roic_stocks = roic.bottom(50, mask=universe)
    
    # Screen to include only securities tradable for the day
    securities_to_trade = (top_roic_stocks | bottom_roic_stocks)
    
    pipe = Pipeline(
              columns={
                'roic': roic,
                'longs': top_roic_stocks,
                'shorts': bottom_roic_stocks,
              },
              screen = securities_to_trade
          )

    return pipe
    
"""
Runs our fundamentals pipeline before the marke opens every day.
"""
def before_trading_start(context, data): 

   
    
    context.pipe_output = pipeline_output('fundamentals_pipeline')

    #high roic stocks for longs
    context.longs = context.pipe_output[context.pipe_output['longs']].index

    # low roic stocks to short
    context.shorts = context.pipe_output[context.pipe_output['shorts']].index

def rebalance(context, data):
    
    my_positions = context.portfolio.positions
    
    # If we have at least one long and at least one short from our pipeline. Note that
    # we should only expect to have 0 of both if we start our first backtest mid-month
    # since our pipeline is scheduled to run at the start of the month.
    if (len(context.longs) > 0) and (len(context.shorts) > 0):

        # Equally weight all of our long positions and all of our short positions.
        long_weight = 0.5/len(context.longs)
        short_weight = -0.5/len(context.shorts)
        
        # Get our target names for our long and short baskets. We can display these
        # later.
        target_long_symbols = [s.symbol for s in context.longs]
        target_short_symbols = [s.symbol for s in context.shorts]

        log.info("Opening long positions each worth %.2f of our portfolio in: %s" \
                 % (long_weight, ','.join(target_long_symbols)))
        
        log.info("Opening short positions each worth %.2f of our portfolio in: %s" \
                 % (short_weight, ','.join(target_short_symbols)))
        
        # Open long positions in our high p/e stocks.
        for security in context.longs:
            if data.can_trade(security):
                if security not in my_positions:
                    order_target_percent(security, long_weight)
            else:
                log.info("Didn't open long position in %s" % security)

        # Open short positions in our low p/e stocks.
        for security in context.shorts:
            if data.can_trade(security):
                if security not in my_positions:
                    order_target_percent(security, short_weight)
            else:
                log.info("Didn't open short position in %s" % security)
                  

    closed_positions = []
    
    # Close our previous positions that are no longer in our pipeline.
    for security in my_positions:
        if security not in context.longs and security not in context.shorts \
        and data.can_trade(security):
            order_target_percent(security, 0)
            closed_positions.append(security)
    
    log.info("Closing our positions in %s." % ','.join([s.symbol for s in closed_positions]))

3 responses

Dan Whitnable

I'd suggest moving the logic into the algorithm and out of pipeline definition. Separate the data from the logic (though here it's still mixed together a bit).
I like using the 'query' method to easily perform logic. Add the SMA factors to the pipeline definition then maybe change your 'before_trading_start' method to something like this.

def before_trading_start(context, data): 

    context.pipe_output = pipeline_output('fundamentals_pipeline')

    #high roic stocks for longs  
    context.longs = (context.pipe_output.  
                     query('longs == True and sma_50 > sma_200').  
                     index.tolist()  
                     )

    # low roic stocks to short  
    context.shorts = (context.pipe_output.  
                     query('shorts == True and sma_50 < sma_200').  
                     index.tolist()  
                     )

Attached is a backtest with that change (note that I shortened the backtest timeframe to reduce run time).