def test_linearity_mul(self, a, seed):
universe = make_randomwalk(seed=seed)
trade0 = RandomTrader(n_trades=1, seed=seed).run(universe).trades[0]
tradeA = a * trade0
result0 = trade0._array_value(universe)
resultA = tradeA._array_value(universe)
assert np.allclose(a * result0, resultA)
def test_series_type():
universe = make_randomwalk()
strategy = RandomTrader().run(universe)
wealth = Wealth(strategy)
series_wealth = wealth.to_series()
assert isinstance(series_wealth, pd.Series)
def test_series_value():
universe = make_randomwalk()
strategy = RandomTrader().run(universe)
wealth = Wealth(strategy)
series_wealth = wealth.to_series()
assert np.array_equal(series_wealth, wealth["wealth"])
def test_random(self, seed):
universe = make_randomwalk(n_bars=100, n_assets=10, seed=seed)
trade = RandomTrader(n_trades=1, seed=seed).run(universe).trades[0]
result = trade.final_pnl(universe)
expected = trade.array_pnl(universe)[-1]
assert np.allclose(result, expected)
def test_ts(self):
universe = make_randomwalk()
strategy = RandomStrategy().run(universe)
trades = strategy.trades
assert_equal(strategy.wealth().values, ts.wealth(trades, universe))
assert_equal(strategy.drawdown().values, ts.drawdown(trades, universe))
def test_init():
"""
Test if `Wealth(strategy) == strategy.wealth`.
"""
universe = make_randomwalk()
strategy = RandomTrader().run(universe)
assert_result_equal(Wealth(strategy), strategy.wealth)
def test_score(self, metric):
np.random.seed(42)
universe = make_randomwalk()
strategy = RandomStrategy().run(universe)
result = strategy.score(metric.__name__)
expected = metric(strategy.trades, universe)
assert result == expected
def test_init():
"""
Test if `History(strategy) == strategy.history`.
"""
universe = make_randomwalk()
strategy = RandomTrader().run(universe)
assert_result_equal(History(strategy), strategy.history)
def test_linearity_mul(self, a):
universe = make_randomwalk()
strategy = RandomStrategy().run(universe)
result = a * ts.wealth(strategy.trades, universe)
expected = ts.wealth([a * t for t in strategy.trades], universe)
assert_allclose(result, expected)
def test(self):
np.random.seed(42)
universe = make_randomwalk()
strategy = RandomStrategy().run(universe)
drawdown = ts.drawdown(strategy.trades, universe)
assert np.min(drawdown) == max_drawdown(strategy.trades, universe)
def test_result(self, seed, rate):
m = self.MetricClass(rate=rate)
strategy = RandomTrader(seed=seed).run(make_randomwalk(seed=seed))
result0 = m.result(strategy)
result1 = m._result_from_wealth(strategy.wealth.wealth)
assert np.equal(result0, result1).all()
def test_score(self, metric):
np.random.seed(42)
universe = make_randomwalk()
strategy = RandomStrategy(n_trades=1000).run(universe)
result = strategy.score(metric.__name__)
expected = metric(strategy.trades, universe)
np.testing.assert_allclose(result, expected, equal_nan=True)
def test(self):
np.random.seed(42)
universe = make_randomwalk()
strategy = RandomStrategy().run(universe)
result = final_wealth(strategy.trades, universe)
expected = strategy.wealth().iat[-1]
np.testing.assert_allclose(result, expected)
def test_random(self, rate, n, risk_free_return, seed, init_wealth):
strategy = RandomTrader(seed=seed).run(make_randomwalk(seed=seed),
budget=init_wealth)
result = self.MetricClass(
rate=rate, n=n, risk_free_return=risk_free_return).result(strategy)
r = AverageReturn(rate=rate, n=n).result(strategy)
s = Volatility(rate=rate, n=n).result(strategy)
expected = (r - risk_free_return) / s
assert result == expected
def test_strategy_evaluate(self, MetricClass, seed):
"""
Test if `strategy.evaluate(metric) == metric.result(strategy)`
"""
m = MetricClass()
strategy = RandomTrader(seed=seed).run(make_randomwalk(seed=seed))
result0 = np.array(m.result(strategy)) # from metric method
result1 = np.array(strategy.evaluate(m)) # from strategy method
assert np.equal(result0, result1).all()
def test_linearity_add(self):
universe = make_randomwalk()
s0 = RandomStrategy().run(universe)
s1 = RandomStrategy().run(universe)
result = ts.wealth(s0.trades, universe) + ts.wealth(s1.trades, universe)
expected = ts.wealth(s0.trades + s1.trades, universe)
assert_allclose(result, expected)
def test_call(self, MetricClass, seed):
"""
Test if `metric.result(strategy) == metric(strategy)`.
"""
m = MetricClass()
strategy = RandomTrader(seed=seed).run(make_randomwalk(seed=seed))
result0 = np.array(m.result(strategy)) # from `result` method
result1 = np.array(m(strategy)) # from __call__
assert np.equal(result0, result1).all()
def test_dataframe_index():
"""
Test if value of history.to_dataframe is correct
"""
universe = make_randomwalk()
strategy = RandomTrader().run(universe)
wealth = Wealth(strategy)
df_wealth = wealth.to_dataframe()
assert_index_equal(df_wealth.index, universe.bars, check_names=False)
def test_linearity_mul(self, a, net, seed):
universe = make_randomwalk(seed=seed)
trade0 = RandomTrader(n_trades=1, seed=seed).run(universe).trades[0]
tradeA = a * trade0
result0 = trade0.series_exposure(universe, net=net)
resultA = tradeA.series_exposure(universe, net=net)
if net:
assert np.allclose(a * result0, resultA)
else:
assert np.allclose(abs(a) * result0, resultA)
def test_dataframe_type():
"""
Test if history.to_dataframe is `pandas.DataFrame`.
"""
universe = make_randomwalk()
strategy = RandomTrader().run(universe)
wealth = Wealth(strategy)
df_wealth = wealth.to_dataframe()
assert isinstance(df_wealth, pd.DataFrame)
def test_dataframe_value():
"""
Test if value of history.to_dataframe is correct
"""
universe = make_randomwalk()
strategy = RandomTrader().run(universe)
wealth = Wealth(strategy)
df_wealth = wealth.to_dataframe()
assert array_equal(df_wealth["wealth"].values, wealth.wealth)
def test_dataframe_columns():
"""
Test if history.to_dataframe has the expected columns.
"""
universe = make_randomwalk()
strategy = RandomTrader().run(universe)
wealth = Wealth(strategy)
df_wealth = wealth.to_dataframe()
assert df_wealth.index.name == "bars"
assert_index_equal(df_wealth.columns, pd.Index(["wealth"]))
def test_strategy_attr(self):
"""
`History.__init__` and `strategy.history` are supposed to give the same results.
"""
universe = make_randomwalk(seed=42)
strategy = RandomTrader(seed=42).run(universe)
result0 = pd.DataFrame(History(strategy)) # from History.__init__
result1 = pd.DataFrame(strategy.history) # from strategy.history
assert_frame_equal(result0, result1)
def test_load(self):
np.random.seed(42)
universe = make_randomwalk()
strategy = RandomStrategy().run(universe, verbose=False)
history = strategy.history()
strategy_load = RandomStrategy().load(history, universe)
pd.testing.assert_frame_equal(history, strategy_load.history())
pd.testing.assert_series_equal(strategy.wealth(),
strategy_load.wealth())
def test_zero(self):
"""
result = 0 if trade is zero
"""
universe = make_randomwalk()
strategy = RandomStrategy(min_lot=0, max_lot=0).run(universe)
result = ts.drawdown(strategy.trades, universe)
expected = np.zeros_like(result)
assert_equal(result, expected)
def test_result_from_wealth(self, rate, n, init_wealth):
"""
`m._result_from_wealth(series_wealth) == m.result(strategy.wealth.wealth)`
"""
m = self.MetricClass(rate=rate, n=n)
strategy = RandomTrader(seed=42).run(make_randomwalk(seed=42),
budget=init_wealth)
series_wealth = strategy.budget + strategy.wealth.wealth
result = m.result(strategy)
result_from_wealth = m._result_from_wealth(series_wealth)
assert np.allclose(result, result_from_wealth)
def test_wealth_sanity(self):
"""
wealth[-1] == sum(pnl)
"""
np.random.seed(42)
universe = make_randomwalk()
strategy = RandomStrategy(max_n_assets=5)
strategy.run(universe)
assert np.isclose(sum(strategy.history().pnl),
strategy.wealth().values[-1])
def test_run_execution(self):
strategy = RandomStrategy()
universe = make_randomwalk()
np.random.seed(42)
trades = strategy.run(universe)
result = [t.close for t in strategy.trades]
np.random.seed(42)
expected = [t.execute(universe).close for t in strategy(universe)]
assert result == expected
def test_load_trades_json(self):
np.random.seed(42)
universe = make_randomwalk()
strategy = RandomStrategy().run(universe, verbose=False)
strategy_load = RandomStrategy().load_universe(universe)
strategy_load.load_trades_json(strategy.trades_to_json())
result = strategy_load.history()
expect = strategy.history()
pd.testing.assert_frame_equal(result, expect)
def _get_df_history(self):
strategy = RandomTrader(seed=42).run(make_randomwalk(42))
return History(strategy).to_dataframe()
