Changed zipline -> catalyst import paths

* Updated cython build scripts
 * Updated setup.py to to install catalyst package
 * Updated momentum example to use catalyst package
 * catalyst executable now supports loading pipelines from multiple bundles

catalyst/examples/__init__.py

@@ -0,0 +1,82 @@
+from importlib import import_module
+import os
+
+from toolz import merge
+
+from catalyst import run_algorithm
+
+
+# These are used by test_examples.py to discover the examples to run.
+from catalyst.utils.calendars import register_calendar, get_calendar
+
+EXAMPLE_MODULES = {}
+for f in os.listdir(os.path.dirname(__file__)):
+    if not f.endswith('.py') or f == '__init__.py':
+        continue
+    modname = f[:-len('.py')]
+    mod = import_module('.' + modname, package=__name__)
+    EXAMPLE_MODULES[modname] = mod
+    globals()[modname] = mod
+
+    # Remove noise from loop variables.
+    del f, modname, mod
+
+
+# Columns that we expect to be able to reliably deterministic
+# Doesn't include fields that have UUIDS.
+_cols_to_check = [
+    'algo_volatility',
+    'algorithm_period_return',
+    'alpha',
+    'benchmark_period_return',
+    'benchmark_volatility',
+    'beta',
+    'capital_used',
+    'ending_cash',
+    'ending_exposure',
+    'ending_value',
+    'excess_return',
+    'gross_leverage',
+    'long_exposure',
+    'long_value',
+    'longs_count',
+    'max_drawdown',
+    'max_leverage',
+    'net_leverage',
+    'period_close',
+    'period_label',
+    'period_open',
+    'pnl',
+    'portfolio_value',
+    'positions',
+    'returns',
+    'short_exposure',
+    'short_value',
+    'shorts_count',
+    'sortino',
+    'starting_cash',
+    'starting_exposure',
+    'starting_value',
+    'trading_days',
+    'treasury_period_return',
+]
+
+
+def run_example(example_name, environ):
+    """
+    Run an example module from catalyst.examples.
+    """
+    mod = EXAMPLE_MODULES[example_name]
+
+    register_calendar("YAHOO", get_calendar("NYSE"), force=True)
+
+    return run_algorithm(
+        initialize=getattr(mod, 'initialize', None),
+        handle_data=getattr(mod, 'handle_data', None),
+        before_trading_start=getattr(mod, 'before_trading_start', None),
+        analyze=getattr(mod, 'analyze', None),
+        bundle='test',
+        environ=environ,
+        # Provide a default capital base, but allow the test to override.
+        **merge({'capital_base': 1e7}, mod._test_args())
+    )

catalyst/examples/buy_and_hold.py

@@ -0,0 +1,41 @@
+#!/usr/bin/env python
+#
+# Copyright 2015 Quantopian, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from catalyst.api import order, symbol
+
+stocks = ['AAPL', 'MSFT']
+
+
+def initialize(context):
+    context.has_ordered = False
+    context.stocks = stocks
+
+
+def handle_data(context, data):
+    if not context.has_ordered:
+        for stock in context.stocks:
+            order(symbol(stock), 100)
+        context.has_ordered = True
+
+
+def _test_args():
+    """Extra arguments to use when catalyst's automated tests run this example.
+    """
+    import pandas as pd
+
+    return {
+        'start': pd.Timestamp('2008', tz='utc'),
+        'end': pd.Timestamp('2013', tz='utc'),
+    }

catalyst/examples/buyapple.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python
+#
+# Copyright 2014 Quantopian, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from catalyst.api import order, record, symbol
+
+
+def initialize(context):
+    context.asset = symbol('AAPL')
+
+
+def handle_data(context, data):
+    order(context.asset, 10)
+    record(AAPL=data.current(context.asset, 'price'))
+
+
+# Note: this function can be removed if running
+# this algorithm on quantopian.com
+def analyze(context=None, results=None):
+    import matplotlib.pyplot as plt
+    # Plot the portfolio and asset data.
+    ax1 = plt.subplot(211)
+    results.portfolio_value.plot(ax=ax1)
+    ax1.set_ylabel('Portfolio value (USD)')
+    ax2 = plt.subplot(212, sharex=ax1)
+    results.AAPL.plot(ax=ax2)
+    ax2.set_ylabel('AAPL price (USD)')
+
+    # Show the plot.
+    plt.gcf().set_size_inches(18, 8)
+    plt.show()
+
+
+def _test_args():
+    """Extra arguments to use when catalyst's automated tests run this example.
+    """
+    import pandas as pd
+
+    return {
+        'start': pd.Timestamp('2014-01-01', tz='utc'),
+        'end': pd.Timestamp('2014-11-01', tz='utc'),
+    }

