def test_subscribe_bars(self, name, datastore):
start_date = date(2011, 1, 1)
end_date = date(2011, 1, 5)
sub_key = HistDataSubscriptionKey(
inst_id=10,
provider_id=Broker.IB,
subscription_type=BarSubscriptionType(bar_type=BarType.Time,
bar_size=BarSize.D1),
from_date=start_date,
to_date=end_date)
date_val = start_date
expect_val = []
for i in range(1, 5):
persistable = Bar(
timestamp=DateUtils.date_to_unixtimemillis(date_val),
type=BarType.Time,
size=BarSize.D1,
inst_id=10,
open=18 + i,
high=19 + i,
low=17 + i,
close=17.5 + i,
vol=100)
datastore.save_bar(persistable)
expect_val.append(persistable)
date_val = date_val + timedelta(days=1)
actual_val = datastore.load_mktdata(sub_key)
self.assertEqual(expect_val, actual_val)
def test_strategy(self, name, datastore):
instrument = 0
dates = [datetime(2000, 1, 1), datetime(2015, 1, 1)]
conf = BacktestingConfig(stg_id="sma",
portfolio_id='test',
instrument_ids=[instrument],
subscription_types=[
BarSubscriptionType(bar_type=BarType.Time,
bar_size=BarSize.D1)
],
from_date=dates[0],
to_date=dates[-1],
broker_id=Broker.Simulator,
feed_id=Feed.PandasMemory)
stg = Strategy(stg_id='st1')
# nos = NewOrderRequest(cl_id='test', cl_ord_id=1, inst_id=1, action=OrdAction.BUY, type=OrdType.LIMIT, qty=1000,
# limit_price=18.5)
#
# order = Order(nos=nos)
# stg.ord_reqs[nos.cl_ord_id] = nos
# stg.orders[order.cl_ord_id] = order
# stg.add_position(nos.inst_id, nos.cl_id, nos.cl_ord_id, nos.qty)
# stg.update_position_price(time=0, inst_id=nos.inst_id, price=100)
DataStoreTest.save_load(name, stg, datastore, datastore.save_strategy,
'strategies')
def __init__(self, id=None, stg_id=None, stg_cls=None, portfolio_id=None,
instrument_ids=None,
subscription_types=None,
feed_id=None, broker_id=None, stg_configs=None,
ref_data_mgr_type=RefDataManager.InMemory,
clock_type = Clock.Simulation,
persistence_config=None,
provider_configs=None):
super(TradingConfig, self).__init__(id = id if id else stg_id, ref_data_mgr_type=ref_data_mgr_type, clock_type=clock_type, persistence_config= persistence_config, provider_configs=provider_configs)
self.stg_id = stg_id
self.stg_cls = stg_cls
self.portfolio_id = portfolio_id
self.instrument_ids = instrument_ids
if not isinstance(self.instrument_ids, (list, tuple)):
self.instrument_ids = [self.instrument_ids]
self.subscription_types = subscription_types if subscription_types else [
BarSubscriptionType(bar_type=BarType.Time, bar_size=BarSize.D1)]
if not isinstance(self.subscription_types, (list, tuple)):
self.subscription_types = [self.subscription_types]
self.feed_id = feed_id
self.broker_id = broker_id
self.clock_type = clock_type
self.stg_configs = stg_configs
def test_trading_config(self, name, serializer):
instrument = 0
dates = [datetime.datetime(2000, 1, 1), datetime.datetime(2015, 1, 1)]
config = BacktestingConfig(stg_id="sma", portfolio_id='test',
instrument_ids=[instrument],
subscription_types=[BarSubscriptionType(bar_type=BarType.Time, bar_size=BarSize.D1)],
from_date=dates[0], to_date=dates[-1],
broker_id=Broker.Simulator,
feed_id=Feed.PandasMemory)
SerializerTest.ser_deser(name, serializer, config)
def test_trading_config(self, name, datastore):
instrument = 0
dates = [datetime(2000, 1, 1), datetime(2015, 1, 1)]
persistable = BacktestingConfig(stg_id="sma",
portfolio_id='test',
instrument_ids=[instrument],
subscription_types=[
BarSubscriptionType(
bar_type=BarType.Time,
bar_size=BarSize.D1)
],
from_date=dates[0],
to_date=dates[-1],
broker_id=Broker.Simulator,
feed_id=Feed.PandasMemory)
DataStoreTest.save_load(name, persistable, datastore,
datastore.save_config, 'configs')
def main():
symbols = ['XXX', 'YYY']
inst_df = build_inst_dataframe_from_list(symbols)
ccy_df = pd.DataFrame({
"ccy_id": ["USD", "HKD"],
"name": ["US Dollar", "HK Dollar"]
})
exchange_df = pd.DataFrame({
"exch_id": ["NYSE"],
"name": ["New York Stock Exchange"]
})
mgr = MockRefDataManager(inst_df=inst_df,
ccy_df=ccy_df,
exch_df=exchange_df)
portfolio = Portfolio(cash=100000)
start_date = datetime(2000, 1, 1)
num_days = 300
dates = [start_date + timedelta(days=i) for i in range(num_days)]
drift = lambda x, t: 0.02 * x
diffusion = lambda x, t: 0.3 * x
ou_k = 2.0
ou_theta = 0.25
ou_eta = 0.08
ou_drift = lambda x, t: ou_k * (ou_theta - x)
ou_diffusion = lambda x, t: ou_eta * x
sim_asset_paths = euler(drift, diffusion, 100.0, 1.0, num_days, 10)
sim_spread_paths = euler(ou_drift, ou_diffusion, 0.1, 1.0, num_days, 10)
asset_x = sim_asset_paths[1, :]
spread = sim_spread_paths[1, :]
asset_y = np.exp(np.log(asset_x) + spread)
asset_x_df = pd.DataFrame({
"dates": dates,
"Open": asset_x,
"High": asset_x,
"Low": asset_x,
"Close": asset_x,
"Volume": 10000 * np.ones(num_days)
})
asset_y_df = pd.DataFrame({
"dates": dates,
"Open": asset_y,
"High": asset_y,
"Low": asset_y,
"Close": asset_y,
"Volume": 10000 * np.ones(num_days)
})
asset_x_df = asset_x_df.set_index(keys="dates")
asset_y_df = asset_y_df.set_index(keys="dates")
dict_df = {'XXX': asset_x_df, 'YYY': asset_y_df}
feed = PandasMemoryDataFeed(dict_df, ref_data_mgr=mgr)
broker = Simulator()
config = BacktestingConfig(stg_id="pairou",
portfolio_id='test',
instrument_ids=[0, 1],
subscription_types=[
BarSubscriptionType(bar_type=BarType.Time,
bar_size=BarSize.D1)
],
from_date=dates[0],
to_date=dates[-1],
broker_id=Simulator.ID,
feed_id=PandasMemoryDataFeed.ID)
ou_params = {"k": ou_k, "theta": ou_theta, "eta": ou_eta}
strategy = PairTradingWithOUSpread("pairou",
ou_params=ou_params,
gamma=1.0,
trading_config=config,
ref_data_mgr=mgr)
runner = BacktestRunner(strategy)
runner.start()
print portfolio.get_result()
# pyfolio
rets = strategy.get_portfolio().get_return()
# import pyfolio as pf
# pf.create_returns_tear_sheet(rets)
# pf.create_full_tear_sheet(rets)
# build in plot
plotter = StrategyPlotter(strategy)
plotter.plot(instrument=0)
def test(self):
backtest_config0 = BacktestingConfig(
id="down2%-test-config",
stg_id="down2%",
stg_cls='algotrader.strategy.down_2pct_strategy.Down2PctStrategy',
portfolio_id='test',
portfolio_initial_cash=100000,
instrument_ids=[4],
subscription_types=[
BarSubscriptionType(bar_type=BarType.Time, bar_size=BarSize.D1)
],
from_date=date(1993, 1, 1),
to_date=date(2017, 1, 1),
broker_id=Broker.Simulator,
feed_id=Feed.CSV,
stg_configs={'qty': 1000},
ref_data_mgr_type=RefDataManager.InMemory,
persistence_config=PersistenceConfig(),
provider_configs=CSVFeedConfig(path='data/tradedata'))
app_context0 = ApplicationContext(app_config=backtest_config0)
runner = BacktestRunner(isplot=False)
runner.start(app_context0)
total_begin_result = runner.initial_result
total_end_result = runner.portfolio.get_result()
backtest_config1 = BacktestingConfig(
id="down2%-test-config_1",
stg_id="down2%_1",
stg_cls='algotrader.strategy.down_2pct_strategy.Down2PctStrategy',
portfolio_id='test_1',
portfolio_initial_cash=100000,
instrument_ids=[4],
subscription_types=[
BarSubscriptionType(bar_type=BarType.Time, bar_size=BarSize.D1)
],
from_date=date(1993, 1, 1),
to_date=date(2008, 1, 1),
broker_id=Broker.Simulator,
feed_id=Feed.CSV,
stg_configs={'qty': 1000},
ref_data_mgr_type=RefDataManager.InMemory,
persistence_config=PersistenceConfig(
seq_ds_id=DataStore.InMemoryDB,
seq_persist_mode=PersistenceMode.Batch,
ts_ds_id=DataStore.InMemoryDB,
ts_persist_mode=PersistenceMode.Batch,
trade_ds_id=DataStore.InMemoryDB,
trade_persist_mode=PersistenceMode.Batch),
provider_configs=CSVFeedConfig(path='data/tradedata'))
app_context1 = ApplicationContext(app_config=backtest_config1)
runner1 = BacktestRunner(isplot=False)
runner1.start(app_context1)
part1_begin_result = runner1.initial_result
part1_end_result = runner1.portfolio.get_result()
backtest_config2 = BacktestingConfig(
id="down2%-test-config_1",
stg_id="down2%_1",
stg_cls='algotrader.strategy.down_2pct_strategy.Down2PctStrategy',
portfolio_id='test_1',
portfolio_initial_cash=100000,
instrument_ids=[4],
subscription_types=[
BarSubscriptionType(bar_type=BarType.Time, bar_size=BarSize.D1)
],
from_date=date(2008, 1, 1),
to_date=date(2017, 1, 1),
broker_id=Broker.Simulator,
feed_id=Feed.CSV,
stg_configs={'qty': 1000},
ref_data_mgr_type=RefDataManager.InMemory,
persistence_config=PersistenceConfig(
seq_ds_id=DataStore.InMemoryDB,
seq_persist_mode=PersistenceMode.Batch,
ts_ds_id=DataStore.InMemoryDB,
ts_persist_mode=PersistenceMode.Batch,
trade_ds_id=DataStore.InMemoryDB,
trade_persist_mode=PersistenceMode.Batch),
provider_configs=CSVFeedConfig(path='data/tradedata'))
app_context2 = ApplicationContext(app_config=backtest_config2)
app_context2.start()
db = app_context2.get_seq_data_store()
runner2 = BacktestRunner(isplot=False)
runner2.start(app_context2)
part2_begin_result = runner2.initial_result
part2_end_result = runner2.portfolio.get_result()
self.assertEqual(total_begin_result, part1_begin_result)
self.assertEqual(part1_end_result, part2_begin_result)
self.assertEqual(total_end_result, part2_end_result)
print "total begin = %s" % total_begin_result
print "total end = %s" % total_end_result
print "part1 begin = %s" % part1_begin_result
print "part1 end = %s" % part1_end_result
print "part2 begin = %s" % part2_begin_result
print "part2 end = %s" % part2_end_result
db.remove_database()
def test_with_sma(self):
sigma = 0.3
x0 = 100
dt = 1. / 252
dW = np.random.normal(0, math.sqrt(dt),
TestCompareWithFunctionalBacktest.num_days)
asset = []
asset.append(x0)
for i in xrange(1, TestCompareWithFunctionalBacktest.num_days):
xprev = asset[-1]
x = xprev + xprev * 0.02 * dt + sigma * xprev * dW[i]
asset.append(x)
instrument = 0
lot_size = 10000
symbols = ['SPY', 'VXX', 'XLV', 'XIV']
dict_df = {}
self.df = self.get_df(asset=asset)
for symbol in symbols:
dict_df[symbol] = self.df
config = BacktestingConfig(
id=None,
stg_id='sma',
portfolio_id='test2',
instrument_ids=[instrument],
subscription_types=[
BarSubscriptionType(bar_type=BarType.Time, bar_size=BarSize.D1)
],
from_date=TestCompareWithFunctionalBacktest.dates[0],
to_date=TestCompareWithFunctionalBacktest.dates[-1],
broker_id=Broker.Simulator,
feed_id=Feed.PandasMemory,
stg_configs={'qty': lot_size},
ref_data_mgr_type=None,
persistence_config=None,
provider_configs=PandasMemoryDataFeedConfig(dict_df=dict_df))
self.init_context(symbols=symbols, asset=asset, app_config=config)
close = self.app_context.inst_data_mgr.get_series("Bar.%s.Time.86400" %
instrument)
close.start(self.app_context)
strategy = SMAStrategy("sma", config.stg_configs)
strategy.start(self.app_context)
rets = strategy.get_portfolio().get_return()
bt_result = strategy.get_portfolio().get_result()
sma10 = talib.SMA(self.df.Close.values, 10)
sma25 = talib.SMA(self.df.Close.values, 25)
signal = pd.Series(1 * (sma10 > sma25), index=self.df.index)
cash = []
stock_value = []
cash.append(TestCompareWithFunctionalBacktest.init_cash)
stock_value.append(0)
for i in xrange(1, signal.shape[0]):
cash.append(cash[-1] - lot_size *
(signal[i] - signal[i - 1]) * self.df['Close'][i])
stock_value.append(lot_size * signal[i] * self.df['Close'][i])
target_port = pd.DataFrame({"cash": cash, "stock_value": stock_value})
target_port[
"total_equity"] = target_port["cash"] + target_port["stock_value"]
target_port["return"] = target_port["total_equity"].pct_change()
try:
np.testing.assert_almost_equal(target_port["return"].values[1:],
rets.values, 5)
except AssertionError as e:
self.fail(e.message)
finally:
strategy.stop()
def test_multi_subscriptions(self, name, datastore):
start_date = date(2011, 1, 1)
end_date = date(2011, 1, 5)
sub_key1 = HistDataSubscriptionKey(
inst_id=99,
provider_id=Broker.IB,
subscription_type=BarSubscriptionType(bar_type=BarType.Time,
bar_size=BarSize.D1),
from_date=start_date,
to_date=end_date)
sub_key2 = HistDataSubscriptionKey(
inst_id=99,
provider_id=Broker.IB,
subscription_type=QuoteSubscriptionType(),
from_date=start_date,
to_date=end_date)
sub_key3 = HistDataSubscriptionKey(
inst_id=99,
provider_id=Broker.IB,
subscription_type=TradeSubscriptionType(),
from_date=start_date,
to_date=end_date)
expect_val = []
#out of range
persistable = Bar(timestamp=DateUtils.date_to_unixtimemillis(
date(2010, 12, 31)),
type=BarType.Time,
size=BarSize.D1,
inst_id=99,
open=18,
high=19,
low=17,
close=17.5,
vol=100)
datastore.save_bar(persistable)
persistable = Bar(timestamp=DateUtils.date_to_unixtimemillis(
date(2011, 1, 1)),
type=BarType.Time,
size=BarSize.D1,
inst_id=99,
open=28,
high=29,
low=27,
close=27.5,
vol=100)
datastore.save_bar(persistable)
expect_val.append(persistable)
persistable = Trade(timestamp=DateUtils.date_to_unixtimemillis(
date(2011, 1, 2)),
price=20,
size=200,
inst_id=99)
datastore.save_trade(persistable)
expect_val.append(persistable)
persistable = Trade(timestamp=DateUtils.date_to_unixtimemillis(
date(2011, 1, 3)),
price=30,
size=200,
inst_id=99)
datastore.save_trade(persistable)
expect_val.append(persistable)
# not same instrument
persistable = Quote(timestamp=DateUtils.date_to_unixtimemillis(
date(2011, 1, 3)),
bid=18,
ask=19,
bid_size=200,
ask_size=500,
inst_id=11)
datastore.save_quote(persistable)
persistable = Quote(timestamp=DateUtils.date_to_unixtimemillis(
date(2011, 1, 4)),
bid=18,
ask=19,
bid_size=200,
ask_size=500,
inst_id=99)
datastore.save_quote(persistable)
expect_val.append(persistable)
# out of range
persistable = Quote(timestamp=DateUtils.date_to_unixtimemillis(
date(2011, 1, 5)),
bid=28,
ask=29,
bid_size=200,
ask_size=500,
inst_id=99)
datastore.save_quote(persistable)
actual_val = datastore.load_mktdata(sub_key1, sub_key2, sub_key3)
self.assertEqual(expect_val, actual_val)
