API Reference

Examples

Create a Factor for the prior day’s close price:

>>> from zipline.pipeline import EquityPricing
>>> prior_close = EquityPricing.close.latest.shift()

pct_change(periods=1, mask=None)¶

Create a new Factor that calculates the percent change between the current and prior periods.

Parameters:

periods (int, optional) – Number of periods to shift for forming percent change.
mask (zipline.pipeline.Filter, optional) – A Filter defining values to ignore when computing pct_change.

Returns:

pct_change – A Factor computing the percent change between the current and prior periods.

Return type:

Examples

Create a Factor for the percent change in the closing price:

>>> from zipline.pipeline import EquityPricing
>>> pct_change = EquityPricing.close.latest.pct_change()

demean(mask=None, groupby=None)¶

Construct a Factor that computes self and subtracts the mean from row of the result.

If mask is supplied, ignore values where mask returns False when computing row means, and output NaN anywhere the mask is False.

If groupby is supplied, compute by partitioning each row based on the values produced by groupby, de-meaning the partitioned arrays, and stitching the sub-results back together.

Parameters:

mask (zipline.pipeline.Filter, optional) – A Filter defining values to ignore when computing means.
groupby (zipline.pipeline.Classifier, optional) – A classifier defining partitions over which to compute means.

Examples

Let f be a Factor which would produce the following output:

             AAPL   MSFT    MCD     BK
2017-03-13    1.0    2.0    3.0    4.0
2017-03-14    1.5    2.5    3.5    1.0
2017-03-15    2.0    3.0    4.0    1.5
2017-03-16    2.5    3.5    1.0    2.0

Let c be a Classifier producing the following output:

             AAPL   MSFT    MCD     BK
2017-03-13      1      1      2      2
2017-03-14      1      1      2      2
2017-03-15      1      1      2      2
2017-03-16      1      1      2      2

Let m be a Filter producing the following output:

             AAPL   MSFT    MCD     BK
2017-03-13  False   True   True   True
2017-03-14   True  False   True   True
2017-03-15   True   True  False   True
2017-03-16   True   True   True  False

Then f.demean() will subtract the mean from each row produced by f:

             AAPL   MSFT    MCD     BK
2017-03-13 -1.500 -0.500  0.500  1.500
2017-03-14 -0.625  0.375  1.375 -1.125
2017-03-15 -0.625  0.375  1.375 -1.125
2017-03-16  0.250  1.250 -1.250 -0.250

f.demean(mask=m) will subtract the mean from each row, but means will be calculated ignoring values on the diagonal, and NaNs will written to the diagonal in the output. Diagonal values are ignored because they are the locations where the mask m produced False:

             AAPL   MSFT    MCD     BK
2017-03-13    NaN -1.000  0.000  1.000
2017-03-14 -0.500    NaN  1.500 -1.000
2017-03-15 -0.166  0.833    NaN -0.666
2017-03-16  0.166  1.166 -1.333    NaN

f.demean(groupby=c) will subtract the group-mean of AAPL/MSFT and MCD/BK from their respective entries. The AAPL/MSFT are grouped together because both assets always produce 1 in the output of the classifier c. Similarly, MCD/BK are grouped together because they always produce 2:

             AAPL   MSFT    MCD     BK
2017-03-13 -0.500  0.500 -0.500  0.500
2017-03-14 -0.500  0.500  1.250 -1.250
2017-03-15 -0.500  0.500  1.250 -1.250
2017-03-16 -0.500  0.500 -0.500  0.500

f.demean(mask=m, groupby=c) will also subtract the group-mean of AAPL/MSFT and MCD/BK, but means will be calculated ignoring values on the diagonal , and NaNs will be written to the diagonal in the output:

             AAPL   MSFT    MCD     BK
2017-03-13    NaN  0.000 -0.500  0.500
2017-03-14  0.000    NaN  1.250 -1.250
2017-03-15 -0.500  0.500    NaN  0.000
2017-03-16 -0.500  0.500  0.000    NaN

Notes

Mean is sensitive to the magnitudes of outliers. When working with factor that can potentially produce large outliers, it is often useful to use the mask parameter to discard values at the extremes of the distribution:

base = MyFactor(...)
normalized = base.demean(
    mask=base.percentile_between(1, 99),
)

demean() is only supported on Factors of dtype float64.

See also

pandas.DataFrame.groupby()

zscore(mask=None, groupby=None)¶

Construct a Factor that Z-Scores each day’s results.

The Z-Score of a row is defined as:

(row - row.mean()) / row.stddev()

If mask is supplied, ignore values where mask returns False when computing row means and standard deviations, and output NaN anywhere the mask is False.

If groupby is supplied, compute by partitioning each row based on the values produced by groupby, z-scoring the partitioned arrays, and stitching the sub-results back together.

Parameters:

mask (zipline.pipeline.Filter, optional) – A Filter defining values to ignore when Z-Scoring.
groupby (zipline.pipeline.Classifier, optional) – A classifier defining partitions over which to compute Z-Scores.

Returns:

zscored – A Factor producing that z-scores the output of self.

Return type:

Notes

Mean and standard deviation are sensitive to the magnitudes of outliers. When working with factor that can potentially produce large outliers, it is often useful to use the mask parameter to discard values at the extremes of the distribution:

base = MyFactor(...)
normalized = base.zscore(
   mask=base.percentile_between(1, 99),
)

zscore() is only supported on Factors of dtype float64.

Examples

See demean() for an in-depth example of the semantics for mask and groupby.

See also

pandas.DataFrame.groupby()

rank(method='ordinal', ascending=True, mask=None, groupby=None)¶

Construct a new Factor representing the sorted rank of each column within each row.

Parameters:

method (str, {'ordinal', 'min', 'max', 'dense', 'average'}) – The method used to assign ranks to tied elements. See scipy.stats.rankdata for a full description of the semantics for each ranking method. Default is ‘ordinal’.
ascending (bool, optional) – Whether to return sorted rank in ascending or descending order. Default is True.
mask (zipline.pipeline.Filter, optional) – A Filter representing assets to consider when computing ranks. If mask is supplied, ranks are computed ignoring any asset/date pairs for which mask produces a value of False.
groupby (zipline.pipeline.Classifier, optional) – A classifier defining partitions over which to perform ranking.

Returns:

ranks – A new factor that will compute the ranking of the data produced by self.

Return type:

Notes

The default value for method is different from the default for scipy.stats.rankdata. See that function’s documentation for a full description of the valid inputs to method.

Missing or non-existent data on a given day will cause an asset to be given a rank of NaN for that day.

See also

scipy.stats.rankdata()

pearsonr(target, correlation_length, mask=None)¶

Construct a new Factor that computes rolling pearson correlation coefficients between target and the columns of self.

Parameters:

target (zipline.pipeline.Term) – The term used to compute correlations against each column of data produced by self. This may be a Factor, a BoundColumn or a Slice. If target is two-dimensional, correlations are computed asset-wise.
correlation_length (int) – Length of the lookback window over which to compute each correlation coefficient.
mask (zipline.pipeline.Filter, optional) – A Filter describing which assets should have their correlation with the target slice computed each day.

Returns:

correlations – A new Factor that will compute correlations between target and the columns of self.

Return type:

Notes

This method can only be called on expressions which are deemed safe for use as inputs to windowed Factor objects. Examples of such expressions include This includes BoundColumn Returns and any factors created from rank() or zscore().

Examples

Suppose we want to create a factor that computes the correlation between AAPL’s 10-day returns and the 10-day returns of all other assets, computing each correlation over 30 days. This can be achieved by doing the following:

returns = Returns(window_length=10)
returns_slice = returns[sid(24)]
aapl_correlations = returns.pearsonr(
    target=returns_slice, correlation_length=30,
)

This is equivalent to doing:

aapl_correlations = RollingPearsonOfReturns(
    target=sid(24), returns_length=10, correlation_length=30,
)

spearmanr(target, correlation_length, mask=None)¶

Construct a new Factor that computes rolling spearman rank correlation coefficients between target and the columns of self.

Parameters:

target (zipline.pipeline.Term) – The term used to compute correlations against each column of data produced by self. This may be a Factor, a BoundColumn or a Slice. If target is two-dimensional, correlations are computed asset-wise.
correlation_length (int) – Length of the lookback window over which to compute each correlation coefficient.
mask (zipline.pipeline.Filter, optional) – A Filter describing which assets should have their correlation with the target slice computed each day.

Returns:

correlations – A new Factor that will compute correlations between target and the columns of self.

Return type:

Notes

Examples

returns = Returns(window_length=10)
returns_slice = returns[sid(24)]
aapl_correlations = returns.spearmanr(
    target=returns_slice, correlation_length=30,
)

This is equivalent to doing:

aapl_correlations = RollingSpearmanOfReturns(
    target=sid(24), returns_length=10, correlation_length=30,
)

See also

scipy.stats.spearmanr(), Factor.pearsonr()

linear_regression(target, regression_length, mask=None)¶

Construct a new Factor that performs an ordinary least-squares regression predicting the columns of self from target.

Parameters:

target (zipline.pipeline.Term) – The term to use as the predictor/independent variable in each regression. This may be a Factor, a BoundColumn or a Slice. If target is two-dimensional, regressions are computed asset-wise.
regression_length (int) – Length of the lookback window over which to compute each regression.
mask (zipline.pipeline.Filter, optional) – A Filter describing which assets should be regressed with the target slice each day.

Returns:

regressions – A new Factor that will compute linear regressions of target against the columns of self.

Return type:

Notes

Examples

Suppose we want to create a factor that regresses AAPL’s 10-day returns against the 10-day returns of all other assets, computing each regression over 30 days. This can be achieved by doing the following:

returns = Returns(window_length=10)
returns_slice = returns[sid(24)]
aapl_regressions = returns.linear_regression(
    target=returns_slice, regression_length=30,
)

This is equivalent to doing:

aapl_regressions = RollingLinearRegressionOfReturns(
    target=sid(24), returns_length=10, regression_length=30,
)

See also

scipy.stats.linregress()

winsorize(min_percentile, max_percentile, mask=None, groupby=None)¶

Construct a new factor that winsorizes the result of this factor.

Winsorizing changes values ranked less than the minimum percentile to the value at the minimum percentile. Similarly, values ranking above the maximum percentile are changed to the value at the maximum percentile.

Winsorizing is useful for limiting the impact of extreme data points without completely removing those points.

If mask is supplied, ignore values where mask returns False when computing percentile cutoffs, and output NaN anywhere the mask is False.

If groupby is supplied, winsorization is applied separately separately to each group defined by groupby.

Parameters:

min_percentile (float, int) – Entries with values at or below this percentile will be replaced with the (len(input) * min_percentile)th lowest value. If low values should not be clipped, use 0.
max_percentile (float, int) – Entries with values at or above this percentile will be replaced with the (len(input) * max_percentile)th lowest value. If high values should not be clipped, use 1.
mask (zipline.pipeline.Filter, optional) – A Filter defining values to ignore when winsorizing.
groupby (zipline.pipeline.Classifier, optional) – A classifier defining partitions over which to winsorize.

Returns:

winsorized – A Factor producing a winsorized version of self.

Return type:

zipline.pipeline.Classifier

Examples

Given a pipeline with the following columns:

price = USEquityPricing.close.latest
columns={
    'PRICE': price,
    'WINSOR_1: price.winsorize(
        min_percentile=0.25, max_percentile=0.75
    ),
    'WINSOR_2': price.winsorize(
        min_percentile=0.50, max_percentile=1.0
    ),
    'WINSOR_3': price.winsorize(
        min_percentile=0.0, max_percentile=0.5
    ),

}

The result for a given day could look like:

        'PRICE' 'WINSOR_1' 'WINSOR_2' 'WINSOR_3'
Asset_1    1        2          4          3
Asset_2    2        2          4          3
Asset_3    3        3          4          3
Asset_4    4        4          4          4
Asset_5    5        5          5          4
Asset_6    6        5          5          4

See also

scipy.stats.mstats.winsorize(), pandas.DataFrame.groupby()

quantiles(bins, mask=None)¶

Construct a Classifier computing quantiles of the output of self.

Every non-NaN data point the output is labelled with an integer value from 0 to (bins - 1). NaNs are labelled with -1.

If mask is supplied, ignore data points in locations for which mask produces False, and emit a label of -1 at those locations.

Parameters:

bins (int) – Number of bins labels to compute.
mask (zipline.pipeline.Filter, optional) – Mask of values to ignore when computing quantiles.

Returns:

quantiles – A classifier producing integer labels ranging from 0 to (bins - 1).

Return type:

quartiles(mask=None)¶

Construct a Classifier computing quartiles over the output of self.

Every non-NaN data point the output is labelled with a value of either 0, 1, 2, or 3, corresponding to the first, second, third, or fourth quartile over each row. NaN data points are labelled with -1.

If mask is supplied, ignore data points in locations for which mask produces False, and emit a label of -1 at those locations.

Parameters:: mask (zipline.pipeline.Filter, optional) – Mask of values to ignore when computing quartiles.
Returns:: quartiles – A classifier producing integer labels ranging from 0 to 3.
Return type:: zipline.pipeline.Classifier

quintiles(mask=None)¶

Construct a Classifier computing quintile labels on self.

Every non-NaN data point the output is labelled with a value of either 0, 1, 2, 3, or 4, corresponding to quintiles over each row. NaN data points are labelled with -1.

If mask is supplied, ignore data points in locations for which mask produces False, and emit a label of -1 at those locations.

Parameters:: mask (zipline.pipeline.Filter, optional) – Mask of values to ignore when computing quintiles.
Returns:: quintiles – A classifier producing integer labels ranging from 0 to 4.
Return type:: zipline.pipeline.Classifier

deciles(mask=None)¶

Construct a Classifier computing decile labels on self.

Every non-NaN data point the output is labelled with a value from 0 to 9 corresonding to deciles over each row. NaN data points are labelled with -1.

If mask is supplied, ignore data points in locations for which mask produces False, and emit a label of -1 at those locations.

Parameters:: mask (zipline.pipeline.Filter, optional) – Mask of values to ignore when computing deciles.
Returns:: deciles – A classifier producing integer labels ranging from 0 to 9.
Return type:: zipline.pipeline.Classifier

top(N, mask=None, groupby=None)¶

Construct a Filter matching the top N asset values of self each day.

If groupby is supplied, returns a Filter matching the top N asset values for each group.

Parameters:

N (int) – Number of assets passing the returned filter each day.
mask (zipline.pipeline.Filter, optional) – A Filter representing assets to consider when computing ranks. If mask is supplied, top values are computed ignoring any asset/date pairs for which mask produces a value of False.
groupby (zipline.pipeline.Classifier, optional) – A classifier defining partitions over which to perform ranking.

Returns:

filter

Return type:

bottom(N, mask=None, groupby=None)¶

Construct a Filter matching the bottom N asset values of self each day.

If groupby is supplied, returns a Filter matching the bottom N asset values for each group defined by groupby.

Parameters:

N (int) – Number of assets passing the returned filter each day.
mask (zipline.pipeline.Filter, optional) – A Filter representing assets to consider when computing ranks. If mask is supplied, bottom values are computed ignoring any asset/date pairs for which mask produces a value of False.
groupby (zipline.pipeline.Classifier, optional) – A classifier defining partitions over which to perform ranking.

Returns:

filter

Return type:

percentile_between(min_percentile, max_percentile, mask=None)¶

Construct a Filter matching values of self that fall within the range defined by min_percentile and max_percentile.

Parameters:

min_percentile (float [0.0, 100.0]) – Return True for assets falling above this percentile in the data.
max_percentile (float [0.0, 100.0]) – Return True for assets falling below this percentile in the data.
mask (zipline.pipeline.Filter, optional) – A Filter representing assets to consider when percentile calculating thresholds. If mask is supplied, percentile cutoffs are computed each day using only assets for which mask returns True. Assets for which mask produces False will produce False in the output of this Factor as well.

Returns:

out – A new filter that will compute the specified percentile-range mask.

Return type:

isnan()¶

A Filter producing True for all values where this Factor is NaN.

Returns:: nanfilter
Return type:: zipline.pipeline.Filter

notnan()¶

A Filter producing True for values where this Factor is not NaN.

Returns:: nanfilter
Return type:: zipline.pipeline.Filter

isfinite()¶: A Filter producing True for values where this Factor is anything but NaN, inf, or -inf.

all_present(window_length, mask=None)¶

Create a Filter that returns True for assets with no missing values for window_length consecutive days.

Parameters:

window_length (int) – the number of consecutive days over which there must be no missing values
mask (zipline.pipeline.Filter, optional) – A Filter representing assets to consider when computing results. If supplied, we ignore asset/date pairs where mask produces False.

Returns:

filter – Filter returning True for assets with no missing values for window_length consecutive days.

Return type:

Examples

Create a Filter for assets with no missing price data for 200 consecutive days:

>>> from zipline.pipeline.data import EquityPricing
>>> consistently_has_data = EquityPricing.close.all_present(200)

isnull()¶

A Filter producing True for values where this Factor has missing data.

Equivalent to self.isnan() when self.dtype is float64. Otherwise equivalent to self.eq(self.missing_value).

Returns:: filter
Return type:: zipline.pipeline.Filter

notnull()¶

A Filter producing True for values where this Factor has complete data.