catalyst/examples/dual_ema_talib.py

@@ -0,0 +1,109 @@
+#!/usr/bin/env python
+#
+# Copyright 2014 Quantopian, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+"""Dual Moving Average Crossover algorithm.
+
+This algorithm buys apple once its short moving average crosses
+its long moving average (indicating upwards momentum) and sells
+its shares once the averages cross again (indicating downwards
+momentum).
+
+"""
+
+from catalyst.api import order, record, symbol
+# Import exponential moving average from talib wrapper
+from talib import EMA
+
+
+def initialize(context):
+    context.asset = symbol('AAPL')
+
+    # To keep track of whether we invested in the stock or not
+    context.invested = False
+
+
+def handle_data(context, data):
+    trailing_window = data.history(context.asset, 'price', 40, '1d')
+    if trailing_window.isnull().values.any():
+        return
+    short_ema = EMA(trailing_window.values, timeperiod=20)
+    long_ema = EMA(trailing_window.values, timeperiod=40)
+
+    buy = False
+    sell = False
+
+    if (short_ema[-1] > long_ema[-1]) and not context.invested:
+        order(context.asset, 100)
+        context.invested = True
+        buy = True
+    elif (short_ema[-1] < long_ema[-1]) and context.invested:
+        order(context.asset, -100)
+        context.invested = False
+        sell = True
+
+    record(AAPL=data.current(context.asset, "price"),
+           short_ema=short_ema[-1],
+           long_ema=long_ema[-1],
+           buy=buy,
+           sell=sell)
+
+
+# Note: this function can be removed if running
+# this algorithm on quantopian.com
+def analyze(context=None, results=None):
+    import matplotlib.pyplot as plt
+    import logbook
+    logbook.StderrHandler().push_application()
+    log = logbook.Logger('Algorithm')
+
+    fig = plt.figure()
+    ax1 = fig.add_subplot(211)
+    results.portfolio_value.plot(ax=ax1)
+    ax1.set_ylabel('Portfolio value (USD)')
+
+    ax2 = fig.add_subplot(212)
+    ax2.set_ylabel('Price (USD)')
+
+    # If data has been record()ed, then plot it.
+    # Otherwise, log the fact that no data has been recorded.
+    if 'AAPL' in results and 'short_ema' in results and 'long_ema' in results:
+        results[['AAPL', 'short_ema', 'long_ema']].plot(ax=ax2)
+
+        ax2.plot(results.ix[results.buy].index, results.short_ema[results.buy],
+                 '^', markersize=10, color='m')
+        ax2.plot(results.ix[results.sell].index,
+                 results.short_ema[results.sell],
+                 'v', markersize=10, color='k')
+        plt.legend(loc=0)
+        plt.gcf().set_size_inches(18, 8)
+    else:
+        msg = 'AAPL, short_ema and long_ema data not captured using record().'
+        ax2.annotate(msg, xy=(0.1, 0.5))
+        log.info(msg)
+
+    plt.show()
+
+
+def _test_args():
+    """Extra arguments to use when catalyst's automated tests run this example.
+    """
+    import pandas as pd
+
+    return {
+        'start': pd.Timestamp('2014-01-01', tz='utc'),
+        'end': pd.Timestamp('2014-11-01', tz='utc'),
+    }

catalyst/examples/dual_moving_average.py

@@ -0,0 +1,108 @@
+#!/usr/bin/env python
+#
+# Copyright 2014 Quantopian, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Dual Moving Average Crossover algorithm.
+
+This algorithm buys apple once its short moving average crosses
+its long moving average (indicating upwards momentum) and sells
+its shares once the averages cross again (indicating downwards
+momentum).
+"""
+
+from catalyst.api import order_target, record, symbol
+
+
+def initialize(context):
+    context.sym = symbol('AAPL')
+    context.i = 0
+
+
+def handle_data(context, data):
+    # Skip first 300 days to get full windows
+    context.i += 1
+    if context.i < 300:
+        return
+
+    # Compute averages
+    # history() has to be called with the same params
+    # from above and returns a pandas dataframe.
+    short_mavg = data.history(context.sym, 'price', 100, '1d').mean()
+    long_mavg = data.history(context.sym, 'price', 300, '1d').mean()
+
+    # Trading logic
+    if short_mavg > long_mavg:
+        # order_target orders as many shares as needed to
+        # achieve the desired number of shares.
+        order_target(context.sym, 100)
+    elif short_mavg < long_mavg:
+        order_target(context.sym, 0)
+
+    # Save values for later inspection
+    record(AAPL=data.current(context.sym, "price"),
+           short_mavg=short_mavg,
+           long_mavg=long_mavg)
+
+
+# Note: this function can be removed if running
+# this algorithm on quantopian.com
+def analyze(context=None, results=None):
+    import matplotlib.pyplot as plt
+    import logbook
+    logbook.StderrHandler().push_application()
+    log = logbook.Logger('Algorithm')
+
+    fig = plt.figure()
+    ax1 = fig.add_subplot(211)
+    results.portfolio_value.plot(ax=ax1)
+    ax1.set_ylabel('Portfolio value (USD)')
+
+    ax2 = fig.add_subplot(212)
+    ax2.set_ylabel('Price (USD)')
+
+    # If data has been record()ed, then plot it.
+    # Otherwise, log the fact that no data has been recorded.
+    if ('AAPL' in results and 'short_mavg' in results and
+            'long_mavg' in results):
+        results['AAPL'].plot(ax=ax2)
+        results[['short_mavg', 'long_mavg']].plot(ax=ax2)
+
+        trans = results.ix[[t != [] for t in results.transactions]]
+        buys = trans.ix[[t[0]['amount'] > 0 for t in
+                         trans.transactions]]
+        sells = trans.ix[
+            [t[0]['amount'] < 0 for t in trans.transactions]]
+        ax2.plot(buys.index, results.short_mavg.ix[buys.index],
+                 '^', markersize=10, color='m')
+        ax2.plot(sells.index, results.short_mavg.ix[sells.index],
+                 'v', markersize=10, color='k')
+        plt.legend(loc=0)
+    else:
+        msg = 'AAPL, short_mavg & long_mavg data not captured using record().'
+        ax2.annotate(msg, xy=(0.1, 0.5))
+        log.info(msg)
+
+    plt.show()
+
+
+def _test_args():
+    """Extra arguments to use when catalyst's automated tests run this example.
+    """
+    import pandas as pd
+
+    return {
+        'start': pd.Timestamp('2011', tz='utc'),
+        'end': pd.Timestamp('2013', tz='utc'),
+    }

