def run_algorithm(
        security='AAPL',
        start_date='20100101',
        end_date='20150101',
        initial_cash=100000,
        rsi_window=15,
        low_RSI=30,
        high_RSI=70):
    logging.debug('run_algorithm begin')
    # dates
    start = dateutil.parser.parse(start_date)
    end = dateutil.parser.parse(end_date)

    # get data from yahoo
    data = load_from_yahoo(stocks=[security], indexes={}, start=start, end=end)
    logging.debug('done loading from yahoo. {} {} {}'.format(
        security, start_date, end_date))

    # create and run algorithm
    algo = TradingAlgorithm(
        initialize=initialize,
        handle_data=handle_data,
        capital_base=initial_cash)
    algo.security = security
    initialize.low_RSI = low_RSI
    initialize.high_RSI = high_RSI
    initialize.rsi_window = rsi_window
    logging.debug('starting to run algo...')
    results = algo.run(data).dropna()
    logging.debug('done running algo')
    return results

def stock_process():
    start = datetime(2010, 1, 1, 0, 0, 0, 0, pytz.utc)
    end = datetime(2011, 1, 1, 0, 0, 0, 0, pytz.utc)
    data = load_from_yahoo(stocks=['AAPL'], indexes={}, start=start, end=end)

    plt.plot(data[:sample_size])
    plt.show()

def example():
    start = datetime(1990, 1, 1, 0, 0, 0, 0, pytz.utc)
    end = datetime(1991, 1, 1, 0, 0, 0, 0, pytz.utc)
    data = load_from_yahoo(stocks=['IBM'], indexes={}, start=start,
                           end=end)

    dma = DualMovingAverage()
    results = dma.run(data)

    index = [br.date for br in trading.environment.benchmark_returns]
    rets = [br.returns for br in trading.environment.benchmark_returns]
    bm_returns = pd.Series(rets, index=index).ix[start:end]
    results['benchmark_returns'] = (1 + bm_returns).cumprod().values
    results['algorithm_returns'] = (1 + results.returns).cumprod()
    fig = plt.figure()
    ax1 = fig.add_subplot(211, ylabel='cumulative returns')

    results[['algorithm_returns', 'benchmark_returns']].plot(ax=ax1,
                                                             sharex=True)

    ax2 = fig.add_subplot(212)
    data['IBM'].plot(ax=ax2, color='r')
    results[['short_mavg', 'long_mavg']].plot(ax=ax2)

    ax2.plot(results.ix[results.buy].index, results.short_mavg[results.buy],
             '^', markersize=10, color='m')
    ax2.plot(results.ix[results.sell].index, results.short_mavg[results.sell],
             'v', markersize=10, color='k')
    plt.legend(loc=0)

    def setUp(self):
        setup_logger(self)
        start = pd.datetime(1993, 1, 1, 0, 0, 0, 0, pytz.utc)
        end = pd.datetime(1994, 1, 1, 0, 0, 0, 0, pytz.utc)

        self.data = factory.load_from_yahoo(stocks=['AAPL'],
                                            indexes={},
                                            start=start, end=end)

 def __init__(self, movimientos):
     self.movimientos = movimientos
     fechas = []
     emisoras = set()
     for movimiento in movimientos:
         fechas.append(movimiento.fecha)
         emisoras.add(movimiento.emisora)
     emisoras = list(emisoras)
     fecha_inicio = min(fechas)
     self.data = load_from_yahoo(stocks=emisoras, indexes={}, start=fecha_inicio, adjusted=False)

 def load_symbols(self, name, symbols=['AAPL','FB','CSCO','INTC'], start=None, end=None):
     start = start or date.today() - datetime.timedelta(days=1*365)
     end   = end   or date.today()
     name  = "%s%s" % (self.path, name)
     print "Loading %s from %s to %s into %s" % (",".join(symbols), start, end, name)
     if os.path.isfile(name):
         self.data = pd.read_pickle(name)
     else:
         self.data = load_from_yahoo(stocks=symbols, start=start, end=end)
         self.data.to_pickle(name)
     return self.data

    def querydata(symbols, start, end, useDatastore=True):
        def utc(dt):
            return datetime(dt.year, dt.month, dt.day, 0, 0, 0, 0, pytz.utc)

        if not isinstance(start, datetime):
            start = utc(datetime.strptime(start, '%Y-%m-%d'))
            end = utc(datetime.strptime(end, '%Y-%m-%d'))

        if useDatastore:
            return load_from_datastore(stocks=symbols, start=start, end=end)
        else:
            return load_from_yahoo(stocks=symbols, indexes={}, start=start, end=end)

    def test_load_from_yahoo(self):
        stocks = ['AAPL', 'GE']
        start = pd.datetime(1993, 1, 1, 0, 0, 0, 0, pytz.utc)
        end = pd.datetime(2002, 1, 1, 0, 0, 0, 0, pytz.utc)
        data = load_from_yahoo(stocks=stocks, start=start, end=end)

        assert data.index[0] == pd.Timestamp('1993-01-04 00:00:00+0000')
        assert data.index[-1] == pd.Timestamp('2001-12-31 00:00:00+0000')
        for stock in stocks:
            assert stock in data.columns

        np.testing.assert_raises(
            AssertionError, load_from_yahoo, stocks=stocks,
            start=end, end=start
        )

    def fetch_equities_daily(self, symbols, ohlc=False, r_type=False, returns=False, **kwargs):
        if len(symbols) == 0:
            return pd.DataFrame()
        if isinstance(symbols, str):
            symbols = symbols.split(",")

        if ohlc:
            data = load_bars_from_yahoo(stocks=symbols, **kwargs)
            # data.items = symbols
        else:
            data = load_from_yahoo(stocks=symbols, **kwargs)
            # data.columns = symbols

            # NOTE Would it work with a pandas panel ?
            if returns:
                data = ((data - data.shift(1)) / data).fillna(method="bfill")
            if r_type:
                data = convert_to_r_matrix(data)

        return data

    def fetch_equities_daily(self, equities, ohlc=False,
                             r_type=False, returns=False, **kwargs):
        if len(equities) == 0:
            return pd.DataFrame()
        if isinstance(equities, str):
            equities = equities.split(',')
        symbols = [self.datafeed.guess_name(equity) for equity in equities]

        if ohlc:
            data = load_bars_from_yahoo(stocks=symbols, **kwargs)
            data.items = equities
        else:
            data = load_from_yahoo(stocks=symbols, **kwargs)
            data.columns = equities

            #NOTE Would it work with a pandas panel ?
            if returns:
                data = ((data - data.shift(1)) / data).fillna(method='bfill')
            if r_type:
                data = convert_to_r_matrix(data)

        return data

        elif abs(zscore) < .5 and self.invested:
            self.sell_spread()
            self.invested = False

    def sell_spread(self):
        """
        decrease exposure, regardless of position long/short.
        buy for a short position, sell for a long.
        """
        CVX_amount = self.portfolio.positions['CVX'].amount
        self.order('CVX', -1 * CVX_amount)
        XOM_amount = self.portfolio.positions['XOM'].amount
        self.order('XOM', -1 * XOM_amount)