Equivalent to ~self.isnan()` when ``self.dtype is float64. Otherwise equivalent to (self != self.missing_value).

Returns:: filter
Return type:: zipline.pipeline.Filter

zipline.pipeline.CustomFactor ¶

class zipline.pipeline.CustomFactor(*args, **kwargs)¶

Base class for user-defined Factors.

Parameters:

inputs (iterable, optional) – An iterable of BoundColumn instances (e.g. USEquityPricing.close), describing the data to load and pass to self.compute. If this argument is not passed to the CustomFactor constructor, we look for a class-level attribute named inputs.
outputs (iterable[str], optional) – An iterable of strings which represent the names of each output this factor should compute and return. If this argument is not passed to the CustomFactor constructor, we look for a class-level attribute named outputs.
window_length (int, optional) – Number of rows to pass for each input. If this argument is not passed to the CustomFactor constructor, we look for a class-level attribute named window_length.
mask (zipline.pipeline.Filter, optional) – A Filter describing the assets on which we should compute each day. Each call to CustomFactor.compute will only receive assets for which mask produced True on the day for which compute is being called.

Notes

Users implementing their own Factors should subclass CustomFactor and implement a method named compute with the following signature:

def compute(self, today, assets, out, *inputs):
   ...

On each simulation date, compute will be called with the current date, an array of sids, an output array, and an input array for each expression passed as inputs to the CustomFactor constructor.

The specific types of the values passed to compute are as follows:

today : np.datetime64[ns]
    Row label for the last row of all arrays passed as `inputs`.
assets : np.array[int64, ndim=1]
    Column labels for `out` and`inputs`.
out : np.array[self.dtype, ndim=1]
    Output array of the same shape as `assets`.  `compute` should write
    its desired return values into `out`. If multiple outputs are
    specified, `compute` should write its desired return values into
    `out.<output_name>` for each output name in `self.outputs`.
*inputs : tuple of np.array
    Raw data arrays corresponding to the values of `self.inputs`.

compute functions should expect to be passed NaN values for dates on which no data was available for an asset. This may include dates on which an asset did not yet exist.

For example, if a CustomFactor requires 10 rows of close price data, and asset A started trading on Monday June 2nd, 2014, then on Tuesday, June 3rd, 2014, the column of input data for asset A will have 9 leading NaNs for the preceding days on which data was not yet available.

Usage Guide:

Custom Factors: https://qrok.it/dl/z/pipeline-custom-factors

Examples

A CustomFactor with pre-declared defaults:

class TenDayRange(CustomFactor):
    """
    Computes the difference between the highest high in the last 10
    days and the lowest low.

    Pre-declares high and low as default inputs and `window_length` as
    10.
    """

    inputs = [USEquityPricing.high, USEquityPricing.low]
    window_length = 10

    def compute(self, today, assets, out, highs, lows):
        from numpy import nanmin, nanmax

        highest_highs = nanmax(highs, axis=0)
        lowest_lows = nanmin(lows, axis=0)
        out[:] = highest_highs - lowest_lows

# Doesn't require passing inputs or window_length because they're
# pre-declared as defaults for the TenDayRange class.
ten_day_range = TenDayRange()

A CustomFactor without defaults:

class MedianValue(CustomFactor):
    """
    Computes the median value of an arbitrary single input over an
    arbitrary window..

    Does not declare any defaults, so values for `window_length` and
    `inputs` must be passed explicitly on every construction.
    """

    def compute(self, today, assets, out, data):
        from numpy import nanmedian
        out[:] = data.nanmedian(data, axis=0)

# Values for `inputs` and `window_length` must be passed explicitly to
# MedianValue.
median_close10 = MedianValue([USEquityPricing.close], window_length=10)
median_low15 = MedianValue([USEquityPricing.low], window_length=15)

A CustomFactor with multiple outputs:

class MultipleOutputs(CustomFactor):
    inputs = [USEquityPricing.close]
    outputs = ['alpha', 'beta']
    window_length = N

    def compute(self, today, assets, out, close):
        computed_alpha, computed_beta = some_function(close)
        out.alpha[:] = computed_alpha
        out.beta[:] = computed_beta

# Each output is returned as its own Factor upon instantiation.
alpha, beta = MultipleOutputs()

# Equivalently, we can create a single factor instance and access each
# output as an attribute of that instance.
multiple_outputs = MultipleOutputs()
alpha = multiple_outputs.alpha
beta = multiple_outputs.beta

Note: If a CustomFactor has multiple outputs, all outputs must have the same dtype. For instance, in the example above, if alpha is a float then beta must also be a float.

dtype¶

zipline.pipeline.Filter ¶

class zipline.pipeline.Filter(*args, **kwargs)¶

Pipeline expression computing a boolean output.

Filters are most commonly useful for describing sets of assets to include or exclude for some particular purpose. Many Pipeline API functions accept a mask argument, which can be supplied a Filter indicating that only values passing the Filter should be considered when performing the requested computation. For example, zipline.pipeline.Factor.top() accepts a mask indicating that ranks should be computed only on assets that passed the specified Filter.

The most common way to construct a Filter is via one of the comparison operators (<, <=, !=, eq, >, >=) of Factor. For example, a natural way to construct a Filter for stocks with a 10-day VWAP less than $20.0 is to first construct a Factor computing 10-day VWAP and compare it to the scalar value 20.0:

>>> from zipline.pipeline.factors import VWAP
>>> vwap_10 = VWAP(window_length=10)
>>> vwaps_under_20 = (vwap_10 <= 20)

Filters can also be constructed via comparisons between two Factors. For example, to construct a Filter producing True for asset/date pairs where the asset’s 10-day VWAP was greater than it’s 30-day VWAP:

>>> short_vwap = VWAP(window_length=10)
>>> long_vwap = VWAP(window_length=30)
>>> higher_short_vwap = (short_vwap > long_vwap)

Filters can be combined via the & (and) and | (or) operators.

&-ing together two filters produces a new Filter that produces True if both of the inputs produced True.

|-ing together two filters produces a new Filter that produces True if either of its inputs produced True.

The ~ operator can be used to invert a Filter, swapping all True values with Falses and vice-versa.

Filters may be set as the screen attribute of a Pipeline, indicating asset/date pairs for which the filter produces False should be excluded from the Pipeline’s output. This is useful both for reducing noise in the output of a Pipeline and for reducing memory consumption of Pipeline results.

if_else(if_true, if_false)¶

Create a term that selects values from one of two choices.

Parameters:

if_true (zipline.pipeline.term.ComputableTerm) – Expression whose values should be used at locations where this filter outputs True.
if_false (zipline.pipeline.term.ComputableTerm) – Expression whose values should be used at locations where this filter outputs False.

Returns:

merged – A term that computes by taking values from either if_true or if_false, depending on the values produced by self.

The returned term draws from``if_true`` at locations where self produces True, and it draws from if_false at locations where self produces False.

Return type:

zipline.pipeline.term.ComputableTerm

Example

Let f be a Factor that produces the following output:

             AAPL   MSFT    MCD     BK
2017-03-13    1.0    2.0    3.0    4.0
2017-03-14    5.0    6.0    7.0    8.0

Let g be another Factor that produces the following output:

             AAPL   MSFT    MCD     BK
2017-03-13   10.0   20.0   30.0   40.0
2017-03-14   50.0   60.0   70.0   80.0

Finally, let condition be a Filter that produces the following output:

             AAPL   MSFT    MCD     BK
2017-03-13   True  False   True  False
2017-03-14   True   True  False  False

Then, the expression condition.if_else(f, g) produces the following output:

             AAPL   MSFT    MCD     BK
2017-03-13    1.0   20.0    3.0   40.0
2017-03-14    5.0    6.0   70.0   80.0

See also

numpy.where, Factor.fillna

as_factor()¶

Create a Factor that returns 1s for True and 0s for False.

Returns:: factor – Factor returning 1s for True and 0s for False.
Return type:: Factor

Notes

Usage Guide:

Scores from Filters: https://qrok.it/dl/z/pipeline-scores

Examples

A common use for as_factor is to combine multiple boolean conditions into scores. First, create two Filters that compute whether price and volume are above certain levels:

>>> from zipline.pipeline.data import EquityPricing
>>> price = EquityPricing.close.latest
>>> volume = EquityPricing.volume.latest
>>> price_is_high = price > 100
>>> volume_is_high = volume > 1e6

Next, convert the boolean Filters to 1s and 0s and combine them into a score with a possible range of 0 to 2:

>>> score = price_is_high.as_factor() + volume_is_high.as_factor()

shift(periods=1)¶

Create a new Filter that computes the value of this Filter shifted forward by periods rows.

Parameters:: periods (int) – Number of periods to shift forward. Defaults to 1.
Returns:: shifted – A Filter computing the value of this Filter shifted forward by periods rows.
Return type:: zipline.pipeline.Filter

Examples

Create a Filter that computes True if the price was higher yesterday than the day before:

>>> from zipline.pipeline import EquityPricing
>>> closed_up = EquityPricing.close.latest.pct_change() > 0
>>> closed_up_yesterday = closed_up.shift(1)

all(window_length, mask=None)¶

Create a new Filter that returns True for assets that produce True for window_length consecutive days.

Parameters:

window_length (int) – the number of consecutive days over which assets must return True
mask (zipline.pipeline.Filter, optional) – A Filter representing assets to consider when computing results. If supplied, we ignore asset/date pairs where mask produces False.

Returns:

filter – Filter returning True for assets that produce True for window_length consecutive days.

Return type:

Examples

Start with a Filter for assets with nonzero volume:

>>> from zipline.pipeline.data import EquityPricing
>>> has_volume = EquityPricing.volume.latest > 0

Create a new Filter for assets with nonzero volume for 200 consecutive days:

>>> consistently_has_volume = has_volume.all(200)

any(window_length, mask=None)¶

Create a new Filter that returns True for assets that produce True for at least one day in the last window_length days.

Parameters:

window_length (int) – the number of days over which assets must return True on at least one day

Returns:

filter (Filter) – Filter returning True for assets that produce True for at least one day in the last window_length days.
mask (zipline.pipeline.Filter, optional) – A Filter representing assets to consider when computing results. If supplied, we ignore asset/date pairs where mask produces False.

Examples

Start with a Filter for assets with returns greater than 10%:

>>> from zipline.pipeline.factors import DailyReturns
>>> has_big_gain = DailyReturns() > 0.10

Create a new Filter for assets with a big gain on any of the last 5 days:

>>> has_recent_big_gain = has_big_gain.any(5)

at_least_n(N, window_length, mask=None)¶

Create a new Filter that returns True for assets that produce True for at least N days in the last window_length days.

Parameters:

N (int) – the minimum number of days on which assets must return True
window_length (int) – the number of days over which assets must return True on at least N days
mask (zipline.pipeline.Filter, optional) – A Filter representing assets to consider when computing results. If supplied, we ignore asset/date pairs where mask produces False.

Returns:

filter – Filter returning True for assets that produce True for at least N days in the last window_length days.

Return type:

zipline.pipeline.Classifier

Examples

Start with a Filter for assets with returns greater than 10%:

>>> from zipline.pipeline.factors import DailyReturns
>>> has_big_gain = DailyReturns() > 0.10

Create a new Filter for assets with a big gain on at least 2 of the last 5 days:

>>> has_multiple_big_gains = has_big_gain.at_least_n(2, window_length=5)

zipline.pipeline.Classifier ¶

class zipline.pipeline.Classifier(*args, **kwargs)¶

A Pipeline expression computing a categorical output.

Classifiers are most commonly useful for describing grouping keys for complex transformations on Factor outputs. For example, Factor.demean() and Factor.zscore() can be passed a Classifier in their groupby argument, indicating that means/standard deviations should be computed on assets for which the classifier produced the same label.

eq(other)¶: Construct a Filter returning True for asset/date pairs where the output of self matches other.

startswith(prefix)¶

Construct a Filter matching values starting with prefix.

Parameters:: prefix (str) – String prefix against which to compare values produced by self.
Returns:: matches – Filter returning True for all sid/date pairs for which self produces a string starting with prefix.
Return type:: Filter

endswith(suffix)¶

Construct a Filter matching values ending with suffix.

Parameters:: suffix (str) – String suffix against which to compare values produced by self.
Returns:: matches – Filter returning True for all sid/date pairs for which self produces a string ending with prefix.
Return type:: Filter

has_substring(substring)¶

Construct a Filter matching values containing substring.

Parameters:: substring (str) – Sub-string against which to compare values produced by self.
Returns:: matches – Filter returning True for all sid/date pairs for which self produces a string containing substring.
Return type:: Filter

matches(pattern)¶

Construct a Filter that checks regex matches against pattern.

Parameters:: pattern (str) – Regex pattern against which to compare values produced by self.
Returns:: matches – Filter returning True for all sid/date pairs for which self produces a string matched by pattern.
Return type:: Filter

See also

Python Regular Expressions

relabel(relabeler)¶

Convert self into a new classifier by mapping a function over each element produced by self.

Parameters:: relabeler (function[str -> str or None]) – A function to apply to each unique value produced by self.
Returns:: relabeled – A classifier produced by applying relabeler to each unique value produced by self.
Return type:: Classifier

isin(choices)¶

Construct a Filter indicating whether values are in choices.

Parameters:: choices (iterable[str or int]) – An iterable of choices.
Returns:: matches – Filter returning True for all sid/date pairs for which self produces an entry in choices.
Return type:: Filter

peer_count(mask=None)¶

Construct a factor that gives the number of occurrences of each distinct category in a classifier.

Parameters:: mask (zipline.pipeline.Filter, optional) – If passed, only count assets passing the filter. Default behavior is to count all assets.

Examples

Let c be a Classifier which would produce the following output:

             AAPL   MSFT    MCD     BK   AMZN     FB
2015-05-05    'a'    'a'   None    'b'    'a'   None
2015-05-06    'b'    'a'    'c'    'b'    'b'    'b'
2015-05-07   None    'a'   'aa'   'aa'   'aa'   None
2015-05-08    'c'    'c'    'c'    'c'    'c'    'c'

Then c.peer_count() will count, for each row, the total number of assets in each classifier category produced by c. Missing data will be evaluated to NaN:

             AAPL   MSFT    MCD     BK   AMZN     FB
2015-05-05    3.0    3.0    NaN    1.0    3.0    NaN
2015-05-06    4.0    1.0    1.0    4.0    4.0    4.0
2015-05-07    NaN    1.0    3.0    3.0    3.0    NaN
2015-05-08    6.0    6.0    6.0    6.0    6.0    6.0

Returns:: factor – A CustomFactor that counts, for each asset, the total number of assets with the same classifier category label.
Return type:: CustomFactor

fillna(fill_value)¶

Create a new Classifier that fills missing values of this classifier’s output with fill_value.

Parameters:

fill_value (zipline.pipeline.Classifier, or object.) –

Object to use as replacement for missing values.

If a Classifier is passed, that term’s results will be used as fill values.

If a scalar (e.g. a number) is passed, the scalar will be used as a fill value.

Examples

Filling with a Scalar:

Let c be a Classifier which would produce the following output:

             AAPL   MSFT    MCD     BK
2017-03-13      A             B      B
2017-03-14      A      A

Then c.fillna('C') produces the following output:

             AAPL   MSFT    MCD     BK
2017-03-13      A      C      B      B
2017-03-14      A      A      C      C

Filling with a Classifier:

Let c be as above, and let d be another Classifier which would produce the following output:

             AAPL   MSFT    MCD     BK
2017-03-13      D      E      F      G
2017-03-14      D      E      F      G

Then, c.fillna(d) produces the following output:

             AAPL   MSFT    MCD     BK
2017-03-13      A      E      B      B
2017-03-14      A      A      F      G

Returns:: filled – A Classifier computing the same results as the original classifier, but with missing values filled in using values from fill_value.
Return type:: zipline.pipeline.Classifier

where(condition, fill_value=None)¶

Create a new Classifier that preserves original values where condition is True and replaced values with fill_value (or empty string if fill_value is omitted) where condition is False.

Parameters:

condition (zipline.pipeline.Filter) – a Filter indicating which values to keep
fill_value (zipline.pipeline.Classifier, or object, optional) –
Object to use as replacement for values not fulfilling condition.
If a Classifier is passed, that term’s results will be used as fill values.
If a scalar (e.g. a number) is passed, the scalar will be used as a fill value.

Examples

Let c be a Classifier which would produce the following output:

             AAPL   MSFT    MCD     BK
2017-03-13      A            B      B
2017-03-14      A      A

Then c.where(c == 'A') produces the following output:

             AAPL   MSFT    MCD     BK
2017-03-13      A
2017-03-14      A      A

Filling with a Scalar:

Let c be as above. Then c.where(c == 'A', 'Z') produces the following output:

             AAPL   MSFT    MCD     BK
2017-03-13      A      Z      Z      Z
2017-03-14      A      A      Z      Z

Filling with a Classifier:

Let C be as above, and let d be another Classifier which would produce the following output:

             AAPL   MSFT    MCD     BK
2017-03-13      R      S      T      U
2017-03-14      R      S      T      U

Then, c.where(c == 'A', d) produces the following output:

             AAPL   MSFT    MCD     BK
2017-03-13      A      S      T      U
2017-03-14      A      A      T      U

Returns:: filled – A Classifier computing the same results as the original Classifier where condition is True, and fill_value (or empty string if fill value is omitted) where condition is False.
Return type:: zipline.pipeline.Classifier

shift(periods=1, mask=None)¶

Create a new Classifier that computes the value of this Classifier shifted forward by periods rows.

Parameters:

periods (int) – Number of periods to shift forward. Defaults to 1.
mask (zipline.pipeline.Filter, optional) – A Filter defining values to ignore when computing shift.

Returns:

shifted – A Classifier computing the value of this Classifier shifted forward by periods rows.

Return type:

all_present(window_length, mask=None)¶

Create a Filter that returns True for assets with no missing values for window_length consecutive days.

Parameters:

window_length (int) – the number of consecutive days over which there must be no missing values
mask (zipline.pipeline.Filter, optional) – A Filter representing assets to consider when computing results. If supplied, we ignore asset/date pairs where mask produces False.

Returns:

filter – Filter returning True for assets with no missing values for window_length consecutive days.

Return type:

Examples

Create a Filter for assets with no missing price data for 200 consecutive days:

>>> from zipline.pipeline.data import EquityPricing
>>> consistently_has_data = EquityPricing.close.all_present(200)

zipline.pipeline.data.BoundColumn ¶

class zipline.pipeline.data.BoundColumn¶

property dataset¶

The dataset to which this column is bound.

Return type:: zipline.pipeline.data.DataSet

property name¶: The name of this column.

all_present(window_length, mask=None)¶

Create a Filter that returns True for assets with no missing values for window_length consecutive days.

Parameters:

window_length (int) – the number of consecutive days over which there must be no missing values
mask (zipline.pipeline.Filter, optional) –
results. (A Filter representing assets to consider when computing) –
supplied (If) –
produces (we ignore asset/date pairs where mask) –
False. –

Returns:

filter – Filter returning True for assets with no missing values for window_length consecutive days.

Return type:

Examples

Create a Filter for assets with no missing price data for 200 consecutive days:

>>> from zipline.pipeline.data import EquityPricing
>>> consistently_has_data = EquityPricing.close.all_present(200)

zipline.pipeline.Term ¶

class zipline.pipeline.Term(*args, **kwargs)¶

Base class for objects that can appear in the compute graph of a zipline.pipeline.Pipeline.

Notes

Most Pipeline API users only interact with Term via subclasses:

BoundColumn
Factor
Filter
Classifier

Instances of Term are memoized. If you call a Term’s constructor with the same arguments twice, the same object will be returned from both calls:

Example:

>>> from zipline.pipeline.data import EquityPricing
>>> from zipline.pipeline.factors import SimpleMovingAverage
>>> x = SimpleMovingAverage(inputs=[EquityPricing.close], window_length=5)
>>> y = SimpleMovingAverage(inputs=[EquityPricing.close], window_length=5)
>>> x is y
True

Warning

Memoization of terms means that it’s generally unsafe to modify attributes of a term after construction.

graph_repr()¶: A short repr to use when rendering GraphViz graphs.

recursive_repr()¶: A short repr to use when recursively rendering terms with inputs.

all_present(window_length, mask=None)¶

Create a Filter that returns True for assets with no missing values for window_length consecutive days.

Parameters:

window_length (int) – the number of consecutive days over which there must be no missing values
mask (zipline.pipeline.Filter, optional) – A Filter representing assets to consider when computing results. If supplied, we ignore asset/date pairs where mask produces False.

Returns:

filter – Filter returning True for assets with no missing values for window_length consecutive days.

Return type:

Examples

Create a Filter for assets with no missing price data for 200 consecutive days:

>>> from zipline.pipeline.data import EquityPricing
>>> consistently_has_data = EquityPricing.close.all_present(200)

Pipeline Data ¶

EquityPricing
SecuritiesMaster
Database
ShortableShares
BorrowFees
Fundamentals
SP500
Institutions
ETB
BSI
BLMCF
BLMECT

zipline.pipeline.EquityPricing ¶

class zipline.pipeline.data.EquityPricing¶

DataSet containing daily trading prices and volumes.

open¶

The opening price of the asset for the day.

Type:: float64

high¶

The highest trade price of the asset for the day.

Type:: float64

low¶

The lowest trade price of the asset for the day.

Type:: float64

close¶

The closing price of the asset for the day.

Type:: float64

volume¶

The volume of shares traded for the asset for the day.

Type:: float64

Notes

Usage Guide:

Pipeline data concepts: https://qrok.it/dl/z/pipeline-data-concepts

Examples

Get a Pipeline factor that returns the closing price:

>>> from zipline.pipeline import EquityPricing
>>> close_price = EquityPricing.close.latest

zipline.pipeline.master.SecuritiesMaster ¶

class zipline.pipeline.data.master.SecuritiesMaster¶

Dataset representing the securities master file.

Sid¶

the security identifier

Type:: str

Symbol¶

the ticker symbol

Type:: str

Exchange¶

primary exchange of the security

Type:: str

Currency¶

currency in which the security is traded

Type:: str

SecType¶

the security type

Type:: str

Etf¶

whether the security is an ETF

Type:: bool

Timezone¶

the timezone in which the security is traded

Type:: str

Name¶

the name of the security

Type:: str

PriceMagnifier¶

price divisor to use when prices are quoted in a different currency than the security’s currency (for example GBP-denominated securities which trade in GBX will have a PriceMagnifier of 100)

Type:: float

Multiplier¶

contract multiplier for options and futures

Type:: float

Delisted¶

whether the security is delisted

Type:: bool

DateDelisted¶

date the security was delisted

Type:: datetime64D

LastTradeDate¶

last trade date for derivatives

Type:: datetime64D

RolloverDate¶

rollover date for futures

Type:: datetime64D

alpaca_AssetId¶

Asset ID

Type:: str

alpaca_AssetClass¶

always “us_equity”

Type:: str

alpaca_Exchange¶

AMEX, ARCA, BATS, NYSE, NASDAQ or NYSEARCA

Type:: str

alpaca_Symbol¶

ticker symbol

Type:: str

alpaca_Name¶

the name of the security

Type:: str

alpaca_Status¶

active or inactive

Type:: str

alpaca_Tradable¶

Asset is tradable on Alpaca or not.

Type:: float

alpaca_Marginable¶

Asset is marginable or not.

Type:: float

alpaca_Shortable¶

Asset is shortable or not.

Type:: float

alpaca_EasyToBorrow¶

Asset is easy-to-borrow or not (filtering for easy_to_borrow = True is the best way to check whether the name is currently available to short at Alpaca).

Type:: float

edi_SecId¶

Unique global level Security ID (can be used to link all multiple listings together)

Type:: float

edi_Currency¶

the currency in which the security is traded

Type:: str

edi_PrimaryMic¶

MIC code for the primary listing (empty if unknown)

Type:: str

edi_Mic¶

ISO standard Market Identification Code

Type:: str

edi_MicSegment¶

ISO standard Market Identification Code

Type:: str

edi_MicTimezone¶

the timezone in which the security is traded

Type:: str

edi_IsPrimaryListing¶

1 if PrimaryMic = Mic

Type:: float

edi_LocalSymbol¶

Local code unique at Market level - a ticker or number

Type:: str

edi_IssuerId¶

Unique global level Issuer ID (can be used to link all securities of a company togther)

Type:: float

edi_IssuerName¶

the name of the issuer

Type:: str

edi_IsoCountryInc¶

ISO Country of Incorporation of Issuer

Type:: str

edi_CountryInc¶

country of incorporation of the issuer

Type:: str

edi_IsoCountryListed¶

country of Exchange where listed

Type:: str

edi_CountryListed¶

country of Exchange where listed

Type:: str

edi_SicCode¶

Standard Industrial Classification Code

Type:: int

edi_Sic¶

SIC name

Type:: str

edi_SicIndustryGroup¶

SIC Industry Group

Type:: str

edi_SicMajorGroup¶

SIC Major Group

Type:: str

edi_SicDivision¶

SIC Division

Type:: str

edi_Cik¶

Central Index Key

Type:: str

edi_Industry¶

Industry of the issuer

Type:: str

edi_SecTypeCode¶

Type of Equity Instrument

Type:: str

edi_SecTypeDesc¶

Type of Equity Instrument (lookup SECTYPE with SectyCD)

Type:: str

edi_SecurityDesc¶

description of security

Type:: str

edi_PreferredName¶

for ETFs, the SecurityDesc, else the IssuerName

Type:: str

edi_GlobalListingStatus¶

Inactive at the global level else security is active. Not to be confused with delisted which is inactive at the exchange level (lookup SECSTATUS)

Type:: str

edi_ExchangeListingStatus¶

Indicates whether a security is Listed on an Exchange or Unlisted Indicates Exchange Listing Status (lookup LISTSTAT)

Type:: str

edi_DateDelisted¶

date the security was delisted

Type:: datetime64D

edi_StructureCode¶

Type:: str

edi_StructureDesc¶

Type:: str

edi_RecordModified¶

Date event updated, format is yyyy/mm/dd hh:mm:ss

Type:: str

edi_RecordCreated¶

Date event first entered

Type:: str

edi_FirstPriceDate¶

first date a price is available

Type:: datetime64D

edi_LastPriceDate¶

latest date a price is available

Type:: datetime64D

ibkr_ConId¶

IBKR Contract ID

Type:: float

ibkr_Symbol¶

ticker symbol

Type:: str

ibkr_SecType¶

security type

Type:: str

ibkr_Etf¶

whether the security is an ETF

Type:: bool

ibkr_PrimaryExchange¶

the primary exchange of the security

Type:: str

ibkr_Currency¶

the currency in which the security is traded

Type:: str

ibkr_StockType¶

the stock type, e.g. COMMON, PREFERRED, ADR, ETF, etc.

Type:: str

ibkr_LocalSymbol¶

ticker symbol used on the exchange

Type:: str

ibkr_TradingClass¶

Type:: str

ibkr_MarketName¶

Type:: str

ibkr_LongName¶

the name of the security

Type:: str

ibkr_Timezone¶

the timezone in which the security is traded

Type:: str

ibkr_ValidExchanges¶

comma-separated list of exchanges where the security is traded

Type:: str

ibkr_AggGroup¶

Type:: float

ibkr_Sector¶

the sector of the security

Type:: str

ibkr_Industry¶

the industry of the security

Type:: str

ibkr_Category¶

the category of the security

Type:: str

ibkr_MinTick¶

Type:: float

ibkr_PriceMagnifier¶

price divisor to use when prices are quoted in a different currency than the security’s currency (for example GBP-denominated securities which trade in GBX will have an ibkr_PriceMagnifier of 100)

Type:: float

ibkr_LastTradeDate¶

the last trade date for derivatives

Type:: datetime64D

ibkr_ContractMonth¶

expiration year-month for derivatives

Type:: float

ibkr_RealExpirationDate¶

expiration date for derivative contracts

Type:: datetime64D

ibkr_Multiplier¶

contract multiplier for options and futures

Type:: float

ibkr_UnderConId¶

Contract ID of the underlying security for derivatives

Type:: float

ibkr_UnderSymbol¶

ticker symbol of the underlying security for derivatives

Type:: str

ibkr_UnderSecType¶

security type of the underlying security for derivatives

Type:: str

ibkr_MarketRuleIds¶

Type:: str

ibkr_Strike¶

option strike price

Type:: float

ibkr_Right¶

whether the option is a call or put

Type:: str

ibkr_Isin¶

ISIN identifier for the security

Type:: str

ibkr_Cusip¶

Type:: str

ibkr_EvRule¶

Type:: str

ibkr_EvMultiplier¶

Type:: float

ibkr_MinSize¶

minimum order size, i.e. lot size

Type:: float

ibkr_SizeIncrement¶

minimum order size increment that can be added to ibkr_MinSize

Type:: float

ibkr_SuggestedSizeIncrement¶

suggested order size increment (i.e. suggested lot size)

Type:: float

ibkr_Delisted¶

whether the security is delisted

Type:: bool

ibkr_DateDelisted¶

date the security was delisted

Type:: datetime64D

sharadar_Permaticker¶

Permanent Ticker Symbol - The permaticker is a unique and unchanging identifier for an issuer in the dataset which is issued by Sharadar.

Type:: float

sharadar_Ticker¶

Ticker Symbol - The ticker is a unique identifer for an issuer in the database. Where a ticker contains a “.” or a “-” this is removed from the ticker. For example BRK.B is BRKB. We include the BRK.B ticker in the Related Tickers field. Where a company is delisted and the ticker is recycled; we use that ticker for the currently active company and append a number to the ticker of the delisted company. eg GM is the current actively traded entity; & GM1 is the entity that filed for bankruptcy in 2009.

Type:: str

sharadar_Name¶

Issuer Name - The name of the security issuer.

Type:: str

sharadar_Exchange¶

Stock Exchange - The exchange on which the security trades. Examples are: “NASDAQ”;”NYSE”;”NYSEARCA”;”BATS”;”OTC” and “NYSEMKT” (previously the American Stock exchange).

Type:: str

sharadar_Delisted¶

Is Delisted? - Is the security delisted?

Type:: bool

sharadar_DateDelisted¶

Date the security was delisted

Type:: datetime64D

sharadar_Category¶

Issuer Category - The category of the issuer: “Domestic”; “Canadian” or “ADR”.

Type:: str

sharadar_Cusips¶

CUSIPs - A security identifier. Space delimited in the event of multiple identifiers.

Type:: str

sharadar_SicCode¶

Standard Industrial Classification (SIC) Code - The Standard Industrial Classification (SIC) is a system for classifying industries by a four-digit code; as sourced from SEC filings. More on the SIC system here: https://en.wikipedia.org/wiki/Standard_Industrial_Classification

Type:: int

sharadar_SicSector¶

SIC Sector - The SIC sector is based on the SIC code and the division tabled here: https://en.wikipedia.org/wiki/Standard_Industrial_Classification

Type:: str

sharadar_SicIndustry¶

SIC Industry - The SIC industry is based on the SIC code and the industry tabled here: https://www.sec.gov/info/edgar/siccodes.htm

Type:: str

sharadar_FamaSector¶

Fama Sector - Not currently active - coming in a future update.

Type:: str

sharadar_FamaIndustry¶

Fama Industry - Industry classifications based on the SIC code and classifications by Fama and French here: http://mba.tuck.dartmouth.edu /pages/faculty/ken.french/Data_Library/det_48_ind_port.html

Type:: str

sharadar_Sector¶

Sector - Sharadar’s sector classification based on SIC codes in a format which approximates to GICS.

Type:: str

sharadar_Industry¶

Industry - Sharadar’s industry classification based on SIC codes in a format which approximates to GICS.

Type:: str

sharadar_ScaleMarketCap¶

Company Scale - Market Cap - This field is experimental and subject to change. It categorises the company according to it’s maximum observed market cap as follows: 1 - Nano <$50m; 2 - Micro < $300m; 3 - Small < $2bn; 4 - Mid <$10bn; 5 - Large < $200bn; 6 - Mega >= $200bn

Type:: str

sharadar_ScaleRevenue¶

Company Scale - Revenue - This field is experimental and subject to change. It categorises the company according to it’s maximum observed annual revenue as follows: 1 - Nano <$50m; 2 - Micro < $300m; 3 - Small < $2bn; 4 - Mid <$10bn; 5 - Large < $200bn; 6 - Mega >= $200bn

Type:: str

sharadar_RelatedTickers¶

Related Tickers - Where related tickers have been identified this field is populated. Related tickers can include the prior ticker before a ticker change; and it tickers for alternative share classes.

Type:: str

sharadar_Currency¶

Currency - The company functional reporting currency for the SF1 Fundamentals table or the currency for EOD prices in SEP and SFP.

Type:: str

sharadar_Location¶

Location - The company location as registered with the Securities and Exchange Commission.

Type:: str

sharadar_CountryListed¶

ISO country code where security is listed

Type:: str

sharadar_LastUpdated¶

Last Updated Date - Last Updated represents the last date that this database entry was updated; which is useful to users when updating their local records.

Type:: datetime64D

sharadar_FirstAdded¶

First Added Date - The date that the ticker was first added to coverage in the dataset.

Type:: datetime64D

sharadar_FirstPriceDate¶

First Price Date - The date of the first price observation for a given ticker. Can be used as a proxy for IPO date. Minimum value of 1986-01-01 for IPO’s that occurred prior to this date. Note: this does not necessarily represent the first price date available in our datasets since our end of day price history currently starts in December 1998.

Type:: datetime64D

sharadar_LastPriceDate¶

Last Price Date - The most recent price observation available.

Type:: datetime64D

sharadar_FirstQuarter¶

First Quarter - The first financial quarter available in the dataset.

Type:: datetime64D

sharadar_LastQuarter¶

Last Quarter - The last financial quarter available in the dataset.

Type:: datetime64D

sharadar_SecFilings¶

SEC Filings URL - The URL pointing to the SEC filings which also contains the Central Index Key (CIK).

Type:: str

sharadar_CompanySite¶

Company Website URL - The URL pointing to the company website.

Type:: str

usstock_Mic¶

market identifier code for the security

Type:: str

usstock_Symbol¶

ticker symbol

Type:: str

usstock_Name¶

the name of the security

Type:: str

usstock_Sector¶

sector in which company operates. There are 11 possible sectors.

Type:: str

usstock_Industry¶

industry in which company operates. There are 58 possible industries.

Type:: str

usstock_SicCode¶

Standard Industrial Classification Code, used in SEC filings

Type:: str

usstock_Sic¶

SIC code description, bottom tier in SIC hierarchy, e.g. “Electronic Computers”

Type:: str

usstock_SicIndustryGroup¶

3rd-level tier in SIC hierarchy, e.g. “Computer And Office Equipment”

Type:: str

usstock_SicMajorGroup¶

2nd-level tier in SIC hierarchy, e.g. “Industrial And Commercial Machinery And Computer Equipment”

Type:: str

usstock_SicDivision¶

Top-level tier in SIC hierarchy

Type:: str

usstock_SecurityType¶

security type (more detailed than usstock_SecurityType2)

Type:: str

usstock_SecurityType2¶

security type (less detailed than usstock_SecurityType)

Type:: str

usstock_CIK¶

the Central Index Key is the unique company identifier in SEC filings

Type:: str

usstock_PrimaryShareSid¶

the sid of the primary share class, if not this security (for companies with multiple share classes). Filtering to securities where usstock_PrimaryShareSid is null is a way to deduplicate companies with multiple share classes.

Type:: str

usstock_DateDelisted¶

date the security was delisted

Type:: datetime64D

usstock_FirstPriceDate¶

date of first available price

Type:: datetime64D

usstock_LastPriceDate¶

date of last available price

Type:: datetime64D

figi_Figi¶

e.g. BBG000BBBRC7

Type:: str

figi_Name¶

e.g. AFLAC INC

Type:: str

figi_Ticker¶

e.g. AFL

Type:: str

figi_CompositeFigi¶

e.g. BBG000BBBNC6

Type:: str

figi_ExchCode¶

e.g. UN

Type:: str

figi_UniqueId¶

e.g. EQ0010001500001000

Type:: str

figi_SecurityType¶

e.g. Common Stock

Type:: str

figi_MarketSector¶

e.g. Equity

Type:: str

figi_ShareClassFigi¶

e.g. BBG001S5NGJ4

Type:: str

figi_UniqueIdFutOpt¶

Type:: str

figi_SecurityType2¶

e.g. Common Stock

Type:: str

figi_SecurityDescription¶

e.g. AFL

Type:: str

figi_IsComposite¶

whether the Figi column contains a composite FIGI

Type:: bool

Notes

Usage Guide:

Securities master: https://qrok.it/dl/z/pipeline-securities-master

Examples

Filter ETFs:

are_etfs = SecuritiesMaster.Etf.latest

Filter NYSE stocks:

are_nyse_stocks = SecuritiesMaster.Exchange.latest.eq("XNYS")

Filter to primary shares, which can be identified by a null usstock_PrimaryShareSid field (i.e. they have no pointer to another primary share):

are_primary_shares = master.SecuritiesMaster.usstock_PrimaryShareSid.latest.isnull()

zipline.pipeline.db.Database ¶

class zipline.pipeline.data.db.Database¶

A Pipeline DataSet representing a database queryable with quantrocket.get_prices.

This class cannot be used directly. Instead, subclass this class, specify the database to query using the CODE attribute, and specify one or more columns (zipline.pipeline.data.Column) to include in the Dataset. See the examples below.

This DataSet is implemented as a wrapper around quantrocket.get_prices_reindexed_like, with most DataSet attributes being passed directly to that function.

CODE¶

the database code

Type:: str, required

SHIFT¶

number of periods to shift the resulting data forward to avoid lookahead bias. Default is 1. Shifting one period implies that data timestamped to a particular date is available and actionable on the following date.

Type:: int, optional

FFILL¶

forward-fill values in the pipeline output so that each date reflects the latest available value as of that date. If False, values appear only on the first date they were available, followed by NaNs. Default True.

Type:: bool, optional

LOOKBACK_WINDOW¶

how many calendar days of back data prior to the pipeline start date should be loaded, to ensure an adequate cushion of data is available before shifting. Default is 10. Sparse data such as fundamentals will require a higher value.

Type:: int, optional

TIMES¶

limit to these times, specified in the timezone of the bundle. Only applicable to querying intraday databases. See additional information in the Notes section of quantrocket.get_prices.

Type:: list of str (HH:MM:SS), optional

AGG¶

when querying intraday databases, how to aggregate each day’s intraday values to produce a single value per day. Default is “last”, meaning use the last non-null value of each day. This parameter is passed directly to the pandas agg function. Example choices include “last”, “first”, “min”, “max”, “mean”, “sum”, etc. See https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.core.groupby.DataFrameGroupBy.aggregate.html for more info. Note that aggregation occurs after the TIMES filters are applied.

Type:: str or function, optional

CONT_FUT¶

stitch futures into continuous contracts using this method (default is not to stitch together). Only applicable to history databases. Possible choices: concat

Type:: str, optional

DATA_FREQUENCY¶

for Zipline bundles, whether to query minute or daily data. If omitted, defaults to minute data for minute bundles and to daily data for daily bundles. This parameter only needs to be set to request daily data from a minute bundle. Possible choices: daily, minute (or aliases d, m).

Type:: str, optional

Notes

Because numpy has no native support for integers with missing values, users are strongly encouraged to use floats for any data that’s semantically numeric. Doing so enables the use of NaN as a natural missing value, which has useful propagation semantics.

Usage Guide:

Pipeline databases: https://qrok.it/dl/z/pipeline-db

Examples

Define a Pipeline dataset that points to a database of custom fundamentals:

from zipline.pipeline.data.db import Database, Column
class CustomFundamentals(Database):
    CODE = "custom-fundamentals"
    Revenue = Column(float)
    EPS = Column(float)
    Currency = Column(object)
    TotalAssets = Column(float)

Instantiate a column from the dataset:

revenues = CustomFundamentals.Revenue.latest

Columns can have different data types.Use float for semantically-numeric data, even if it’s always integral valued (see Notes section below). The default missing value for floats is NaN:

Revenue = Column(float)

Use object for string columns. The default missing value for object-dtype columns is an empty string:

Currency = Column(object)

Use bool for boolean-valued flags. Note that the default missing value for bool-dtype columns is False:

IsEtf = Column(bool)

zipline.pipeline.ibkr.ShortableShares ¶

class zipline.pipeline.data.ibkr.ShortableShares¶

DataSet representing the previous day’s shortable shares.

MinQuantity¶

minimum quantity of shortable shares for the day

Type:: float

MaxQuantity¶

maximum quantity of shortable shares for the day

Type:: float

MeanQuantity¶

average quantity of shortable shares for the day

Type:: float

LastQuantity¶

last quantity of shortable shares for the day

Type:: float

Notes

Usage Guide:

IBKR shortable shares: https://qrok.it/dl/z/pipeline-shortshares

Examples

Get the number of shortable shares for the previous day:

shares = ibkr.ShortableShares.LastQuantity.latest

zipline.pipeline.ibkr.BorrowFees ¶

class zipline.pipeline.data.ibkr.BorrowFees¶

DataSet representing the previous day’s borrow fees.

FeeRate¶

The annualized interest rate on short positions. For example, 1.0198 indicates an annualized interest rate of 1.0198%.

Type:: float

Notes

Usage Guide:

IBKR borrow fees: https://qrok.it/dl/z/pipeline-borrowfees

Examples

Get the previous day’s borrow fees:

fees = ibkr.BorrowFee.FeeRate.latest

zipline.pipeline.sharadar.Fundamentals ¶

class zipline.pipeline.data.sharadar.Fundamentals¶

DataSetFamily representing Sharadar fundamentals. In order to use the data in a pipeline, it must first be sliced to generate a regular pipeline DataSet.

Fundamentals can be sliced along two dimensions:

dimension : the choices are ARQ, ARY, ART, MRQ, MRY, MRT, where AR=As Reported, MR=Most Recent Reported, Q=Quarterly, Y=Annual, and T=Trailing Twelve Month.
period_offset : which fiscal period to return data for. If period_offset is 0 (the default), returns the most recent point-in-time fundamentals. If period_offset is -1, returns fundamentals for the prior fiscal period; if -2, two fiscal periods ago, etc. For quarterly and trailing-twelve-month dimensions, previous period means previous quarter, while for annual dimensions, previous period means previous year. Value should be a negative integer or 0.

ACCOCI¶

Accumulated Other Comprehensive Income - [Balance Sheet] A component of [Equity] representing the accumulated change in equity from transactions and other events and circumstances from non-owner sources; net of tax effect; at period end. Includes foreign currency translation items; certain pension adjustments; unrealized gains and losses on certain investments in debt and equity securities.

Type:: float

ASSETS¶

Total Assets - [Balance Sheet] Sum of the carrying amounts as of the balance sheet date of all assets that are recognized. Major components are [CashnEq]; [Investments];[Intangibles]; [PPNENet];[TaxAssets] and [Receivables].

Type:: float

ASSETSAVG¶

Average Assets - [Metrics] Average asset value for the period used in calculation of [ROE] and [ROA]; derived from [Assets].

Type:: float

ASSETSC¶

Current Assets - [Balance Sheet] The current portion of [Assets]; reported if a company operates a classified balance sheet that segments current and non-current assets.

Type:: float

ASSETSNC¶

Assets Non-Current - [Balance Sheet] Amount of non-current assets; for companies that operate a classified balance sheet. Calculated as the different between Total Assets [Assets] and Current Assets [AssetsC].

Type:: float

ASSETTURNOVER¶

Asset Turnover - [Metrics] Asset turnover is a measure of a firms operating efficiency; calculated by dividing [Revenue] by [AssetsAVG]. Often a component of DuPont ROE analysis.

Type:: float

BVPS¶

Book Value per Share - [Metrics] Measures the ratio between [Equity] and [SharesWA] as adjusted by [ShareFactor].

Type:: float

CALENDARDATE¶

Calendar Date - [Entity] The Calendar Date represents the normalized [ReportPeriod]. This provides a common date to query for which is necessary due to irregularity in report periods across companies. For example; if the report period is “2015-09-26”; the calendar date will be “2015-09-30” for quarterly and trailing-twelve-month dimensions (ARQ;MRQ;ART;MRT); and “2015-12-31” for annual dimensions (ARY;MRY). We also employ offsets in order to maximise comparability of the period across companies. For example consider two companies: one with a quarter ending on 2018-07-24; and the other with a quarter ending on 2018-06-28. A naive normalization process would assign these to differing calendar quarters of 2018-09-30 and 2018-06-30 respectively. However, we assign these both to the 2018-06-30 calendar quarter because this maximises the overlap in the report periods in question and therefore the comparability of this period.

Type:: datetime64D

CAPEX¶

Capital Expenditure - [Cash Flow Statement] A component of [NCFI] representing the net cash inflow (outflow) associated with the acquisition & disposal of long-lived; physical & intangible assets that are used in the normal conduct of business to produce goods and services and are not intended for resale. Includes cash inflows/outflows to pay for construction of self-constructed assets & software.

Type:: float

CASHNEQ¶

Cash and Equivalents - [Balance Sheet] A component of [Assets] representing the amount of currency on hand as well as demand deposits with banks or financial institutions.

Type:: float

CASHNEQUSD¶

Cash and Equivalents (USD) - [Balance Sheet] [CashnEq] in USD; converted by [FXUSD].

Type:: float

CONSOLINC¶

Consolidated Income - [Income Statement] The portion of profit or loss for the period; net of income taxes; which is attributable to the consolidated entity; before the deduction of [NetIncNCI].

Type:: float

COR¶

Cost of Revenue - [Income Statement] The aggregate cost of goods produced and sold and services rendered during the reporting period.

Type:: float

CURRENTRATIO¶

Current Ratio - [Metrics] The ratio between [AssetsC] and [LiabilitiesC]; for companies that operate a classified balance sheet.

Type:: float

DE¶

Debt to Equity Ratio - [Metrics] Measures the ratio between [Liabilities] and [Equity].

Type:: float

DEBT¶

Total Debt - [Balance Sheet] A component of [Liabilities] representing the total amount of current and non-current debt owed. Includes secured and unsecured bonds issued; commercial paper; notes payable; credit facilities; lines of credit; capital lease obligations; and convertible notes.

Type:: float

DEBTC¶

Debt Current - [Balance Sheet] The current portion of [Debt]; reported if the company operates a classified balance sheet that segments current and non-current liabilities.

Type:: float

DEBTNC¶

Debt Non-Current - [Balance Sheet] The non-current portion of [Debt] reported if the company operates a classified balance sheet that segments current and non-current liabilities.

Type:: float

DEBTUSD¶

Total Debt (USD) - [Balance Sheet] [Debt] in USD; converted by [FXUSD].

Type:: float

DEFERREDREV¶

Deferred Revenue - [Balance Sheet] A component of [Liabilities] representing the carrying amount of consideration received or receivable on potential earnings that were not recognized as revenue; including sales; license fees; and royalties; but excluding interest income.

Type:: float

DEPAMOR¶

Depreciation Amortization & Accretion - [Cash Flow Statement] A component of operating cash flow representing the aggregate net amount of depreciation; amortization; and accretion recognized during an accounting period. As a non-cash item; the net amount is added back to net income when calculating cash provided by or used in operations using the indirect method.

Type:: float

DEPOSITS¶

Deposit Liabilities - [Balance Sheet] A component of [Liabilities] representing the total of all deposit liabilities held; including foreign and domestic; interest and noninterest bearing. May include demand deposits; saving deposits; Negotiable Order of Withdrawal and time deposits among others.

Type:: float

DIVYIELD¶

Dividend Yield - [Metrics] Dividend Yield measures the ratio between a company’s [DPS] and its [Price].

Type:: float

DPS¶

Dividends per Basic Common Share - [Income Statement] Aggregate dividends declared during the period for each split-adjusted share of common stock outstanding. Includes spinoffs where identified.

Type:: float

EBIT¶

Earning Before Interest & Taxes (EBIT) - [Income Statement] Earnings Before Interest and Tax is calculated by adding [TaxExp] and [IntExp] back to [NetInc].

Type:: float

EBITDA¶

Earnings Before Interest Taxes & Depreciation Amortization (EBITDA) - [Metrics] EBITDA is a non-GAAP accounting metric that is widely used when assessing the performance of companies; calculated by adding [DepAmor] back to [EBIT].

Type:: float

EBITDAMARGIN¶

EBITDA Margin - [Metrics] Measures the ratio between a company’s [EBITDA] and [Revenue].

Type:: float

EBITDAUSD¶

Earnings Before Interest Taxes & Depreciation Amortization (USD) - [Metrics] [EBITDA] in USD; converted by [FXUSD].

Type:: float

EBITUSD¶

Earning Before Interest & Taxes (USD) - [Income Statement] [EBIT] in USD; converted by [FXUSD].

Type:: float

EBT¶

Earnings before Tax - [Metrics] Earnings Before Tax is calculated by adding [TaxExp] back to [NetInc].

Type:: float

EPS¶

Earnings per Basic Share - [Income Statement] Earnings per share as calculated and reported by the company. Approximates to the amount of [NetIncCmn] for the period per each [SharesWA] after adjusting for [ShareFactor].

Type:: float

EPSDIL¶

Earnings per Diluted Share - [Income Statement] Earnings per diluted share as calculated and reported by the company. Approximates to the amount of [NetIncCmn] for the period per each [SharesWADil] after adjusting for [ShareFactor]..

Type:: float

EPSUSD¶

Earnings per Basic Share (USD) - [Income Statement] [EPS] in USD; converted by [FXUSD].

Type:: float

EQUITY¶

Shareholders Equity - [Balance Sheet] A principal component of the balance sheet; in addition to [Liabilities] and [Assets]; that represents the total of all stockholders’ equity (deficit) items; net of receivables from officers; directors; owners; and affiliates of the entity which are attributable to the parent.

Type:: float

EQUITYAVG¶

Average Equity - [Metrics] Average equity value for the period used in calculation of [ROE]; derived from [Equity].

Type:: float

EQUITYUSD¶

Shareholders Equity (USD) - [Balance Sheet] [Equity] in USD; converted by [FXUSD].

Type:: float

EV¶

Enterprise Value - [Metrics] Enterprise value is a measure of the value of a business as a whole; calculated as [MarketCap] plus [DebtUSD] minus [CashnEqUSD].

Type:: float

EVEBIT¶

Enterprise Value over EBIT - [Metrics] Measures the ratio between [EV] and [EBITUSD].

Type:: float

EVEBITDA¶

Enterprise Value over EBITDA - [Metrics] Measures the ratio between [EV] and [EBITDAUSD].

Type:: float

FCF¶

Free Cash Flow - [Metrics] Free Cash Flow is a measure of financial performance calculated as [NCFO] minus [CapEx].

Type:: float

FCFPS¶

Free Cash Flow per Share - [Metrics] Free Cash Flow per Share is a valuation metric calculated by dividing [FCF] by [SharesWA] and [ShareFactor].

Type:: float

FXUSD¶

Foreign Currency to USD Exchange Rate - [Metrics] The exchange rate used for the conversion of foreign currency to USD for non-US companies that do not report in USD.

Type:: float

GP¶

Gross Profit - [Income Statement] Aggregate revenue [Revenue] less cost of revenue [CoR] directly attributable to the revenue generation activity.

Type:: float

GROSSMARGIN¶

Gross Margin - [Metrics] Gross Margin measures the ratio between a company’s [GP] and [Revenue].

Type:: float

INTANGIBLES¶

Goodwill and Intangible Assets - [Balance Sheet] A component of [Assets] representing the carrying amounts of all intangible assets and goodwill as of the balance sheet date; net of accumulated amortization and impairment charges.

Type:: float

INTEXP¶

Interest Expense - [Income Statement] Amount of the cost of borrowed funds accounted for as interest expense.

Type:: float

INVCAP¶

Invested Capital - [Metrics] Invested capital is an input into the calculation of [ROIC]; and is calculated as: [Debt] plus [Assets] minus [Intangibles] minus [CashnEq] minus [LiabilitiesC]. Please note this calculation method is subject to change.

Type:: float

INVCAPAVG¶

Invested Capital Average - [Metrics] Average invested capital value for the period used in the calculation of [ROIC]; and derived from [InvCap]. Invested capital is an input into the calculation of [ROIC]; and is calculated as: [Debt] plus [Assets] minus [Intangibles] minus [CashnEq] minus [LiabilitiesC]. Please note this calculation method is subject to change.

Type:: float

INVENTORY¶

Inventory - [Balance Sheet] A component of [Assets] representing the amount after valuation and reserves of inventory expected to be sold; or consumed within one year or operating cycle; if longer.

Type:: float

INVESTMENTS¶

Investments - [Balance Sheet] A component of [Assets] representing the total amount of marketable and non-marketable securties; loans receivable and other invested assets.

Type:: float

INVESTMENTSC¶

Investments Current - [Balance Sheet] The current portion of [Investments]; reported if the company operates a classified balance sheet that segments current and non-current assets.

Type:: float

INVESTMENTSNC¶

Investments Non-Current - [Balance Sheet] The non-current portion of [Investments]; reported if the company operates a classified balance sheet that segments current and non-current assets.

Type:: float

LIABILITIES¶

Total Liabilities - [Balance Sheet] Sum of the carrying amounts as of the balance sheet date of all liabilities that are recognized. Principal components are [Debt]; [DeferredRev]; [Payables];[Deposits]; and [TaxLiabilities].

Type:: float

LIABILITIESC¶

Current Liabilities - [Balance Sheet] The current portion of [Liabilities]; reported if the company operates a classified balance sheet that segments current and non-current liabilities.

Type:: float

LIABILITIESNC¶

Liabilities Non-Current - [Balance Sheet] The non-current portion of [Liabilities]; reported if the company operates a classified balance sheet that segments current and non-current liabilities.

Type:: float

MARKETCAP¶

Market Capitalization - [Metrics] Represents the product of [SharesBas]; [Price] and [ShareFactor].

Type:: float

NCF¶

Net Cash Flow / Change in Cash & Cash Equivalents - [Cash Flow Statement] Principal component of the cash flow statement representing the amount of increase (decrease) in cash and cash equivalents. Includes [NCFO]; investing [NCFI] and financing [NCFF] for continuing and discontinued operations; and the effect of exchange rate changes on cash [NCFX].

Type:: float

NCFBUS¶

Net Cash Flow - Business Acquisitions and Disposals - [Cash Flow Statement] A component of [NCFI] representing the net cash inflow (outflow) associated with the acquisition & disposal of businesses; joint-ventures; affiliates; and other named investments.

Type:: float

NCFCOMMON¶

Issuance (Purchase) of Equity Shares - [Cash Flow Statement] A component of [NCFF] representing the net cash inflow (outflow) from common equity changes. Includes additional capital contributions from share issuances and exercise of stock options; and outflow from share repurchases.

Type:: float

NCFDEBT¶

Issuance (Repayment) of Debt Securities - [Cash Flow Statement] A component of [NCFF] representing the net cash inflow (outflow) from issuance (repayment) of debt securities.

Type:: float

NCFDIV¶

Payment of Dividends & Other Cash Distributions - [Cash Flow Statement] A component of [NCFF] representing dividends and dividend equivalents paid on common stock and restricted stock units.

Type:: float

NCFF¶

Net Cash Flow from Financing - [Cash Flow Statement] A component of [NCF] representing the amount of cash inflow (outflow) from financing activities; from continuing and discontinued operations. Principal components of financing cash flow are: issuance (purchase) of equity shares; issuance (repayment) of debt securities; and payment of dividends & other cash distributions.

Type:: float

NCFI¶

Net Cash Flow from Investing - [Cash Flow Statement] A component of [NCF] representing the amount of cash inflow (outflow) from investing activities; from continuing and discontinued operations. Principal components of investing cash flow are: capital (expenditure) disposal of equipment [CapEx]; business (acquisitions) disposition [NCFBus] and investment (acquisition) disposal [NCFInv].

Type:: float

NCFINV¶

Net Cash Flow - Investment Acquisitions and Disposals - [Cash Flow Statement] A component of [NCFI] representing the net cash inflow (outflow) associated with the acquisition & disposal of investments; including marketable securities and loan originations.

Type:: float

NCFO¶

Net Cash Flow from Operations - [Cash Flow Statement] A component of [NCF] representing the amount of cash inflow (outflow) from operating activities; from continuing and discontinued operations.

Type:: float

NCFX¶

Effect of Exchange Rate Changes on Cash - [Cash Flow Statement] A component of Net Cash Flow [NCF] representing the amount of increase (decrease) from the effect of exchange rate changes on cash and cash equivalent balances held in foreign currencies.

Type:: float

NETINC¶

Net Income - [Income Statement] The portion of profit or loss for the period; net of income taxes; which is attributable to the parent after the deduction of [NetIncNCI] from [ConsolInc]; and before the deduction of [PrefDivIS].

Type:: float

NETINCCMN¶

Net Income Common Stock - [Income Statement] The amount of net income (loss) for the period due to common shareholders. Typically differs from [NetInc] to the parent entity due to the deduction of [PrefDivIS].

Type:: float

NETINCCMNUSD¶

Net Income Common Stock (USD) - [Income Statement] [NetIncCmn] in USD; converted by [FXUSD].

Type:: float

NETINCDIS¶

Net Loss Income from Discontinued Operations - [Income Statement] Amount of loss (income) from a disposal group; net of income tax; reported as a separate component of income.

Type:: float

NETINCNCI¶

Net Income to Non-Controlling Interests - [Income Statement] The portion of income which is attributable to non-controlling interest shareholders; subtracted from [ConsolInc] in order to obtain [NetInc].

Type:: float

NETMARGIN¶

Profit Margin - [Metrics] Measures the ratio between a company’s [NetIncCmn] and [Revenue].

Type:: float

OPEX¶

Operating Expenses - [Income Statement] Operating expenses represents the total expenditure on [SGnA]; [RnD] and other operating expense items; it excludes [CoR].

Type:: float

OPINC¶

Operating Income - [Income Statement] Operating income is a measure of financial performance before the deduction of [IntExp]; [TaxExp] and other Non-Operating items. It is calculated as [GP] minus [OpEx].

Type:: float

PAYABLES¶

Trade and Non-Trade Payables - [Balance Sheet] A component of [Liabilities] representing trade and non-trade payables.

Type:: float

PAYOUTRATIO¶

Payout Ratio - [Metrics] The percentage of earnings paid as dividends to common stockholders. Calculated by dividing [DPS] by [EPSUSD].

Type:: float

PB¶

Price to Book Value - [Metrics] Measures the ratio between [MarketCap] and [EquityUSD].

Type:: float

PE¶

Price Earnings (Damodaran Method) - [Metrics] Measures the ratio between [MarketCap] and [NetIncCmnUSD]

Type:: float

PE1¶

Price to Earnings Ratio - [Metrics] An alternative to [PE] representing the ratio between [Price] and [EPSUSD].

Type:: float

PPNENET¶

Property Plant & Equipment Net - [Balance Sheet] A component of [Assets] representing the amount after accumulated depreciation; depletion and amortization of physical assets used in the normal conduct of business to produce goods and services and not intended for resale.

Type:: float

PREFDIVIS¶

Preferred Dividends Income Statement Impact - [Income Statement] Income statement item reflecting dividend payments to preferred stockholders. Subtracted from Net Income to Parent [NetInc] to obtain Net Income to Common Stockholders [NetIncCmn].

Type:: float

PRICE¶

Share Price (Adjusted Close) - [Entity] The price per common share adjusted for stock splits but not adjusted for dividends; used in the computation of [PE1]; [PS1]; [DivYield] and [SPS].

Type:: float

PS¶

Price Sales (Damodaran Method) - [Metrics] Measures the ratio between [MarketCap] and [RevenueUSD].

Type:: float

PS1¶

Price to Sales Ratio - [Metrics] An alternative calculation method to [PS]; that measures the ratio between a company’s [Price] and it’s [SPS].

Type:: float

RECEIVABLES¶

Trade and Non-Trade Receivables - [Balance Sheet] A component of [Assets] representing trade and non-trade receivables.

Type:: float

REPORTPERIOD¶

Report Period - [Entity] The Report Period represents the end date of the fiscal period.

Type:: datetime64D

RETEARN¶

Accumulated Retained Earnings (Deficit) - [Balance Sheet] A component of [Equity] representing the cumulative amount of the entities undistributed earnings or deficit. May only be reported annually by certain companies; rather than quarterly.

Type:: float

REVENUE¶

Revenues - [Income Statement] Amount of Revenue recognized from goods sold; services rendered; insurance premiums; or other activities that constitute an earning process. Interest income for financial institutions is reported net of interest expense and provision for credit losses.

Type:: float

REVENUEUSD¶

Revenues (USD) - [Income Statement] [Revenue] in USD; converted by [FXUSD].

Type:: float

RND¶

Research and Development Expense - [Income Statement] A component of [OpEx] representing the aggregate costs incurred in a planned search or critical investigation aimed at discovery of new knowledge with the hope that such knowledge will be useful in developing a new product or service.

Type:: float

ROA¶

Return on Average Assets - [Metrics] Return on assets measures how profitable a company is [NetIncCmn] relative to its total assets [AssetsAvg].

Type:: float

ROE¶

Return on Average Equity - [Metrics] Return on equity measures a corporation’s profitability by calculating the amount of [NetIncCmn] returned as a percentage of [EquityAvg].

Type:: float

ROIC¶

Return on Invested Capital - [Metrics] Return on Invested Capital is ratio estimated by dividing [EBIT] by [InvCapAvg]. [InvCap] is calculated as: [Debt] plus [Assets] minus [Intangibles] minus [CashnEq] minus [LiabilitiesC]. Please note this calculation method is subject to change.

Type:: float

ROS¶

Return on Sales - [Metrics] Return on Sales is a ratio to evaluate a company’s operational efficiency; calculated by dividing [EBIT] by [Revenue]. ROS is often a component of DuPont ROE analysis.

Type:: float

SBCOMP¶

Share Based Compensation - [Cash Flow Statement] A component of [NCFO] representing the total amount of noncash; equity-based employee remuneration. This may include the value of stock or unit options; amortization of restricted stock or units; and adjustment for officers’ compensation. As noncash; this element is an add back when calculating net cash generated by operating activities using the indirect method.

Type:: float

SGNA¶

Selling General and Administrative Expense - [Income Statement] A component of [OpEx] representing the aggregate total costs related to selling a firm’s product and services; as well as all other general and administrative expenses. Direct selling expenses (for example; credit; warranty; and advertising) are expenses that can be directly linked to the sale of specific products. Indirect selling expenses are expenses that cannot be directly linked to the sale of specific products; for example telephone expenses; Internet; and postal charges. General and administrative expenses include salaries of non- sales personnel; rent; utilities; communication; etc.

Type:: float

SHAREFACTOR¶

Share Factor - [Entity] Share factor is a multiplicant in the calculation of [MarketCap] and is used to adjust for: American Depository Receipts (ADRs) that represent more or less than 1 underlying share; and; companies which have different earnings share for different share classes (eg Berkshire Hathaway - BRKB).

Type:: float

SHARESBAS¶

Shares (Basic) - [Entity] The number of shares or other units outstanding of the entity’s capital or common stock or other ownership interests; as stated on the cover of related periodic report (10-K/10-Q); after adjustment for stock splits.

Type:: float

SHARESWA¶

Weighted Average Shares - [Income Statement] The weighted average number of shares or units issued and outstanding that are used by the company to calculate [EPS]; determined based on the timing of issuance of shares or units in the period.

Type:: float

SHARESWADIL¶

Weighted Average Shares Diluted - [Income Statement] The weighted average number of shares or units issued and outstanding that are used by the company to calculate [EPSDil]; determined based on the timing of issuance of shares or units in the period.

Type:: float

SPS¶

Sales per Share - [Metrics] Sales per Share measures the ratio between [RevenueUSD] and [SharesWA] as adjusted by [ShareFactor].

Type:: float

TANGIBLES¶

Tangible Asset Value - [Metrics] The value of tangibles assets calculated as the difference between [Assets] and [Intangibles].

Type:: float

TAXASSETS¶

Tax Assets - [Balance Sheet] A component of [Assets] representing tax assets and receivables.

Type:: float

TAXEXP¶

Income Tax Expense - [Income Statement] Amount of current income tax expense (benefit) and deferred income tax expense (benefit) pertaining to continuing operations.

Type:: float

TAXLIABILITIES¶

Tax Liabilities - [Balance Sheet] A component of [Liabilities] representing outstanding tax liabilities.

Type:: float

TBVPS¶

Tangible Assets Book Value per Share - [Metrics] Measures the ratio between [Tangibles] and [SharesWA] as adjusted by [ShareFactor].

Type:: float

WORKINGCAPITAL¶

Working Capital - [Metrics] Working capital measures the difference between [AssetsC] and [LiabilitiesC].

Type:: float

Notes

Usage Guide:

Sharadar fundamentals: https://qrok.it/dl/z/pipeline-sharadar-fundamentals
Pipeline data concepts: https://qrok.it/dl/z/pipeline-data-concepts

Examples

Select stocks with low enterprise multiples using quarterly fundamentals:

have_low_enterprise_multiples = sharadar.Fundamentals.slice(
'ARQ').EVEBITDA.latest.percentile_between(0, 20)

Create a boolean filter indicating whether assets increased in the current year relative to the prior year:

current_year_fundamentals = sharadar.Fundamentals.slice('ARY')
previous_year_fundamentals = sharadar.Fundamentals.slice(
    'ARY',
    period_offset=-1)
total_assets = current_year_fundamentals.ASSETS.latest
previous_total_assets = previous_year_fundamentals.ASSETS.latest
assets_increased = total_assets > previous_total_assets

classmethod slice(dimension, period_offset=0)¶

Return a Sharadar Fundamentals DataSet tied to a particular dimension and period_offset.

Parameters:

dimension (str, required) – the type of reports to return. Choices are ARQ, ARY, ART, MRQ, MRY, MRT, where AR=As Reported, MR=Most Recent Reported, Q=Quarterly, Y=Annual, and T=Trailing Twelve Month.
period_offset (int, optional) – which fiscal period to return data for. If period_offset is 0 (the default), returns the most recent point-in-time fundamentals. If period_offset is -1, returns fundamentals for the prior fiscal period; if -2, two fiscal periods ago, etc. For quarterly and trailing-twelve-month dimensions, previous period means previous quarter, while for annual dimensions, previous period means previous year. Value should be a negative integer or 0.

Returns:

Fundamentals DataSet with the specified dimension and period_offset.

Return type:

DataSet

Notes

Usage Guide:

Sharadar fundamentals: https://qrok.it/dl/z/pipeline-sharadar-fundamentals
Pipeline data concepts: https://qrok.it/dl/z/pipeline-data-concepts

Examples

Select stocks with low enterprise multiples using quarterly fundamentals:

have_low_enterprise_multiples = sharadar.Fundamentals.slice(
'ARQ').EVEBITDA.latest.percentile_between(0, 20)

Create a boolean filter indicating whether assets increased in the current year relative to the prior year:

current_year_fundamentals = sharadar.Fundamentals.slice('ARY')
previous_year_fundamentals = sharadar.Fundamentals.slice(
    'ARY',
    period_offset=-1)
total_assets = current_year_fundamentals.ASSETS.latest
previous_total_assets = previous_year_fundamentals.ASSETS.latest
assets_increased = total_assets > previous_total_assets

zipline.pipeline.sharadar.SP500 ¶

class zipline.pipeline.data.sharadar.SP500¶

Dataset representing membership in the S&P 500.

in_sp500¶

whether the security is a member of the S&P 500

Type:: bool

Notes

Usage Guide:

Sharadar S&P 500: https://qrok.it/dl/z/pipeline-sharadar-sp500

Examples

Create a filter that computes True for securities that are in the S&P 500 on the given date:

in_sp500 = sharadar.SP500.in_sp500.latest

zipline.pipeline.sharadar.Institutions ¶

class zipline.pipeline.data.sharadar.Institutions¶

DataSetFamily representing Sharadar institutional ownership. In order to use the data in a pipeline, it must first be sliced to generate a regular pipeline DataSet.

Institutions can be sliced along one dimension:

period_offset : defaults to 0, which is the only allowed value. In the future this dimension will allow requesting data from earlier quarters.

CLLHOLDERS¶

Number of Call holders (Institutional) - The number of call holders.

Type:: float

CLLUNITS¶

Number of Call Units held (institutional) - The total number of call units held.

Type:: float

CLLVALUE¶

Value of Call units held (institutional) - The total value of call units held.

Type:: float

DBTHOLDERS¶

Number of Debt holders (institutional) - The number of debt holders.

Type:: float

DBTUNITS¶

Number of Debt Units held (institutional) - The total number of debt units held.

Type:: float

DBTVALUE¶

Value of Debt units held (institutional) - The total value of debt units held.

Type:: float

FNDHOLDERS¶

Number of Fund holders (institutional) - The number of fund holders.

Type:: float

FNDUNITS¶

Number of Fund units held (institutional) - The total number of fund units held.

Type:: float

FNDVALUE¶

Value of Fund units held (institutional) - The total value of fund units held.

Type:: float

PERCENTOFTOTAL¶

Percentage of Total Institutional Holdings for the Quarter - The percentage that the [TotalValue] of this line item constitutes of all institutional holdings for this quarter.

Type:: float

PRFHOLDERS¶

Number of Preferred Stock holders (institutional) - The number of preferred stock holders.

Type:: float

PRFUNITS¶

Number of Preferred Stock units held (institutional) - The total number of preferred stock units held.

Type:: float

PRFVALUE¶

Value of Preferred Stock units held (institutional) - The total value of preferred stock units held.

Type:: float

PUTHOLDERS¶

Number of Put holders (institutional) - The number of put holders.

Type:: float

PUTUNITS¶

Number of Put Units held (institutional) - The total number of put units held.

Type:: float

PUTVALUE¶

Value of Put units held (institutional) - The total value of put units held.

Type:: float

SHRHOLDERS¶

Number of Shareholders (Institutional) - The number of shareholders.

Type:: float

SHRUNITS¶

Number of Share Units held (institutional) - The total number of share units held.

Type:: float

SHRVALUE¶

Value of Share units held (institutional) - The total value of share units held.

Type:: float

TOTALVALUE¶

Total Value of all Security types held (institutional) - The total value of all security types held.

Type:: float

UNDHOLDERS¶

Number of Unidentified Security type holders (institutional) - The number of unidentified security type holders.

Type:: float

UNDUNITS¶

Number of Unidentified Security type units held (institutional) - The total number of unidentified security type units held.

Type:: float

UNDVALUE¶

Value of Unidentified Security type units held (institutional) - The total value of unidentified security type units held.

Type:: float

WNTHOLDERS¶

Number of Warrant holders (institutional) - The number of warrant holders.

Type:: float

WNTUNITS¶

Number of Warrant Units held (institutional) - The total number of warrant units held.

Type:: float

WNTVALUE¶

Value of Warrant units held (institutional) - The total value of warrant units held.

Type:: float

Notes

Usage Guide:

Sharadar institutions: https://qrok.it/dl/z/pipeline-sharadar-institutions
Pipeline data concepts: https://qrok.it/dl/z/pipeline-data-concepts

Examples

Select stocks with large institutional ownership:

have_inst_own = sharadar.Institutions.slice(period_offset=0).TOTALVALUE.latest.percentile_between(80, 100)

classmethod slice(period_offset=0)¶

Return a Sharadar Institutions DataSet tied to a particular period_offset.

Parameters:: period_offset (int, optional) – defaults to 0, which is the only allowed value. In the future this dimension will allow requesting data from earlier quarters.
Returns:: Institutions DataSet with the specified period_offset.
Return type:: DataSet

Notes

Usage Guide:

Sharadar institutions: https://qrok.it/dl/z/pipeline-sharadar-institutions
Pipeline data concepts: https://qrok.it/dl/z/pipeline-data-concepts

Examples

Select stocks with large institutional ownership:

have_inst_own = sharadar.Institutions.slice(period_offset=0).TOTALVALUE.latest.percentile_between(80, 100)

zipline.pipeline.alpaca.ETB ¶

class zipline.pipeline.data.alpaca.ETB¶

Dataset representing whether securities are easy-to-borrow through Alpaca.

etb¶

whether the security is easy-to-borrow

Type:: bool

Notes

Usage Guide:

Alpaca ETB: https://qrok.it/dl/z/pipeline-alpaca-etb

Examples

Create a Filter that computes True for easy-to-borrow securities:

are_etb = alpaca.ETB.etb.latest

zipline.pipeline.brain.BSI ¶

class zipline.pipeline.data.brain.BSI¶

DataSetFamily representing Brain Sentiment Indicator (BSI) data.

This dataset provides news sentiment scores for US stocks, with history back to August 2, 2016.

The sentiment scores are averaged using news articles published over the last 1, 7, or 30 days. To use the data in a pipeline, it must first be sliced by selecting the calculation window using the N dimension. For example, to select the 7-day sentiment scores, use BSI.slice(7).

VOLUME¶

Number of news articles detected in the previous $N days for the company.

Type:: float

VOLUME_SENTIMENT¶

Number of news articles in the previous $N days used to calculate the sentiment. This number is less or equal to the field VOLUME and corresponds to not neutral news according to the sentiment algorithm.

Type:: float

SENTIMENT_SCORE¶

Sentiment score from -1 to 1 where 1 is the most positive and -1 the most negative. The sentiment score is calculated as an average of sentiment of news articles collected in the previous $N days for the specific company.

Type:: float

BUZZ_VOLUME¶

Buzz score that quantifies how much attention in terms of news VOLUME one company is receiving compared to the past. This is calculated by considering the VOLUME distribution of past six months. Then the buzz is calculated as current VOLUME minus the average of VOLUME for past 6 months in units of standard deviations. A value close to 0 means that the stock is covered by a VOLUME of stories similar to its past average, a value larger than 0 gives how many standard deviations the current VOLUME is larger than average. The value is reported only if there are enough stories in the past to estimate a reliable value.

Type:: float

BUZZ_VOLUME_SENTIMENT¶

Buzz score that quantifies how much attention in terms of news VOLUME_SENTIMENT (only stories with a polarized sentiment) one stock is receiving compared to the past. This is calculated by considering the VOLUME_SENTIMENT distribution of past six months. The buzz is then calculated as current VOLUME_SENTIMENT minus the average of VOLUME_SENTIMENT for past 6 months in units of standard deviations. A value close to 0 means that the stock is covered by a VOLUME_SENTIMENT of stories (sentiment bearing story) similar to its past average, a value larger than 0 gives how many standard deviations the current VOLUME_SENTIMENT is larger than average. The value is reported only if there are enough stories in the past to estimate a reliable value.

Type:: float

Notes

Usage Guide:

Brain Sentiment Indicator: https://qrok.it/dl/z/pipeline-brain-bsi
Pipeline data concepts: https://qrok.it/dl/z/pipeline-data-concepts

Examples

Select the top 100 stocks by 7-day sentiment score:

top_sentiment = brain.BSI.slice(7).SENTIMENT_SCORE.latest.top(100)

classmethod slice(N)¶

Return a Brain Sentiment Indicator (BSI) DataSet tied to a particular calculation window.

Parameters:: N (int, required) – the number of days over which sentiment is calculated. Choices are 1, 7, or 30.
Returns:: Brain Sentiment Indicator (BSI) DataSet with the specified N.
Return type:: DataSet

Notes

Usage Guide:

Brain Sentiment Indicator: https://qrok.it/dl/z/pipeline-brain-bsi
Pipeline data concepts: https://qrok.it/dl/z/pipeline-data-concepts

Examples

Select the top 100 stocks by 7-day sentiment score:

top_sentiment = brain.BSI.slice(7).SENTIMENT_SCORE.latest.top(100)

zipline.pipeline.brain.BLMCF ¶

class zipline.pipeline.data.brain.BLMCF¶

DataSetFamily representing Brain Language Metrics on Company Filings (BLMCF) data.

This dataset provides sentiment scores and other language metrics for 10-K and 10-Q company filings for US stocks, with history back to January 1, 2010.

To use the data in a pipeline, it must first be sliced by selecting the desired report category (10-K, 10-Q, or both) using the report_category dimension. To include both 10-K and 10-Q reports, slice the DataSetFamily without specifying a report category: BLMCF.slice(). For 10-K reports only, use: BLMCF.slice(report_category=’10-K’)

Language metrics are calculated separately for the Risk Factors section of the report (columns starting with RF), the Management Discussion and Analysis section (columns starting with MD), and the report as a whole (columns not starting with RF or MD). Columns containing “DELTA” or “SIMILARITY” in the name compare the current report with the previous report of the same period and category.

LAST_REPORT_CATEGORY¶

The category of the last available report. It can be either “10-K” or “10-Q”.

Type:: str

LAST_REPORT_DATE¶

The date of last report (with respect to the record’s Date) issued by the company in YYYY-MM-DD format.

Type:: datetime

N_SENTENCES¶

Number of sentences extracted from the last available report.

Type:: float

MEAN_SENTENCE_LENGTH¶

The mean sentence length measured in terms of the mean number of words per sentence for the last available report.

Type:: float

SENTIMENT¶

The financial sentiment of the last available report.

Type:: float

SCORE_UNCERTAINTY¶

The percentage of financial domain “uncertainty” language present in the last report.

Type:: float

SCORE_LITIGIOUS¶

The percentage of financial domain “litigious” language present in the last report.

Type:: float

SCORE_CONSTRAINING¶

The percentage of financial domain “constraining” language present in the last report.

Type:: float

SCORE_INTERESTING¶

The percentage of financial domain “interesting” language present in the last report.

Type:: float

READABILITY¶

Reading grade level for the the report expressed by a number corresponding to US education grade. The score is obtained from the average of various readability tests to measure how difficult is the text to understand (e.g. Gunning Fog Index).

Type:: float

LEXICAL_RICHNESS¶

Lexical richness measured in terms of the Type-Token Ratio (TTR) which calculates the number of types (total number of words) divided by the number of tokens (number of unique words). The basic logic behind this measure is that if the text is more complex, the author uses a more varied vocabulary

Type:: float

LEXICAL_DENSITY¶

Lexical density to measure the text complexity by computing the ratio between number of lexical words (nouns, adjectives, lexical verbs, adverbs) divided by the total number of words in the document.

Type:: float

SPECIFIC_DENSITY¶

Percentage of words belonging to the specific dictionary used for company filings analysis present in the last available report.

Type:: float

RF_N_SENTENCES¶

Number of sentences extracted from the “Risk Factors” section of the last available report.

Type:: float

RF_MEAN_SENTENCE_LENGTH¶

The mean sentence length measured in terms of the mean number of words per sentence for the “Risk Factors” section of the last available report.

Type:: float

RF_SENTIMENT¶

The financial sentiment for the “Risk Factors” section of the last available report.

Type:: float

RF_SCORE_UNCERTAINTY¶

The percentage of financial domain “uncertainty” language present in the “Risk Factors” section of the last report.

Type:: float

RF_SCORE_LITIGIOUS¶

The percentage of financial domain “litigious” language present in the “Risk Factors” section of the last report.

Type:: float

RF_SCORE_CONSTRAINING¶

The percentage of financial domain “constraining” language present in the “Risk Factors” section of the last report.

Type:: float

RF_SCORE_INTERESTING¶

The percentage of financial domain “interesting” language present in the “Risk Factors” section of the last report.

Type:: float

RF_READABILITY¶

Reading grade level for the “Risk Factors” section of the report expressed by a number corresponding to US education grade. The score is obtained from the average of various readability tests to measure how difficult is the text to understand (e.g. Gunning Fog Index).

Type:: float

RF_LEXICAL_RICHNESS¶

Lexical richness for the “Risk Factors” section of the last available report, measured in terms of the Type-Token Ratio (TTR) which calculates the number of types (total number of words) divided by the number of tokens (number of unique words).

Type:: float

RF_LEXICAL_DENSITY¶

Lexical density for the “Risk Factors” section of the last available report. Measures the text complexity by computing the ratio between number of lexical words (nouns, adjectives, lexical verbs, adverbs) divided by the total number of words in the document.

Type:: float

RF_SPECIFIC_DENSITY¶

Percentage of words belonging to the specific dictionary used for company filings analysis present in the “Risk Factors” section of the last available report.

Type:: float

MD_N_SENTENCES¶

Number of sentences extracted from the MD&A section of the last available report.

Type:: float

MD_MEAN_SENTENCE_LENGTH¶

The mean sentence length measured in terms of the mean number of words per sentence for the MD&A section of the last available report.

Type:: float

MD_SENTIMENT¶

The financial sentiment for the MD&A section of the last available report.

Type:: float

MD_SCORE_UNCERTAINTY¶

The percentage of financial domain “uncertainty” language present in the MD&A section of the last report.

Type:: float

MD_SCORE_LITIGIOUS¶

The percentage of financial domain “litigious” language present in the MD&A section of the last report.

Type:: float

MD_SCORE_CONSTRAINING¶

The percentage of financial domain “constraining” language present in the MD&A section of the last report.

Type:: float

MD_SCORE_INTERESTING¶

The percentage of financial domain “interesting” language present in the MD&A section of the last report.

Type:: float

MD_READABILITY¶

Reading grade level for the MD&A section of the report expressed by a number corresponding to US education grade. The score is obtained from the average of various readability tests to measure how difficult is the text to understand (e.g. Gunning Fog Index).

Type:: float

MD_LEXICAL_RICHNESS¶

Lexical richness for the MD&A section of the last available report, measured in terms of the Type-Token Ratio (TTR) which calculates the number of types (total number of words) divided by the number of tokens (number of unique words).

Type:: float

MD_LEXICAL_DENSITY¶

Lexical density for the MD&A section of the last available report. Measures the text complexity by computing the ratio between number of lexical words (nouns, adjectives, lexical verbs, adverbs) divided by the total number of words in the document.

Type:: float

MD_SPECIFIC_DENSITY¶

Percentage of words belonging to the specific dictionary used for company filings analysis present in the MD&A section of the last available report.

Type:: float

LAST_REPORT_PERIOD¶

The period of the last available report. For 10-K annual reports this is an integer number labelling the annual reports. For 10-Q quarterly reports this an integer number from 1 to 3 labelling the period report. This is used to perform differences between reports of the same period.

Type:: float

PREV_REPORT_DATE¶

The date of the previous report.

Type:: datetime

PREV_REPORT_CATEGORY¶

The category of the previous report. It can be either “10-K” or “10-Q”.

Type:: str

PREV_REPORT_PERIOD¶

The period of the previous report. For 10-K annual reports this is an integer number labelling the annual reports. For 10-Q quarterly reports this an integer number from 1 to 3 labelling the period report. This is used to perform differences between reports of the same period.

Type:: float

DELTA_PERC_N_SENTENCES¶

Percentage change of the number of sentences between the last available report and the previous report of same period and category.

Type:: float

DELTA_PERC_MEAN_SENTENCE_LENGTH¶

Percentage change of sentence length (mean number of words per sentence) between the last available report and the previous report of same period and category.

Type:: float

DELTA_SENTIMENT¶

The difference of financial sentiment between the last available report and the previous report of same period and category.

Type:: float

DELTA_SCORE_UNCERTAINTY¶

The difference of percentage of financial domain “uncertainty” language between the last available report and the previous report of same period and category.

Type:: float

DELTA_SCORE_LITIGIOUS¶

The difference of percentage of financial domain “litigious” language between the last available report and the previous report of same period and category.

Type:: float

DELTA_SCORE_CONSTRAINING¶

The difference of percentage of financial domain “constraining” language between the last available report and the previous report of same period and category.

Type:: float

DELTA_SCORE_INTERESTING¶

The difference of percentage of financial domain “interesting” language between the last available report and the previous report of same period and category.

Type:: float

DELTA_READABILITY¶

The difference of reading grade level between the last available report and the previous report of same period and category.

Type:: float

DELTA_LEXICAL_RICHNESS¶

The difference of lexical richness between the last available report and the previous report of same period and category.

Type:: float

DELTA_LEXICAL_DENSITY¶

The difference of lexical density between the last available report and the previous report of same period and category.

Type:: float

DELTA_SPECIFIC_DENSITY¶

The difference of percentage of words belonging to the specific dictionary used for company filings analysis between the last available report and the previous report of same period and category.

Type:: float

SIMILARITY_ALL¶

The language similarity between the last available report and the previous report of same period and category.

Type:: float

SIMILARITY_POSITIVE¶

The similarity in terms of financial domain “positive” language between the last available report and the previous report of same period and category.

Type:: float

SIMILARITY_NEGATIVE¶

The similarity in terms of financial domain “negative” language between the last available report and the previous report of same period and category.

Type:: float

SIMILARITY_UNCERTAINTY¶

The similarity in terms of financial domain “uncertainty” language between the last available report and the previous report of same period and category.

Type:: float

SIMILARITY_LITIGIOUS¶

The similarity in terms of financial domain “litigious” language between the last available report and the previous report of same period and category.

Type:: float

SIMILARITY_CONSTRAINING¶

The similarity in terms of financial domain “constraining” language between the last available report and the previous report of same period and category.

Type:: float

SIMILARITY_INTERESTING¶

The similarity in terms of financial domain “interesting” language between the last available report and the previous report of same period and category.

Type:: float

RF_DELTA_PERC_N_SENTENCES¶

Percentage change of the number of sentences in the “Risk Factors” section between the last available report and the previous report of same period and category.

Type:: float

RF_DELTA_PERC_MEAN_SENTENCE_LENGTH¶

Percentage change of sentence length (mean number of words per sentence) in the “Risk Factors” section between the last available report and the previous report of same period and category.

Type:: float

RF_DELTA_SENTIMENT¶

The difference of financial sentiment in the “Risk Factors” section between the last available report and the previous report of same period and category.

Type:: float

RF_DELTA_SCORE_UNCERTAINTY¶

The difference of percentage of financial domain “uncertainty” language in the “Risk Factors” section between the last available report and the previous report of same period and category.

Type:: float

RF_DELTA_SCORE_LITIGIOUS¶

The difference of percentage of financial domain “litigious” language in the “Risk Factors” section between the last available report and the previous report of same period and category.

Type:: float

RF_DELTA_SCORE_CONSTRAINING¶

The difference of percentage of financial domain “constraining” language in the “Risk Factors” section between the last available report and the previous report of same period and category.

Type:: float

RF_DELTA_SCORE_INTERESTING¶

The difference of percentage of financial domain “interesting” language in the “Risk Factors” section between the last available report and the previous report of same period and category.

Type:: float

RF_DELTA_READABILITY¶

The difference of reading grade level in the “Risk Factors” section between the last available report and the previous report of same period and category.

Type:: float

RF_DELTA_LEXICAL_RICHNESS¶

The difference of lexical richness in the “Risk Factors” section between the last available report and the previous report of same period and category.

Type:: float

RF_DELTA_LEXICAL_DENSITY¶

The difference of lexical density in the “Risk Factors” section between the last available report and the previous report of same period and category.

Type:: float

RF_DELTA_SPECIFIC_DENSITY¶

The difference of percentage of words belonging to the specific dictionary used for company filings analysis in the “Risk Factors” section between the last available report and the previous report of same period and category.

Type:: float

RF_SIMILARITY_ALL¶

The language similarity in the “Risk Factors” section between the last available report and the previous report of same period and category.

Type:: float

RF_SIMILARITY_POSITIVE¶

The similarity in terms of financial domain “positive” language in the “Risk Factors” section between the last available report and the previous report of same period and category.

Type:: float

RF_SIMILARITY_NEGATIVE¶

The similarity in terms of financial domain “negative” language in the “Risk Factors” section between the last available report and the previous report of same period and category.

Type:: float

MD_DELTA_PERC_N_SENTENCES¶

Percentage change of the number of sentences in the MD&A section between the last available report and the previous report of same period and category.

Type:: float

MD_DELTA_PERC_MEAN_SENTENCE_LENGTH¶

Percentage change of sentence length (mean number of words per sentence) in the MD&A section between the last available report and the previous report of same period and category.

Type:: float

MD_DELTA_SENTIMENT¶

The difference of financial sentiment in the MD&A section between the last available report and the previous report of same period and category.

Type:: float

MD_DELTA_SCORE_UNCERTAINTY¶

The difference of percentage of financial domain “uncertainty” language in the MD&A section between the last available report and the previous report of same period and category.

Type:: float

MD_DELTA_SCORE_LITIGIOUS¶

The difference of percentage of financial domain “litigious” language in the MD&A section between the last available report and the previous report of same period and category.

Type:: float

MD_DELTA_SCORE_CONSTRAINING¶

The difference of percentage of financial domain “constraining” language in the MD&A section between the last available report and the previous report of same period and category.

Type:: float

MD_DELTA_SCORE_INTERESTING¶

The difference of percentage of financial domain “interesting” language in the MD&A section between the last available report and the previous report of same period an category.

Type:: float

MD_DELTA_READABILITY¶

The difference of reading grade level in the MD&A section between the last available report and the previous report of same period and category.

Type:: float

MD_DELTA_LEXICAL_RICHNESS¶

The difference of lexical richness in the MD&A section between the last available report and the previous report of same period and category.

Type:: float

MD_DELTA_LEXICAL_DENSITY¶

The difference of lexical density in the MD&A section between the last available report and the previous report of same period and category.

Type:: float

MD_DELTA_SPECIFIC_DENSITY¶

The difference of percentage of words belonging to the specific dictionary used for company filings analysis in the MD&A section between the last available report and the previous report of same period and category.

Type:: float

MD_SIMILARITY_ALL¶

The language similarity in the MD&A section between the last available report and the previous report of same period and category.

Type:: float

MD_SIMILARITY_POSITIVE¶

The similarity in terms of financial domain “positive” language in the MD&A section between the last available report and the previous report of same period and category.

Type:: float

MD_SIMILARITY_NEGATIVE¶

The similarity in terms of financial domain “negative” language in the MD&A section between the last available report and the previous report of same period and category.

Type:: float

Notes

Usage Guide:

Brain Language Metrics on Company Filings: https://qrok.it/dl/z/pipeline-brain-blmcf
Pipeline data concepts: https://qrok.it/dl/z/pipeline-data-concepts

Examples

Select the top 100 stocks by sentiment score of the latest company filing:

top_sentiment = brain.BLMCF.slice().SENTIMENT.latest.top(100)

Select the top 100 stocks by sentiment score of the latest 10-K filing:

top_sentiment = brain.BLMCF.slice(report_category='10-K').SENTIMENT.latest.top(100)

classmethod slice(report_category=None)¶

Return a Brain Language Metrics on Company Filings (BLMCF) tied to a particular report category (10-K, 10-Q, or both).

Parameters:: report_category (str, required) – the report category, either ‘10-K’, ‘10-Q’, or None to include both.
Returns:: Brain Language Metrics on Company Filings (BLMCF) DataSet with the specified report_category.
Return type:: DataSet

Notes

Usage Guide:

Brain Language Metrics on Company Filings: https://qrok.it/dl/z/pipeline-brain-blmcf
Pipeline data concepts: https://qrok.it/dl/z/pipeline-data-concepts

Examples

Select the top 100 stocks by sentiment score of the latest company filing:

top_sentiment = brain.BLMCF.slice().SENTIMENT.latest.top(100)

Select the top 100 stocks by sentiment score of the latest 10-K filing:

top_sentiment = brain.BLMCF.slice(report_category='10-K').SENTIMENT.latest.top(100)

zipline.pipeline.brain.BLMECT ¶

class zipline.pipeline.data.brain.BLMECT¶

DataSet representing Brain Earnings Call Transcripts (BLMECT) data.

This dataset provides sentiment scores and other language metrics for earnings call transcripts for US stocks, with history back to January 1, 2012.

Columns are organized into three sections, corresponding to three sections of the earnings call transcripts: “Management Discussion” (MD), “Analyst Questions” (AQ), and “Management Answers” (MA). Columns containing “DELTA” or “SIMILARITY” in the name compare the current earnings call transcript to the previous earnings call transcript.

LAST_TRANSCRIPT_DATE¶

The date of last earnings call transcript (with respect to the record’s Date) issued by the company in YYYY-MM-DD format

Type:: datetime

LAST_TRANSCRIPT_QUARTER¶

Reference quarter of last earnings call transcript

Type:: float

LAST_TRANSCRIPT_YEAR¶

Reference year of last earnings call transcript

Type:: float

MD_N_CHARACTERS¶

The length of the “Management Discussion” section measured in number of characters.

Type:: float

MD_SENTIMENT¶

The financial sentiment for the “Management Discussion” section of the last available transcript.

Type:: float

MD_SCORE_UNCERTAINTY¶

The percentage of financial domain “uncertainty” language in the “Management Discussion” section of the last available transcript.

Type:: float

MD_SCORE_LITIGIOUS¶

The percentage of financial domain “litigious” language in the “Management Discussion” section of the last available transcript.

Type:: float

MD_SCORE_CONSTRAINING¶

The percentage of financial domain “constraining” language in the “Management Discussion” section of the last available transcript.

Type:: float

MD_READABILITY¶

The reading grade level of the “Management Discussion” section of the last available transcript.

Type:: float

MD_LEXICAL_RICHNESS¶

The lexical richness of the “Management Discussion” section of the last available transcript.

Type:: float

MD_LEXICAL_DENSITY¶

The lexical density of the “Management Discussion” section of the last available transcript.

Type:: float

MD_SPECIFIC_DENSITY¶

Percentage of words belonging to the specific dictionary used for the earnings call analysis present in the “Management Discussion” section of the last available transcript.

Type:: float

AQ_N_CHARACTERS¶

The length of the “Analyst Questions” section measured in number of characters.

Type:: float

AQ_SENTIMENT¶

The financial sentiment for the “Analyst Questions” section of the last available transcript.

Type:: float

AQ_SCORE_UNCERTAINTY¶

The percentage of financial domain “uncertainty” language in the “Analyst Questions” section of the last available transcript.

Type:: float

AQ_SCORE_LITIGIOUS¶

The percentage of financial domain “litigious” language in the “Analyst Questions” section of the last available transcript.

Type:: float

AQ_SCORE_CONSTRAINING¶

The percentage of financial domain “constraining” language in the “Analyst Questions” section of the last available transcript.

Type:: float

MA_N_CHARACTERS¶

The length of the “Management Answers” section measured in number of characters.

Type:: float

MA_SENTIMENT¶

The financial sentiment for the “Management Answers” section of the last available transcript.

Type:: float

MA_SCORE_UNCERTAINTY¶

The percentage of financial domain “uncertainty” language in the “Management Answers” section of the last available transcript.

Type:: float

MA_SCORE_LITIGIOUS¶

The percentage of financial domain “litigious” language in the “Management Answers” section of the last available transcript.

Type:: float

MA_SCORE_CONSTRAINING¶

The percentage of financial domain “constraining” language in the “Management Answers” section of the last available transcript.

Type:: float

MA_READABILITY¶

The reading grade level of the “Management Answers” section of the last available transcript.

Type:: float

MA_LEXICAL_RICHNESS¶

The lexical richness of the “Management Answers” section of the last available transcript.

Type:: float

MA_LEXICAL_DENSITY¶

The lexical density of the “Management Answers” section of the last available transcript.

Type:: float

MA_SPECIFIC_DENSITY¶

Percentage of words belonging to the specific dictionary used for the earnings call analysis present in the “Management Answers” section of the last available transcript.

Type:: float

PREV_TRANSCRIPT_DATE¶

Date of the previous earnings call transcript

Type:: datetime

PREV_TRANSCRIPT_QUARTER¶

Reference quarter of the previous earnings call transcript

Type:: float

PREV_TRANSCRIPT_YEAR¶

Reference year of the previous earnings call transcript

Type:: float

MD_DELTA_PERC_N_CHARACTERS¶

The percentage change in the length (measured in number of characters) of the “Management Discussion” section between the last and previous available transcripts.

Type:: float

MD_DELTA_SENTIMENT¶

The difference in financial sentiment for the “Management Discussion” section between the last and previous available transcripts.

Type:: float

MD_DELTA_SCORE_UNCERTAINTY¶

The difference in the percentage of financial domain “uncertainty” language in the “Management Discussion” section between the last and previous available transcripts.

Type:: float

MD_DELTA_SCORE_LITIGIOUS¶

The difference in the percentage of financial domain “litigious” language in the “Management Discussion” section between the last and previous available transcripts.

Type:: float

MD_DELTA_SCORE_CONSTRAINING¶

The difference in the percentage of financial domain “constraining” language in the “Management Discussion” section between the last and previous available transcripts.

Type:: float

MD_DELTA_READABILITY¶

The difference in the reading grade level of the “Management Discussion” section between the last and previous available transcripts.

Type:: float

MD_DELTA_LEXICAL_RICHNESS¶

The difference in the lexical richness of the “Management Discussion” section between the last and previous available transcripts.

Type:: float

MD_DELTA_LEXICAL_DENSITY¶

The difference in the lexical density of the “Management Discussion” section between the last and previous available transcripts.

Type:: float

MD_DELTA_SPECIFIC_DENSITY¶

The difference in the percentage of words belonging to the specific dictionary used for the earnings call analysis present in the “Management Discussion” section between the last and previous available transcripts.

Type:: float

MD_SIMILARITY_ALL¶

The language similarity between the “Management Discussion” sections of the last and previous available transcripts.

Type:: float

MD_SIMILARITY_POSITIVE¶

The similarity in terms of financial domain “positive” language between the “Management Discussion” sections of the last and previous available transcripts.

Type:: float

MD_SIMILARITY_NEGATIVE¶

The similarity in terms of financial domain “negative” language between the “Management Discussion” sections of the last and previous available transcripts.

Type:: float

MD_SIMILARITY_UNCERTAINTY¶

The similarity in terms of financial domain “uncertainty” language between the “Management Discussion” sections of the last and previous available transcripts.

Type:: float

MD_SIMILARITY_LITIGIOUS¶

The similarity in terms of financial domain “litigious” language between the “Management Discussion” sections of the last and previous available transcripts.

Type:: float

MD_SIMILARITY_CONSTRAINING¶

The similarity in terms of financial domain “constraining” language between the “Management Discussion” sections of the last and previous available transcripts.

Type:: float

AQ_DELTA_PERC_N_CHARACTERS¶

The percentage change in the length (measured in number of characters) of the “Analyst Questions” section between the last and previous available transcripts.

Type:: float

AQ_DELTA_SENTIMENT¶

The difference in financial sentiment for the “Analyst Questions” section between the last and previous available transcripts.

Type:: float

AQ_DELTA_SCORE_UNCERTAINTY¶

The difference in the percentage of financial domain “uncertainty” language in the “Analyst Questions” section between the last and previous available transcripts.

Type:: float

AQ_DELTA_SCORE_LITIGIOUS¶

The difference in the percentage of financial domain “litigious” language in the “Analyst Questions” section between the last and previous available transcripts.

Type:: float

AQ_DELTA_SCORE_CONSTRAINING¶

The difference in the percentage of financial domain “constraining” language in the “Analyst Questions” section between the last and previous available transcripts.

Type:: float

AQ_SIMILARITY_ALL¶

The language similarity between the “Analyst Questions” sections of the last and previous available transcripts.

Type:: float

AQ_SIMILARITY_POSITIVE¶

The similarity in terms of financial domain “positive” language between the “Analyst Questions” sections of the last and previous available transcripts.

Type:: float

AQ_SIMILARITY_NEGATIVE¶

The similarity in terms of financial domain “negative” language between the “Analyst Questions” sections of the last and previous available transcripts.

Type:: float

MA_DELTA_PERC_N_CHARACTERS¶

The percentage change in the length (measured in number of characters) of the “Management Answers” section between the last and previous available transcripts.

Type:: float

MA_DELTA_SENTIMENT¶

The difference in financial sentiment for the “Management Answers” section between the last and previous available transcripts.

Type:: float

MA_DELTA_SCORE_UNCERTAINTY¶

The difference in the percentage of financial domain “uncertainty” language in the “Management Answers” section between the last and previous available transcripts.

Type:: float

MA_DELTA_SCORE_LITIGIOUS¶

The difference in the percentage of financial domain “litigious” language in the “Management Answers” section between the last and previous available transcripts.

Type:: float

MA_DELTA_SCORE_CONSTRAINING¶

The difference in the percentage of financial domain “constraining” language in the “Management Answers” section between the last and previous available transcripts.

Type:: float

MA_DELTA_READABILITY¶

The difference in the reading grade level of the “Management Answers” section between the last and previous available transcripts.

Type:: float

MA_DELTA_LEXICAL_RICHNESS¶

The difference in the lexical richness of the “Management Answers” section between the last and previous available transcripts.

Type:: float

MA_DELTA_LEXICAL_DENSITY¶

The difference in the lexical density of the “Management Answers” section between the last and previous available transcripts.

Type:: float

MA_DELTA_SPECIFIC_DENSITY¶

The difference in the percentage of words belonging to the specific dictionary used for the earnings call analysis present in the “Management Answers” section between the last and previous available transcripts.

Type:: float

MA_SIMILARITY_ALL¶

The language similarity between the “Management Answers” sections of the last and previous available transcripts.

Type:: float

MA_SIMILARITY_POSITIVE¶

The similarity in terms of financial domain “positive” language between the “Management Answers” sections of the last and previous available transcripts.

Type:: float

MA_SIMILARITY_NEGATIVE¶

The similarity in terms of financial domain “negative” language between the “Management Answers” sections of the last and previous available transcripts.

Type:: float

MA_SIMILARITY_UNCERTAINTY¶

The similarity in terms of financial domain “uncertainty” language between the “Management Answers” sections of the last and previous available transcripts.

Type:: float

MA_SIMILARITY_LITIGIOUS¶

The similarity in terms of financial domain “litigious” language between the “Management Answers” sections of the last and previous available transcripts.

Type:: float

MA_SIMILARITY_CONSTRAINING¶

The similarity in terms of financial domain “constraining” language between the “Management Answers” sections of the last and previous available transcripts.

Type:: float

Notes

Usage Guide:

Brain Language Metrics on Earnings Call Transcripts: https://qrok.it/dl/z/pipeline-brain-blmect
Pipeline data concepts: https://qrok.it/dl/z/pipeline-data-concepts

Examples

Select the top 100 stocks by sentiment score in the Management Discussion section of the latest earnings call transcript:

top_sentiment = brain.BLMECT.MD_SENTIMENT.latest.top(100)

Built-in Factors ¶

zipline.pipeline.Constant ¶

class zipline.pipeline.Constant¶

Pipeline term that returns a constant value.

Parameters:: const (scalar, required) – the constant value. This can be a float, int, str or bool.

Examples

Create a Pipeline term consisting of ones:

>>> ones = Constant(1)

zipline.pipeline.factors.AnnualizedVolatility ¶

class zipline.pipeline.factors.AnnualizedVolatility(*args, **kwargs)¶

Factor that calculates annualized volatility, the degree of variation of a series over time as measured by the standard deviation of daily returns. https://en.wikipedia.org/wiki/Volatility_(finance)

Default Inputs: [Returns(window_length=2)]

Parameters:

annualization_factor (float, optional) – The number of time units per year. Defaults is 252, the number of NYSE trading days in a normal year.
mask (zipline.pipeline.Filter, optional) – A Filter representing assets to consider when computing results. If supplied, we ignore asset/date pairs where mask produces False.

Examples

Calculate annualized volatility:

>>> annual_vol = AnnualizedVolatility()

zipline.pipeline.factors.Aroon ¶

class zipline.pipeline.factors.Aroon(*args, **kwargs)¶

Factor that calculates Aroon technical indicator. https://www.fidelity.com/learning-center/trading-investing/technical-analysis/technical-indicator-guide/aroon-indicator

Defaults Inputs: zipline.pipeline.data.EquityPricing.low, zipline.pipeline.data.EquityPricing.high

Parameters:

window_length (int > 0) – Length of the lookback window over which to compute the Aroon indicator.
mask (zipline.pipeline.Filter, optional) – A Filter representing assets to consider when computing results. If supplied, we ignore asset/date pairs where mask produces False.

zipline.pipeline.factors.AverageDollarVolume ¶

class zipline.pipeline.factors.AverageDollarVolume(*args, **kwargs)¶

Factor that calculates average daily dollar volume.

Default Inputs: [EquityPricing.close, EquityPricing.volume]

Default Window Length: None

Parameters:

window_length (int > 0) – Length of the lookback window over which to compute average dollar volume.
mask (zipline.pipeline.Filter, optional) – A Filter representing assets to consider when computing results. If supplied, we ignore asset/date pairs where mask produces False.

Examples

Calculate 30-day average dollar volume:

>>> avg_dollar_volume = AverageDollarVolume(window_length=30)

zipline.pipeline.factors.BollingerBands ¶

class zipline.pipeline.factors.BollingerBands(*args, **kwargs)¶

Factor that calculates Bollinger Bands technical indicator. https://en.wikipedia.org/wiki/Bollinger_Bands

Default Inputs: zipline.pipeline.data.EquityPricing.close

Parameters:

inputs (BoundColumn) – The expression over which to compute bollinger bands.
window_length (int > 0) – Length of the lookback window over which to compute the bollinger bands.
k (float) – The number of standard deviations to add or subtract to create the upper and lower bands.
mask (zipline.pipeline.Filter, optional) – A Filter representing assets to consider when computing results. If supplied, we ignore asset/date pairs where mask produces False.

Examples

Calculate 14-day Bolling Bands at 2 standard deviations:

>>> bbands = BollingerBands(window_length=14, k=2)

zipline.pipeline.factors.DailyReturns ¶

class zipline.pipeline.factors.DailyReturns(*args, **kwargs)¶

Factor that calculates daily percent change in close price.

Default Inputs: [EquityPricing.close]

Parameters:

inputs (BoundColumn) – The expression for which to compute daily returns. Default is EquityPricing.close.
mask (zipline.pipeline.Filter, optional) – A Filter representing assets to consider when computing results. If supplied, we ignore asset/date pairs where mask produces False.

Examples

Calculate daily returns:

>>> daily_returns = DailyReturns()

zipline.pipeline.factors.ExponentialWeightedMovingAverage ¶

class zipline.pipeline.factors.ExponentialWeightedMovingAverage(*args, **kwargs)¶

Factor that calculates exponentially-weighted moving average.

Default Inputs: None

Default Window Length: None

Parameters:

inputs (BoundColumn) – The expression over which to compute the average.
window_length (int > 0) – Length of the lookback window over which to compute the average.
decay_rate (float, 0 < decay_rate <= 1) –
Weighting factor by which to discount past observations.
When calculating historical averages, rows are multiplied by the sequence:
```
decay_rate, decay_rate ** 2, decay_rate ** 3, ...
```
mask (zipline.pipeline.Filter, optional) – A Filter representing assets to consider when computing results. If supplied, we ignore asset/date pairs where mask produces False.

Examples

Calculate the 30-day EWMA of EquityPricing.close with a decay rate of 0.08.

>>> ewma = ExponentialWeightedMovingAverage(inputs=EquityPricing.close, window_length=30, decay_rate=0.08)

Notes

This class can also be imported under the name EWMA.

See also

pandas.DataFrame.ewm()

zipline.pipeline.factors.ExponentialWeightedMovingStdDev ¶

class zipline.pipeline.factors.ExponentialWeightedMovingStdDev(*args, **kwargs)¶

Factor that calculates exponentially-weighted moving standard deviation.

Default Inputs: None

Default Window Length: None

Parameters:

inputs (BoundColumn) – The expression over which to compute the average.
window_length (int > 0) – Length of the lookback window over which to compute the average.
decay_rate (float, 0 < decay_rate <= 1) –
Weighting factor by which to discount past observations.
When calculating historical averages, rows are multiplied by the sequence:
```
decay_rate, decay_rate ** 2, decay_rate ** 3, ...
```
mask (zipline.pipeline.Filter, optional) – A Filter representing assets to consider when computing results. If supplied, we ignore asset/date pairs where mask produces False.
-------- –
0.08. (Calculate the 30-day EWMSTD of EquityPricing.close with a decay rate of) –
ExponentialWeightedMovingStdDev(inputs=EquityPricing.close (>>> ewmstd =) –
window_length=30 –
decay_rate=0.08) –

Notes

This class can also be imported under the name EWMSTD.

See also

pandas.DataFrame.ewm()

zipline.pipeline.factors.FastStochasticOscillator ¶

class zipline.pipeline.factors.FastStochasticOscillator(*args, **kwargs)¶

Factor that calculates Fast Stochastic Oscillator Indicator [%K, Momentum Indicator]. https://wiki.timetotrade.eu/Stochastic

This stochastic is considered volatile, and varies a lot when used in market analysis. It is recommended to use the slow stochastic oscillator or a moving average of the %K [%D].

Default Inputs: zipline.pipeline.data.EquityPricing.close, zipline.pipeline.data.EquityPricing.low, zipline.pipeline.data.EquityPricing.high

Default Window Length: 14

Parameters:

window_length (int > 0) – Length of the lookback window over which to compute the indicator.
mask (zipline.pipeline.Filter, optional) – A Filter representing assets to consider when computing results. If supplied, we ignore asset/date pairs where mask produces False.

Returns:

out

Return type:

%K oscillator

Examples

Calculate a 14-day Fast Stochastic Oscillator:

>>> fast_stochastic = FastStochasticOscillator(window_length=14)

zipline.pipeline.factors.IchimokuKinkoHyo ¶

class zipline.pipeline.factors.IchimokuKinkoHyo(*args, **kwargs)¶

Factor that calculates the various metrics for the Ichimoku Kinko Hyo (Ichimoku Cloud). http://stockcharts.com/school/doku.php?id=chart_school:technical_indicators:ichimoku_cloud

Default Inputs: zipline.pipeline.data.EquityPricing.high, zipline.pipeline.data.EquityPricing.low, zipline.pipeline.data.EquityPricing.close

Default Window Length: 52

Parameters:

window_length (int > 0) – The length the the window for the senkou span b.
tenkan_sen_length (int >= 0, <= window_length) – The length of the window for the tenkan-sen.
kijun_sen_length (int >= 0, <= window_length) – The length of the window for the kijou-sen.
chikou_span_length (int >= 0, <= window_length) – The lag for the chikou span.
mask (zipline.pipeline.Filter, optional) – A Filter representing assets to consider when computing results. If supplied, we ignore asset/date pairs where mask produces False.

Examples

Compute the Ichimoku Kinko Hyo with default parameters:

>>> ikh = IchimokuKinkoHyo()

zipline.pipeline.factors.IntradayReturns ¶

class zipline.pipeline.factors.IntradayReturns(*args, **kwargs)¶

Factor that calculates percent change from the open price to the close price.

Parameters:: mask (zipline.pipeline.Filter, optional) – A Filter representing assets to consider when computing results. If supplied, we ignore asset/date pairs where mask produces False.

Examples

Calculate intraday (open-to-close) returns:

>>> intraday_returns = IntradayReturns()

zipline.pipeline.factors.Latest ¶

class zipline.pipeline.factors.Latest(*args, **kwargs)¶

Factor producing the most recently-known value of the input term on each day.

The .latest attribute of DataSet columns returns an instance of this Factor.

zipline.pipeline.factors.LinearWeightedMovingAverage ¶

class zipline.pipeline.factors.LinearWeightedMovingAverage(*args, **kwargs)¶

Factor that calculates weighted average value of an arbitrary column.

Default Inputs: None

Default Window Length: None

Parameters:

inputs (BoundColumn) – The expression for which to compute the average.
window_length (int > 0) – Length of the lookback window over which to compute the average.
mask (zipline.pipeline.Filter, optional) – A Filter representing assets to consider when computing results. If supplied, we ignore asset/date pairs where mask produces False.

Examples

Calculate a 60-day linearly weighted moving average of EquityPricing.close:

>>> lwma = LinearWeightedMovingAverage(inputs=EquityPricing.close, window_length=60)

zipline.pipeline.factors.MACDSignal ¶

class zipline.pipeline.factors.MACDSignal(*args, **kwargs)¶

Factor that calculates Moving Average Convergence/Divergence (MACD) Signal line. https://en.wikipedia.org/wiki/MACD

A technical indicator originally developed by Gerald Appel in the late 1970’s. MACD shows the relationship between two moving averages and reveals changes in the strength, direction, momentum, and duration of a trend in a stock’s price.

Default Inputs: zipline.pipeline.data.EquityPricing.close

Parameters:

fast_period (int > 0, optional) – The window length for the “fast” EWMA. Default is 12.
slow_period (int > 0, > fast_period, optional) – The window length for the “slow” EWMA. Default is 26.
signal_period (int > 0, < fast_period, optional) – The window length for the signal line. Default is 9.
mask (zipline.pipeline.Filter, optional) – A Filter representing assets to consider when computing results. If supplied, we ignore asset/date pairs where mask produces False.

Examples

Construct a 12/26/9 MACD Signal factor:

>>> macd_signal = MACDSignal()

Notes

Unlike most pipeline expressions, this factor does not accept a window_length parameter. window_length is inferred from slow_period and signal_period.

zipline.pipeline.factors.MaxDrawdown ¶

class zipline.pipeline.factors.MaxDrawdown(*args, **kwargs)¶

Factor that calculates maximum drawdown.

Default Inputs: None

Default Window Length: None

Parameters:

inputs (BoundColumn) – The expression for which to compute max drawdown.
window_length (int > 0) – Length of the lookback window over which to compute max drawdown.
mask (zipline.pipeline.Filter, optional) – A Filter representing assets to consider when computing results. If supplied, we ignore asset/date pairs where mask produces False.

Examples

Calculate max drawdown over a rolling 200-day lookback window:

>>> max_drawdown = MaxDrawdown(inputs=EquityPricing.close, window_length=200)

zipline.pipeline.factors.OvernightReturns ¶

class zipline.pipeline.factors.OvernightReturns(*args, **kwargs)¶

Factor that calculates percent change from the previous close price to the open price.

Parameters:: mask (zipline.pipeline.Filter, optional) – A Filter representing assets to consider when computing results. If supplied, we ignore asset/date pairs where mask produces False.

Examples

Calculate overnight returns:

>>> overnight_returns = OvernightReturns()

zipline.pipeline.factors.PercentChange ¶

class zipline.pipeline.factors.PercentChange(*args, **kwargs)¶

Factor that calculates the percent change over the given window_length.

Default Inputs: None

Default Window Length: None

Parameters:

inputs (BoundColumn) – The expression for which to compute percent change.
window_length (int > 0) – Length of the lookback window over which to compute percent change.
mask (zipline.pipeline.Filter, optional) – A Filter representing assets to consider when computing results. If supplied, we ignore asset/date pairs where mask produces False.

Examples

Calculate 5-day percent change of opening price:

>>> percent_change = PercentChange(inputs=EquityPricing.open, window_length=5)

Notes

Percent change is calculated as (new - old) / abs(old).

zipline.pipeline.factors.RateOfChangePercentage ¶

class zipline.pipeline.factors.RateOfChangePercentage(*args, **kwargs)¶

Factor that calculates Rate of change Percentage (ROC), a technical indicator that measures the percentage change in price from one period to the next. The ROC calculation compares the current price with the price n periods ago.

Formula for calculation: ((price - prevPrice) / prevPrice) * 100

price - the current price
prevPrice - the price n days ago, equals window length

Default Inputs: zipline.pipeline.data.EquityPricing.close

Default Window Length: None

Parameters:

inputs (BoundColumn) – The expression for which to compute the indicator.
window_length (int > 0) – Length of the lookback window over which to compute the indicator.
mask (zipline.pipeline.Filter, optional) – A Filter representing assets to consider when computing results. If supplied, we ignore asset/date pairs where mask produces False.

Examples

Calculate 30-day rate of change:

>>> rate_of_change = RateOfChangePercentage(window_length=30)

zipline.pipeline.factors.Returns ¶

class zipline.pipeline.factors.Returns(*args, **kwargs)¶

Factor that calculates the percent change in close price over the given window_length.

Default Inputs: EquityPricing.close

Parameters:

inputs (BoundColumn) – The expression for which to compute returns. Default is EquityPricing.close.
window_length (int > 0) – Length of the lookback window over which to compute returns.
exclude_window_length (int >= 0, optional) – Optional number of most recent observations to exclude from the returns calculation. Default is 0, meaning don’t exclude any observations.

maskzipline.pipeline.Filter, optional: A Filter representing assets to consider when computing results. If supplied, we ignore asset/date pairs where mask produces False.

Examples

Calculate returns over the past year, excluding the most recent month:

>>> returns = Returns(window_length=252, exclude_window_length=21)

zipline.pipeline.factors.RollingLinearRegressionOfReturns ¶

class zipline.pipeline.factors.RollingLinearRegressionOfReturns(*args, **kwargs)¶

Factor that performs an ordinary least-squares regression predicting the returns of all other assets on the given asset.

Parameters:

target (zipline.assets.Asset) – The asset to regress against all other assets.
returns_length (int >= 2) – Length of the lookback window over which to compute returns. Daily returns require a window length of 2.
regression_length (int >= 1) – Length of the lookback window over which to compute each regression.
mask (zipline.pipeline.Filter, optional) – A Filter describing which assets should be regressed against the target asset each day.

Notes

Computing this factor over many assets can be time consuming. It is recommended that a mask be used in order to limit the number of assets over which regressions are computed.

This factor is designed to return five outputs:

alpha, a factor that computes the intercepts of each regression.
beta, a factor that computes the slopes of each regression.
r_value, a factor that computes the correlation coefficient of each regression.
p_value, a factor that computes, for each regression, the two-sided p-value for a hypothesis test whose null hypothesis is that the slope is zero.
stderr, a factor that computes the standard error of the estimate of each regression.

For more help on factors with multiple outputs, see zipline.pipeline.CustomFactor.

Examples

Let the following be example 10-day returns for three different assets:

               SPY    MSFT     FB
2017-03-13    -.03     .03    .04
2017-03-14    -.02    -.03    .02
2017-03-15    -.01     .02    .01
2017-03-16       0    -.02    .01
2017-03-17     .01     .04   -.01
2017-03-20     .02    -.03   -.02
2017-03-21     .03     .01   -.02
2017-03-22     .04    -.02   -.02

Suppose we are interested in predicting each stock’s returns from SPY’s over rolling 5-day look back windows. We can compute rolling regression coefficients (alpha and beta) from 2017-03-17 to 2017-03-22 by doing:

regression_factor = RollingLinearRegressionOfReturns(
    target=sid('FIBBG000BDTBL9'),
    returns_length=10,
    regression_length=5,
)
alpha = regression_factor.alpha
beta = regression_factor.beta

The result of computing alpha from 2017-03-17 to 2017-03-22 gives:

               SPY    MSFT     FB
2017-03-17       0    .011   .003
2017-03-20       0   -.004   .004
2017-03-21       0    .007   .006
2017-03-22       0    .002   .008

And the result of computing beta from 2017-03-17 to 2017-03-22 gives:

               SPY    MSFT     FB
2017-03-17       1      .3   -1.1
2017-03-20       1      .2     -1
2017-03-21       1     -.3     -1
2017-03-22       1     -.3    -.9

Note that SPY’s column for alpha is all 0’s and for beta is all 1’s, as the regression line of SPY with itself is simply the function y = x.

To understand how each of the other values were calculated, take for example MSFT’s alpha and beta values on 2017-03-17 (.011 and .3, respectively). These values are the result of running a linear regression predicting MSFT’s returns from SPY’s returns, using values starting at 2017-03-17 and looking back 5 days. That is, the regression was run with x = [-.03, -.02, -.01, 0, .01] and y = [.03, -.03, .02, -.02, .04], and it produced a slope of .3 and an intercept of .011.

zipline.pipeline.factors.RollingPearsonOfReturns ¶

class zipline.pipeline.factors.RollingPearsonOfReturns(*args, **kwargs)¶

Factor that calculates the Pearson product-moment correlation coefficient of the returns of the given asset with the returns of all other assets.

Pearson correlation is what most people mean when they say “correlation coefficient” or “R-value”.

Parameters:

target (zipline.assets.Asset) – The asset to correlate with all other assets.
returns_length (int >= 2) – Length of the lookback window over which to compute returns. Daily returns require a window length of 2.
correlation_length (int >= 1) – Length of the lookback window over which to compute each correlation coefficient.
mask (zipline.pipeline.Filter, optional) – A Filter describing which assets should have their correlation with the target asset computed each day.

Notes

Computing this factor over many assets can be time consuming. It is recommended that a mask be used in order to limit the number of assets over which correlations are computed.

Examples

Let the following be example 10-day returns for three different assets:

               SPY    MSFT     FB
2017-03-13    -.03     .03    .04
2017-03-14    -.02    -.03    .02
2017-03-15    -.01     .02    .01
2017-03-16       0    -.02    .01
2017-03-17     .01     .04   -.01
2017-03-20     .02    -.03   -.02
2017-03-21     .03     .01   -.02
2017-03-22     .04    -.02   -.02

Suppose we are interested in SPY’s rolling returns correlation with each stock from 2017-03-17 to 2017-03-22, using a 5-day look back window (that is, we calculate each correlation coefficient over 5 days of data). We can achieve this by doing:

rolling_correlations = RollingPearsonOfReturns(
    target=sid('FIBBG000BDTBL9'),
    returns_length=10,
    correlation_length=5,
)

The result of computing rolling_correlations from 2017-03-17 to 2017-03-22 gives:

               SPY   MSFT     FB
2017-03-17       1    .15   -.96
2017-03-20       1    .10   -.96
2017-03-21       1   -.16   -.94
2017-03-22       1   -.16   -.85

Note that the column for SPY is all 1’s, as the correlation of any data series with itself is always 1. To understand how each of the other values were calculated, take for example the .15 in MSFT’s column. This is the correlation coefficient between SPY’s returns looking back from 2017-03-17 (-.03, -.02, -.01, 0, .01) and MSFT’s returns (.03, -.03, .02, -.02, .04).

zipline.pipeline.factors.RollingSpearmanOfReturns ¶

class zipline.pipeline.factors.RollingSpearmanOfReturns(*args, **kwargs)¶

Factor that calculates the Spearman rank correlation coefficient of the returns of the given asset with the returns of all other assets.

Parameters:

target (zipline.assets.Asset) – The asset to correlate with all other assets.
returns_length (int >= 2) – Length of the lookback window over which to compute returns. Daily returns require a window length of 2.
correlation_length (int >= 1) – Length of the lookback window over which to compute each correlation coefficient.
mask (zipline.pipeline.Filter, optional) – A Filter describing which assets should have their correlation with the target asset computed each day.

Notes

Computing this factor over many assets can be time consuming. It is recommended that a mask be used in order to limit the number of assets over which correlations are computed.

zipline.pipeline.factors.RSI ¶

class zipline.pipeline.factors.RSI(*args, **kwargs)¶

Factor that calculates Relative Strength Index.

Default Inputs: zipline.pipeline.data.EquityPricing.close

Default Window Length: 15

Parameters:

inputs (BoundColumn) – The expression for which to compute the indicator.
window_length (int > 0) – Length of the lookback window over which to compute the indicator.
mask (zipline.pipeline.Filter, optional) – A Filter representing assets to consider when computing results. If supplied, we ignore asset/date pairs where mask produces False.

Examples

Calculate a 15-day RSI:

>>> rsi = RSI(window_length=15)

zipline.pipeline.factors.SimpleBeta ¶

class zipline.pipeline.factors.SimpleBeta(*args, **kwargs)¶

Factor producing the slope of a regression line between each asset’s daily returns to the daily returns of a single “target” asset.

Parameters:

target (zipline.Asset) – Asset against which other assets should be regressed.
regression_length (int) – Number of days of daily returns to use for the regression.
allowed_missing_percentage (float, optional) – Percentage of returns observations (between 0 and 1) that are allowed to be missing when calculating betas. Assets with more than this percentage of returns observations missing will produce values of NaN. Default behavior is that 25% of inputs can be missing.
mask (zipline.pipeline.Filter, optional) – A Filter representing assets to consider when computing results. If supplied, we ignore asset/date pairs where mask produces False.

Examples

Calculate 1-year simple betas for each stock against SPY:

beta = SimpleBeta(target=sid('FIBBG000BDTBL9'), regression_length=252)

zipline.pipeline.factors.SimpleMovingAverage ¶

class zipline.pipeline.factors.SimpleMovingAverage(*args, **kwargs)¶

Factor that calculates average value of an arbitrary column.

Default Inputs: None

Default Window Length: None

Parameters:

inputs (BoundColumn) – The expression for which to compute the moving average.
window_length (int > 0) – Length of the lookback window over which to compute the moving average.
mask (zipline.pipeline.Filter, optional) – A Filter representing assets to consider when computing results. If supplied, we ignore asset/date pairs where mask produces False.

Examples

Calculate a 200-day simple moving average of daily close price:

>>> sma_200 = SimpleMovingAverage(inputs=EquityPricing.close, window_length=200)

zipline.pipeline.factors.TrueRange ¶

class zipline.pipeline.factors.TrueRange(*args, **kwargs)¶

Factor that calculates True Range.

A technical indicator originally developed by J. Welles Wilder, Jr. Indicates the true degree of daily price change in an underlying.

Default Inputs: zipline.pipeline.data.EquityPricing.high, zipline.pipeline.data.EquityPricing.low, zipline.pipeline.data.EquityPricing.close

Default Window Length: 2

Parameters:: mask (zipline.pipeline.Filter, optional) – A Filter representing assets to consider when computing results. If supplied, we ignore asset/date pairs where mask produces False.

Examples

Calculate true range:

>>> true_range = TrueRange()

zipline.pipeline.factors.VWAP ¶

class zipline.pipeline.factors.VWAP(*args, **kwargs)¶

Factor that calculates volume-weighted average price.

Default Inputs: [EquityPricing.close, EquityPricing.volume]

Default Window Length: None

Parameters:

window_length (int > 0) – Length of the lookback window over which to compute VWAP.
mask (zipline.pipeline.Filter, optional) – A Filter representing assets to consider when computing results. If supplied, we ignore asset/date pairs where mask produces False.

Examples

Calculate a 5-day VWAP:

>>> vwap = VWAP(window_length=5)

Built-in Filters ¶

SingleAsset
StaticAssets
StaticSids
StaticUniverse

zipline.pipeline.filters.SingleAsset ¶

class zipline.pipeline.filters.SingleAsset(*args, **kwargs)¶

A Filter that computes to True only for the given asset.

Parameters:: asset (Asset) – The asset for which this Filter should compute to True.
Returns:: filter – a Filter that computes to True only for the given asset.
Return type:: Filter

Examples

Create a filter that computes to True only for Apple:

aapl_filter = SingleAsset(sid('FIBBG000B9XRY4'))

zipline.pipeline.filters.StaticAssets ¶

class zipline.pipeline.filters.StaticAssets(*args, **kwargs)¶

A Filter that computes True for a specific set of predetermined assets.

Parameters:: assets (iterable[Asset]) – An iterable of assets for which to filter.
Returns:: filter – A Filter that computes True for a specific set of predetermined assets.
Return type:: Filter

Examples

Create a filter that computes True for Apple and SPY:

screen = StaticAssets([sid('FIBBG000B9XRY4'), sid('FIBBG000BDTBL9')])

zipline.pipeline.filters.StaticSids ¶

class zipline.pipeline.filters.StaticSids(*args, **kwargs)¶

A Filter that computes True for a specific set of predetermined sids.

Parameters:: sids (iterable[str]) – an iterable of sids for which to filter.

Examples

Limit to AAPL and AMZN:

from zipline.pipeline.filters import StaticSids
pipe = Pipeline(screen=StaticSids(["FIBBG000B9XRY4", "FIBBG000BVPV84"]))

zipline.pipeline.filters.StaticUniverse ¶

class zipline.pipeline.filters.StaticUniverse(*args, **kwargs)¶

A Filter that computes True for assets that are members of a specific universe defined in the securities master database.

Parameters:: code (str, required) – the universe code

Examples

Limit to a universe of energy stocks:

from zipline.pipeline.filters import StaticUniverse
pipe = Pipeline(screen=StaticUniverse("energy-stk"))

Sharadar Fundamental Factors ¶

Calculated factors based on Sharadar fundamental data. See also the standard Sharadar fundamental fields.

PiotroskiFScore
AltmanZScore
InterestCoverageRatio

zipline.pipeline.sharadar.PiotroskiFScore ¶

zipline.pipeline.factors.sharadar.PiotroskiFScore(dimension='ART', period_offset=0, previous_period_offset=None, mask=None)¶

Return a Factor that computes the Piotroski F-Score using Sharadar fundamentals.

The Piotroski F-Score evaluates a firm’s financial health on a scale of 0-9, with 9 being the best. The score is calculated being awarding one point for each of the following nine criteria that are met:

Profitability Criteria:

Positive return on assets (ROA) in the current year
Positive operating cash flow in the current year
Higher ROA in the current period than in the previous year
Cash flow from operations is higher than ROA (quality of earnings)

Funding Criteria:

Lower long term debt in the current period than in the previous year (decreased leverage)
Higher current ratio in the current period than in the previous year (more liquidity)
No new shares issued in the last year (lack of dilution)

Operating Efficiency Criteria:

Higher gross margin in the current period than in the previous year
Higher asset turnover ratio in the current period than in the previous year

Parameters:

dimension (str, optional) – the type of reports to use. Choices are ARQ, ARY, ART, MRQ, MRY, MRT, where AR=As Reported, MR=Most Recent Reported, Q=Quarterly, Y=Annual, and T=Trailing Twelve Month. Default is ART.
period_offset (int, optional) – which fiscal period to return F-Scores for. If period_offset is 0, returns the most recent point-in-time F-Scores. If period_offset is -1, returns F-Scores for the prior fiscal period; if -2, two fiscal periods ago, etc. For quarterly and trailing-twelve-month dimensions, previous period means previous quarter, while for annual dimensions, previous period means previous year. Value should be a negative integer or 0. Default is 0.
previous_period_offset (int, optional) – for Piotroski F-Score components that compare current period financial metrics to previous period metrics, how many periods to offset the previous period from the current period. If omitted, this defaults to -1 for Annual dimensions and -4 for Quarterly and TTM dimensions, meaning that the current period would be compared to the period 1 year earlier. Value should be a negative integer or 0.
mask (zipline.pipeline.Filter, optional) – optional Filter to limit the F-Score computation to a subset of stocks.

Returns:

a Factor that computes the Piotroski F-Score when executed

Return type:

Examples

Compute the Piotroski F-Score for the most recent fiscal period, using trailing-twelve-month financials:

>>> from zipline.pipeline.sharadar import PiotroskiFScore
>>> f_score = PiotroskiFScore()

zipline.pipeline.sharadar.AltmanZScore ¶

zipline.pipeline.factors.sharadar.AltmanZScore(dimension='ART', period_offset=0, mask=None)¶

Return a Factor that computes the Altman Z-Score using Sharadar fundamentals. The Altman Z-Score measures the likelihood of future bankruptcy.

The Altman Z-score formula is:

Altman Z-Score = 1.2A + 1.4B + 3.3C + 0.6D + 1.0E

Where:

A = working capital / total assets
B = retained earnings / total assets
C = earnings before interest and tax / total assets
D = market value of equity / total liabilities
E = sales / total assets

Altman Z-Scores are often interpreted as follows:

Z-Score >= 3: “Safe” Zone
0 < Z-Score < 3: “Grey” Zone
Z-Score < 0: “Distress” Zone

The Altman Z-Score is designed for manufacturing firms and is not computed for the financial and real estate sectors.

Parameters:

dimension (str, optional) – the type of reports to use. Choices are ARQ, ARY, ART, MRQ, MRY, MRT, where AR=As Reported, MR=Most Recent Reported, Q=Quarterly, Y=Annual, and T=Trailing Twelve Month. Default is ART.
period_offset (int, optional) – which fiscal period to return Z-Scores for. If period_offset is 0, returns the most recent point-in-time Z-Scores. If period_offset is -1, returns Z-Scores for the prior fiscal period; if -2, two fiscal periods ago, etc. For quarterly and trailing-twelve-month dimensions, previous period means previous quarter, while for annual dimensions, previous period means previous year. Value should be a negative integer or 0. Default is 0.
mask (zipline.pipeline.Filter, optional) – optional Filter to limit the Z-Score computation to a subset of stocks.

Returns:

a Factor that computes the Altman Z-Score when executed

Return type:

Examples

Compute the Altman Z-Score using trailing-twelve-month financials:

>>> from zipline.pipeline.sharadar import AltmanZScore
>>> altman_zscore = AltmanZScore()

zipline.pipeline.sharadar.InterestCoverageRatio ¶

zipline.pipeline.factors.sharadar.InterestCoverageRatio(dimension='ART', period_offset=0, mask=None)¶

Return a Factor that computes the Interest Coverage Ratio (ICR) using Sharadar fundamentals. The Interest Coverage Ratio measures a company’s ability to service its debt.

Interest coverage ratio is calculated as EBIT (earnings before interest, and taxes) divided by interest expense. The ratio shows how many times a company could cover its interest expense using current earnings. An interest coverage ratio of 1 or lower indicates that a company is not generating sufficient revenues to satisfy interest expenses. Generally, investors prefer companies with interest coverage ratios of at least 2.

Interest coverage ratio is only computed for companies with positive earnings and interest expense. For companies with negative earnings or no interest, this Factor returns nulls.

Parameters:

dimension (str, optional) – the type of reports to use. Choices are ARQ, ARY, ART, MRQ, MRY, MRT, where AR=As Reported, MR=Most Recent Reported, Q=Quarterly, Y=Annual, and T=Trailing Twelve Month. Default is ART.
period_offset (int, optional) – which fiscal period to return ICR for. If period_offset is 0, returns the most recent point-in-time ICR. If period_offset is -1, returns ICR for the prior fiscal period; if -2, two fiscal periods ago, etc. For quarterly and trailing-twelve-month dimensions, previous period means previous quarter, while for annual dimensions, previous period means previous year. Value should be a negative integer or 0. Default is 0.
mask (zipline.pipeline.Filter, optional) – optional Filter to limit the ICR computation to a subset of stocks.

Returns:

a Factor that computes the ICR when executed

Return type:

Examples

Compute the interest coverage ratio:

>>> from zipline.pipeline.sharadar import InterestCoverageRatio
>>> icr = InterestCoverageRatio()

Periodic Factors and Filters ¶

Pipeline factors and filters for working with periodic data, defined as data that doesn’t change daily but changes at less frequent intervals, such as quarterly or annual fundamentals. Specifically, these factors and filters are compatible with any Pipeline DataSet that has a period_offset coordinate.

PeriodicAverage
PeriodicHigh
PeriodicLow
PeriodicChange
PeriodicPercentChange
PeriodicCAGR
AllPeriodsIncreasing
AllPeriodsDecreasing
CountPeriodsAbove
CountPeriodsBelow
AllPeriodsAbove
AllPeriodsBelow
AllPeriodsPresent

zipline.pipeline.periodic.PeriodicAverage ¶

zipline.pipeline.periodic.PeriodicAverage(column_or_callable, window_length, step=1, mask=None, **kwargs)¶

Return a Factor that computes the average of a column or factor over a specified number of periods.

Parameters:

column_or_callable (BoundColumn or callable, required) – the dataset column to compute the average for. The column must belong to a Dataset that includes a period_offset coordinate. Alternatively, can be a function or other callable that accepts a period_offset and mask argument and returns a Factor.
window_length (int, required) – the number of periods to use to calculate the average. Must be >=2.
step (int, optional) – optional step for incrementing through window_length. This can be used to only sample certain periods in the computation. Default is 1, meaning use every period in window_length.
mask (zipline.pipeline.Filter, optional) – optional Filter to limit the computation to a subset of stocks.
**kwargs – optional kwargs to pass to column_or_callable if it is a callable

Returns:

a Factor that computes the average

Return type:

Notes

Usage Guide:

Periodic factors and filters: https://qrok.it/dl/z/pipeline-periodic

Examples

Create a Factor that computes the average dividend per share over the last 4 years, using annual financials:

from zipline.pipeline.sharadar import Fundamentals
from zipline.pipeline.periodic import PeriodicAverage

dps = Fundamentals.slice('ARY').DPS
avg_dps = PeriodicAverage(dps, window_length=4)

Instead of passing a BoundColumn, we can also pass a function that returns a Factor. This is useful if we want to compute the average of a Factor that is not a column in a Dataset. For example, the Sharadar data does not include a column for operating margin, but it can easily be calculated by dividing operating income (OPINC) by revenue (REVENUE). First, create a function to calculate operating margin. The function should accept a period_offset and mask argument:

from zipline.pipeline.factors import Latest

def operating_margin(period_offset=0, mask=None):
    fundamentals = Fundamentals.slice("ARY", period_offset)
    return Latest(fundamentals.OPINC, mask=mask) / Latest(fundamentals.REVENUE, mask=mask)

Then, pass the function to PeriodicAverage:

avg_op_margin = PeriodicAverage(operating_margin, window_length=4)

zipline.pipeline.periodic.PeriodicHigh ¶

zipline.pipeline.periodic.PeriodicHigh(column_or_callable, window_length, step=1, mask=None, **kwargs)¶

Return a Factor that computes the high of a column or factor over a specified number of periods.

Parameters:

column_or_callable (BoundColumn or callable, required) – the dataset column to compute the high for. The column must belong to a Dataset that includes a period_offset coordinate. Alternatively, can be a function or other callable that accepts a period_offset and mask argument and returns a Factor.
window_length (int, required) – the number of periods to use to calculate the high. Must be >=2.
step (int, optional) – optional step for incrementing through window_length. This can be used to only sample certain periods in the computation. Default is 1, meaning use every period in window_length.
mask (zipline.pipeline.Filter, optional) – optional Filter to limit the computation to a subset of stocks.
**kwargs – optional kwargs to pass to column_or_callable if it is a callable

Returns:

a Factor that computes the high

Return type:

Notes

Usage Guide:

Periodic factors and filters: https://qrok.it/dl/z/pipeline-periodic

Examples

Create a Factor that computes the highest EPS over the last 4 quarters, using trailing-twelve-month financials:

from zipline.pipeline.sharadar import Fundamentals
from zipline.pipeline.periodic import PeriodicHigh

eps = Fundamentals.slice('ART').EPS
highest_eps = PeriodicHigh(eps, window_length=4)

Instead of passing a BoundColumn, we can also pass a function that returns a Factor. This is useful if we want to compute the high of a Factor that is not a column in a Dataset. For example, the Sharadar data does not include a column for operating margin, but it can easily be calculated by dividing operating income (OPINC) by revenue (REVENUE). First, create a function to calculate operating margin. The function should accept a period_offset and mask argument:

from zipline.pipeline.factors import Latest

def operating_margin(period_offset=0, mask=None):
    fundamentals = Fundamentals.slice("ART", period_offset)
    return Latest(fundamentals.OPINC, mask=mask) / Latest(fundamentals.REVENUE, mask=mask)

Then, pass the function to PeriodicHigh:

highest_op_margin = PeriodicHigh(operating_margin, window_length=4)

zipline.pipeline.periodic.PeriodicLow ¶

zipline.pipeline.periodic.PeriodicLow(column_or_callable, window_length, step=1, mask=None, **kwargs)¶

Return a Factor that computes the low of a column or factor over a specified number of periods.

Parameters:

column_or_callable (BoundColumn or callable, required) – the dataset column to compute the low for. The column must belong to a Dataset that includes a period_offset coordinate. Alternatively, can be a function or other callable that accepts a period_offset and mask argument and returns a Factor.
window_length (int, required) – the number of periods to use to calculate the low. Must be >=2.
step (int, optional) – optional step for incrementing through window_length. This can be used to only sample certain periods in the computation. Default is 1, meaning use every period in window_length.
mask (zipline.pipeline.Filter, optional) – optional Filter to limit the computation to a subset of stocks.
**kwargs – optional kwargs to pass to column_or_callable if it is a callable

Returns:

a Factor that computes the low

Return type:

Notes

Usage Guide:

Periodic factors and filters: https://qrok.it/dl/z/pipeline-periodic

Examples

Create a Factor that computes the lowest EPS over the last 4 quarters, using trailing-twelve-month financials:

from zipline.pipeline.sharadar import Fundamentals
from zipline.pipeline.periodic import PeriodicLow

eps = Fundamentals.slice('ART').EPS
lowest_eps = PeriodicLow(eps, window_length=4)

Instead of passing a BoundColumn, we can also pass a function that returns a Factor. This is useful if we want to compute the low of a Factor that is not a column in a Dataset. For example, the Sharadar data does not include a column for operating margin, but it can easily be calculated by dividing operating income (OPINC) by revenue (REVENUE). First, create a function to calculate operating margin. The function should accept a period_offset and mask argument:

from zipline.pipeline.factors import Latest

def operating_margin(period_offset=0, mask=None):
    fundamentals = Fundamentals.slice("ART", period_offset)
    return Latest(fundamentals.OPINC, mask=mask) / Latest(fundamentals.REVENUE, mask=mask)

Then, pass the function to PeriodicLow:

lowest_op_margin = PeriodicLow(operating_margin, window_length=4)

zipline.pipeline.periodic.PeriodicChange ¶

zipline.pipeline.periodic.PeriodicChange(column_or_callable, window_length, mask=None, **kwargs)¶

Return a Factor that computes the change of a column or factor over a specified number of periods.

Parameters:

column_or_callable (BoundColumn or callable, required) – the dataset column to compute the change for. The column must belong to a Dataset that includes a period_offset coordinate. Alternatively, can be a function or other callable that accepts a period_offset and mask argument and returns a Factor.
window_length (int, required) – the number of periods to use to calculate the change. Must be >=2.
mask (zipline.pipeline.Filter, optional) – optional Filter to limit the computation to a subset of stocks.
**kwargs – optional kwargs to pass to column_or_callable if it is a callable

Returns:

a Factor that computes the change

Return type:

Notes

Usage Guide:

Periodic factors and filters: https://qrok.it/dl/z/pipeline-periodic

Examples

Create a Factor that computes the change in dividend yield over the last 16 quarters, using trailing-twelve-month financials:

from zipline.pipeline.sharadar import Fundamentals
from zipline.pipeline.periodic import PeriodicChange

divyield = Fundamentals.slice('ART').DIVYIELD
divyield_change = PeriodicChange(divyield, window_length=16)

Instead of passing a BoundColumn, we can also pass a function that returns a Factor. This is useful if we want to compute the change of a Factor that is not a column in a Dataset. For example, the Sharadar data does not include a column for operating margin, but it can easily be calculated by dividing operating income (OPINC) by revenue (REVENUE). First, create a function to calculate operating margin. The function should accept a period_offset and mask argument:

from zipline.pipeline.factors import Latest

def operating_margin(period_offset=0, mask=None):
    fundamentals = Fundamentals.slice("ART", period_offset)
    return Latest(fundamentals.OPINC, mask=mask) / Latest(fundamentals.REVENUE, mask=mask)

Then, pass the function to PeriodicChange:

op_margin_change = PeriodicChange(operating_margin, window_length=16)

zipline.pipeline.periodic.PeriodicPercentChange ¶

zipline.pipeline.periodic.PeriodicPercentChange(column_or_callable, window_length, mask=None, **kwargs)¶

Return a Factor that computes the percent change of a column or factor over a specified number of periods.

Parameters:

column_or_callable (BoundColumn or callable, required) – the dataset column to compute the percent change for. The column must belong to a Dataset that includes a period_offset coordinate. Alternatively, can be a function or other callable that accepts a period_offset and mask argument and returns a Factor.
window_length (int, required) – the number of periods to use to calculate the percent change. Must be >=2.
mask (zipline.pipeline.Filter, optional) – optional Filter to limit the computation to a subset of stocks.
**kwargs – optional kwargs to pass to column_or_callable if it is a callable

Returns:

a Factor that computes the percent change

Return type:

Notes

Usage Guide:

Periodic factors and filters: https://qrok.it/dl/z/pipeline-periodic

Examples

Create a Factor that computes the percent change in dividend yield over the last 16 quarters, using trailing-twelve-month financials:

from zipline.pipeline.sharadar import Fundamentals
from zipline.pipeline.periodic import PeriodicPercentChange

divyield = Fundamentals.slice('ART').DIVYIELD
divyield_pct_change = PeriodicPercentChange(divyield, window_length=16)

Instead of passing a BoundColumn, we can also pass a function that returns a Factor. This is useful if we want to compute the percent change of a Factor that is not a column in a Dataset. For example, the Sharadar data does not include a column for operating margin, but it can easily be calculated by dividing operating income (OPINC) by revenue (REVENUE). First, create a function to calculate operating margin. The function should accept a period_offset and mask argument:

from zipline.pipeline.factors import Latest

def operating_margin(period_offset=0, mask=None):
    fundamentals = Fundamentals.slice("ART", period_offset)
    return Latest(fundamentals.OPINC, mask=mask) / Latest(fundamentals.REVENUE, mask=mask)

Then, pass the function to PeriodicPercentChange:

op_margin_pct_change = PeriodicPercentChange(operating_margin, window_length=16)

zipline.pipeline.periodic.PeriodicCAGR ¶

zipline.pipeline.periodic.PeriodicCAGR(column_or_callable, window_length, periods_per_year=None, mask=None, **kwargs)¶

Return a Factor that computes the compound annual growth rate (CAGR) of a column or factor over a specified number of periods.

Parameters:

column_or_callable (BoundColumn or callable, required) – the dataset column to compute the CAGR for. The column must belong to a Dataset that includes a period_offset coordinate. Alternatively, can be a function or other callable that accepts a period_offset and mask argument and returns a Factor.
window_length (int, required) – the number of periods to use to calculate the CAGR. Must be >=2.
periods_per_year (int, optional) – the number of periods per year. If omitted and column_or_callable is a BoundColumn with a dimension coordinate, the periods per year will be inferred from that; otherwise it must be specified.
mask (zipline.pipeline.Filter, optional) – optional Filter to limit the computation to a subset of stocks.
**kwargs – optional kwargs to pass to column_or_callable if it is a callable

Returns:

a Factor that computes the CAGR

Return type:

Notes

Usage Guide:

Periodic factors and filters: https://qrok.it/dl/z/pipeline-periodic

Examples

Create a Factor that computes the compound annual growth rate (CAGR) in dividend per share over the last 16 quarters, using trailing-twelve-month financials:

from zipline.pipeline.sharadar import Fundamentals
from zipline.pipeline.periodic import PeriodicCAGR

dps = Fundamentals.slice('ART').DPS
dps_growth = PeriodicCAGR(dps, window_length=16)

Instead of passing a BoundColumn, we can also pass a function that returns a Factor. This is useful if we want to compute the CAGR of a Factor that is not a column in a Dataset. For example, the Sharadar data does not include a column for operating margin, but it can easily be calculated by dividing operating income (OPINC) by revenue (REVENUE). First, create a function to calculate operating margin. The function should accept a period_offset and mask argument:

from zipline.pipeline.factors import Latest

def operating_margin(period_offset=0, mask=None):
    fundamentals = Fundamentals.slice("ART", period_offset)
    return Latest(fundamentals.OPINC, mask=mask) / Latest(fundamentals.REVENUE, mask=mask)

Then, pass the function to PeriodicCAGR:

op_margin_growth = PeriodicCAGR(operating_margin, window_length=16)

zipline.pipeline.periodic.AllPeriodsIncreasing ¶

zipline.pipeline.periodic.AllPeriodsIncreasing(column_or_callable, window_length, step=1, allow_equal=False, mask=None, **kwargs)¶

Return a Filter that computes whether a column or factor increases from the previous period over each of a specified number of periods.

Parameters:

column_or_callable (BoundColumn or callable, required) – the dataset column to check for increasing values. The column must belong to a Dataset that includes a period_offset coordinate. Alternatively, can be a function or other callable that accepts a period_offset and mask argument and returns a Factor.
window_length (int, required) – the number of periods over which to check for increasing values. Must be >=2.
step (int, optional) – optional step for incrementing through window_length. This can be used to only sample certain periods in the computation. Default is 1, meaning use every period in window_length.
allow_equal (bool) – if True, allow values to be the same or higher than the previous period. If False, only allow values to be higher than the previous period. Default False.
mask (zipline.pipeline.Filter, optional) – optional Filter to limit the computation to a subset of stocks.
**kwargs – optional kwargs to pass to column_or_callable if it is a callable

Returns:

a Filter indicating whether the input factor increases over time

Return type:

Notes

Usage Guide:

Periodic factors and filters: https://qrok.it/dl/z/pipeline-periodic

Examples

Create a Filter that returns True if revenue increased versus the prior year for each of the last 4 years, using annual financials:

from zipline.pipeline.sharadar import Fundamentals
from zipline.pipeline.periodic import AllPeriodsIncreasing

revenue = Fundamentals.slice('ARY').REVENUE
has_consistent_sales_growth = AllPeriodsIncreasing(revenue, window_length=4)

Instead of passing a BoundColumn, we can also pass a function that returns a Factor. This is useful if we want to apply the filter to a Factor that is not a column in a Dataset. For example, the Sharadar data does not include a column for operating margin, but it can easily be calculated by dividing operating income (OPINC) by revenue (REVENUE). First, create a function to calculate operating margin. The function should accept a period_offset and mask argument:

from zipline.pipeline.factors import Latest

def operating_margin(period_offset=0, mask=None):
    fundamentals = Fundamentals.slice("ARY", period_offset)
    return Latest(fundamentals.OPINC, mask=mask) / Latest(fundamentals.REVENUE, mask=mask)

Then, pass the function to AllPeriodsIncreasing:

has_consistent_op_margin_growth = AllPeriodsIncreasing(operating_margin, window_length=4)

zipline.pipeline.periodic.AllPeriodsDecreasing ¶

zipline.pipeline.periodic.AllPeriodsDecreasing(column_or_callable, window_length, step=1, allow_equal=False, mask=None, **kwargs)¶

Return a Filter that computes whether a column or factor decreases over each of a specified number of periods.

Parameters:

column_or_callable (BoundColumn or callable, required) – the dataset column to check for decreasing values. The column must belong to a Dataset that includes a period_offset coordinate. Alternatively, can be a function or other callable that accepts a period_offset and mask argument and returns a Factor.
window_length (int, required) – the number of periods over which to check for decreasing values. Must be >=2.
step (int, optional) – optional step for incrementing through window_length. This can be used to only sample certain periods in the computation. Default is 1, meaning use every period in window_length.
allow_equal (bool) – if True, allow values to be the same or lower than the previous period. If False, only allow values to be lower than the previous period. Default False.
mask (zipline.pipeline.Filter, optional) – optional Filter to limit the computation to a subset of stocks.
**kwargs – optional kwargs to pass to column_or_callable if it is a callable

Returns:

a Filter indicating whether the input factor decreases over time

Return type:

Notes

Usage Guide:

Periodic factors and filters: https://qrok.it/dl/z/pipeline-periodic

Examples

Create a Filter that returns True if debt decreased versus the prior year for each of the last 4 years, using annual financials:

from zipline.pipeline.sharadar import Fundamentals
from zipline.pipeline.periodic import AllPeriodsDecreasing

debt = Fundamentals.slice('ARY').DEBT
has_declining_debt = AllPeriodsDecreasing(debt, window_length=4)

from zipline.pipeline.factors import Latest

def operating_margin(period_offset=0, mask=None):
    fundamentals = Fundamentals.slice("ARY", period_offset)
    return Latest(fundamentals.OPINC, mask=mask) / Latest(fundamentals.REVENUE, mask=mask)

Then, pass the function to AllPeriodsDecreasing:

has_declining_op_margin = AllPeriodsDecreasing(operating_margin, window_length=4)

zipline.pipeline.periodic.CountPeriodsAbove ¶

zipline.pipeline.periodic.CountPeriodsAbove(column_or_callable, value, window_length, step=1, allow_equal=False, mask=None, **kwargs)¶

Return a Factor that computes how many times a column or factor is above a certain value over a specified number of periods.

Parameters:

column_or_callable (BoundColumn or callable, required) – the dataset column to check. The column must belong to a Dataset that includes a period_offset coordinate. Alternatively, can be a function or other callable that accepts a period_offset and mask argument and returns a Factor.
value (int or float, required) – the value that the factor must be above
window_length (int, required) – the number of periods over which the factor must be above the value.
step (int, optional) – optional step for incrementing through window_length. This can be used to only sample certain periods in the computation. Default is 1, meaning use every period in window_length.
allow_equal (bool) – if True, count periods that are above or equal to the value. If False, only count periods that are above the value. Default False.
mask (zipline.pipeline.Filter, optional) – optional Filter to limit the computation to a subset of stocks.
**kwargs – optional kwargs to pass to column_or_callable if it is a callable

Returns:

a Factor counting how many times the input factor is above the value over the window_length

Return type:

Notes

Usage Guide:

Periodic factors and filters: https://qrok.it/dl/z/pipeline-periodic

Examples

Create a Factor that computes the number of quarters with positive EBIT out of the last 8 quarters, using trailing-twelve-month financials:

from zipline.pipeline.sharadar import Fundamentals
from zipline.pipeline.periodic import CountPeriodsAbove

ebit = Fundamentals.slice('ART').EBIT
positive_ebit_count = CountPeriodsAbove(ebit, 0, window_length=8)

Instead of passing a BoundColumn, we can also pass a function that returns a Factor. This is useful if we want to apply the count to a Factor that is not a column in a Dataset. For example, the Sharadar data does not include a column for operating margin, but it can easily be calculated by dividing operating income (OPINC) by revenue (REVENUE). First, create a function to calculate operating margin. The function should accept a period_offset and mask argument:

from zipline.pipeline.factors import Latest

def operating_margin(period_offset=0, mask=None):
    fundamentals = Fundamentals.slice("ART", period_offset)
    return Latest(fundamentals.OPINC, mask=mask) / Latest(fundamentals.REVENUE, mask=mask)

Then, pass the function to CountPeriodsAbove. Here, we count periods with operating margin greater than 15%:

good_op_margin_count = CountPeriodsAbove(operating_margin, 0.15, window_length=8)

zipline.pipeline.periodic.CountPeriodsBelow ¶

zipline.pipeline.periodic.CountPeriodsBelow(column_or_callable, value, window_length, step=1, allow_equal=False, mask=None, **kwargs)¶

Return a Factor that computes how many times a column or factor is below a certain value over a specified number of periods.

Parameters:

column_or_callable (BoundColumn or callable, required) – the dataset column to check. The column must belong to a Dataset that includes a period_offset coordinate. Alternatively, can be a function or other callable that accepts a period_offset and mask argument and returns a Factor.
value (int or float, required) – the value that the factor must be below
window_length (int, required) – the number of periods over which the factor must be below the value.
step (int, optional) – optional step for incrementing through window_length. This can be used to only sample certain periods in the computation. Default is 1, meaning use every period in window_length.
allow_equal (bool) – if True, count periods that are below or equal to the value. If False, only count periods that are below the value. Default False.
mask (zipline.pipeline.Filter, optional) – optional Filter to limit the computation to a subset of stocks.
**kwargs – optional kwargs to pass to column_or_callable if it is a callable

Returns:

a Factor counting how many times the input factor is below the value over the window_length

Return type:

Notes

Usage Guide:

Periodic factors and filters: https://qrok.it/dl/z/pipeline-periodic

Examples

Create a Factor that computes the number of quarters with negative EBIT out of the last 8 quarters, using trailing-twelve-month financials:

from zipline.pipeline.sharadar import Fundamentals
from zipline.pipeline.periodic import CountPeriodsBelow

ebit = Fundamentals.slice('ART').EBIT
negative_ebit_count = CountPeriodsBelow(ebit, 0, window_length=8)

from zipline.pipeline.factors import Latest

def operating_margin(period_offset=0, mask=None):
    fundamentals = Fundamentals.slice("ART", period_offset)
    return Latest(fundamentals.OPINC, mask=mask) / Latest(fundamentals.REVENUE, mask=mask)

Then, pass the function to CountPeriodsBelow. Here, we count periods with operating margin lower than 5%:

low_op_margin_count = CountPeriodsBelow(operating_margin, 0.05, window_length=8)

zipline.pipeline.periodic.AllPeriodsAbove ¶

zipline.pipeline.periodic.AllPeriodsAbove(column_or_callable, value, window_length, step=1, allow_equal=False, mask=None, **kwargs)¶

Return a Filter that computes whether a column or factor is above a certain value over each of a specified number of periods.

Parameters:

column_or_callable (BoundColumn or callable, required) – the dataset column to check. The column must belong to a Dataset that includes a period_offset coordinate. Alternatively, can be a function or other callable that accepts a period_offset and mask argument and returns a Factor.
value (int or float, required) – the value that the factor must be above
window_length (int, required) – the number of periods over which the factor must be above the value.
step (int, optional) – optional step for incrementing through window_length. This can be used to only sample certain periods in the computation. Default is 1, meaning use every period in window_length.
allow_equal (bool) – if True, allow factors to be above or equal to the value. If False, only allow factors to be above the value. Default False.
mask (zipline.pipeline.Filter, optional) – optional Filter to limit the computation to a subset of stocks.
**kwargs – optional kwargs to pass to column_or_callable if it is a callable

Returns:

a Filter indicating whether the input factor is above the value over the full window_length

Return type:

Notes

Usage Guide:

Periodic factors and filters: https://qrok.it/dl/z/pipeline-periodic

Examples

Create a Filter that returns True if dividend per share was positive for each of the last 5 years, using annual financials:

from zipline.pipeline.sharadar import Fundamentals
from zipline.pipeline.periodic import AllPeriodsAbove

dps = Fundamentals.slice('ARY').DPS
consistently_has_dividends = AllPeriodsAbove(dps, 0, window_length=5)

from zipline.pipeline.factors import Latest

def operating_margin(period_offset=0, mask=None):
    fundamentals = Fundamentals.slice("ARY", period_offset)
    return Latest(fundamentals.OPINC, mask=mask) / Latest(fundamentals.REVENUE, mask=mask)

Then, pass the function to AllPeriodsAbove. Here, we look for companies with operating margin consistently above 15%:

consistent_high_op_margin = AllPeriodsAbove(operating_margin, 0.15, window_length=5)

zipline.pipeline.periodic.AllPeriodsBelow ¶

zipline.pipeline.periodic.AllPeriodsBelow(column_or_callable, value, window_length, step=1, allow_equal=False, mask=None, **kwargs)¶

Return a Filter that computes whether a column or factor is below a certain value over each of a specified number of periods.

Parameters:

column_or_callable (BoundColumn or callable, required) – the dataset column to check. The column must belong to a Dataset that includes a period_offset coordinate. Alternatively, can be a function or other callable that accepts a period_offset and mask argument and returns a Factor.
value (int or float, required) – the value that the factor must be below
window_length (int, required) – the number of periods over which the factor must be below the value.
step (int, optional) – optional step for incrementing through window_length. This can be used to only sample certain periods in the computation. Default is 1, meaning use every period in window_length.
allow_equal (bool) – if True, count periods that are below or equal to the value. If False, only count periods that are below the value. Default False.
mask (zipline.pipeline.Filter, optional) – optional Filter to limit the computation to a subset of stocks.
**kwargs – optional kwargs to pass to column_or_callable if it is a callable

Returns:

a Filter indicating whether the input factor is below the value over the full window_length

Return type:

Notes

Usage Guide:

Periodic factors and filters: https://qrok.it/dl/z/pipeline-periodic

Examples

Create a Filter that returns True if return on assets was below 5% for each of the last 5 years, using annual financials:

from zipline.pipeline.sharadar import Fundamentals
from zipline.pipeline.periodic import AllPeriodsBelow

roa = Fundamentals.slice('ARY').ROA
roa_below_5 = AllPeriodsBelow(roa, 0.05, window_length=5)

from zipline.pipeline.factors import Latest

def operating_margin(period_offset=0, mask=None):
    fundamentals = Fundamentals.slice("ARY", period_offset)
    return Latest(fundamentals.OPINC, mask=mask) / Latest(fundamentals.REVENUE, mask=mask)

Then, pass the function to AllPeriodsBelow. Here, we look for companies with operating margin consistently below 5%:

consistent_low_op_margin = AllPeriodsBelow(operating_margin, 0.05, window_length=5)

zipline.pipeline.periodic.AllPeriodsPresent ¶

zipline.pipeline.periodic.AllPeriodsPresent(column_or_callable, window_length, step=1, mask=None, **kwargs)¶

Return a Filter that computes whether a column or factor is present in the data over each of a specified number of periods.

Parameters:

column_or_callable (BoundColumn or callable, required) – the dataset column to check. The column must belong to a Dataset that includes a period_offset coordinate. Alternatively, can be a function or other callable that accepts a period_offset and mask argument and returns a Factor.
window_length (int, required) – the number of periods over which the factor must be present.
step (int, optional) – optional step for incrementing through window_length. This can be used to only sample certain periods in the computation. Default is 1, meaning use every period in window_length.
mask (zipline.pipeline.Filter, optional) – optional Filter to limit the computation to a subset of stocks.
**kwargs – optional kwargs to pass to column_or_callable if it is a callable

Returns:

a Filter indicating whether the input factor is present over the full window_length

Return type: