def portfolio(wallet_usd, wallet_btc, wallet_eth, wallet_xrp, exchange):
portfolio = Portfolio(
USD, wallets=[wallet_usd, wallet_btc, wallet_eth, wallet_xrp])
with mock.patch.object(Portfolio, 'clock',
return_value=exchange.clock) as clock:
portfolio = Portfolio(
USD, wallets=[wallet_usd, wallet_btc, wallet_eth, wallet_xrp])
return portfolio
def test_on_fill(mock_trade_class, mock_exchange_class):
exchange = mock_exchange_class.return_value
exchange.id = "fake_exchange_id"
broker = Broker(exchange)
wallets = [Wallet(exchange, 10000 * USD), Wallet(exchange, 0 * BTC)]
portfolio = Portfolio(USD, wallets)
order = Order(side=TradeSide.BUY,
trade_type=TradeType.MARKET,
pair=USD / BTC,
quantity=5200.00 * USD,
portfolio=portfolio,
price=7000.00)
order.attach(broker)
order.execute(exchange)
broker._executed[order.id] = order
trade = mock_trade_class.return_value
trade.size = 5197.00
trade.commission = 3.00 * USD
trade.order_id = order.id
assert order.status == OrderStatus.OPEN
order.fill(exchange, trade)
assert order.status == OrderStatus.FILLED
assert order.remaining_size == 0
assert trade in broker.trades[order.id]
def test_on_fill(mock_trade_class,
mock_exchange_class,
fill_listener):
exchange = mock_exchange_class.return_value
exchange.id = "fake_exchange_id"
wallets = [Wallet(exchange, 10000 * USD), Wallet(exchange, 0 * BTC)]
portfolio = Portfolio(USD, wallets)
order = Order(side=TradeSide.BUY,
trade_type=TradeType.MARKET,
pair=USD / BTC,
quantity=5200.00 * USD,
portfolio=portfolio,
price=7000.00)
order.attach(fill_listener)
order.execute(exchange)
trade = mock_trade_class.return_value
trade.size = 3997.00
trade.commission = 3.00 * USD
assert not fill_listener.listened
order.fill(exchange, trade)
assert fill_listener.listened
def test_on_complete(mock_trade_class, mock_exchange_class, complete_listener):
exchange = mock_exchange_class.return_value
exchange.id = "fake_exchange_id"
exchange.name = "coinbase"
wallets = [Wallet(exchange, 10000 * USD), Wallet(exchange, 0 * BTC)]
portfolio = Portfolio(USD, wallets)
order = Order(step=0,
exchange_name="coinbase",
side=TradeSide.BUY,
trade_type=TradeType.MARKET,
pair=USD / BTC,
quantity=5200.00 * USD,
portfolio=portfolio,
price=7000.00)
order.attach(complete_listener)
order.execute(exchange)
trade = mock_trade_class.return_value
trade.size = 5217.00
trade.commission = 3.00 * USD
order.fill(exchange, trade)
assert not complete_listener.listened
order.complete(exchange)
assert complete_listener.listened
def test_path_order_runs_though_broker():
wallets = [Wallet(exchange, 10000 * USD), Wallet(exchange, 0 * BTC)]
portfolio = Portfolio(base_instrument=USD, wallets=wallets)
exchange.reset()
portfolio.reset()
broker.reset()
base_wallet = portfolio.get_wallet(exchange.id, USD)
quantity = (1 / 10) * base_wallet.balance
order = Order(side=TradeSide.BUY,
trade_type=TradeType.MARKET,
pair=USD / BTC,
quantity=quantity,
portfolio=portfolio)
order = order.add_recipe(
Recipe(side=TradeSide.SELL,
trade_type=TradeType.MARKET,
pair=USD / BTC,
criteria=StopLoss(direction=StopDirection.EITHER,
up_percent=0.02,
down_percent=0.10)))
broker.submit(order)
while len(broker.unexecuted) > 0:
broker.update()
portfolio.update()
obs = exchange.next_observation(1)
pytest.fail("Failed.")
def test_sell_on_exchange():
wallets = [Wallet(exchange, 0 * USD), Wallet(exchange, 10 * BTC)]
portfolio = Portfolio(base_instrument=USD, wallets=wallets)
base_wallet = portfolio.get_wallet(exchange.id, USD)
quote_wallet = portfolio.get_wallet(exchange.id, BTC)
quantity = (1 / 10) * quote_wallet.balance
order = Order(side=TradeSide.SELL,
trade_type=TradeType.MARKET,
pair=USD / BTC,
quantity=quantity,
portfolio=portfolio)
current_price = 12390.90
quote_wallet -= quantity.size * order.pair.quote
quote_wallet += order.quantity
trade = exchange._execute_sell_order(order, base_wallet, quote_wallet,
current_price)
assert trade
assert trade.size == 0.997 * BTC
assert trade.commission == 0.003 * BTC
def test_on_complete(mock_trade_class, mock_exchange_class, complete_listener):
exchange = mock_exchange_class.return_value
exchange.options = ExchangeOptions()
exchange.id = "fake_exchange_id"
exchange.name = "coinbase"
exchange.clock = mock.Mock()
exchange.clock.step = 0
exchange.quote_price = mock.Mock(return_value=Decimal(7000.00))
wallets = [Wallet(exchange, 10000 * USD), Wallet(exchange, 0 * BTC)]
portfolio = Portfolio(USD, wallets)
order = Order(step=0,
exchange_pair=ExchangePair(exchange, USD / BTC),
side=TradeSide.BUY,
trade_type=TradeType.MARKET,
quantity=5200.00 * USD,
portfolio=portfolio,
price=Decimal(7000.00))
order.attach(complete_listener)
order.execute()
trade = mock_trade_class.return_value
trade.size = Decimal(5197.00)
trade.quantity = trade.size * USD
trade.commission = 3.00 * USD
order.fill(trade)
assert not complete_listener.listened
order.complete()
assert complete_listener.listened
def test_init_empty():
portfolio = Portfolio(USD)
assert portfolio.base_instrument == USD
assert portfolio.base_balance == 0 * USD
assert portfolio.initial_balance == 0 * USD
assert len(portfolio.wallets) == 0
def test_cancel(mock_order_listener_class,
mock_trade_class,
mock_exchange_class):
exchange = mock_exchange_class.return_value
exchange.id = "fake_exchange_id"
wallets = [Wallet(exchange, 10000 * USD), Wallet(exchange, 0 * BTC)]
portfolio = Portfolio(USD, wallets)
order = Order(step=0,
exchange_name="coinbase",
side=TradeSide.BUY,
trade_type=TradeType.MARKET,
pair=USD / BTC,
quantity=5200.00 * USD,
portfolio=portfolio,
price=7000.00)
listener = mock_order_listener_class.return_value
listener.on_cancel = mock.Mock(return_value=None)
order.attach(listener)
order.execute(exchange)
# Execute fake trade
price = 7010.00
scale = order.price / price
commission = 3.00 * USD
trade = mock_trade_class.return_value
trade.size = scale * order.size - commission.size
trade.price = price
trade.commission = commission
base_wallet = portfolio.get_wallet(exchange.id, USD)
quote_wallet = portfolio.get_wallet(exchange.id, BTC)
base_size = trade.size + commission.size
quote_size = (order.price / trade.price) * (trade.size / trade.price)
base_wallet -= Quantity(USD, size=base_size, path_id=order.path_id)
quote_wallet += Quantity(BTC, size=quote_size, path_id=order.path_id)
order.fill(exchange, trade)
assert order.status == OrderStatus.PARTIALLY_FILLED
assert base_wallet.balance == 4800.00 * USD
assert round(base_wallet.locked[order.path_id].size, 2) == 7.42
assert quote_wallet.balance == 0 * BTC
assert round(quote_wallet.locked[order.path_id].size, 8) == 0.73925519
order.cancel()
listener.on_cancel.assert_called_once_with(order)
assert round(base_wallet.balance.size, 2) == 4807.42
assert order.path_id not in base_wallet.locked
assert round(quote_wallet.balance.size, 8) == 0.73925519
assert order.path_id not in quote_wallet.locked
def test_smoke():
cdd = CryptoDataDownload()
coinbase_btc = cdd.fetch("Coinbase", "USD", "BTC", "1h")
coinbase_eth = cdd.fetch("Coinbase", "USD", "ETH", "1h")
bitstamp_btc = cdd.fetch("Bitstamp", "USD", "BTC", "1h")
bitstamp_eth = cdd.fetch("Bitstamp", "USD", "ETH", "1h")
bitstamp_ltc = cdd.fetch("Bitstamp", "USD", "LTC", "1h")
steps = len(coinbase_btc)
coinbase = Exchange("coinbase", service=execute_order)(
Stream("USD-BTC", list(coinbase_btc['close'][-steps:])),
Stream("USD-ETH", list(coinbase_eth['close'][-steps:])))
bitstamp = Exchange("bitstamp", service=execute_order)(
Stream("USD-BTC", list(bitstamp_btc['close'][-steps:])),
Stream("USD-ETH", list(bitstamp_eth['close'][-steps:])),
Stream("USD-LTC", list(bitstamp_ltc['close'][-steps:])))
portfolio = Portfolio(USD, [
Wallet(coinbase, 200000 * USD),
Wallet(coinbase, 0 * BTC),
Wallet(bitstamp, 10000 * USD),
Wallet(bitstamp, 2 * BTC),
Wallet(bitstamp, 20 * ETH),
Wallet(bitstamp, 30 * LTC)
])
action_scheme = ManagedRiskOrders(
durations=[4, 6, 8, 10],
stop_loss_percentages=[0.01, 0.003, 0.3],
take_profit_percentages=[0.01, 0.003, 0.3],
trade_sizes=[0.99999999999999])
env = TradingEnvironment(action_scheme=action_scheme,
reward_scheme="simple",
portfolio=portfolio)
done = False
n_steps = 0
while not done:
action = env.action_space.sample()
obs, reward, done, info = env.step(action)
n_steps += 1
portfolio.ledger.as_frame().sort_values(["step",
"poid"]).to_clipboard(index=False)
df = portfolio.ledger.as_frame()
frames = []
for poid in df.poid.unique():
frames += [df.loc[df.poid == poid, :]]
pd.concat(frames, ignore_index=True, axis=0).to_clipboard(index=False)
pytest.fail("Failed.")
def test_init_from_wallet_tuples(exchange):
portfolio = Portfolio(USD,
wallets=[(exchange, USD, 10000), (exchange, BTC, 0)])
assert portfolio.base_instrument == USD
assert portfolio.base_balance == 10000 * USD
assert portfolio.initial_balance == 10000 * USD
assert len(portfolio.wallets) == 2
def test_init_from_wallets(exchange):
portfolio = Portfolio(USD, wallets=[
Wallet(exchange, 10000 * USD),
Wallet(exchange, 0 * BTC)
])
assert portfolio.base_instrument == USD
assert portfolio.base_balance == 10000 * USD
assert portfolio.initial_balance == 10000 * USD
assert len(portfolio.wallets) == 2
def main():
trading_pair = TradingPair(USD, BTC)
action = DynamicOrders(trading_pair)
exchange = CCXTExchange('bitmex', observation_pairs=[trading_pair],
timeframe='1m')
wallet = Wallet(exchange, .01 * BTC)
portfolio = Portfolio(USD, wallets=[wallet])
env = TradingEnvironment(portfolio, exchange, action, 'simple')
while True:
env.step(0)
env.render('human')
time.sleep(.02)
def create_env():
def fetch_data(exchange_name, symbol, timeframe):
url = "https://www.cryptodatadownload.com/cdd/"
filename = "{}_{}USD_{}.csv".format(exchange_name, symbol, timeframe)
volume_column = "Volume {}".format(symbol)
new_volume_column = "Volume_{}".format(symbol)
df = pd.read_csv(url + filename, skiprows=1)
df = df[::-1]
df = df.drop(["Symbol"], axis=1)
df = df.rename(
{
"Volume USD": "volume",
volume_column: new_volume_column
}, axis=1)
df = df.set_index("Date")
df.columns = [symbol + ":" + name.lower() for name in df.columns]
return df
ssl._create_default_https_context = ssl._create_unverified_context # Only used if pandas gives a SSLError
coinbase_data = pd.concat([
fetch_data("Coinbase", "BTC", "1h"),
fetch_data("Coinbase", "ETH", "1h")
],
axis=1)
coinbase = Exchange("coinbase", service=execute_order)(
Stream("USD-BTC", list(coinbase_data['BTC:close'])),
Stream("USD-ETH", list(coinbase_data['ETH:close'])))
with Module("coinbase") as coinbase_ns:
nodes = [
Stream(name, list(coinbase_data[name]))
for name in coinbase_data.columns
]
feed = DataFeed([coinbase_ns])
portfolio = Portfolio(USD, [
Wallet(coinbase, 10000 * USD),
Wallet(coinbase, 10 * BTC),
Wallet(coinbase, 5 * ETH),
])
env = TradingEnvironment(feed=feed,
portfolio=portfolio,
action_scheme='managed-risk',
reward_scheme='risk-adjusted',
window_size=20)
return env
def trading(agent_path, n_step = len(test),):
from tensortrade.exchanges import Exchange
from tensortrade.exchanges.services.execution.simulated import execute_order
from tensortrade.data import Stream, DataFeed, Module
from tensortrade.instruments import USD, BTC
from tensortrade.wallets import Wallet, Portfolio
coinbase = Exchange("coinbase", service=execute_order)(
Stream("USD-BTC", price_history['close'].tolist())
)
portfolio = Portfolio(USD, [
Wallet(coinbase, 10000 * USD),
Wallet(coinbase, 10 * BTC),
])
with Module("coinbase") as coinbase_ns:
nodes = [Stream(name, test[name].tolist()) for name in test.columns]
feed = DataFeed([coinbase_ns])
from tensortrade.environments import TradingEnvironment
env = TradingEnvironment(
feed=feed,
portfolio=portfolio,
action_scheme='managed-risk',
reward_scheme='risk-adjusted',
window_size=20
)
agent = DQNAgent(env)
agent.restore()
action = agent.env.action_space.sample()
state, reward, done, info = agent.env.step(action)
action = agent.get_action(state)
action = agent.env.action_space.sample()
step = 0
while not done and (step < n_steps):
state, reward, done, info = agent.env.step(action)
action = agent.get_action(state)
print('step:', step, '-- action:', action)
step += 1
env.portfolio.performance.plot(figsize=(16, 10))
env.portfolio.performance.net_worth.plot(figsize=(16, 10))
def test_update_on_single_exchange_with_multiple_orders(mock_exchange_class):
exchange = mock_exchange_class.return_value
exchange.id = "fake_exchange_id"
exchange.name = "coinbase"
wallets = [Wallet(exchange, 10000 * USD), Wallet(exchange, 0 * BTC)]
portfolio = Portfolio(USD, wallets)
broker = Broker(exchange)
# Submit order 1
o1 = Order(step=0,
exchange_name="coinbase",
side=TradeSide.BUY,
trade_type=TradeType.MARKET,
pair=USD / BTC,
quantity=5200.00 * USD,
portfolio=portfolio,
price=7000.00)
o1.is_executable_on = mock.MagicMock(side_effect=[False, True])
broker.submit(o1)
# Submit order 2
o2 = Order(step=0,
exchange_name="coinbase",
side=TradeSide.BUY,
trade_type=TradeType.MARKET,
pair=USD / BTC,
quantity=230.00 * USD,
portfolio=portfolio,
price=7300.00)
o2.is_executable_on = mock.MagicMock(side_effect=[True, False])
broker.submit(o2)
# No updates have been made yet
assert o1 in broker.unexecuted and o1 not in broker.executed
assert o2 in broker.unexecuted and o2 not in broker.executed
# First update
broker.update()
assert o1 in broker.unexecuted and o1.id not in broker.executed
assert o2 not in broker.unexecuted and o2.id in broker.executed
# Second update
broker.update()
assert o1 not in broker.unexecuted and o1.id in broker.executed
assert o2 not in broker.unexecuted and o2.id in broker.executed
def env():
context = {
"base_instrument": USD,
"actions": {
"pairs": [USD / BTC],
"stop_loss_percentages": [0.02, 0.04, 0.06],
"take_profit_percentages": [0.01, 0.02, 0.03],
"trade_sizes": 10,
"trade_side": TradeSide.BUY,
"trade_type": TradeType.MARKET,
"order_listener": None
},
"rewards": {
"return_algorithm": "sharpe",
"risk_free_rate": 0,
"target_returns": 0
},
"exchanges": {
"model_type": "FBM",
"hurst": 0.61,
"timeframe": "1d",
"base_price": 7500,
"base_volume": 12000
}
}
with TradingContext(**context):
action_scheme = ManagedRiskOrders()
reward_scheme = RiskAdjustedReturns()
exchange = Exchange()
portfolio = Portfolio(USD, [
Wallet(exchange, 100000 * USD),
Wallet(exchange, 0 * BTC)
])
env = TradingEnvironment(
portfolio=portfolio,
action_scheme=action_scheme,
reward_scheme=reward_scheme,
window_size=14,
enable_logger=False
)
return env
