def test_account_in_init(self):
"""
Test that accessing account in init doesn't break.
"""
test_algo = TradingAlgorithm(
script=access_account_in_init,
sim_params=self.sim_params,
)
set_algo_instance(test_algo)
self.zipline_test_config['algorithm'] = test_algo
self.zipline_test_config['trade_count'] = 1
zipline = simfactory.create_test_zipline(
**self.zipline_test_config)
output, _ = drain_zipline(self, zipline)
def test_pipeline_beyond_daily_bars(self):
"""
Ensure that we can run an algo with pipeline beyond the max date
of the daily bars.
"""
# For ensuring we call before_trading_start.
count = [0]
current_day = default_nyse_schedule.next_execution_day(
self.pipeline_loader.raw_price_loader.last_available_dt, )
def initialize(context):
pipeline = attach_pipeline(Pipeline(), 'test')
vwap = VWAP(window_length=10)
pipeline.add(vwap, 'vwap')
# Nothing should have prices less than 0.
pipeline.set_screen(vwap < 0)
def handle_data(context, data):
pass
def before_trading_start(context, data):
context.results = pipeline_output('test')
self.assertTrue(context.results.empty)
count[0] += 1
algo = TradingAlgorithm(
initialize=initialize,
handle_data=handle_data,
before_trading_start=before_trading_start,
data_frequency='daily',
get_pipeline_loader=lambda column: self.pipeline_loader,
start=self.dates[0],
end=current_day,
env=self.env,
)
algo.run(
FakeDataPortal(),
overwrite_sim_params=False,
)
self.assertTrue(count[0] > 0)
def _algo_record_float_magic_should_pass(self, var_type):
test_algo = TradingAlgorithm(
script=record_float_magic % var_type,
sim_params=self.sim_params,
)
set_algo_instance(test_algo)
self.zipline_test_config['algorithm'] = test_algo
self.zipline_test_config['trade_count'] = 200
zipline = simfactory.create_test_zipline(**self.zipline_test_config)
output, _ = drain_zipline(self, zipline)
self.assertEqual(len(output), 252)
incr = []
for o in output[:200]:
incr.append(o['daily_perf']['recorded_vars']['data'])
np.testing.assert_array_equal(incr, [np.nan] * 200)
def test_history(self):
history_algo = """
from zipline.api import history, add_history
def initialize(context):
add_history(10, '1d', 'price')
def handle_data(context, data):
df = history(10, '1d', 'price')
"""
algo = TradingAlgorithm(
script=history_algo,
sim_params=self.sim_params,
)
output = algo.run(self.source)
self.assertIsNot(output, None)
def test_order_methods(self):
"""
Only test that order methods can be called without error.
Correct filling of orders is tested in zipline.
"""
test_algo = TradingAlgorithm(
script=call_all_order_methods,
sim_params=self.sim_params,
)
set_algo_instance(test_algo)
self.zipline_test_config['algorithm'] = test_algo
self.zipline_test_config['trade_count'] = 200
zipline = simfactory.create_test_zipline(**self.zipline_test_config)
output, _ = drain_zipline(self, zipline)
def test_assets_appear_on_correct_days(self, test_name, chunksize):
"""
Assert that assets appear at correct times during a backtest, with
correctly-adjusted close price values.
"""
if chunksize == 'all_but_one_day':
chunksize = (
self.dates.get_loc(self.last_asset_end) -
self.dates.get_loc(self.first_asset_start)
) - 1
def initialize(context):
p = attach_pipeline(Pipeline(), 'test', chunksize=chunksize)
p.add(USEquityPricing.close.latest, 'close')
def handle_data(context, data):
results = pipeline_output('test')
date = get_datetime().normalize()
for asset in self.assets:
# Assets should appear iff they exist today and yesterday.
exists_today = self.exists(date, asset)
existed_yesterday = self.exists(date - trading_day, asset)
if exists_today and existed_yesterday:
latest = results.loc[asset, 'close']
self.assertEqual(latest, self.expected_close(date, asset))
else:
self.assertNotIn(asset, results.index)
before_trading_start = handle_data
algo = TradingAlgorithm(
initialize=initialize,
handle_data=handle_data,
before_trading_start=before_trading_start,
data_frequency='daily',
get_pipeline_loader=lambda column: self.pipeline_loader,
start=self.first_asset_start,
end=self.last_asset_end,
env=self.env,
)
# Run for a week in the middle of our data.
algo.run(source=self.closes.loc[self.first_asset_start:
self.last_asset_end])
def test_multiple_pipelines(self):
"""
Test that we can attach multiple pipelines and access the correct
output based on the pipeline name.
"""
def initialize(context):
pipeline_close = attach_pipeline(Pipeline(), 'test_close')
pipeline_volume = attach_pipeline(Pipeline(), 'test_volume')
pipeline_close.add(USEquityPricing.close.latest, 'close')
pipeline_volume.add(USEquityPricing.volume.latest, 'volume')
def handle_data(context, data):
closes = pipeline_output('test_close')
volumes = pipeline_output('test_volume')
date = get_datetime().normalize()
for asset in self.assets:
# Assets should appear iff they exist today and yesterday.
exists_today = self.exists(date, asset)
existed_yesterday = self.exists(date - self.trading_day, asset)
if exists_today and existed_yesterday:
self.assertEqual(closes.loc[asset, 'close'],
self.expected_close(date, asset))
self.assertEqual(volumes.loc[asset, 'volume'],
self.expected_volume(date, asset))
else:
self.assertNotIn(asset, closes.index)
self.assertNotIn(asset, volumes.index)
column_to_loader = {
USEquityPricing.close: self.pipeline_close_loader,
USEquityPricing.volume: self.pipeline_volume_loader,
}
algo = TradingAlgorithm(
initialize=initialize,
handle_data=handle_data,
data_frequency='daily',
get_pipeline_loader=lambda column: column_to_loader[column],
start=self.first_asset_start,
end=self.last_asset_end,
env=self.env,
)
algo.run(self.data_portal)
def test_register_post_init(self):
def initialize(algo):
algo.initialized = True
def handle_data(algo, data):
with self.assertRaises(RegisterTradingControlPostInit):
algo.set_max_position_size(self.sid, 1, 1)
with self.assertRaises(RegisterTradingControlPostInit):
algo.set_max_order_size(self.sid, 1, 1)
with self.assertRaises(RegisterTradingControlPostInit):
algo.set_max_order_count(1)
with self.assertRaises(RegisterTradingControlPostInit):
algo.set_long_only()
algo = TradingAlgorithm(initialize=initialize, handle_data=handle_data)
algo.run(self.source)
self.source.rewind()
def test_history(self):
history_algo = """
from zipline.api import history, add_history
def initialize(context):
add_history(10, '1d', 'price')
def handle_data(context, data):
df = history(10, '1d', 'price')
"""
start = pd.Timestamp('1991-01-01', tz='UTC')
end = pd.Timestamp('1991-01-15', tz='UTC')
source = RandomWalkSource(start=start, end=end)
sim_params = factory.create_simulation_parameters(
data_frequency='minute')
algo = TradingAlgorithm(script=history_algo, sim_params=sim_params)
output = algo.run(source)
self.assertIsNot(output, None)
def test_algo_record_vars(self):
test_algo = TradingAlgorithm(
script=record_variables,
sim_params=self.sim_params,
)
set_algo_instance(test_algo)
self.zipline_test_config['algorithm'] = test_algo
self.zipline_test_config['trade_count'] = 200
zipline = simfactory.create_test_zipline(**self.zipline_test_config)
output, _ = drain_zipline(self, zipline)
self.assertEqual(len(output), 252)
incr = []
for o in output[:200]:
incr.append(o['daily_perf']['recorded_vars']['incr'])
np.testing.assert_array_equal(incr, range(1, 201))
def test_zipline_api_resolves_dynamically(self):
# Make a dummy algo.
algo = TradingAlgorithm(
initialize=lambda context: None,
handle_data=lambda context, data: None,
sim_params=self.sim_params,
)
# Verify that api methods get resolved dynamically by patching them out
# and then calling them
for method in algo.all_api_methods():
name = method.__name__
sentinel = object()
def fake_method(*args, **kwargs):
return sentinel
setattr(algo, name, fake_method)
with ZiplineAPI(algo):
self.assertIs(sentinel, getattr(zipline.api, name)())
def test_duplicate_pipeline_names(self):
"""
Test that we raise an error when we try to attach a pipeline with a
name that already exists for another attached pipeline.
"""
def initialize(context):
attach_pipeline(Pipeline(), 'test')
attach_pipeline(Pipeline(), 'test')
algo = TradingAlgorithm(
initialize=initialize,
data_frequency='daily',
get_pipeline_loader=lambda column: self.pipeline_close_loader,
start=self.first_asset_start,
end=self.last_asset_end,
env=self.env,
)
with self.assertRaises(DuplicatePipelineName):
algo.run(self.data_portal)
def test_get_environment(self):
expected_env = {
'arena': 'backtest',
'data_frequency': 'minute',
'start': pd.Timestamp('2006-01-03 14:31:00+0000', tz='UTC'),
'end': pd.Timestamp('2006-01-04 21:00:00+0000', tz='UTC'),
'capital_base': 100000.0,
'platform': 'zipline'
}
def initialize(algo):
self.assertEqual('zipline', algo.get_environment())
self.assertEqual(expected_env, algo.get_environment('*'))
def handle_data(algo, data):
pass
algo = TradingAlgorithm(initialize=initialize,
handle_data=handle_data,
sim_params=self.sim_params)
algo.run(self.source)
def test_get_datetime(self, name, tz):
algo = dedent(
"""
import pandas as pd
from zipline.api import get_datetime
def initialize(context):
context.tz = {tz} or 'UTC'
context.first_bar = True
def handle_data(context, data):
if context.first_bar:
dt = get_datetime({tz})
if dt.tz.zone != context.tz:
raise ValueError("Mismatched Zone")
elif dt.tz_convert("US/Eastern").hour != 9:
raise ValueError("Mismatched Hour")
elif dt.tz_convert("US/Eastern").minute != 31:
raise ValueError("Mismatched Minute")
context.first_bar = False
""".format(tz=repr(tz))
)
start = to_utc('2014-01-02 9:31')
end = to_utc('2014-01-03 9:31')
source = RandomWalkSource(
start=start,
end=end,
)
sim_params = factory.create_simulation_parameters(
data_frequency='minute'
)
algo = TradingAlgorithm(
script=algo,
sim_params=sim_params,
identifiers=[1]
)
algo.run(source)
self.assertFalse(algo.first_bar)
def test_asset_lookup(self):
metadata = {0: {'symbol': 'PLAY',
'asset_type': 'equity',
'start_date': '2002-01-01',
'end_date': '2004-01-01'},
1: {'symbol': 'PLAY',
'asset_type': 'equity',
'start_date': '2005-01-01',
'end_date': '2006-01-01'}}
algo = TradingAlgorithm(asset_metadata=metadata)
# Test before either PLAY existed
algo.datetime = pd.Timestamp('2001-12-01', tz='UTC')
with self.assertRaises(SymbolNotFound):
algo.symbol('PLAY')
with self.assertRaises(SymbolNotFound):
algo.symbols('PLAY')
# Test when first PLAY exists
algo.datetime = pd.Timestamp('2002-12-01', tz='UTC')
list_result = algo.symbols('PLAY')
self.assertEqual(0, list_result[0])
# Test after first PLAY ends
algo.datetime = pd.Timestamp('2004-12-01', tz='UTC')
self.assertEqual(0, algo.symbol('PLAY'))
# Test after second PLAY begins
algo.datetime = pd.Timestamp('2005-12-01', tz='UTC')
self.assertEqual(1, algo.symbol('PLAY'))
# Test after second PLAY ends
algo.datetime = pd.Timestamp('2006-12-01', tz='UTC')
self.assertEqual(1, algo.symbol('PLAY'))
list_result = algo.symbols('PLAY')
self.assertEqual(1, list_result[0])
# Test lookup SID
self.assertIsInstance(algo.sid(0), Equity)
self.assertIsInstance(algo.sid(1), Equity)
def agent_train(data_train):
"""Train the agent
Learn from the environment
"""
for iter in range(0, Q_training_iters):
gv.mylogger.logger.info("Agent Iteration :" + str(iter + 1))
# Create algorithm object passing in initialize,
# handle_data functions and so on
algo = TradingAlgorithm(initialize=train.initialize,
handle_data=train.handle_data,
data_frequency='daily',
capital_base=gv.capital_base)
# Run algorithm
perf = algo.run(data_train)
# Train neural network with produced training set
Q_update()
# Update epsilon
gv.epsilon = pow(gv.epsilon, iter + 2)
def test_empty_pipeline(self):
# For ensuring we call before_trading_start.
count = [0]
def initialize(context):
pipeline = attach_pipeline(Pipeline(), 'test')
vwap = VWAP(window_length=10)
pipeline.add(vwap, 'vwap')
# Nothing should have prices less than 0.
pipeline.set_screen(vwap < 0)
def handle_data(context, data):
pass
def before_trading_start(context, data):
context.results = pipeline_output('test')
self.assertTrue(context.results.empty)
count[0] += 1
algo = TradingAlgorithm(
initialize=initialize,
handle_data=handle_data,
before_trading_start=before_trading_start,
data_frequency='daily',
get_pipeline_loader=lambda column: self.pipeline_loader,
start=self.dates[0],
end=self.dates[-1],
env=self.env,
)
algo.run(
FakeDataPortal(),
overwrite_sim_params=False,
)
self.assertTrue(count[0] > 0)
def worker(args):
"""thread worker function"""
period, bottom, top, shift, max_long, prob_window, prob = args
algo_obj = TradingAlgorithm(initialize=initialize,
handle_data=handle_data,
analyze=analyze,
sim_params=sim_params)
algo_obj.RSI_PERIOD = period
algo_obj.RSI_BOTTOM, algo_obj.RSI_TOP, algo_obj.RSI_SHIFT = bottom, top, shift
algo_obj.MAX_LONG, algo_obj.MAX_SHORT = max_long, max_long
algo_obj.PROB_WINDOW = prob_window
algo_obj.MIN_PROB = prob
perf = algo_obj.run(data, overwrite_sim_params=False)
print(("Returns: {0:.2f}% MaxDrawdown: {1:.2f}% " +
"Benchmark: {2:.2f}% Args: {3}").format(
perf.algorithm_period_return[-1] * 100,
perf.max_drawdown[-1] * 100,
perf.benchmark_period_return[-1] * 100, args))
return
def test_schedule_function(self):
date_rules = DateRuleFactory
time_rules = TimeRuleFactory
def incrementer(algo, data):
algo.func_called += 1
self.assertEqual(
algo.get_datetime().time(),
datetime.time(hour=14, minute=31),
)
def initialize(algo):
algo.func_called = 0
algo.days = 1
algo.date = None
algo.schedule_function(
func=incrementer,
date_rule=date_rules.every_day(),
time_rule=time_rules.market_open(),
)
def handle_data(algo, data):
if not algo.date:
algo.date = algo.get_datetime().date()
if algo.date < algo.get_datetime().date():
algo.days += 1
algo.date = algo.get_datetime().date()
algo = TradingAlgorithm(
initialize=initialize,
handle_data=handle_data,
sim_params=self.sim_params,
)
algo.run(self.source)
self.assertEqual(algo.func_called, algo.days)
# 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()
# Note: this if-block should be removed if running
# this algorithm on quantopian.com
if __name__ == '__main__':
# Set the simulation start and end dates.
start = datetime(2004, 1, 1, 0, 0, 0, 0, pytz.utc)
end = datetime(2008, 1, 1, 0, 0, 0, 0, pytz.utc)
# Load price data from yahoo.
data = load_from_yahoo(stocks=STOCKS, indexes={}, start=start, end=end)
data = data.dropna()
# Create and run the algorithm.
olmar = TradingAlgorithm(handle_data=handle_data,
initialize=initialize,
identifiers=STOCKS)
results = olmar.run(data)
# Plot the portfolio data.
analyze(results=results)
def test_volshare_slippage(self):
# verify order -> transaction -> portfolio position.
# --------------
test_algo = TradingAlgorithm(
script="""
from zipline.api import *
def initialize(context):
model = slippage.VolumeShareSlippage(
volume_limit=.3,
price_impact=0.05
)
set_slippage(model)
set_commission(commission.PerShare(0.02))
context.count = 2
context.incr = 0
def handle_data(context, data):
if context.incr < context.count:
# order small lots to be sure the
# order will fill in a single transaction
order(0, 5000)
record(price=data[0].price)
record(volume=data[0].volume)
record(incr=context.incr)
context.incr += 1
""",
sim_params=self.sim_params,
)
set_algo_instance(test_algo)
self.zipline_test_config['algorithm'] = test_algo
self.zipline_test_config['trade_count'] = 100
# 67 will be used inside assert_single_position
# to confirm we have as many transactions as expected.
# The algo places 2 trades of 5000 shares each. The trade
# events have volume ranging from 100 to 950. The volume cap
# of 0.3 limits the trade volume to a range of 30 - 316 shares.
# The spreadsheet linked below calculates the total position
# size over each bar, and predicts 67 txns will be required
# to fill the two orders. The number of bars and transactions
# differ because some bars result in multiple txns. See
# spreadsheet for details:
# https://www.dropbox.com/s/ulrk2qt0nrtrigb/Volume%20Share%20Worksheet.xlsx
self.zipline_test_config['expected_transactions'] = 67
# self.zipline_test_config['transforms'] = \
# test_algo.transform_visitor.transforms.values()
zipline = simfactory.create_test_zipline(
**self.zipline_test_config)
output, _ = assert_single_position(self, zipline)
# confirm the slippage and commission on a sample
# transaction
per_share_commish = 0.02
perf = output[1]
transaction = perf['daily_perf']['transactions'][0]
commish = transaction['amount'] * per_share_commish
self.assertEqual(commish, transaction['commission'])
self.assertEqual(2.029, transaction['price'])
def test_api_symbol(self):
algo = TradingAlgorithm(script=api_symbol_algo)
algo.run(self.df)
def test_api_calls_string(self):
algo = TradingAlgorithm(script=api_algo)
algo.run(self.df)
def test_api_calls(self):
algo = TradingAlgorithm(initialize=initialize_api,
handle_data=handle_data_api)
algo.run(self.df)
def test_noop_string(self):
algo = TradingAlgorithm(script=noop_algo)
algo.run(self.df)
def test_noop(self):
algo = TradingAlgorithm(initialize=initialize_noop,
handle_data=handle_data_noop)
algo.run(self.df)
def form_valid(self, form):
# SMA data prepare
sma = form.save(commit=False)
name = form.cleaned_data['name']
code = form.cleaned_data['code']
market = form.cleaned_data['market']
short_ma = form.cleaned_data['short_ma']
long_ma = form.cleaned_data['long_ma']
buy_quantity = form.cleaned_data['buy_quantity']
sell_quantity = form.cleaned_data['sell_quantity']
capital_base = form.cleaned_data['capital_base']
start_date = form.cleaned_data['start_date']
end_date = form.cleaned_data['end_date']
# Backtesting
def initialize(context):
context.i = 0
context.symbol = symbol(name)
context.hold = False
def handle_data(context, data):
context.i += 1
if context.i < long_ma:
return
buy = False
sell = False
short_mavg = data.history(context.symbol, 'price', short_ma,
'1d').mean()
long_mavg = data.history(context.symbol, 'price', long_ma,
'1d').mean()
if short_mavg > long_mavg and context.hold == False:
order(context.symbol, buy_quantity)
context.hold = True
buy = True
elif short_mavg < long_mavg and context.hold == True:
order(context.symbol, -sell_quantity)
context.hold = False
sell = True
record(Price=data.current(context.symbol,'price'),short_mavg=short_mavg, \
long_mavg=long_mavg,buy=buy,sell=sell)
# Data preparing
df = fdr.DataReader(code, start_date, end_date)
data = df[['Close']]
data.columns = [name]
xkrx = get_calendar('XKRX')
# Call backtesting
if market == 'KOSPI' or market == 'KOSDAQ':
algo = TradingAlgorithm(sim_params=create_simulation_parameters(capital_base=capital_base,\
trading_calendar=xkrx),initialize=initialize,handle_data=handle_data,trading_calendar=xkrx)
result = algo.run(data)
elif market == 'NASDAQ':
algo = TradingAlgorithm(sim_params=create_simulation_parameters(capital_base=capital_base),\
initialize=initialize,handle_data=handle_data)
result = algo.run(data)
# Quantile plot and save
now = timezone.now()
file_home = '/home/seungyong/FindMore/static/'
bt_file_name = name + '_' + str(now) + '_SMA-BT.png'
bt_file_path = file_home + bt_file_name
bt_static_path = '/static/' + bt_file_name
pv_file_name = name + '_' + str(now) + '_SMA-PV.png'
pv_file_path = file_home + pv_file_name
pv_static_path = '/static/' + pv_file_name
plt.plot(result.index, result.Price)
plt.plot(result.index, result.short_mavg)
plt.plot(result.index, result.long_mavg)
plt.legend(loc='best')
if sell_quantity > 0:
plt.plot(result.loc[result.buy == True].index,
result.short_mavg[result.buy == True],
'^',
color='r',
markersize=5)
plt.plot(result.loc[result.sell == True].index,
result.short_mavg[result.sell == True],
'v',
color='g',
markersize=5)
elif sell_quantity == 0:
plt.plot(result.loc[result.buy == True].index,
result.short_mavg[result.buy == True],
'^',
color='r',
markersize=5)
plt.savefig(bt_file_path, dpi=150)
plt.clf()
plt.plot(result.index, result.portfolio_value)
plt.savefig(pv_file_path, dpi=150)
plt.clf()
# SMA result insert
sma.name = name
sma.code = code
sma.market = market
sma.start_date = start_date
sma.end_date = end_date
sma.short_ma = short_ma
sma.long_ma = long_ma
sma.buy_quantity = buy_quantity
sma.sell_quantity = sell_quantity
sma.capital_base = capital_base
sma.last_pv = result.portfolio_value[-1]
sma.last_value = result.ending_value[-1]
sma.last_cash = result.ending_cash[-1]
sma.capital_used = sum(result.capital_used)
if result.positions.values[-1] == []:
sma.shares = 0
sma.expected_return = (
(result.ending_cash[-1] / capital_base) - 1) * 100
elif result.positions.values[-1] != []:
sma.shares = result.positions.values[-1][0]['amount']
sma.expected_return = (
(result.portfolio_value[-1] / capital_base) - 1) * 100
sma.bt_path = bt_static_path
sma.pv_path = pv_static_path
form.save()
return super(SMACreateView, self).form_valid(form)
year += 1
data[each] = result
columns = ['date'].extend(column)
return DataFrame(data, index=date, columns=None)
# Define algorithm
def initialize(context):
pass
def handle_data(context, data):
order('Close', 10)
record(Close=data['Close'])
data = generate_data('sh600000', '2010-01-01', '2015-01-01',
['open', 'high', 'low', 'close'])
print data
# Create algorithm object passing in initialize and
# handle_data functions
algo_obj = TradingAlgorithm(initialize=initialize, handle_data=handle_data)
# Run algorithm
perf_manual = algo_obj.run(data)
# Print
perf_manual.to_csv('output.csv')
def before_trading_start(context, data):
context.pipeline_data = pipeline_output('my_pipeline')
#print("pipeline_data",type(context.pipeline_data))
#print(context.portfolio)
pass
#################################################################################################################################################
for i in range(0, len(g_models)):
#for i in range(0,4):
g_idx = i
algor_obj = TradingAlgorithm(
initialize=initialize,
handle_data=handle_data,
before_trading_start=before_trading_start,
sim_params=sim_params,
env=trading_environment,
data_frequency='daily',
get_pipeline_loader=choose_loader,
)
result = algor_obj.run(data)
#result.to_csv("result.csv", encoding="utf-8")
#print(result)
# for index,values in result.iterrows():
# print index
# for t in values['transactions']:
# print t
# print "++++++++++++++++++++++++++++++++++++++++++++"
def _run(handle_data, initialize, before_trading_start, analyze, algofile,
algotext, defines, data_frequency, capital_base, data, bundle,
bundle_timestamp, start, end, algo_params, bm_symbol, output,
print_algo, local_namespace, environ):
"""Run a backtest for the given algorithm.
This is shared between the cli and :func:`zipline.run_algo`.
"""
if algotext is not None:
if local_namespace:
ip = get_ipython() # noqa
namespace = ip.user_ns
else:
namespace = {}
for assign in defines:
try:
name, value = assign.split('=', 2)
except ValueError:
raise ValueError(
'invalid define %r, should be of the form name=value' %
assign, )
try:
# evaluate in the same namespace so names may refer to
# eachother
namespace[name] = eval(value, namespace)
except Exception as e:
raise ValueError(
'failed to execute definition for name %r: %s' %
(name, e), )
elif defines:
raise _RunAlgoError(
'cannot pass define without `algotext`',
"cannot pass '-D' / '--define' without '-t' / '--algotext'",
)
else:
namespace = {}
if algofile is not None:
algotext = algofile.read()
if print_algo:
if PYGMENTS:
highlight(
algotext,
PythonLexer(),
TerminalFormatter(),
outfile=sys.stdout,
)
else:
click.echo(algotext)
if bundle is not None:
bundle_data = load(
bundle,
environ,
bundle_timestamp,
)
prefix, connstr = re.split(
r'sqlite:///',
str(bundle_data.asset_finder.engine.url),
maxsplit=1,
)
if prefix:
raise ValueError(
"invalid url %r, must begin with 'sqlite:///'" %
str(bundle_data.asset_finder.engine.url), )
env = TradingEnvironment(bm_symbol=bm_symbol, asset_db_path=connstr)
#env = TradingEnvironment(bm_symbol='000001',
# exchange_tz='Asia/Shanghai',
# trading_calendar=get_calendar('SHSZ'),
# asset_db_path=connstr)
first_trading_day =\
bundle_data.equity_minute_bar_reader.first_trading_day
data = DataPortal(
env.asset_finder,
get_calendar("SHSZ"),
first_trading_day=first_trading_day,
equity_minute_reader=bundle_data.equity_minute_bar_reader,
equity_daily_reader=bundle_data.equity_daily_bar_reader,
adjustment_reader=bundle_data.adjustment_reader,
)
pipeline_loader = USEquityPricingLoader(
bundle_data.equity_daily_bar_reader,
bundle_data.adjustment_reader,
)
def choose_loader(column):
if column in USEquityPricing.columns:
return pipeline_loader
raise ValueError("No PipelineLoader registered for column %s." %
column)
else:
env = TradingEnvironment(environ=environ)
choose_loader = None
perf = TradingAlgorithm(
namespace=namespace,
#capital_base=capital_base,
algo_params=algo_params,
env=env,
get_pipeline_loader=choose_loader,
sim_params=create_simulation_parameters(
start=start,
end=end,
capital_base=capital_base,
data_frequency=data_frequency,
trading_calendar=get_calendar("SHSZ"),
),
**{
'initialize': initialize,
'handle_data': handle_data,
'before_trading_start': before_trading_start,
'analyze': analyze,
} if algotext is None else {
'algo_filename': getattr(algofile, 'name', '<algorithm>'),
'script': algotext,
}).run(
data,
overwrite_sim_params=False,
)
if output == '-':
click.echo(str(perf))
elif output != os.devnull: # make the zipline magic not write any data
perf.to_pickle(output)
return perf
