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_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_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_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_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 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_get_reward(self, net_worths): portfolio = Portfolio(USD) performance = pd.DataFrame({'net_worth': net_worths}) portfolio._performance = performance pct_chg = net_worths.pct_change() reward_scheme = SimpleProfit() assert reward_scheme.get_reward(portfolio) == pct_chg.iloc[ -1] # default window size 1 reward_scheme.window_size = 3 reward = ((1 + pct_chg.iloc[-1]) * (1 + pct_chg.iloc[-2]) * (1 + pct_chg.iloc[-3])) - 1 assert reward_scheme.get_reward(portfolio) == reward
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
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_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_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_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_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_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_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_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_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_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_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_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_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_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_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 test_init(): wallets = [Wallet(exchange, 10000 * USD), Wallet(exchange, 0 * BTC)] portfolio = Portfolio(base_instrument=USD, wallets=wallets) 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) assert order assert order.id assert order.path_id assert order.quantity.instrument == USD assert order.filled_size == 0 assert order.remaining_size == order.quantity assert isinstance(order.pair, TradingPair) assert order.pair.base == USD assert order.pair.quote == BTC
def test_adding_recipe(): wallets = [Wallet(exchange, 10000 * USD), Wallet(exchange, 0 * BTC)] portfolio = Portfolio(base_instrument=USD, wallets=wallets) 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 += Recipe( side=TradeSide.SELL, trade_type=TradeType.MARKET, pair=BTC / USD, criteria=StopLoss(direction=StopDirection.EITHER, up_percent=0.02, down_percent=0.10), ) assert order.pair
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))