catalyst/examples/momentum_pipeline.py

@@ -0,0 +1,95 @@
+"""
+A simple Pipeline algorithm that longs the top 3 stocks by RSI and shorts
+the bottom 3 each day.
+"""
+from six import viewkeys
+from catalyst.api import (
+    attach_pipeline,
+    date_rules,
+    order_target_percent,
+    pipeline_output,
+    record,
+    schedule_function,
+)
+from catalyst.pipeline import Pipeline
+from catalyst.pipeline.factors.crypto import RSI as cRSI
+from catalyst.pipeline.factors.equity import RSI as eRSI
+
+
+def make_pipeline():
+    crsi = cRSI()
+    ersi = eRSI()
+    return Pipeline(
+        columns={
+            'longs': crsi.top(3),
+            'shorts': crsi.bottom(3),
+            'equity': ersi.top(3),
+        },
+    )
+
+
+def rebalance(context, data):
+
+    # Pipeline data will be a dataframe with boolean columns named 'longs' and
+    # 'shorts'.
+    pipeline_data = context.pipeline_data
+    all_assets = pipeline_data.index
+
+    longs = all_assets[pipeline_data.longs]
+    shorts = all_assets[pipeline_data.shorts]
+
+    record(universe_size=len(all_assets))
+
+    # Build a 2x-leveraged, equal-weight, long-short portfolio.
+    one_third = 1.0 / 3.0
+    for asset in longs:
+        order_target_percent(asset, one_third)
+
+    for asset in shorts:
+        order_target_percent(asset, -one_third)
+
+    # Remove any assets that should no longer be in our portfolio.
+    portfolio_assets = longs | shorts
+    positions = context.portfolio.positions
+    for asset in viewkeys(positions) - set(portfolio_assets):
+        # This will fail if the asset was removed from our portfolio because it
+        # was delisted.
+        if data.can_trade(asset):
+            order_target_percent(asset, 0)
+
+
+def initialize(context):
+    attach_pipeline(make_pipeline(), 'my_pipeline')
+
+    # Rebalance each day.  In daily mode, this is equivalent to putting
+    # `rebalance` in our handle_data, but in minute mode, it's equivalent to
+    # running at the start of the day each day.
+    schedule_function(rebalance, date_rules.every_day())
+
+
+def before_trading_start(context, data):
+    context.pipeline_data = pipeline_output('my_pipeline')
+
+
+def _test_args():
+    """
+    Extra arguments to use when catalyst's automated tests run this example.
+
+    Notes for testers:
+
+    Gross leverage should be roughly 2.0 on every day except the first.
+    Net leverage should be roughly 2.0 on every day except the first.
+
+    Longs Count should always be 3 after the first day.
+    Shorts Count should be 3 after the first day, except on 2013-10-30, when it
+    dips to 2 for a day because DELL is delisted.
+    """
+    import pandas as pd
+
+    return {
+        # We run through october of 2013 because DELL is in the test data and
+        # it went private on 2013-10-29.
+        'start': pd.Timestamp('2013-10-07', tz='utc'),
+        'end': pd.Timestamp('2013-11-30', tz='utc'),
+        'capital_base': 100000,
+    }

