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
