Python factory.load_from_yahoo函数代码示例

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