catalyst/examples/olmar.py

@@ -0,0 +1,167 @@
+import sys
+import logbook
+import numpy as np
+
+from catalyst.finance import commission
+
+catalyst_logging = logbook.NestedSetup([
+    logbook.NullHandler(),
+    logbook.StreamHandler(sys.stdout, level=logbook.INFO),
+    logbook.StreamHandler(sys.stderr, level=logbook.ERROR),
+])
+catalyst_logging.push_application()
+
+STOCKS = ['AMD', 'CERN', 'COST', 'DELL', 'GPS', 'INTC', 'MMM']
+
+
+# On-Line Portfolio Moving Average Reversion
+
+# More info can be found in the corresponding paper:
+# http://icml.cc/2012/papers/168.pdf
+def initialize(algo, eps=1, window_length=5):
+    algo.stocks = STOCKS
+    algo.sids = [algo.symbol(symbol) for symbol in algo.stocks]
+    algo.m = len(algo.stocks)
+    algo.price = {}
+    algo.b_t = np.ones(algo.m) / algo.m
+    algo.last_desired_port = np.ones(algo.m) / algo.m
+    algo.eps = eps
+    algo.init = True
+    algo.days = 0
+    algo.window_length = window_length
+
+    algo.set_commission(commission.PerShare(cost=0))
+
+
+def handle_data(algo, data):
+    algo.days += 1
+    if algo.days < algo.window_length:
+        return
+
+    if algo.init:
+        rebalance_portfolio(algo, data, algo.b_t)
+        algo.init = False
+        return
+
+    m = algo.m
+
+    x_tilde = np.zeros(m)
+
+    # find relative moving average price for each asset
+    mavgs = data.history(algo.sids, 'price', algo.window_length, '1d').mean()
+    for i, sid in enumerate(algo.sids):
+        price = data.current(sid, "price")
+        # Relative mean deviation
+        x_tilde[i] = mavgs[sid] / price
+
+    ###########################
+    # Inside of OLMAR (algo 2)
+    x_bar = x_tilde.mean()
+
+    # market relative deviation
+    mark_rel_dev = x_tilde - x_bar
+
+    # Expected return with current portfolio
+    exp_return = np.dot(algo.b_t, x_tilde)
+    weight = algo.eps - exp_return
+    variability = (np.linalg.norm(mark_rel_dev)) ** 2
+
+    # test for divide-by-zero case
+    if variability == 0.0:
+        step_size = 0
+    else:
+        step_size = max(0, weight / variability)
+
+    b = algo.b_t + step_size * mark_rel_dev
+    b_norm = simplex_projection(b)
+    np.testing.assert_almost_equal(b_norm.sum(), 1)
+
+    rebalance_portfolio(algo, data, b_norm)
+
+    # update portfolio
+    algo.b_t = b_norm
+
+
+def rebalance_portfolio(algo, data, desired_port):
+    # rebalance portfolio
+    desired_amount = np.zeros_like(desired_port)
+    current_amount = np.zeros_like(desired_port)
+    prices = np.zeros_like(desired_port)
+
+    if algo.init:
+        positions_value = algo.portfolio.starting_cash
+    else:
+        positions_value = algo.portfolio.positions_value + \
+            algo.portfolio.cash
+
+    for i, sid in enumerate(algo.sids):
+        current_amount[i] = algo.portfolio.positions[sid].amount
+        prices[i] = data.current(sid, "price")
+
+    desired_amount = np.round(desired_port * positions_value / prices)
+
+    algo.last_desired_port = desired_port
+    diff_amount = desired_amount - current_amount
+
+    for i, sid in enumerate(algo.sids):
+        algo.order(sid, diff_amount[i])
+
+
+def simplex_projection(v, b=1):
+    """Projection vectors to the simplex domain
+
+    Implemented according to the paper: Efficient projections onto the
+    l1-ball for learning in high dimensions, John Duchi, et al. ICML 2008.
+    Implementation Time: 2011 June 17 by Bin@libin AT pmail.ntu.edu.sg
+    Optimization Problem: min_{w}\| w - v \|_{2}^{2}
+    s.t. sum_{i=1}^{m}=z, w_{i}\geq 0
+
+    Input: A vector v \in R^{m}, and a scalar z > 0 (default=1)
+    Output: Projection vector w
+
+    :Example:
+    >>> proj = simplex_projection([.4 ,.3, -.4, .5])
+    >>> proj  # doctest: +NORMALIZE_WHITESPACE
+    array([ 0.33333333, 0.23333333, 0. , 0.43333333])
+    >>> print(proj.sum())
+    1.0
+
+    Original matlab implementation: John Duchi (jduchi@cs.berkeley.edu)
+    Python-port: Copyright 2013 by Thomas Wiecki (thomas.wiecki@gmail.com).
+    """
+
+    v = np.asarray(v)
+    p = len(v)
+
+    # Sort v into u in descending order
+    v = (v > 0) * v
+    u = np.sort(v)[::-1]
+    sv = np.cumsum(u)
+
+    rho = np.where(u > (sv - b) / np.arange(1, p + 1))[0][-1]
+    theta = np.max([0, (sv[rho] - b) / (rho + 1)])
+    w = (v - theta)
+    w[w < 0] = 0
+    return w
+
+
+# Note: this function can be removed if running
+# this algorithm on quantopian.com
+def analyze(context=None, results=None):
+    import matplotlib.pyplot as plt
+    fig = plt.figure()
+    ax = fig.add_subplot(111)
+    results.portfolio_value.plot(ax=ax)
+    ax.set_ylabel('Portfolio value (USD)')
+    plt.show()
+
+
+def _test_args():
+    """Extra arguments to use when catalyst's automated tests run this example.
+    """
+    import pandas as pd
+
+    return {
+        'start': pd.Timestamp('2004', tz='utc'),
+        'end': pd.Timestamp('2008', tz='utc'),
+    }