class TestColumn:
universe = Universe(
pd.DataFrame({f"A{i}": range(10)
for i in range(10)},
index=[f"B{i}" for i in range(10)]))
trades = [
Trade(
asset=["A0", "A1"],
lot=[1, 2],
open_bar="B0",
shut_bar="B8",
take=1.0,
stop=-1.0,
),
Trade(
asset=["A2", "A3"],
lot=[3, 4],
open_bar="B1",
shut_bar="B9",
take=2.0,
stop=-2.0,
),
]
def _get_history(self):
strategy = DeterminedTrader(trades=self.trades).run(self.universe)
return History(strategy)
def test_trade_id(self):
result = self._get_history().trade_id
assert np.array_equal(result, [0, 0, 1, 1])
def test_order_id(self):
result = self._get_history().order_id
assert np.array_equal(result, [0, 1, 2, 3])
def test_asset(self):
result = self._get_history().asset
assert np.array_equal(result, ["A0", "A1", "A2", "A3"])
def test_open_bar(self):
result = self._get_history().open_bar
assert np.array_equal(result, ["B0", "B0", "B1", "B1"])
def test_shut_bar(self):
result = self._get_history().shut_bar
assert np.array_equal(result, ["B8", "B8", "B9", "B9"])
def test_take(self):
result = self._get_history().take
assert np.array_equal(result, [1.0, 1.0, 2.0, 2.0])
def test_stop(self):
result = self._get_history().stop
assert np.array_equal(result, [-1.0, -1.0, -2.0, -2.0])
def test_pnl(self):
pass # TODO
def test_hand(self, net):
trade = Trade(asset=["A0", "A1"], lot=[2, -3], open_bar=1, shut_bar=3)
result = trade.series_exposure(net=net, universe=self.universe_hand)
if net:
expected = [0, -19, 5, -22, 0, 0, 0]
else:
expected = [0, 23, 11, 26, 0, 0, 0]
assert np.allclose(result, expected)
class TestNOrders:
"""
Test `Trade.n_orders`.
"""
trade0 = Trade(asset="A0", lot=1.0)
trade1 = Trade(asset=["A0", "A1"], lot=[2.0, 3.0])
@pytest.mark.parametrize("trade, expected", [(trade0, 1), (trade1, 2)])
def test_value(self, trade, expected):
assert trade.n_orders == expected
class TestArrayExposure:
"""
Test `Trade.array_exposure()`.
"""
universe_hand = Universe(
pd.DataFrame(
{"A0": [3, 1, 4, 1, 5, 9, 2], "A1": [2, 7, 1, 8, 2, 8, 1],},
index=range(7),
dtype=float,
)
)
trade0 = Trade(asset=["A0", "A1"], lot=[2, -3], open_bar=1, shut_bar=3)
trade1 = Trade(asset=["A1", "A0"], lot=[-3, 2], open_bar=1, shut_bar=3)
expected0 = [[0, 0], [2, -21], [8, -3], [2, -24], [0, 0], [0, 0], [0, 0]]
expected1 = [[0, 0], [-21, 2], [-3, 8], [-24, 2], [0, 0], [0, 0], [0, 0]]
@pytest.mark.parametrize(
"trade, expected", [(trade0, expected0), (trade1, expected1)],
)
def test_hand(self, trade, expected):
result = trade.array_exposure(universe=self.universe_hand)
assert np.allclose(result, expected)
def test_value_zero(self):
trade = Trade(asset=["A0", "A1"], lot=[0, 0], open_bar=1, shut_bar=3)
result = trade.array_exposure(self.universe_hand)
expected = np.zeros((self.universe_hand.n_bars, 2))
assert np.allclose(result, expected)
@pytest.mark.parametrize("seed", range(1))
def test_linearity_add(self, seed):
np.random.seed(seed)
lot0, lot1 = np.random.random(2)
trade0 = Trade(asset="A0", lot=lot0, open_bar=1, shut_bar=3)
trade1 = Trade(asset="A0", lot=lot1, open_bar=1, shut_bar=3)
tradeA = Trade(asset="A0", lot=lot0 + lot1, open_bar=1, shut_bar=3)
result0 = trade0.array_exposure(self.universe_hand)
result1 = trade1.array_exposure(self.universe_hand)
resultA = tradeA.array_exposure(self.universe_hand)
assert np.allclose(result0 + result1, resultA)
@pytest.mark.parametrize("a", [-2.0, -1.0, 0.0, 1.0, 2.0])
@pytest.mark.parametrize("seed", range(1))
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_exposure(universe)
resultA = tradeA.array_exposure(universe)
assert np.allclose(a * result0, resultA)
class TestArrayLot:
"""
Test `Trade.array_lot`.
"""
trade0 = Trade(asset="A0", lot=1.0)
trade1 = Trade(asset=["A0", "A1"], lot=[2.0, 3.0])
@pytest.mark.parametrize("trade, expected", [(trade0, [1.0]),
(trade1, [2.0, 3.0])])
def test_value(self, trade, expected):
assert isinstance(trade.array_lot, np.ndarray)
assert np.array_equal(trade.array_lot, expected)
def test_linearity_add(self, net, seed):
np.random.seed(seed)
lot0, lot1 = np.random.random(2)
trade0 = Trade(asset="A0", lot=lot0, open_bar=1, shut_bar=3)
trade1 = Trade(asset="A0", lot=lot1, open_bar=1, shut_bar=3)
tradeA = Trade(asset="A0", lot=lot0 + lot1, open_bar=1, shut_bar=3)
result0 = trade0.series_exposure(self.universe_hand, net=net)
result1 = trade1.series_exposure(self.universe_hand, net=net)
resultA = tradeA.series_exposure(self.universe_hand, net=net)
assert np.allclose(result0 + result1, resultA)
def test_linearity_add(self, seed):
np.random.seed(seed)
lot0, lot1 = np.random.random(2)
trade0 = Trade(asset="A0", lot=lot0, open_bar=1, shut_bar=3)
trade1 = Trade(asset="A0", lot=lot1, open_bar=1, shut_bar=3)
tradeA = Trade(asset="A0", lot=lot0 + lot1, open_bar=1, shut_bar=3)
result0 = trade0._array_value(self.universe_hand)
result1 = trade1._array_value(self.universe_hand)
resultA = tradeA._array_value(self.universe_hand)
assert np.allclose(result0 + result1, resultA)
def test_hand(self, net):
universe = self.universe_hand
trade0 = Trade("A0", lot=2.0, open_bar=1, shut_bar=5)
trade1 = Trade("A1", lot=-3.0, open_bar=2, shut_bar=4)
strategy = DeterminedTrader([trade0, trade1]).run(universe)
result = Exposure(net=net).result(strategy)
if net:
# 0 2 8 2 10 18 0
# 0 0 -3 -24 -3 0 0
expected = [0, 2, 5, -22, 7, 18, 0]
else:
expected = [0, 2, 11, 26, 13, 18, 0]
assert np.allclose(result, expected)
def yield_trades(n_orders):
"""
Examples
--------
>>> for trade in yield_trades(1):
... print(trade)
Trade(asset='A0', open_bar='B0', shut_bar='B1', lot=0.0, take=1.0, stop=-1.0)
Trade(asset='A0', open_bar='B0', shut_bar='B1', lot=1, take=1.0, stop=-1.0)
Trade(asset='A0', open_bar='B0', shut_bar='B1', lot=1.23, take=1.0, stop=-1.0)
Trade(asset='A0', open_bar='B0', shut_bar='B1', lot=-1.23, take=1.0, stop=-1.0)
Trade(asset='A0', open_bar='B0', shut_bar='B1', lot=123.4, take=1.0, stop=-1.0)
Trade(asset='A0', open_bar='B0', shut_bar='B1', lot=-123.4, take=1.0, stop=-1.0)
>>> for trade in yield_trades(2):
... print(trade)
Trade(asset=['A0', 'A1'], open_bar='B0', shut_bar='B1', lot=[0.0, 1], take=1.0, stop=-1.0)
Trade(asset=['A0', 'A1'], open_bar='B0', shut_bar='B1', lot=[1, 1.23], take=1.0, stop=-1.0)
Trade(asset=['A0', 'A1'], open_bar='B0', shut_bar='B1', lot=[1.23, -1.23], take=1.0, stop=-1.0)
Trade(asset=['A0', 'A1'], open_bar='B0', shut_bar='B1', lot=[-1.23, 123.4], take=1.0, stop=-1.0)
Trade(asset=['A0', 'A1'], open_bar='B0', shut_bar='B1', lot=[123.4, -123.4], take=1.0, stop=-1.0)
Trade(asset=['A0', 'A1'], open_bar='B0', shut_bar='B1', lot=[-123.4, 0.0], take=1.0, stop=-1.0)
"""
params_lot = [0.0, 1, 1.23, -1.23, 123.4, -123.4]
if n_orders == 1:
for lot in params_lot:
yield Trade(
asset="A0",
open_bar="B0",
shut_bar="B1",
lot=lot,
take=1.0,
stop=-1.0,
)
else:
for i, _ in enumerate(params_lot):
asset = [f"A{i}" for i in range(n_orders)]
lot = list(islice(cycle(params_lot), i, i + n_orders))
yield Trade(
asset=asset,
open_bar="B0",
shut_bar="B1",
lot=lot,
take=1.0,
stop=-1.0,
)
def test_result_zero_1(self, net, n_bars):
universe = Universe(
pd.DataFrame({
"A0": np.linspace(0.0, 1.0, n_bars),
}))
strategy = DeterminedTrader([Trade("A0", lot=0.0)]).run(universe)
result = self.MetricClass(net=net).result(strategy)
expected = np.zeros(n_bars)
assert np.allclose(result, expected)
def test_result_zero_0(self, net, n_bars):
universe = Universe(
pd.DataFrame({
"A0": np.zeros(n_bars, dtype=float),
}))
strategy = DeterminedTrader([Trade("A0")]).run(universe)
result = self.MetricClass(net=net).result(strategy)
expected = np.zeros(n_bars)
assert np.allclose(result, expected)
def test_result_zero(self, rate, init_wealth, n_bars):
universe = Universe(
pd.DataFrame({
"A0": np.ones(n_bars, dtype=float),
}))
strategy = DeterminedTrader([Trade("A0")]).run(universe,
budget=init_wealth)
result = self.MetricClass(rate=rate).result(strategy)
expected = 0
assert np.allclose(result, expected)
class TestIsExecuted:
"""
Test `Trade.is_executed`.
"""
trade0 = Trade(asset="A0", lot=1.0)
def test_value(self):
trade = self.trade0
assert not trade.is_executed
trade = trade.execute(make_randomwalk(seed=42))
assert trade.is_executed
def logic(self, universe):
n_trade = int(universe.n_assets * self.percentile)
date_range = pd.date_range(universe.bars[0],
universe.bars[-1],
freq="BM")
for open_date in date_range[1:]:
for asset in self.sorted_assets(universe, open_date)[:n_trade]:
yield Trade(
asset=asset,
lot=self.bet / universe.prices.at[open_date, asset],
open_bar=open_date,
shut_bar=open_date + self.hold,
take=self.take,
stop=self.stop,
)
def test_value_0(self):
asset = "A0"
open_bar = "B0"
shut_bar = "B1"
lot = 1.0
take = 2.0
stop = -2.0
trade = Trade(
asset=asset,
open_bar=open_bar,
shut_bar=shut_bar,
lot=lot,
take=take,
stop=stop,
)
expected = "Trade(asset='A0', open_bar='B0', shut_bar='B1', lot=1.0, take=2.0, stop=-2.0)"
assert repr(trade) == expected
def logic(self, universe):
if self.seed is not None:
np.random.seed(self.seed)
random.seed(self.seed)
for _ in range(self.__n_trades):
n_orders = np.random.randint(1, self.max_n_orders + 1, size=1)[0]
asset = random.sample(list(universe.assets), n_orders)
lot = (self.max_lot -
self.min_lot) * np.random.rand(n_orders) - self.min_lot
open_bar, shut_bar = sorted(random.sample(list(universe.bars), 2))
yield Trade(asset=asset,
lot=lot,
open_bar=open_bar,
shut_bar=shut_bar)
def logic(self, universe):
asset = np.array(list(self.weight.keys()))
lot = (np.array(list(self.weight.values())) /
universe.prices.loc[:, self.weight.keys()].iloc[0, :].values)
yield Trade(asset=asset, lot=lot, open_bar=universe.bars[0])
def logic(self, univers):
yield Trade(asset=["A0", "A1"])
yield Trade(asset=["A2", "A3"])
def test_value_1(self):
asset = "A0"
trade = Trade(asset=asset)
expected = "Trade(asset='A0', lot=1.0)" # default value of lot = 1.0
assert repr(trade) == expected
def test_value_zero(self):
trade = Trade(asset=["A0", "A1"], lot=[0, 0], open_bar=1, shut_bar=3)
result = trade._array_value(self.universe_hand)
expected = np.zeros((self.universe_hand.n_bars, 2))
assert np.allclose(result, expected)
