def get_by_time(s, xh, search_window): """ :param s: "2017-08-21 20:00:00 PDT" :param xh: "gdax" :param search_window: Milliseconds """ return get_by_timestamp(epoch.to_long(s), xh, search_window)
def test__003(self): """ About capital signals """ timestamp = epoch.to_long('2017-08-21 06:00:00 PDT') acc1_js = ensure_test_data({ "uid": "backtesting_gdx_" + random_str(), "timestamp__long": timestamp, "exchange": "gdax", "country": "usa", "usd__num": 0.0, "eth__num": 0.0, "btc__num": 0.0 }) acc1 = AccountModel.build(acc1_js) acc1.db_save(es) acc2_js = ensure_test_data({ "uid": "backtesting_cex_" + random_str(), "timestamp__long": timestamp, "exchange": "cex", "country": "gbr", "usd__num": 1700.0, "eth__num": 0.0, "btc__num": 0.0 }) acc2 = AccountModel.build(acc2_js) acc2.db_save(es) trading_acc1 = BacktestingTradingAccount(acc1.uid, 'gdax') trading_acc2 = BacktestingTradingAccount(acc2.uid, 'cex') strat = Strat1(trading_acc1, trading_acc2) signal = strat.get_signal__available_to_deposit(timestamp) assert signal['signal'] == False
def test__001(self): timestamp = epoch.to_long('2017-08-21 13:00:00 PDT') amount = 1000.0 trading_acc1 = BacktestingTradingAccount(None, 'gdax') ob = trading_acc1.get_order_book(ticker='eth-usd', timestamp=timestamp) shares = helpers.compute_shares_needed(amount, ob) assert shares == amount / 330.2
def test__002(self): timestamp = epoch.to_long('2017-08-23 20:00:00 PDT') amount = 20000.0 trading_acc1 = BacktestingTradingAccount(None, 'gdax') ob = trading_acc1.get_order_book(ticker='eth-usd', timestamp=timestamp) shares = helpers.compute_shares_needed(amount, ob) direct_calculation = 45.39426145+0.03269+(amount-45.39426145*316.17-0.03269*316.01)/316.0 assert shares == direct_calculation
def test__004(self): timestamp = epoch.to_long('2017-08-23 20:00:00 PDT') shares = 25.86 trading_acc1 = BacktestingTradingAccount(None, 'gdax') ob = trading_acc1.get_order_book(ticker='eth-usd', timestamp=timestamp) usd = helpers.compute_usd_spent(shares, ob) direct_calculation = 316.19 * 25.86 assert usd == direct_calculation
def test__003(self): """ go """ timestamp = epoch.to_long('2017-08-22 08:00:00 PDT') trading_acc1 = BacktestingTradingAccount(None, 'gdax') trading_acc2 = BacktestingTradingAccount(None, 'cex') strat = Strat1(trading_acc1, trading_acc2) signal = strat.get_signal__withdraw_delta(timestamp) assert signal['signal'] == True
def test__005(self): """ no go """ timestamp = epoch.to_long('2017-08-22 06:00:00 PDT') trading_acc1 = BacktestingTradingAccount(None, 'gdax') trading_acc2 = BacktestingTradingAccount(None, 'cex') strat = Strat1(trading_acc1, trading_acc2) signal = strat.get_signal__deposit_delta(timestamp) assert signal['signal'] == False
def get_ds(strategy_run_id, check_window): window = tuple(epoch.to_long(x) for x in check_window) query = { "size": 1000, "sort": [{ "timestamp__long": { "order": "asc" } }], "query": { "bool": { "must": [{ "match": { "strategy_run_id.raw": strategy_run_id } }, { "range": { "timestamp__long": { "gte": window[0], "lte": window[1] } } }] } } } logger.info(pretty_json(query)) hits = es.search('audit_trading', 'data', query)['hits']['hits'] # Data vectors x = [] y_total_usd = [] y_gdax_usd = [] y_cex_usd = [] for hit in hits: hit = hit['_source'] x.append(hit['timestamp__long']) y_total_usd.append(hit['total_usd__num']) y_gdax_usd.append(hit['gdax_account']['usd__num']) y_cex_usd.append(hit['cex_account']['usd__num']) # Data series x_index = pd.to_datetime(x, unit='ms') ds1 = pd.Series(index=x_index, data=y_total_usd) ds2 = pd.Series(index=x_index, data=y_gdax_usd) ds3 = pd.Series(index=x_index, data=y_cex_usd) return ds1, ds2, ds3
def get_ds_trading_result(check_window, check_interval, amount, holding_period, threshold_delta, gdax_trading_account, cex_trading_account): """ data series in dates that: 1. show trading results """ window = tuple(epoch.to_long(x) for x in check_window) interval = MILLIS_IN_MINUTE * check_interval x = [] y1 = [] y2 = [] # Use the strategy to calculate deltas strategy001 = Strat1(None, None, [gdax_trading_account, cex_trading_account]) n = (window[1] - window[0]) / interval timestamp = window[0] for i in range(n): withdraw_signal = strategy001.get_signal__withdraw_delta(timestamp) withdraw_delta = withdraw_signal['withdraw_delta'] if withdraw_delta > threshold_delta: result = trade_result(amount, holding_period, timestamp, gdax_trading_account, cex_trading_account) x.append(timestamp) y1.append(withdraw_delta) y2.append(result) # print i, timestamp, epoch.to_str(timestamp), withdraw_delta, result # next timestamp timestamp += interval # checking progress if i % 50 == 0: logger.info("[{}] timestamp:{}|date:{}".format(str(i), str(timestamp), epoch.to_str(timestamp))) x_index = pd.to_datetime(x, unit='ms') ds1 = pd.Series(index=x_index, data=y1) ds2 = pd.Series(index=x_index, data=y2) logger.info(check_window) logger.info(window) logger.info(ds1.head()) logger.info(ds1.head()) return ds1, ds2
def get_two_deltas(check_window, check_interval): window = tuple(epoch.to_long(x) for x in check_window) interval = MILLIS_IN_MINUTE * check_interval x = [] y1 = [] y2 = [] # Use the strategy to calculate deltas gdax_t_account = BacktestingTradingAccount('backtesting_gdx_001', 'gdax') cex_t_account = BacktestingTradingAccount('backtesting_cex_001', 'cex') strategy001 = Strat1(None, None, [gdax_t_account, cex_t_account]) n = (window[1] - window[0]) / interval timestamp = window[0] for i in range(n): withdraw_signal = strategy001.get_signal__withdraw_delta(timestamp) deposit_signal = strategy001.get_signal__deposit_delta(timestamp) withdraw_delta = withdraw_signal['withdraw_delta'] deposit_delta = deposit_signal['deposit_delta'] x.append(timestamp) y1.append(withdraw_delta) y2.append(deposit_delta) # print i, timestamp, epoch.to_str(timestamp) # next timestamp timestamp += interval # checking progress if i % 50 == 0: logger.info("timestamp:{0}|date:{1}".format(str(timestamp), epoch.to_str(timestamp))) x_index = pd.to_datetime(x, unit='ms') ds1 = pd.Series(index=x_index, data=y1) ds2 = pd.Series(index=x_index, data=y2) logger.info(check_window) logger.info(window) logger.info(ds1.head()) logger.info(ds1.head()) return ds1, ds2
import time import pytz import datetime from arb.utils.epoch import current_milli_time, to_str, to_long if __name__ == '__main__': t = current_milli_time() s = to_str(t) t2 = to_long(s) print t print s print t2 time1 = '2017-08-28 09:00:00 PDT' time2 = '2017-08-29 09:00:00 PDT' print to_long(time1) print to_long(time2) pass
def get_results_for_a_mock_strategy(check_window, check_interval, amount, holding_period, threshold_delta, gdax_trading_account, cex_trading_account): """ keep track of how we we are doing with one trade at a time """ window = tuple(epoch.to_long(x) for x in check_window) interval = MILLIS_IN_MINUTE * check_interval x = [] y1 = [] y2 = [] # Use the strategy to calculate deltas strategy001 = Strat1(None, None, [gdax_trading_account, cex_trading_account]) n = (window[1] - window[0]) / interval ONE_DAY_IN_MINUTES =1440 cash = amount eth = 0.0 waiting_liquidate_ticks = 0 waiting_capital_ticks = ONE_DAY_IN_MINUTES # def signal__has_eth(): # return eth > 0.0 timestamp = window[0] for i in range(n): waiting_liquidate_ticks += check_interval waiting_capital_ticks += check_interval withdraw_signal = strategy001.get_signal__withdraw_delta(timestamp) withdraw_delta = withdraw_signal['withdraw_delta'] # handling gdax if withdraw_delta >= threshold_delta and eth == 0.0 and waiting_capital_ticks >= ONE_DAY_IN_MINUTES: gdax_ob = gdax_trading_account.get_order_book(ticker='eth', timestamp=timestamp) shares = helpers.compute_buy(amount, gdax_ob) usd_used = helpers.compute_usd_spent(shares, gdax_ob) # accounting cash = cash - usd_used eth = eth + shares * (1 - 0.003) # Including fees waiting_liquidate_ticks = 0 waiting_capital_ticks = 0 # x.append(timestamp) # y1.append(cash) # y2.append(eth) if eth > 0.0 and waiting_liquidate_ticks >= holding_period: cex_ob = cex_trading_account.get_order_book(ticker='eth', timestamp=timestamp) shares = eth usd_gotten = helpers.compute_usd_made(shares, cex_ob) * (1 - 0.002) # Including fees # accounting cash = cash + usd_gotten eth = 0 x.append(timestamp) y1.append(cash) y2.append(eth) print i, epoch.to_str(timestamp) print "cash: {} | eth: {}".format(str(cash), str(eth)) print "capital tick: {} | liquidate tick: {}".format(waiting_capital_ticks, waiting_liquidate_ticks) # next timestamp timestamp += interval # checking progress # print i, epoch.to_str(timestamp) # print "cash: {} | eth: {}".format(str(cash), str(eth)) # print "capital tick: {} | liquidate tick: {}".format(waiting_capital_ticks, waiting_liquidate_ticks) if i % 50 == 0: print i, epoch.to_str(timestamp) print "cash: {} | eth: {}".format(str(cash), str(eth)) print "capital tick: {} | liquidate tick: {}".format(waiting_capital_ticks, waiting_liquidate_ticks) x_index = pd.to_datetime(x, unit='ms') ds1 = pd.Series(index=x_index, data=y1) ds2 = pd.Series(index=x_index, data=y2) logger.info(check_window) logger.info(window) logger.info(ds1.head()) return ds1, ds2
if __name__ == '__main__': # ------------------- # Signals Environment # ------------------- # check_window = ("2017-09-13 00:00:00 PDT", "2017-09-18 08:00:00 PDT") # check_interval = 30 # In minutes # # ds1, ds2 = do_work(check_window, check_interval) timestamp = epoch.to_long("2017-10-01 00:00:00 PDT") gdax_trading_account = BacktestingTradingAccount('gdax', 'gdax') cex_trading_account = BacktestingTradingAccount('cex', 'cex') # gdax_ob = gdax_trading_account.get_order_book(ticker='eth', timestamp=timestamp) # cex_ob = cex_trading_account.get_order_book(ticker='eth', timestamp=timestamp) one_result = trade_result(10000.0, 40, timestamp, gdax_trading_account, cex_trading_account) print one_result # def get_ds_trading_result(check_window, check_interval, amount, holding_period, threshold_delta, # gdax_trading_account, cex_trading_account): check_window = ("2017-09-13 00:00:00 PDT", "2017-09-14 08:00:00 PDT") check_interval = 30 # In minutes