prices = get_pricing('MSFT', fields=['high', 'low', 'close_price'], start_date='2014', end_date='2014-03')
prices.head()

from talib import WILLR

msft_willr = WILLR(prices.high.values, prices.low.values, prices.close_price.values, timeperiod=14)
msft_willr

from matplotlib.pyplot import subplots

# Create a figure with a 2 x 1 stack of subplots.
figure, (top, bottom) = subplots(2, 1, sharex=True)

# Write our computed WILLR values into the top plot.
top.plot(prices.index, msft_willr, color='purple')
top.set_ylabel("Williams' %R")
top.set_title('MSFT Momentum')

# Tell pandas to write our DataFrame values into the bottom plot.
prices.plot(ax=bottom).set_ylabel('US Dollars')

from numpy import nan, isnan

from quantopian.pipeline import Pipeline, CustomFactor
from quantopian.pipeline.data.builtin import USEquityPricing as USEP
from quantopian.research import run_pipeline

def columnwise_anynan(array2d):
    # isnan will be broadcasted over the array to produce a 2D array of bools.
    # array.any(axis=0) gives us a 1D array whose length is equal to the
    # number of columns in the array.
    return isnan(array2d).any(axis=0)


class WILLRFactor(CustomFactor):
    inputs = [USEP.high, USEP.low, USEP.close]
    window_length = 14
    
    def compute(self, today, assets, out, high, low, close):
        """
        Compute WILLR on each column of high, low, and close.
        """
        # Assume that a nan in high implies a nan in low or close.
        # If we had datasets from different sources, we'd probably
        # want to do something like:
        # columnwise_anynan(high) | columnwise_anynan(low) | columnwise_anynan(close).
        anynan = columnwise_anynan(high)
        
        # In general, it's a bad practice to iterate over numpy arrays like this in pure
        # python. Unfortunately, TALib doesn't provide us with an API to vectorize
        # operations over 2D arrays, so we're stuck with doing this.
        # A nice improvement to Zipline would be to provide a module that does this 
        # efficiently in Cython.
        for col_ix, have_nans in enumerate(anynan):
            
            # If we have nans in the input (e.g., because an asset didn't trade for a 
            # full day, or because the asset hasn't existed for 14 days), just forward
            # the NaN.
            if have_nans:
                out[col_ix] = nan
                continue
            
            # Compute our actual WILLR value.
            # The [:, ix] syntax here is telling Numpy to slice along the second dimension.
            # Just doing array[ix] would give us rows instead of columns
            results = WILLR(
                high[:, col_ix], 
                low[:, col_ix], 
                close[:, col_ix], 
                timeperiod=self.window_length
            )
            
            # Results is a length 14 array containing 13 leading NaNs and then the actual value
            # we care about.  Needless to say, this is less efficient than it could be.
            out[col_ix] = results[-1]

willr = WILLRFactor()

p = Pipeline(
    columns={
        'willr': willr, 
        'latest_close': USEP.close.latest, 
        'latest_high': USEP.high.latest, 
        'latest_low': USEP.low.latest
    }, 
    screen=willr.notnan(),
)

result = run_pipeline(p, '2014', '2014-03')

result

MSFT = symbols('MSFT')

msft_result = result.xs(MSFT, level=1)
msft_result