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_cancel(mock_exchange_class, cancel_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(cancel_listener)
assert not cancel_listener.listened
order.cancel()
assert cancel_listener.listened
def test_properties(mock_exchange_class):
exchange = mock_exchange_class.return_value
exchange.options = ExchangeOptions()
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_pair=ExchangePair(exchange, USD / BTC),
side=TradeSide.BUY,
trade_type=TradeType.LIMIT,
quantity=5000.00 * USD,
portfolio=portfolio,
price=7000.00)
assert order
assert order.step == 0
assert order.base_instrument == USD
assert order.quote_instrument == BTC
assert order.size == 5000.00 * USD
assert order.price == 7000.00
assert order.trades == []
assert order.is_buy
assert not order.is_sell
assert not order.is_market_order
assert order.is_limit_order
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_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_release(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,
side=TradeSide.BUY,
trade_type=TradeType.MARKET,
pair=USD / BTC,
quantity=5200.00 * USD,
portfolio=portfolio,
price=7000.00)
order.execute(exchange)
wallet_usd = portfolio.get_wallet(exchange.id, USD)
assert wallet_usd.balance == 4800 * USD
assert wallet_usd.locked_balance == 5200 * USD
assert order.path_id in wallet_usd.locked.keys()
order.release()
assert wallet_usd.balance == 10000 * USD
assert wallet_usd.locked_balance == 0 * USD
assert order.path_id not in wallet_usd.locked.keys()
def test_fill(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,
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_fill = mock.Mock(return_value=None)
order.attach(listener)
order.execute(exchange)
trade = mock_trade_class.return_value
trade.size = 3997.00
trade.commission = 3.00 * USD
assert order.status == OrderStatus.OPEN
order.fill(exchange, trade)
assert order.status == OrderStatus.PARTIALLY_FILLED
assert order.remaining_size == 1200.00
listener.on_fill.assert_called_once_with(order, exchange, trade)
def test_str(mock_exchange_class):
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))
pattern = re.compile("<[A-Z][a-zA-Z]*:\\s(\\w+=.*,\\s)*(\\w+=.*)>")
string = str(order)
assert string
assert string == pattern.fullmatch(string).string
def test_init(mock_exchange_class):
exchange = mock_exchange_class.return_value
exchange.options = ExchangeOptions()
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_pair=ExchangePair(exchange, USD / BTC),
side=TradeSide.BUY,
trade_type=TradeType.MARKET,
quantity=5000 * USD,
price=7000,
portfolio=portfolio)
assert order
assert order.id
assert order.path_id
assert order.step == 0
assert order.quantity.instrument == USD
assert order.remaining == order.quantity
assert isinstance(order.pair, TradingPair)
assert order.pair.base == USD
assert order.pair.quote == BTC
def test_execute(mock_order_listener_class,
mock_exchange_class):
exchange = mock_exchange_class.return_value
exchange.id = "fake_id"
wallets = [Wallet(exchange, 10000 * USD), Wallet(exchange, 0 * BTC)]
portfolio = Portfolio(USD, wallets)
order = Order(step=0,
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_execute = mock.Mock(return_value=None)
order.attach(listener)
assert order.status == OrderStatus.PENDING
order.execute(exchange)
assert order.status == OrderStatus.OPEN
wallet_usd = portfolio.get_wallet(exchange.id, USD)
wallet_btc = portfolio.get_wallet(exchange.id, BTC)
assert wallet_usd.balance == 4800 * USD
assert wallet_usd.locked_balance == 5200 * USD
assert order.path_id in wallet_usd.locked.keys()
assert wallet_btc.balance == 0 * BTC
listener.on_execute.assert_called_once_with(order, exchange)
def test_invalid_deposit():
# Add to free unlocked balance with different instrument
wallet = Wallet(exchange, 10000 * USD)
with pytest.raises(IncompatibleInstrumentOperation):
wallet.deposit(500 * BTC, reason="test")
def test_iadd(mock_exchange_class, mock_order_spec_class):
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)
# Market order
order = Order(step=0,
exchange_pair=ExchangePair(exchange, USD / BTC),
side=TradeSide.BUY,
trade_type=TradeType.MARKET,
quantity=5000.00 * USD,
portfolio=portfolio,
price=Decimal(7000.00))
order_spec = mock_order_spec_class.return_value
assert len(order._specs) == 0
order += order_spec
assert len(order._specs) == 1
assert order_spec in order._specs
def test_release(mock_exchange_class):
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.execute()
wallet_usd = portfolio.get_wallet(exchange.id, USD)
assert wallet_usd.balance == 4800 * USD
assert wallet_usd.locked_balance == 5200 * USD
assert order.path_id in wallet_usd.locked.keys()
order.release()
assert wallet_usd.balance == 10000 * USD
assert wallet_usd.locked_balance == 0 * USD
assert order.path_id not in wallet_usd.locked.keys()
def test_is_complete(mock_exchange_class):
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
wallets = [Wallet(exchange, 10000 * USD), Wallet(exchange, 0 * BTC)]
portfolio = Portfolio(USD, wallets)
# Market order
order = Order(step=0,
exchange_pair=ExchangePair(exchange, USD / BTC),
side=TradeSide.BUY,
trade_type=TradeType.MARKET,
quantity=5000.00 * USD,
portfolio=portfolio,
price=Decimal(7000.00))
assert not order.is_complete()
order.remaining = 0 * USD
assert order.is_complete()
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_exchange_with_wallets_feed():
ex1 = Exchange("coinbase",
service=execute_order)(Array("USD-BTC", [7000, 7500, 8300]),
Array("USD-ETH", [200, 212, 400]))
ex2 = Exchange("binance",
service=execute_order)(Array("USD-BTC", [7005, 7600, 8200]),
Array("USD-ETH", [201, 208, 402]),
Array("USD-LTC", [56, 52, 60]))
wallet_btc = Wallet(ex1, 10 * BTC)
wallet_btc_ds = create_wallet_source(wallet_btc)
wallet_usd = Wallet(ex2, 1000 * USD)
wallet_usd -= 400 * USD
wallet_usd += Quantity(USD, 400, path_id="fake_id")
wallet_usd_ds = create_wallet_source(wallet_usd, include_worth=False)
feed = DataFeed([ex1, ex2, wallet_btc_ds, wallet_usd_ds])
assert feed.next() == {
"coinbase:/USD-BTC": 7000,
"coinbase:/USD-ETH": 200,
"coinbase:/BTC:/free": 10,
"coinbase:/BTC:/locked": 0,
"coinbase:/BTC:/total": 10,
"coinbase:/BTC:/worth": 70000,
"binance:/USD-BTC": 7005,
"binance:/USD-ETH": 201,
"binance:/USD-LTC": 56,
"binance:/USD:/free": 600,
"binance:/USD:/locked": 400,
"binance:/USD:/total": 1000
}
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_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_detach(mock_exchange_class, mock_order_listener_class):
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
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=5000.00 * USD,
portfolio=portfolio,
price=Decimal(7000.00))
listener = mock_order_listener_class.return_value
order.attach(listener)
assert len(order._listeners) == 1
assert listener in order._listeners
order.detach(listener)
assert len(order._listeners) == 0
assert listener not in order._listeners
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_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 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 test_add(portfolio, exchange):
wallet_bch = Wallet(exchange, 1000 * BCH)
portfolio.add(wallet_bch)
assert wallet_bch in portfolio.wallets
def test_invalid_iadd():
# Add to free unlocked balance with different instrument
wallet = Wallet(exchange, 10000 * USD)
with pytest.raises(IncompatibleInstrumentOperation):
wallet += 500 * BTC
def execute_sell_order(order: 'Order', base_wallet: 'Wallet',
quote_wallet: 'Wallet', current_price: float,
options: 'ExchangeOptions', clock: 'Clock') -> 'Trade':
if order.type == TradeType.LIMIT and order.price > current_price:
return None
filled = order.remaining.contain(order.exchange_pair)
commission = options.commission * filled
quantity = filled - commission
if commission.size < Decimal(10)**-quantity.instrument.precision:
order.cancel("COMMISSION IS LESS THAN PRECISION.")
return None
# Transfer Funds from Quote Wallet to Base Wallet
transfer = Wallet.transfer(source=quote_wallet,
target=base_wallet,
quantity=quantity,
commission=commission,
exchange_pair=order.exchange_pair,
reason="SELL")
trade = Trade(order_id=order.id,
step=clock.step,
exchange_pair=order.exchange_pair,
side=TradeSide.SELL,
trade_type=order.type,
quantity=transfer.quantity,
price=transfer.price,
commission=transfer.commission)
return trade
def test_total_balance():
wallet = Wallet(exchange, 10000 * USD)
wallet += Quantity(USD, 500, path_id=path_id)
wallet += Quantity(USD, 700, path_id=other_id)
assert wallet.total_balance == 11200 * USD
def test_init():
wallet = Wallet(exchange, 10000 * USD)
assert wallet.balance == 10000 * USD
assert wallet.exchange == exchange
assert wallet.instrument == USD
assert len(wallet.locked) == 0
def portfolio():
df1 = pd.read_csv("tests/data/input/coinbase_(BTC,ETH)USD_d.csv").tail(100)
df1 = df1.rename({"Unnamed: 0": "date"}, axis=1)
df1 = df1.set_index("date")
df2 = pd.read_csv("tests/data/input/bitstamp_(BTC,ETH,LTC)USD_d.csv").tail(
100)
df2 = df2.rename({"Unnamed: 0": "date"}, axis=1)
df2 = df2.set_index("date")
ex1 = Exchange("coinbase",
service=execute_order)(Stream("USD-BTC",
list(df1['BTC:close'])),
Stream("USD-ETH",
list(df1['ETH:close'])))
ex2 = Exchange("binance",
service=execute_order)(Stream("USD-BTC",
list(df2['BTC:close'])),
Stream("USD-ETH",
list(df2['ETH:close'])),
Stream("USD-LTC",
list(df2['LTC:close'])))
p = Portfolio(USD, [
Wallet(ex1, 10000 * USD),
Wallet(ex1, 10 * BTC),
Wallet(ex1, 5 * ETH),
Wallet(ex2, 1000 * USD),
Wallet(ex2, 5 * BTC),
Wallet(ex2, 20 * ETH),
Wallet(ex2, 3 * LTC),
])
return p