if __name__ == '__main__':
    data = load_from_yahoo(stocks=['XOM', 'CVX'], start=datetime(2008,1,1), end=datetime(2012,1,1), indexes={})

    pairtrade = Pairtrade()
    results = pairtrade.run(data)
    data['spreads'] = np.nan
    data.spreads[pairtrade.window_length:] = pairtrade.spreads

    ax1 = plt.subplot(211)
    data[['XOM', 'CVX']].plot(ax=ax1)
    plt.ylabel('price')
    plt.setp(ax1.get_xticklabels(), visible=False)

    ax2 = plt.subplot(212, sharex=ax1)
    data.spreads.plot(ax=ax2, color='r')
    plt.ylabel('spread')

    Original matlab implementation: John Duchi ([email protected])
    Python-port: Copyright 2013 by Thomas Wiecki ([email protected]).
    """

    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

if __name__ == '__main__':
    import pylab as pl
    start = datetime(2004, 1, 1, 0, 0, 0, 0, pytz.utc)
    end = datetime(2008, 1, 1, 0, 0, 0, 0, pytz.utc)
    data = load_from_yahoo(stocks=STOCKS, indexes={}, start=start, end=end)
    data = data.dropna()
    olmar = TradingAlgorithm(handle_data=handle_data,
                             initialize=initialize,
                             identifiers=STOCKS)
    results = olmar.run(data)
    results.portfolio_value.plot()
    pl.show()

        # Record our variables to see the algo behavior. You can record up to 
        # 5 custom variables. To see only a certain variable, deselect the 
        # variable name in the custom graph in the backtest. 
        context.record(short_mavg = short[context.stocks[1]],
               long_mavg = long[context.stocks[1]],
               goog_price = context.price)   
if __name__ == '__main__':
    import sys
    sys.path.append('/home/mid/PythonProjects/xpower')      
    
    import zipline.utils.factory as zpf
    import matplotlib.pyplot as plt
    
    data = zpf.load_from_yahoo(stocks=['BA','AAPL'],
                               indexes={},
                               start=datetime(2015, 1, 1),
                               end=datetime(2016, 3, 5),
                               adjusted=True)
    algo = DualEmaTalib(instant_fill=True,
                          capital_base=50000,
                          env=None,
                          sim_params = None,  # 设置有此参数时，start和end不能再设置，否则，显得多余也会运行assert错误
                          #start = algo['start'],
                          #end = algo['end'],
                          data_frequency = 'daily')
    def dumpDict(dictStr):
        """"""
        import json
        jsonDumpsIndentStr = json.dumps(dictStr, indent=4,skipkeys = False,default=str,sort_keys=True)
        print (jsonDumpsIndentStr) 
    def analyze(data,  results):

# 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.

import matplotlib.pyplot as plt

from zipline.algorithm import TradingAlgorithm
from zipline.utils.factory import load_from_yahoo


class BuyApple(TradingAlgorithm):  # inherit from TradingAlgorithm
    """This is the simplest possible algorithm that does nothing but
    buy 1 apple share on each event.
    """
    def handle_data(self, data):  # overload handle_data() method
        self.order('SPY', 1)  # order SID (=0) and amount (=1 shares)


if __name__ == '__main__':
    data = load_from_yahoo(stocks=['SPY'], indexes={}, start="1990-01-01", end="2012-01-01")
    simple_algo = BuyApple()
    results = simple_algo.run(data)
    results.portfolio_value.plot()
    plt.show()

            self.order(sym, -1 * sym_amount)
            if sym_amount > 0:
                action = 'SELL'
                self.set_log(day, sym, etf, zscore, action, (sym_price-etf_price))
            else:
                action = 'BUY'
                self.set_log(day, sym, etf, zscore, action, (sym_price-etf_price))
        else:
            action = '---'
        self.actions[sym]['ACTION'].append(action)
        return


if __name__ == '__main__':
    feed = build_feed()
    data = load_from_yahoo(stocks=feed, indexes={},
                           start=start, end=end, adjusted=True)
    
    pairtrade = Pairtrade()
    results = pairtrade.run(data)
    
    ###########################################################################
    # Generate metrics
    print 'Generating Risk Report...........'
    print 'Using S&P500 as benchmark........'

    start = results.first_valid_index().replace(tzinfo=pytz.utc)
    end = results.last_valid_index().replace(tzinfo=pytz.utc)
    env = trading.SimulationParameters(start, end)
    returns_risk = create_returns_from_list(results.returns, env)
    
    algo_returns = RiskMetricsBase(start, end, returns_risk).algorithm_period_returns

            
    def sell_spread(self,sid1,sid2):
        """
        decrease exposure, regardless of position long/short.
        buy for a short position, sell for a long.
        """
        sad1_amount = self.portfolio.positions[sid1].amount
        self.order(sid1, -1 * sad1_amount)
        sad2_amount = self.portfolio.positions[sid2].amount
        self.order(sid2, -1 * sad2_amount)

if __name__ == '__main__':
    ###########################################################################################################
    start = datetime(2006, 1, 1, 0, 0, 0, 0, pytz.utc)
    end = datetime(2008, 1, 1, 0, 0, 0, 0, pytz.utc)
    data = load_from_yahoo(stocks=['XLF', 'JPM'], indexes={},
                           start=start, end=end)
    ## heard to save in the csv file and reget it. because the time zone and the timestampe is different
    
    
    #data.to_csv("PEP_KO_2007-2008.csv",index = True ,cols=('PEP','KO'))
    # the cols = () is order sensitive. If we save them as PEP and KO in cols them they will change the order
    # If want to load another dataset then denote these lines.
    ############################################################################################################
    #read_data = pd.DataFrame.from_csv('PEP_KO_2007-2008.csv',infer_datetime_format = True)
    #read_data.index = pd.DatetimeIndex(read_data["Date"])

    pairtrade = Pairtrade()
    results = pairtrade.run(data)
    #pd.DataFrame.join(data, results.pnl, on = 'index')
    
    result = pd.concat([results.zscores,results.orders,results.positions,results.pnl],axis = 1)

	cumulative['cp_sum'] = cumulative['cumsum_c'] + cumulative['cumsum_p']
	mpp = cumulative.ix[cumulative['cp_sum'].idxmax()]['strike']	
	return mpp

def add_to_window(context, window_size, datapoint, ticker):
	tw = context.target_window[ticker]
	tw.append(datapoint)
	context.target_window[ticker] = tw[-window_size:] if len(tw) > window_size else tw
	

# (6) Create CI for n-day window as price target range
# Return tuple with upper and lower bound
def CI(window, sds):
	mean = 	np.mean(window)
	sd = np.std(window)

	return (mean - sds * sd, mean + sds * sd)

if __name__ == '__main__':
	universe = ['FB']
	data = load_from_yahoo(stocks=universe,
		indexes={}, start=datetime(2016, 4, 3), 
		end=datetime.today())  
	olmar = TradingAlgorithm(initialize=initialize, handle_data=handle_data, capital_base=10000)  
	backtest = olmar.run(data)
	backtest.to_csv('backtest-50-2012.csv') 
	print backtest['algorithm_period_return'][-1]

	import pyfolio as pf
	returns, positions, transactions, gross_lev = pf.utils.extract_rets_pos_txn_from_zipline(backtest)
	pf.create_full_tear_sheet(returns, positions=positions, transactions=transactions, gross_lev=gross_lev, live_start_date='2004-10-22')

            self.order('DDD', -100)
            self.invested = False
            sell = True

    # Record state variables. A column for each
    # variable will be added to the performance
    # DataFrame returned by .run()
        self.record(short_mavg=short_mavg,
                    long_mavg=long_mavg,
                    buy=buy,
                    sell=sell)

# Load data
start = datetime(2008, 11, 11, 0, 0, 0, 0, pytz.utc)
end = datetime(2013, 11, 11, 0, 0, 0, 0, pytz.utc)
data = load_from_yahoo(stocks=['DDD'], indexes={}, start=start,
                   end=end, adjusted=False)

# Run algorithm
dma = DualMovingAverage()
perf = dma.run(data)

# Plot results
fig = plt.figure()
ax1 = fig.add_subplot(211,  ylabel='Price in $')
data['DDD'].plot(ax=ax1, color='r', lw=2.)
perf[['short_mavg', 'long_mavg']].plot(ax=ax1, lw=2.)

ax1.plot(perf.ix[perf.buy].index, perf.short_mavg[perf.buy],
         '^', markersize=10, color='m')
ax1.plot(perf.ix[perf.sell].index, perf.short_mavg[perf.sell],
         'v', markersize=10, color='k')

        self.short_mavgs = []
        self.long_mavgs = []

    def handle_data(self, data):
        short_mavg = data['AAPL'].short_mavg['price']
        long_mavg = data['AAPL'].long_mavg['price']
        if short_mavg > long_mavg and not self.invested:
            self.order('AAPL', 100)
            self.invested = True
        elif short_mavg < long_mavg and self.invested:
            self.order('AAPL', -100)
            self.invested = False

        # Save mavgs for later analysis.
        self.short_mavgs.append(short_mavg)
        self.long_mavgs.append(long_mavg)


if __name__ == '__main__':
    data = load_from_yahoo(stocks=['AAPL'], indexes={})
    dma = DualMovingAverage()
    results = dma.run(data)

    results.portfolio_value.plot()

    data['short'] = dma.short_mavgs
    data['long'] = dma.long_mavgs
    data[['AAPL', 'short', 'long']].plot()
    plt.legend(loc=0)
    plt.show()

        self.amount = 100
        self.data = []
        print("--->BuEveryDay.initialize() end")
    def handle_data(self,data):
        print('----BuyEveryDay.handle_data().',data[0]['dt'])
        self.data.append(data[0]['dt'])             #mid collect all data
        self.order(self.sid,self.amount)            #mid open 1 long position.
        self.record(AAPL=data[self.sid].price)      #mid add one column named 'AAPL' to returns of Algorithm.run()                   
if __name__ == '__main__':
    import zipline.utils.factory as zpf
    from datetime import datetime
    import matplotlib.pyplot as plt
    
    data = zpf.load_from_yahoo(stocks=['AAPL'],
                               indexes={},
                               start=datetime(1997, 1, 1),
                               end=datetime(1998, 6, 1),
                               adjusted=True)
    algo = BuyEveryDay(instant_fill=True,
                          capital_base=50000,
                          env=None,
                          sim_params = None,  # 设置有此参数时，start和end不能再设置，否则，显得多余也会运行assert错误
                          #start = algo['start'],
                          #end = algo['end'],
                          data_frequency = 'daily')
    def dumpDict(dictStr):
        """"""
        import json
        jsonDumpsIndentStr = json.dumps(dictStr, indent=4,skipkeys = False,default=str,sort_keys=True)
        print (jsonDumpsIndentStr) 
    algo.dumpDict = dumpDict