def setUp(self): self.app_context = ApplicationContext(config=empty_config) self.app_context.start() self.db = InMemoryDataStore() self.db.start(self.app_context)
def init(self): logger.info("starting ATS") self.app_config = self.app_config self.app_context = ApplicationContext(app_config=self.app_config) self.app_context.start() self.portfolio = self.app_context.portf_mgr.get_or_new_portfolio( self.app_config.portfolio_id, self.app_config.portfolio_initial_cash) self.app_context.add_startable(self.portfolio) self.strategy = self.app_context.stg_mgr.get_or_new_stg( self.app_config) self.app_context.add_startable(self.strategy)
def main(): backtest_config = 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=[1], subscription_types=[ BarSubscriptionType(bar_type=BarType.Time, bar_size=BarSize.D1) ], from_date=date(2010, 1, 1), to_date=date.today(), broker_id=Broker.Simulator, feed_id=Feed.CSV, stg_configs={'qty': 1000}, ref_data_mgr_type=RefDataManager.DB, persistence_config=backtest_mongo_persistance_config(), provider_configs=[ MongoDBConfig(), CSVFeedConfig(path='../../data/tradedata') ]) app_context = ApplicationContext(app_config=backtest_config) BacktestRunner(True).start(app_context)
def main(): config = Config(load_from_yaml("../../config/live_ib.yaml"), load_from_yaml("../../config/down2%.yaml")) app_context = ApplicationContext(config=config) ATSRunner().start(app_context)
def new_app_context(self): name = "test" create_at_start = True delete_at_stop = False app_config = ApplicationConfig("app", None, Clock.Simulation, PersistenceConfig( ref_ds_id=DataStore.InMemoryDB, ref_persist_mode=PersistenceMode.RealTime, trade_ds_id=DataStore.InMemoryDB, trade_persist_mode=PersistenceMode.RealTime, ts_ds_id=DataStore.InMemoryDB, ts_persist_mode=PersistenceMode.RealTime, seq_ds_id=DataStore.InMemoryDB, seq_persist_mode=PersistenceMode.RealTime), InMemoryStoreConfig(file="%s_db.p" % name, create_at_start=create_at_start, delete_at_stop=delete_at_stop)) app_context = ApplicationContext(app_config=app_config) app_context.start() return app_context
def main(): config = Config(load_from_yaml("../../config/data_import.yaml"), {"Application": { "feedId": "Yahoo" }}) app_context = ApplicationContext(config=config) MktDataImporter().start(app_context)
def main(): config = Config(load_from_yaml("../../config/backtest.yaml"), load_from_yaml("../../config/down2%.yaml")) app_context = ApplicationContext(config=config) BacktestRunner().start(app_context)
def create_app_context(self, override): return ApplicationContext(config=Config( load_from_yaml("../config/backtest.yaml"), load_from_yaml("../config/down2%.yaml"), test_override, StrategyPersistenceTest.stg_override, override))
def setUp(self): self.app_context = ApplicationContext() # self.app_context.inst_data_mgr.clear() self.exec_handler = SimulatorTest.ExecHandler() self.app_context.order_mgr = self.exec_handler self.simulator = Simulator() self.simulator.start(app_context=self.app_context)
def get_default_app_context(): config = MongoDBConfig() persistence_config = PersistenceConfig( None, DataStore.Mongo, PersistenceMode.Batch, DataStore.Mongo, PersistenceMode.Batch, DataStore.Mongo, PersistenceMode.Batch, DataStore.Mongo, PersistenceMode.Batch) app_config = ApplicationConfig(None, None, None, persistence_config, config) return ApplicationContext(app_config=app_config)
def create_app_context(self, conf): return ApplicationContext(config=Config( load_from_yaml("../config/backtest.yaml"), load_from_yaml("../config/down2%.yaml"), test_override, { "Application": { "ceateAtStart": True, "deleteDBAtStop": False, "persistenceMode": "RealTime" } }, conf))
def init_context(self, symbols, asset, config): self.app_context = ApplicationContext(config=config) 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"]}) self.app_context.start() datastore = self.app_context.get_data_store() load_exch_from_df(datastore, exchange_df) load_ccy_from_df(datastore, ccy_df) load_inst_from_df(datastore, inst_df) self.portfolio = self.app_context.portf_mgr.new_portfolio(portf_id='test2', initial_cash=TestCompareWithFunctionalBacktest.init_cash) self.portfolio.start(self.app_context)
def app_context(): persistence_config = PersistenceConfig(None, DataStore.Mongo, PersistenceMode.RealTime, DataStore.Mongo, PersistenceMode.RealTime, DataStore.Mongo, PersistenceMode.RealTime, DataStore.Mongo, PersistenceMode.RealTime) app_config = ApplicationConfig(id=None, ref_data_mgr_type=RefDataManager.DB, clock_type=Clock.RealTime, persistence_config=persistence_config, provider_configs=[MongoDBConfig(), IBConfig(client_id=2, use_gevent=True)]) app_context = ApplicationContext(app_config=app_config) return app_context
def test_loaded_bar(self, feed_id, subscription_types): app_context = ApplicationContext(config=config) app_context.start() feed = app_context.provider_mgr.get(feed_id) feed.start(app_context) # logger.setLevel(logging.DEBUG) eventLogger = EventLogger() eventLogger.start(app_context) instruments = app_context.ref_data_mgr.get_insts_by_ids( ["SPY@NYSEARCA"]) for sub_req in build_subscription_requests(feed_id, instruments, subscription_types, 20100101, 20170101): feed.subscribe_mktdata(sub_req) self.assertTrue(eventLogger.count[Bar] > 0) self.assertTrue(eventLogger.count[Trade] == 0) self.assertTrue(eventLogger.count[Quote] == 0)
def get_default_app_context(): config = MongoDBConfig() persistence_config = PersistenceConfig( None, DataStore.Mongo, PersistenceMode.RealTime, DataStore.Mongo, PersistenceMode.RealTime, DataStore.Mongo, PersistenceMode.RealTime, DataStore.Mongo, PersistenceMode.RealTime) app_config = ApplicationConfig("InstrumentImport", RefDataManager.DB, Clock.Simulation, persistence_config, config) return ApplicationContext(app_config=app_config)
def init(self): logger.info("starting ATS") self.app_config = self.app_config self.app_context = ApplicationContext(app_config=self.app_config) self.app_context.start() self.portfolio = self.app_context.portf_mgr.get_or_new_portfolio(self.app_config.portfolio_id, self.app_config.portfolio_initial_cash) self.app_context.add_startable(self.portfolio) self.strategy = self.app_context.stg_mgr.get_or_new_stg(self.app_config) self.app_context.add_startable(self.strategy)
def init_context(self, symbols, asset, app_config): self.app_context = ApplicationContext(app_config=app_config) 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"] }) ref_data_mgr = MockRefDataManager(inst_df=inst_df, ccy_df=ccy_df, exch_df=exchange_df) self.app_context.ref_data_mgr = ref_data_mgr self.app_context.start() self.portfolio = self.app_context.portf_mgr.new_portfolio( portf_id='test2', cash=TestCompareWithFunctionalBacktest.init_cash) self.portfolio.start(self.app_context)
class InMemoryDBTest(TestCase): def setUp(self): self.app_context = ApplicationContext(config=empty_config) self.app_context.start() self.db = InMemoryDataStore() self.db.start(self.app_context) def tearDown(self): self.db.remove_database() def test_save_and_load(self): inputs = [] for x in range(0, 10): data = sorted([random.randint(0, 100) for i in range(0, 4)]) bar = ModelFactory.build_bar(timestamp=x, inst_id="3", open=data[1], high=data[3], low=data[0], close=data[2], vol=random.randint(100, 1000)) inputs.append(bar) self.db.save_bar(bar) self.db.stop() self.db = InMemoryDataStore() self.db.start(self.app_context) bars = self.db.load_all('bars') bars = sorted(bars, key=lambda x: x.timestamp, reverse=False) self.assertEquals(10, len(bars)) for x in range(0, 10): self.assertEquals(inputs[x], bars[x])
def test_indicator(self, name, serializer): self.app_context = ApplicationContext() bar = self.app_context.inst_data_mgr.get_series("bar") sma = SMA(bar.name, 'close', 1, missing_value=0) t1 = datetime.datetime.now() t2 = t1 + datetime.timedelta(0, 3) t3 = t2 + datetime.timedelta(0, 3) bar.add({"timestamp": t1, "close": 2.0, "open": 0}) bar.add({"timestamp": t2, "close": 2.4, "open": 1.4}) bar.add({"timestamp": t3, "close": 2.8, "open": 1.8}) SerializerTest.ser_deser(name, serializer, sma)
def test_indicator(self, name, datastore): self.app_context = ApplicationContext() bar = self.app_context.inst_data_mgr.get_series("bar") sma = SMA(bar.name, 'close', 1, missing_value=0) t1 = datetime.now() t2 = t1 + timedelta(0, 3) t3 = t2 + timedelta(0, 3) bar.add({"timestamp": t1, "close": 2.0, "open": 0}) bar.add({"timestamp": t2, "close": 2.4, "open": 1.4}) bar.add({"timestamp": t3, "close": 2.8, "open": 1.8}) DataStoreTest.save_load(name, sma, datastore, datastore.save_time_series, 'time_series')
def main(): # logger.setLevel(logging.DEBUG) symbols = ["BAC", "F", "FCX", "TWTR", "VALE", "PFE", "NOK", "ABBV", "PBR", "MRK", "KMI", "MRO", "KEY", "AMX", "COP", "C", "CVX", "BSX", "RF", "CVS"] nyse_data = {} with pd.HDFStore('/Users/jchan/workspace/data/temp/NYSE.h5') as store: for s in store.keys(): sym = re.sub('/', '', s) df = store[s] df['DateTime'] = pd.to_datetime(df['Date'] + 'T' + df['Time']) df = df.set_index('DateTime') nyse_data[sym] = df # backtest_config = 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=[3348], # subscription_types=[ # BarSubscriptionType(bar_type=BarType.Time, bar_size=BarSize.D1)], # from_date=date(2010, 1, 1), to_date=date.today(), # broker_id=Broker.Simulator, # feed_id=Feed.CSV, # stg_configs={'qty': 1000}, # ref_data_mgr_type=RefDataManager.DB, # persistence_config= backtest_mongo_persistance_config(), # provider_configs=[MongoDBConfig(), CSVFeedConfig(path='../../data/tradedata')]) backtest_config = BacktestingConfig(id="test_alpha", stg_id="alpha2", stg_cls='algotrader.strategy.alpha_formula.AlphaFormula3', portfolio_id='test', portfolio_initial_cash=100000, instrument_ids=[1248, 450, 1225], subscription_types=[ BarSubscriptionType(bar_type=BarType.Time, bar_size=BarSize.M5)], from_date=date(2016, 9, 1), to_date=date.today(), broker_id=Broker.Simulator, feed_id=Feed.PandasMemory, stg_configs={'qty': 1000}, ref_data_mgr_type=RefDataManager.DB, persistence_config= backtest_mongo_persistance_config(), provider_configs=[MongoDBConfig, PandasMemoryDataFeedConfig(dict_df=nyse_data)]) app_context = ApplicationContext(app_config=backtest_config) BacktestRunner(True).start(app_context)
def init_context(self, symbols, asset, app_config): self.app_context = ApplicationContext(app_config=app_config) 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"]}) ref_data_mgr = MockRefDataManager(inst_df=inst_df, ccy_df=ccy_df, exch_df=exchange_df) self.app_context.ref_data_mgr = ref_data_mgr self.app_context.start() self.portfolio = self.app_context.portf_mgr.new_portfolio(portf_id='test2', cash=TestCompareWithFunctionalBacktest.init_cash) self.portfolio.start(self.app_context)
def setUp(self): persistence_config = PersistenceConfig( None, DataStore.InMemoryDB, PersistenceMode.Batch, DataStore.InMemoryDB, PersistenceMode.Batch, DataStore.InMemoryDB, PersistenceMode.Batch, DataStore.InMemoryDB, PersistenceMode.Batch) name = "test" create_at_start = True delete_at_stop = False app_config = ApplicationConfig( None, None, Clock.RealTime, persistence_config, InMemoryStoreConfig(file="%s_db.p" % name, create_at_start=create_at_start, delete_at_stop=delete_at_stop)) self.context = ApplicationContext(app_config=app_config) self.db = InMemoryDataStore() self.db.start(self.context)
def main(): persistence_config = PersistenceConfig( None, DataStore.Mongo, PersistenceMode.RealTime, DataStore.Mongo, PersistenceMode.RealTime, DataStore.Mongo, PersistenceMode.RealTime, DataStore.Mongo, PersistenceMode.RealTime) app_config = RealtimeMarketDataImporterConfig( None, feed_id=Broker.IB, instrument_ids=[3], subscription_types=[ BarSubscriptionType(bar_type=BarType.Time, bar_size=BarSize.D1) ], ref_data_mgr_type=RefDataManager.InMemory, clock_type=Clock.RealTime, persistence_config=persistence_config, provider_configs=[MongoDBConfig(), IBConfig(client_id=2)]) app_context = ApplicationContext(app_config=app_config) MktDataImporter().start(app_context)
def main(): broker_config = IBConfig(client_id=2) live_trading_config = LiveTradingConfig( id=None, stg_id="down2%", stg_cls='algotrader.strategy.down_2pct_strategy.Down2PctStrategy', portfolio_id='test', instrument_ids=[4], subscription_types=[ BarSubscriptionType(bar_type=BarType.Time, bar_size=BarSize.M1) ], feed_id=Broker.IB, broker_id=Broker.IB, ref_data_mgr_type=RefDataManager.DB, clock_type=Clock.RealTime, persistence_config=PersistenceConfig(), configs=[broker_config]) app_context = ApplicationContext(app_config=live_trading_config) ATSRunner().start(app_context)
def main(): file = '../data/tradedata/SPY.csv' dateparse = lambda x: pd.datetime.strptime(x, '%Y-%m-%d') df = pd.read_csv(file, index_col='Date', parse_dates=['Date'], date_parser=dateparse) df['Symbol'] = "SPY" df['BarSize'] = int(BarSize.D1) df = df.sort_index(ascending=True) dict_df = {"SPY": df} instruments = [3348] backtest_config = BacktestingConfig( id="sma", stg_id='test_sma1', # stg_cls='algotrader.strategy.sma_strategy.SMAStrategy', stg_cls='algotrader.strategy.down_2pct_strategy.Down2PctStrategy', portfolio_id='test2', portfolio_initial_cash=100000, instrument_ids=instruments, subscription_types=[ BarSubscriptionType(bar_type=BarType.Time, bar_size=BarSize.D1) ], from_date=date(2010, 1, 1), to_date=date.today(), broker_id=Broker.Simulator, feed_id=Feed.PandasMemory, stg_configs={'qty': 1000}, ref_data_mgr_type=RefDataManager.DB, persistence_config=backtest_mongo_persistance_config(), provider_configs=PandasMemoryDataFeedConfig(dict_df=dict_df)) app_context = ApplicationContext(app_config=backtest_config) BacktestRunner(True).start(app_context)
def test_vix(): logger.setLevel(logging.DEBUG) symbols = ["VXF2015", "VXG2015", "VXH2015", "VXJ2015"] vix_data = {} with pd.HDFStore('/Users/jchan/workspace/data/temp/VX.h5') as store: for s in store.keys(): sym = re.sub('/', '', s) df = store[s] df = df.reset_index() df['DateTime'] = df['Trade Date'] df['Volume'] = df['Total Volume'] df = df.set_index('DateTime') vix_data[sym] = df backtest_config = BacktestingConfig(id="test_vix", stg_id="vix6", stg_cls= 'algotrader.strategy.vix_future.VIXFuture', portfolio_id='test', portfolio_initial_cash=100000, instrument_ids=[125, 126, 127, 128, 129], subscription_types=[ BarSubscriptionType(bar_type=BarType.Time, bar_size=BarSize.D1)], from_date=date(2014, 11, 1), to_date=date(2015,4,1), broker_id=Broker.Simulator, feed_id=Feed.PandasMemory, #stg_configs={'qty': 10, 'contracts': [125, 126, 127, 128]}, stg_configs={'qty': 10, 'exp_date_lb' : 10, 'exp_date_ub' : 180, 'short_entry_threshold' : 0.02, 'short_exit_threshold' : -0.01 }, ref_data_mgr_type=RefDataManager.DB, persistence_config= backtest_mongo_persistance_config(), provider_configs=[MongoDBConfig, PandasMemoryDataFeedConfig(dict_df=vix_data)]) app_context = ApplicationContext(app_config=backtest_config) BacktestRunner(True).start(app_context)
class ATSRunner(Application): def init(self): logger.info("starting ATS") self.app_config = self.app_config self.app_context = ApplicationContext(app_config=self.app_config) self.app_context.start() self.portfolio = self.app_context.portf_mgr.get_or_new_portfolio(self.app_config.portfolio_id, self.app_config.portfolio_initial_cash) self.app_context.add_startable(self.portfolio) self.strategy = self.app_context.stg_mgr.get_or_new_stg(self.app_config) self.app_context.add_startable(self.strategy) def run(self): self.strategy.start(self.app_context) logger.info("ATS started, presss Ctrl-C to stop")
class ATSRunner(Application): def init(self): logger.info("starting ATS") self.app_config = self.app_config self.app_context = ApplicationContext(app_config=self.app_config) self.app_context.start() self.portfolio = self.app_context.portf_mgr.get_or_new_portfolio( self.app_config.portfolio_id, self.app_config.portfolio_initial_cash) self.app_context.add_startable(self.portfolio) self.strategy = self.app_context.stg_mgr.get_or_new_stg( self.app_config) self.app_context.add_startable(self.strategy) def run(self): self.strategy.start(self.app_context) logger.info("ATS started, presss Ctrl-C to stop")
def setUp(self): self.app_context = ApplicationContext() self.app_context.start() self.portfolio = self.app_context.portf_mgr.new_portfolio(portf_id="test", cash=100000) self.portfolio.start(self.app_context)
def setUp(self): self.app_context = ApplicationContext() self.utils = DataSeriesUtils(self.app_context)
broker.on_ord_cancel_req(order) time.sleep(5) if __name__ == "__main__": logger.setLevel(logging.DEBUG) persistence_config = PersistenceConfig( None, DataStore.InMemoryDB, PersistenceMode.RealTime, DataStore.InMemoryDB, PersistenceMode.RealTime, DataStore.InMemoryDB, PersistenceMode.RealTime, DataStore.InMemoryDB, PersistenceMode.RealTime) app_config = RealtimeMarketDataImporterConfig( None, RefDataManager.InMemory, Clock.RealTime, Broker.IB, [3], [BarSubscriptionType(bar_type=BarType.Time, bar_size=BarSize.D1)], persistence_config, MongoDBConfig(), IBConfig(client_id=2, use_gevent=True)) app_context = ApplicationContext(app_config=app_config) app_context.start() broker = app_context.provider_mgr.get(Broker.IB) broker.start(app_context) # test_sub_hist_bar(broker) test_sub_realtime_bar(broker) time.sleep(1000) # test_sub_realtime_trade(broker) # test_sub_realtime_quote(broker)
def setUp(self): self.app_context = ApplicationContext()
None, Clock.RealTime, persistence_config, provider_configs=[ MongoDBConfig(dbname=name, create_at_start=create_at_start, delete_at_stop=mongo_delete_at_stop), CassandraConfig(contact_points=['127.0.0.1'], keyspace=name, create_at_start=create_at_start, delete_at_stop=cass_delete_at_stop), InMemoryStoreConfig(file="%s_db.p" % name, create_at_start=create_at_start, delete_at_stop=im_memory_delete_at_stop) ]) context = ApplicationContext(app_config=app_config) clock = context.clock mongo = context.provider_mgr.get(DataStore.Mongo) cassandra = context.provider_mgr.get(DataStore.Cassandra) inmemory = context.provider_mgr.get(DataStore.InMemory) params = [ param('Mongo', mongo), #param('Cassandra', cassandra), param('InMemory', inmemory) ] class DataStoreTest(TestCase): @classmethod def setUpClass(cls):
class TestCompareWithFunctionalBacktest(TestCase): start_date = datetime(2000, 1, 1) num_days = 3000 dates = [start_date + timedelta(days=i) for i in range(num_days)] init_cash = 1000000 def get_df(self, asset): df = pd.DataFrame({"dates": TestCompareWithFunctionalBacktest.dates, "Open": asset, "High": asset, "Low": asset, "Close": asset, "Volume": 10000 * np.ones(TestCompareWithFunctionalBacktest.num_days)}) df = df.set_index(keys="dates") return df def init_context(self, symbols, asset, app_config): self.app_context = ApplicationContext(app_config=app_config) 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"]}) ref_data_mgr = MockRefDataManager(inst_df=inst_df, ccy_df=ccy_df, exch_df=exchange_df) self.app_context.ref_data_mgr = ref_data_mgr self.app_context.start() self.portfolio = self.app_context.portf_mgr.new_portfolio(portf_id='test2', cash=TestCompareWithFunctionalBacktest.init_cash) self.portfolio.start(self.app_context) def tearDown(self): self.app_context.stop() 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()
broker.on_ord_cancel_req(order) time.sleep(5) if __name__ == "__main__": logger.setLevel(logging.DEBUG) persistence_config = PersistenceConfig(None, DataStore.InMemoryDB, PersistenceMode.RealTime, DataStore.InMemoryDB, PersistenceMode.RealTime, DataStore.InMemoryDB, PersistenceMode.RealTime, DataStore.InMemoryDB, PersistenceMode.RealTime) app_config = RealtimeMarketDataImporterConfig(None, RefDataManager.InMemory, Clock.RealTime, Broker.IB, [3], [BarSubscriptionType(bar_type=BarType.Time, bar_size=BarSize.D1)], persistence_config, MongoDBConfig(), IBConfig(client_id=2, use_gevent=True)) app_context = ApplicationContext(app_config=app_config) app_context.start() broker = app_context.provider_mgr.get(Broker.IB) broker.start(app_context) # test_sub_hist_bar(broker) test_sub_realtime_bar(broker) time.sleep(1000) # test_sub_realtime_trade(broker) # test_sub_realtime_quote(broker)
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()
class PortfolioTest(TestCase): def setUp(self): self.app_context = ApplicationContext() self.app_context.start() self.portfolio = self.app_context.portf_mgr.new_portfolio(portf_id="test", cash=100000) self.portfolio.start(self.app_context) def tearDown(self): self.app_context.stop() def test_portfolio(self): self.assertEqual(Portfolio(cash=100000).cash, 100000) def test_position(self): ord_req1 = NewOrderRequest(cl_id='test', cl_ord_id=1, portf_id="test", broker_id="Dummy", inst_id=1, action=OrdAction.BUY, type=OrdType.LIMIT, qty=1000, limit_price=18.5) ord_req2 = NewOrderRequest(cl_id='test', cl_ord_id=2, portf_id="test", broker_id="Dummy", inst_id=1, action=OrdAction.BUY, type=OrdType.LIMIT, qty=1800, limit_price=18.2) self.assertEqual(0, len(self.portfolio.positions)) self.assertEqual(100000, self.portfolio.cash) self.assertEqual(0, (self.portfolio.performance_series.now("total_equity"))) order1 = self.portfolio.send_order(ord_req1) self.check_order(self.portfolio, [order1], {1: (1000, 0)}) self.assertEqual(100000, self.portfolio.cash) self.assertEqual(0, (self.portfolio.performance_series.now("total_equity"))) order2 = self.portfolio.send_order(ord_req2) self.check_order(self.portfolio, [order1, order2], {1: (2800, 0)}) self.assertEqual(100000, self.portfolio.cash) self.assertEqual(0, (self.portfolio.performance_series.now("total_equity"))) def test_on_exec_report(self): ord_req = NewOrderRequest(cl_id='test', cl_ord_id=1, portf_id="test", broker_id="Dummy", inst_id=1, action=OrdAction.BUY, type=OrdType.LIMIT, qty=1000, limit_price=18.5) order1 = self.portfolio.send_order(ord_req) er1 = ExecutionReport(cl_id='test', cl_ord_id=1, ord_id=1, er_id=1, inst_id=1, last_qty=500, last_price=18.4, status=OrdStatus.PARTIALLY_FILLED) self.app_context.order_mgr.on_exec_report(er1) self.assertEqual(500, order1.last_qty) self.assertEqual(18.4, order1.last_price) self.assertEqual(500, order1.filled_qty) self.assertEqual(18.4, order1.avg_price) self.assertEqual(OrdStatus.PARTIALLY_FILLED, order1.status) self.check_order(self.portfolio, [order1], {1: (1000, 500)}) expected_cash = 100000 - 500 * 18.4 expected_stock_value = 500 * 18.4 expected_total_equity = expected_cash + expected_stock_value self.assertEqual(expected_cash, self.portfolio.cash) self.assertEqual(expected_stock_value, self.portfolio.performance_series.now('stock_value')) self.assertEqual(expected_total_equity, self.portfolio.performance_series.now('total_equity')) er2 = ExecutionReport(cl_id='test', cl_ord_id=1, ord_id=1, er_id=2, inst_id=1, last_qty=500, last_price=18.2, status=OrdStatus.FILLED) self.app_context.order_mgr.on_exec_report(er2) self.assertEqual(500, order1.last_qty) self.assertEqual(18.2, order1.last_price) self.assertEqual(1000, order1.filled_qty) self.assertEqual(18.3, order1.avg_price) self.assertEqual(OrdStatus.FILLED, order1.status) self.check_order(self.portfolio, [order1], {1: (1000, 1000)}) expected_cash = 100000 - 500 * 18.4 - 500 * 18.2 expected_stock_value = 1000 * 18.2 expected_total_equity = expected_cash + expected_stock_value self.assertEqual(expected_cash, self.portfolio.cash) self.assertEqual(expected_stock_value, self.portfolio.performance_series.now('stock_value')) self.assertEqual(expected_total_equity, self.portfolio.performance_series.now('total_equity')) def test_on_market_date_update(self): ord_req = NewOrderRequest(cl_id='test', cl_ord_id=1, portf_id="test", broker_id="Dummy", inst_id=1, action=OrdAction.BUY, type=OrdType.LIMIT, qty=1000, limit_price=18.5, timestamp=0) order1 = self.portfolio.on_new_ord_req(ord_req) er1 = ExecutionReport(cl_id='test', cl_ord_id=1, ord_id=1, er_id=1, inst_id=1, last_qty=500, last_price=18.4, status=OrdStatus.PARTIALLY_FILLED, timestamp=1) self.app_context.order_mgr.on_exec_report(er1) expected_cash = 100000 - 500 * 18.4 expected_stock_value = 500 * 18.4 expected_total_equity = expected_cash + expected_stock_value self.assertEqual(expected_cash, self.portfolio.cash) self.assertEqual(expected_stock_value, self.portfolio.performance_series.get_by_idx(0, 'stock_value')) self.assertEqual(expected_total_equity, self.portfolio.performance_series.get_by_idx(0, 'total_equity')) self.portfolio.on_trade(Trade(inst_id=1, price=20, size=1000, timestamp=2)) expected_cash = 100000 - 500 * 18.4 expected_stock_value = 500 * 20 expected_total_equity = expected_cash + expected_stock_value self.assertEqual(expected_cash, self.portfolio.cash) self.assertEqual(expected_stock_value, self.portfolio.performance_series.get_by_idx(1, 'stock_value')) self.assertEqual(expected_total_equity, self.portfolio.performance_series.get_by_idx(1, 'total_equity')) self.portfolio.on_bar(Bar(inst_id=1, close=16, adj_close=16, vol=1000, timestamp=3)) expected_cash = 100000 - 500 * 18.4 expected_stock_value = 500 * 16 expected_total_equity = expected_cash + expected_stock_value self.assertEqual(expected_cash, self.portfolio.cash) self.assertEqual(expected_stock_value, self.portfolio.performance_series.get_by_idx(2, 'stock_value')) self.assertEqual(expected_total_equity, self.portfolio.performance_series.get_by_idx(2, 'total_equity')) self.portfolio.on_quote(Quote(inst_id=1, bid=16, ask=18, timestamp=4)) expected_cash = 100000 - 500 * 18.4 expected_stock_value = 500 * 17 expected_total_equity = expected_cash + expected_stock_value self.assertEqual(expected_cash, self.portfolio.cash) self.assertEqual(expected_stock_value, self.portfolio.performance_series.get_by_idx(3, 'stock_value')) self.assertEqual(expected_total_equity, self.portfolio.performance_series.get_by_idx(3, 'total_equity')) def check_order(self, portfolio, orders, qtys): expected_positon = defaultdict(list) for order in orders: expected_positon[order.inst_id].append(order) self.assertEqual(len(expected_positon), len(portfolio.positions)) all_orders = portfolio.all_orders() self.assertEqual(len(orders), len(all_orders)) for order in orders: self.assertTrue(order in all_orders) for inst, pos_orders in expected_positon.iteritems(): position = portfolio.positions[str(inst)] all_position_orders = position.all_orders() self.assertEqual(len(pos_orders), len(all_position_orders)) (ord_qty, fill_qty) = qtys[inst] for pos_order in pos_orders: self.assertEquals(pos_order, position.orders[pos_order.cl_id][pos_order.cl_ord_id]) self.assertEqual(ord_qty, position.ordered_qty()) self.assertEqual(fill_qty, position.filled_qty()) def test_no_position(self): self.assertEquals(False, self.portfolio.has_position(cl_id=1, inst_id=1)) self.assertEquals(False, self.portfolio.has_position(cl_id=2, inst_id=1)) self.assertEquals(False, self.portfolio.has_position(cl_id=2, inst_id=2)) def test_position(self): ord_req = NewOrderRequest(cl_id='test', cl_ord_id=1, portf_id="test", broker_id="Dummy", inst_id=1, action=OrdAction.BUY, type=OrdType.LIMIT, qty=1000, limit_price=18.5) order1 = self.portfolio.send_order(ord_req) er1 = ExecutionReport(cl_id='test', cl_ord_id=1, ord_id=1, er_id=1, inst_id=1, last_qty=500, last_price=18.4, status=OrdStatus.PARTIALLY_FILLED) self.app_context.order_mgr.on_exec_report(er1) self.assertEqual(500, order1.last_qty) self.assertEqual(18.4, order1.last_price) self.assertEqual(500, order1.filled_qty) self.assertEqual(18.4, order1.avg_price) self.assertEqual(OrdStatus.PARTIALLY_FILLED, order1.status) self.assertEquals(True, self.portfolio.has_position(cl_id='test', inst_id=1)) self.assertEquals(False, self.portfolio.has_position(cl_id='test', inst_id=2)) self.assertEquals(False, self.portfolio.has_position(cl_id='dummy', inst_id=2))