def run(self, trade_time, trade_price, trade_size):
self.price_array.append(trade_price)
self.size_array.append(trade_size)
if len(self.price_array) == int(self.tick):
self.data['low'].append(min(self.price_array))
self.data['high'].append(max(self.price_array))
self.data['volume'].append(sum(self.size_array))
close = self.price_array[-1]
self.data['close'].append(close)
if len(self.data['volume']) > 1:
force = ((close - self.data['close'][-2]) *
self.data['volume'][-1])
else:
force = 0
self.data['force'].append(force)
force_array = np.array(self.data['force']).astype('double')
ema = stream.EMA(force_array, timeperiod=self.force_ema_period)
if math.isnan(ema):
self.data['ema'].append(0)
else:
self.data['ema'].append(ema)
self.price_array.clear()
self.size_array.clear()
def longterm():
# part where I manage the non-funding long/shorts using 1054, 373 dual ema
global desired_contracts, recalculate_flag, previous_trade
old_desired_direction = 'none'
previous_calc_time = datetime.datetime.now(
tz=pytz.UTC) - datetime.timedelta(minutes=200)
ema1 = []
ema2 = []
recalculate_flag = False
old_desired_direction = None
if os.path.isfile('previous_trade'):
previous_trade = pickle.load(open('previous_trade', 'rb'))
if previous_trade > 0:
old_desired_direction = 'long'
else:
old_desired_direction = 'short'
else:
previous_trade = None
recalculate_flag = True
sleep(10)
while True:
now = datetime.datetime.now(tz=pytz.UTC)
if previous_calc_time and now.minute == previous_calc_time.minute and not recalculate_flag:
sleep(1)
continue
while bm.ws.exited or not bm.ws.wst.is_alive():
bm.reconnect()
sleep(1)
if not testing:
with lock:
while not get_history_bitmex.main(bm):
pass
time_since_prev_calc = datetime.datetime.now(
tz=pytz.UTC) - previous_calc_time
# num_to_calculate = int(time_since_prev_calc.seconds / 60)
previous_calc_time = datetime.datetime.now(tz=pytz.UTC)
with lock:
globalvar.dbcur.execute(
"SELECT * FROM bmxswap ORDER BY time DESC limit 1427")
data = globalvar.dbcur.fetchall()
data = np.array(data[::-1])
# while num_to_calculate > 0:
while len(ema1) < 373:
offset = 373 - len(ema1)
truncated_data = data[-offset - 1054:-offset]
ema1.append(ta.EMA(truncated_data[:, 4], timeperiod=1054))
while len(ema2) < 3:
offset = 3 - len(ema2)
truncated_data_ema1 = ema1[-offset - 373:-offset]
ema2.append(ta.EMA(np.array(truncated_data_ema1), timeperiod=370))
if old_desired_direction is None:
if ema2[-1] > ema2[-2]:
old_desired_direction = 'long'
else:
old_desired_direction = 'short'
prediction_ema = ema2[-1] > ema2[-2]
if prediction_ema > 0: #
desired_direction = 'long'
if desired_direction != old_desired_direction:
logger.info("longterm going long")
recalculate_flag = True
logger.debug("continuing going long")
else:
desired_direction = 'short'
if desired_direction != old_desired_direction:
logger.info("longterm going short")
recalculate_flag = True
logger.debug("continuing going short")
if np.nan in np.array(ema1):
logger.critical("got NAN in prediction_ema, restarting")
# trade(0)
with lock:
desired_contracts = 0
sleep(10)
while bm.position(symbol)['currentQty'] != 0:
sleep(1)
pass
raise ValueError("got NAN in prediction_EMA")
if recalculate_flag:
desired_contracts_longterm = desired_contracts_func(
desired_direction=desired_direction, leverage_desired=5)
previous_trade = desired_contracts_longterm
recalculate_flag = False
pickle.dump(desired_contracts_longterm,
open('previous_trade', 'wb'))
else:
desired_contracts_longterm = previous_trade
# num_to_calculate += 1
while bm.ws.exited or not bm.ws.wst.is_alive():
bm.reconnect()
sleep(1)
# trade(desired_contracts_outer, longterm=True)
if funding_has_control is False:
with lock:
desired_contracts = desired_contracts_longterm
# finishing up
del ema1[0]
del ema2[0]
old_desired_direction = desired_direction
recalculate_flag = False
def objective(variables, data=None, size=None, train=None, plot=None):
variables[0], variables[1] = \
int(variables[0]), int(variables[1])
usd = 100.0 # investing 5 dollars at 20x
position = []
long = False
in_position = False
trades = 0
EMA_length = max(int(variables[0]), int(variables[1])) + 1
#EMA_length = min(EMA_length, 80000)
ema1, ema2, adx, plusdi, minusdi, buyselllist= [], [], [100], [], [], []
# plusdi_ema, minusdi_ema, adx_ema = 0,0,0
returns = 100
initialized = False
max_draw_down = 0
mdd_relative = 0
peak_value = 0
stoploss_triggers = 0
reversal_flag = False
local_return_graph_x = []
local_return_graph_y = []
#if abs(variables[0]) > abs(variables[2]) + abs(variables[4]): return 0
#if abs(variables[4]) > abs(variables[2]) + abs(variables[0]): return 0
#variables[0], variables[2], variables[4] = 0,0,0\
#ema1_ema, ema2_ema = 0,0
for iteration in range(size):
if iteration > .9 * size and train: break
if iteration < .9 * size and not train: continue # use 90% train, 10% test, separated in time
line = data[-1 * size + iteration] # single line
if iteration != size - 1:
max_exec_price = np.amax(data[[[-1 * size + iteration],[-1*size+iteration+2]], [1,2,3,4]])
min_exec_price = np.amin(data[[[-1 * size + iteration],[-1*size+iteration+2]], [1,2,3,4]])
else:
max_exec_price = np.amax(line[1:5])
min_exec_price = np.amin(line[1:5])
# for item in [plusdi_ema, minusdi_ema, adx_ema]:
# if item == 0: item = line[1]
try:
# multiplier = (2 / (variables[1] + 1))
truncated_data = data[-1 * size + iteration - EMA_length:-1 * size + iteration, :] # numpy array view
ema1.append(ta.EMA(truncated_data[:, 4], timeperiod=variables[0]))
# adx_close = ta.ADX(truncated_data[:, 2], truncated_data[:, 3], truncated_data[:, 4], timeperiod=variables[2])/(100/variables[2])
# if len(adx) == 0: adx = [adx_close]
# else:
# adx.append((adx_close - adx[-1]) * multiplier + adx[-1])
# plusdi_close = ta.PLUS_DI(truncated_data[:, 2], truncated_data[:, 3], truncated_data[:, 4], timeperiod=variables[2])/(100/variables[2])
# if len(plusdi) == 0: plusdi = [plusdi_close]
# else:
# plusdi.append((plusdi_close - plusdi[-1]) * multiplier + plusdi[-1])
# minusdi_close = ta.MINUS_DI(truncated_data[:, 2], truncated_data[:, 3], truncated_data[:, 4], timeperiod=variables[2])/(100/variables[2])
# if len(minusdi) == 0: minusdi = [minusdi_close]
# else:
# minusdi.append((minusdi_close - minusdi[-1]) * multiplier + minusdi[-1])
#print(int((variables[1]/stddev[-1])*.0056), stddev[-1])
ema2.append(ta.EMA(truncated_data[:, 4], timeperiod=variables[1])) # todo change
ema1_last = ema1[-1]
ema2_last = ema2[-1]
if math.isnan(adx[-1]) or math.isnan(ema1[-1]) or math.isnan(ema2[-1]):
raise ValueError
except:
print(list(variables), EMA_length)
print(ema1, ema2, adx)
e = sys.exc_info()
print(("<p>Error: %s</p>" % e))
# multiplier = (2 / (10 + 1))
# plusdi_ema = (plusdi[-1] - plusdi_ema) * multiplier + plusdi_ema
# minusdi_ema = (minusdi[-1] - minusdi_ema) * multiplier + minusdi_ema
# plusdi_ema = (adx[-1] - adx_ema) * multiplier + adx_ema
if (iteration <= 1 and train) or (iteration <= .9 * size + 1 and not train): continue
truncated_data = data[-1 * size + iteration - EMA_length:-1 * size + iteration, :] # numpy array view
buy = 0
sell = 0
# if ema1[-1] > line[1]:
# buy += variables[0] #* (ema1[-1] - line[1])
# else:
# sell += variables[0] #* (ema1[-1] - line[1])
# if ema2[-1] > line[1]:
# buy += variables[2] #* (ema2[-1] - line[1])
# else:
# sell += variables[2] #* (ema2[-1] - line[1])
if ema1[-1] > ema2[-1]:
#if plusdi[-1] > minusdi[-1]:
buy += 1
else:
sell += 1
buy_sell = buy - sell
buyselllist.append(buy_sell)
#print(buy_sell) # todo debug
# end programmable bits, begin simulation
if not initialized:
initialized = True
if buy_sell > 0: # only executed on first run, from dollars to btc/shorts
position = [usd * .9997, max_exec_price] # store entry price
usd = 0
long = True
in_position = True
last_trade_time = iteration
if plot:
#global long_enter_x
#global long_enter_y
long_enter_x.append(line[0])
long_enter_y.append(line[1]-.1)
return_graph_x.append(line[0])
return_graph_y.append(position[0])
local_return_graph_x.append(line[0])
local_return_graph_y.append(position[0])
continue
elif buy_sell < 0:
position = [usd * .9997, min_exec_price] # store entry price
usd = 0
long = False
in_position = True
last_trade_time = iteration
if plot:
#global short_enter_x
#global short_enter_y
short_enter_x.append(line[0])
short_enter_y.append(line[1]+.1)
return_graph_x.append(line[0])
return_graph_y.append(position[0])
local_return_graph_x.append(line[0])
local_return_graph_y.append(position[0])
continue
else:
if buy_sell > 0:
long = True
in_position = False
last_trade_time = iteration
trailing_stop_max = 0
continue
if buy_sell < 0:
long = False
in_position = False
last_trade_time = iteration
trailing_stop_max = 0
continue
time_since_last_trade = iteration - last_trade_time
if in_position and position[0] > peak_value:
peak_value = position[0]
if initialized and in_position:
if long:
returns = usd + (line[1] / position[1]) * position[0]
draw_down = (returns - peak_value) / peak_value
if draw_down < max_draw_down:
max_draw_down = draw_down
#if plot: print("new mdd long from", position[1], "to", line[1])
dd_relative = (returns - position[0]) / position[0]
trailing_stop_max = (line[1] - np.max(data[-size + last_trade_time:-size + iteration, 4])) / np.max(
data[-size + last_trade_time:-size + iteration, 4])
if dd_relative < mdd_relative:
mdd_relative = dd_relative
# if plot: print("new relative dd long from", position[1], "to", line[1], "at", iteration)
else:
returns = usd + (position[1] /line[1]) * position[0]
draw_down = (returns - peak_value) / peak_value
if draw_down < max_draw_down:
max_draw_down = draw_down
#if plot: print("new mdd short from", position[1], "to", line[1])
dd_relative = (returns - position[0]) / position[0]
trailing_stop_max = (np.min(data[-size + last_trade_time:-size + iteration, 4]) - line[1]) / line[1]
if dd_relative < mdd_relative:
mdd_relative = dd_relative
# if plot: print("new rel dd short from", position[1], "to", line[1], "at", iteration)
if not in_position:
returns = usd
if long:
trailing_stop_max = (line[1] - np.min(data[-size + last_trade_time:-size + iteration, 4])) / np.min(data[-size + last_trade_time:-size + iteration, 4])
else:
trailing_stop_max = (np.max(data[-size + last_trade_time:-size + iteration, 4]) - line[1]) / line[1]
if in_position:
if long:
# if adx[-1] > variables[3]:# and line[1] > ema2[-1] - (ema2[-1] * variables[4]): # trailing_stop_max > variables[4]:
desire_position = True
# else:
# desire_position = False
else:
# if adx[-1] > variables[3]:# and line[1] < ema2[-1] + (ema2[-1] * variables[4]):
desire_position = True
# else:
# desire_position = False
if not in_position:
if long:
# if adx[-1] > variables[3]:# and line[1] > ema2[-1]: # and trailing_stop_max > -variables[4] * 4:
desire_position = True
# else:
# desire_position = False
else:
# if adx[-1] > variables[3]:# and line[1] < ema2[-1]:
desire_position = True
# else:
# desire_position = False
if not desire_position and in_position: # stop loss section 1
if not long:
usd = (position[1] / max_exec_price) * position[0]
position = 0
# position = [usd * .9997, max(line[1:5])]
# usd = 0.0
#long = False
in_position = False
stoploss_triggers += 1
last_trade_time = iteration
reversal_flag = True
if plot:
#global short_exit_x
#global short_exit_y
short_exit_x.append(line[0])
short_exit_y.append(line[1] + .1)
return_graph_x.append(line[0])
return_graph_y.append(returns)
local_return_graph_x.append(line[0])
local_return_graph_y.append(returns)
continue
if long: # stoploss part 1
usd = (min_exec_price / position[1]) * position[0] # assume bad execution
position = 0
# position = [usd * .9997, min(line[1:5])]
# usd = 0.0
#long = True
in_position = False
stoploss_triggers += 1
last_trade_time = iteration
reversal_flag = True
if plot:
#global long_exit_x
#global long_exit_y
long_exit_x.append(line[0])
long_exit_y.append(line[1] - .1)
return_graph_x.append(line[0])
return_graph_y.append(returns)
local_return_graph_x.append(line[0])
local_return_graph_y.append(returns)
continue
upper_bound = ema2[-1] * (1+(variables[2]*(variables[3]-(min(time_since_last_trade, variables[4])/(variables[4]/(variables[3]-1))))))
lower_bound = ema2[-1] * (1-(variables[2]*(variables[3]-(min(time_since_last_trade, variables[4])/(variables[4]/(variables[3]-1))))))
if desire_position and in_position: # section 2
if long: # section where we release control back to buy_sell
if line[1] < lower_bound:
reversal_flag = False
else:
if line[1] > upper_bound:
reversal_flag = False
if long:
if buy_sell > 0.0:
reversal_flag = False
else:
if buy_sell < 0.0:
reversal_flag = False
if not long and ((buy_sell > 0.0) or (line[1] > upper_bound)) and not reversal_flag: # main buy/sell
usd = (position[1] / max_exec_price) * position[0]
position = 0
position = [usd * .9997, max_exec_price]
usd = 0.0
long = True
in_position = True
trades += 1
last_trade_time = iteration
if line[1] > upper_bound:
reversal_flag = True
stoploss_triggers += 1
else:
reversal_flag = False
if plot:
#global long_enter_x
#global long_enter_y
long_enter_x.append(line[0])
long_enter_y.append(max_exec_price-.1)
return_graph_x.append(line[0])
return_graph_y.append(returns)
local_return_graph_x.append(line[0])
local_return_graph_y.append(returns)
continue
if long and ((buy_sell < 0.0) or (line[1] < lower_bound)) and not reversal_flag: # main buy/sell 2
# on 20x
usd = (min_exec_price / position[1]) * position[0] # assume bad execution
position = 0
position = [usd * .9997, min_exec_price]
usd = 0.0
long = False
in_position = True
trades += 1
last_trade_time = iteration
if line[1] < lower_bound:
reversal_flag = True
stoploss_triggers += 1
else:
reversal_flag = False
if plot:
#global short_enter_x
#global short_enter_y
short_enter_x.append(line[0])
short_enter_y.append(min_exec_price+.1)
return_graph_x.append(line[0])
return_graph_y.append(returns)
local_return_graph_x.append(line[0])
local_return_graph_y.append(returns)
continue
if not desire_position and not in_position: # section 3
if not long and ((buy_sell > 0.0) ^ (line[1] > upper_bound)): # moves understanding of long/short desire despite not being in position
#usd = (position[1] / max(line[1:5])) * position[0]
#position = 0
#position = [usd * .9997, max(line[1:5])]
#usd = 0.0
long = True
#in_position = True
#trades += 1
last_trade_time = iteration
if line[1] > ema2[-1] * (1 + variables[2]):
reversal_flag = True
else:
reversal_flag = False
# if plot:
# #global long_enter_x
# #global long_enter_y
# long_enter_x.append(line[0])
# long_enter_y.append(line[1]-.1)
# return_graph_x.append(line[0])
# return_graph_y.append(returns)
continue
if long and ((buy_sell < 0.0) ^ (line[1] < lower_bound)): # moves understanding of long/short desire despite not being in position
#usd = (min(line[1:5]) / position[1]) * position[0]
#position = 0
# position = [usd * .9997, min(line[1:5])]
# usd = 0.0
long = False
# in_position = True
# trades += 1
last_trade_time = iteration
if line[1] < lower_bound:
reversal_flag = True
else:
reversal_flag = False
# if plot:
# #global short_enter_x
# #global short_enter_y
# short_enter_x.append(line[0])
# short_enter_y.append(line[1]+.1)
# return_graph_x.append(line[0])
# return_graph_y.append(returns)
continue
if desire_position and not in_position: # if adx reverses direction, reenter position section 4
if not long: #
#usd = (position[1] / max(line[1:5])) * position[0]
#position = 0
position = [usd * .9997, min_exec_price]
usd = 0.0
#long = True
in_position = True
trades += 1
last_trade_time = iteration
reversal_flag = False
if plot:
#global short_enter_x
#global short_enter_y
short_enter_x.append(line[0])
short_enter_y.append(line[1]+.1)
return_graph_x.append(line[0])
return_graph_y.append(returns)
local_return_graph_x.append(line[0])
local_return_graph_y.append(returns)
continue
if long:
#usd = (min(line[1:5]) / position[1]) * position[0] # assume bad execution
#position = 0
position = [usd * .9997, min_exec_price]
usd = 0.0
#long = False
in_position = True
trades += 1
last_trade_time = iteration
reversal_flag = False
if plot:
#global long_enter_x
#global long_enter_y
long_enter_x.append(line[0])
long_enter_y.append(line[1] - .1)
return_graph_x.append(line[0])
return_graph_y.append(returns)
local_return_graph_x.append(line[0])
local_return_graph_y.append(returns)
continue
if returns < 50 and not plot: # fail-quick
returns = 0
position = [0, line[1]]
max_draw_down = -.9271
break
ema1_switches = 0
for index, item in enumerate(ema1):
if (item > ema1[index-1]) is not (ema1[index-1] > ema1[index-2]):
ema1_switches += 1
ema2_switches = 0
for index, item in enumerate(ema2):
if (item > ema2[index - 1]) is not (ema2[index - 1] > ema2[index - 2]):
ema2_switches += 1
macd_switches = 0
for index, item in enumerate(buyselllist):
if (item > 0) is not (buyselllist[index-1] > 0):
macd_switches += 1
buyselllist = []
longest_time_since_last_high = 0
for index, tick in enumerate(local_return_graph_y): # TODO TEMPORARY
if index == 0:
buyselllist.append(0)
continue
#print((tick - local_return_graph_y[index - 1]) / tick)
buyselllist.append((tick - local_return_graph_y[index - 1]) / tick)
print(sorted(buyselllist))
if plot:
for leverage in range(1, 101):
max_value = 0
last_value = 0
time_of_last_high = local_return_graph_x[0]
time_since_last_high = 0
for tickindex, tick in enumerate(local_return_graph_y):
if tickindex == 0:
max_value = tick
last_value = tick
continue
delta = (tick - local_return_graph_y[tickindex - 1]) / tick
delta *= leverage
last_value *= delta + 1
if last_value > max_value:
time_since_last_high = local_return_graph_x[tickindex] - time_of_last_high
time_of_last_high = local_return_graph_x[tickindex]
if time_since_last_high > longest_time_since_last_high:
longest_time_since_last_high = time_since_last_high
max_value = last_value
if last_value < max_value / float(4):
break
if last_value < max_value / float(4): # when broken out of the inner for by too much leverage
max_leverage = leverage - 1
break
elif leverage == 100:
print("got max leverage 100 somehow")
max_leverage = leverage
break
# max_leverage = min(math.floor(-1/min(mdd_relative, -.0001)), max_leverage)
# print(max(adx), "avg:", np.average(adx), min(adx))
if plot:
print (ema1_switches, ema2_switches, "trade signals:", macd_switches, "MDD%", max_draw_down * 100, "dd_rel%:", mdd_relative * 100, "max leverage:", max_leverage)
else:
print(ema1_switches, ema2_switches, "trade signals:", macd_switches, "MDD%", max_draw_down * 100, "dd_rel%:",
mdd_relative * 100)
#print(max(atr), min(atr))
#print("min, max, stddev, avg of stddev", min(stddev), max(stddev), np.std(stddev), np.average(stddev))
if plot:
global plot_minusdi
global plot_plusdi
if train:
plt.plot(data[int(-len(ema1)-(size/10)):int(-(size/10)), 0], ema1)
plt.plot(data[int(-len(ema2)-(size/10)):int(-(size/10)), 0], ema2)
##global plot_adx
# plot_adx += adx
plot_minusdi += minusdi
plot_plusdi += plusdi
else:
plt.plot(data[-len(ema1):, 0], ema1)
plt.plot(data[-len(ema2):, 0], ema2)
# global plot_adx
# plot_adx += adx
plot_minusdi += minusdi
plot_plusdi += plusdi
if long and in_position:
returns = usd + (min_exec_price / position[1]) * position[0]
if plot:
return_graph_x.append(line[0])
return_graph_y.append(returns)
local_return_graph_x.append(line[0])
local_return_graph_y.append(returns)
elif in_position:
returns = usd + (position[1] / max_exec_price) * position[0]
if plot:
return_graph_x.append(line[0])
return_graph_y.append(returns)
local_return_graph_x.append(line[0])
local_return_graph_y.append(returns)
if not in_position:
returns = usd
if plot:
return_graph_x.append(line[0])
return_graph_y.append(returns)
local_return_graph_x.append(line[0])
local_return_graph_y.append(returns)
if trades < 20 and not plot and train: returns = 0
print(list(variables), returns, trades)
if plot:
print("Score metric:", returns * (1 + max_draw_down), "stoplosses hit:", stoploss_triggers,
"longest defecit:", round(longest_time_since_last_high/86400., 2), "days")
else:
print("Score metric:", returns * (1 + max_draw_down), "stoplosses hit:", stoploss_triggers)
return -(returns * (1 + max_draw_down))
def objective(variables,
data=None,
size=None,
train=None,
plot=None,
try_leverages=None):
variables[0] = int(variables[0])
variables[1] = int(variables[1])
if variables[0] < variables[1]: variables[1] = variables[0]
usd = 1.0 # investing 5 dollars at 20x
# position = []
long = False
in_position = False
trades = 0
EMA_length = int(variables[0]) + 1
# EMA_length = max(EMA_length, 80000)
ema1, ema2, adx, plusdi, minusdi, buyselllist = [], [], [100], [], [], []
# plusdi_ema, minusdi_ema, adx_ema = 0,0,0
returns = 1
initialized = False
max_draw_down = 0
mdd_relative = 0
peak_value = usd
stoploss_triggers = 0
reversal_flag = False
local_return_graph_x = []
local_return_graph_y = []
#if abs(variables[0]) > abs(variables[2]) + abs(variables[4]): return 0
#if abs(variables[4]) > abs(variables[2]) + abs(variables[0]): return 0
#variables[0], variables[2], variables[4] = 0,0,0\
#ema1_ema, ema2_ema = 0,0
for iteration in range(size):
if iteration > .9 * size and train: break
if iteration < .9 * size and not train:
continue # use 90% train, 10% test, separated in time
line = data[-1 * size + iteration] # single line
# if iteration != size - 1:
# max_exec_price = np.amax(data[[[-1 * size + iteration],[-1*size+iteration+2]], [1,2,3,4]])
# min_exec_price = np.amin(data[[[-1 * size + iteration],[-1*size+iteration+2]], [1,2,3,4]])
# else:
# max_exec_price = np.amax(line[1:5])
# min_exec_price = np.amin(line[1:5])
min_exec_price, max_exec_price = np.mean(line[1:5]), np.mean(line[1:5])
# for item in [plusdi_ema, minusdi_ema, adx_ema]:
# if item == 0: item = line[1]
try:
# multiplier = (2 / (variables[1] + 1))
truncated_data = data[-1 * size + iteration -
EMA_length:-1 * size +
iteration, :] # numpy array view
# ema1.append(ta.TRIMA(truncated_data[:, 4], timeperiod=variables[0]))
ema1.append(ta.EMA(truncated_data[:, 4], timeperiod=variables[0]))
if len(ema1) < 2: continue
ema2.append(
ta.EMA(np.array(ema1[int(-variables[1]):]),
timeperiod=int(min(len(ema1), variables[1]))))
# ema1.append(ta.ULTOSC(truncated_data[:, 2], truncated_data[:, 3], truncated_data[:, 4],
# timeperiod1=int(variables[0]/4.0), timeperiod2=int(variables[0]/2.0), timeperiod3=int(variables[0])))
# adx_close = ta.ADX(truncated_data[:, 2], truncated_data[:, 3], truncated_data[:, 4], timeperiod=variables[2])/(100/variables[2])
# if len(adx) == 0: adx = [adx_close]
# else:
# adx.append((adx_close - adx[-1]) * multiplier + adx[-1])
# plusdi_close = ta.PLUS_DI(truncated_data[:, 2], truncated_data[:, 3], truncated_data[:, 4], timeperiod=variables[2])/(100/variables[2])
# if len(plusdi) == 0: plusdi = [plusdi_close]
# else:
# plusdi.append((plusdi_close - plusdi[-1]) * multiplier + plusdi[-1])
# minusdi_close = ta.MINUS_DI(truncated_data[:, 2], truncated_data[:, 3], truncated_data[:, 4], timeperiod=variables[2])/(100/variables[2])
# if len(minusdi) == 0: minusdi = [minusdi_close]
# else:
# minusdi.append((minusdi_close - minusdi[-1]) * multiplier + minusdi[-1])
#print(int((variables[1]/stddev[-1])*.0056), stddev[-1])
# ema2.append(ta.EMA(truncated_data[:, 4], timeperiod=variables[1])) # todo change
# ema1_last = ema1[-1]
# ema2_last = ema2[-1]
# ATR = ta.ATR(truncated_data[:, 2], truncated_data[:, 3], truncated_data[:, 4], timeperiod=variables[1]) / line[4]
# uband, middleband, lband = ta.BBANDS(truncated_data[:, 4], timeperiod=variables[1], matype=5)
# bw = (uband - lband) / middleband
# adx = ta.ADX(truncated_data[:, 2], truncated_data[:, 3], truncated_data[:, 4], timeperiod=variables[1])/100
# rsi = ta.RSI(truncated_data[:, 4], timeperiod=variables[1])/100.0
# mfi = ta.MFI(truncated_data[:, 2], truncated_data[:, 3], truncated_data[:, 4], truncated_data[:, 5], timeperiod=variables[1])
# if math.isnan(adx[-1]) or math.isnan(ema1[-1]) or math.isnan(ema2[-1]):
# raise ValueError
except:
print(list(variables), EMA_length)
#print(ema1, ema2, adx)
e = sys.exc_info()
print(("<p>Error: %s</p>" % e))
# multiplier = (2 / (10 + 1))
# plusdi_ema = (plusdi[-1] - plusdi_ema) * multiplier + plusdi_ema
# minusdi_ema = (minusdi[-1] - minusdi_ema) * multiplier + minusdi_ema
# plusdi_ema = (adx[-1] - adx_ema) * multiplier + adx_ema
if (iteration <= 1 and train) or (iteration <= .9 * size + 1
and not train):
continue
# truncated_data = data[-1 * size + iteration - EMA_length:-1 * size + iteration, :] # numpy array view
buy = 0
sell = 0
# if ema1[-1] > line[1]:
# buy += variables[0] #* (ema1[-1] - line[1])
# else:
# sell += variables[0] #* (ema1[-1] - line[1])
# if ema2[-1] > line[1]:
# buy += variables[2] #* (ema2[-1] - line[1])
# else:
# sell += variables[2] #* (ema2[-1] - line[1])
#if abs(ema1[-1] - ema2[-1])/ema2[-1] > variables[2]:
#if plusdi[-1] > minusdi[-1]:
#slope = ema1[-1] - ema1[-2]
if ema2[-1] > ema2[-2]:
buy += 1
else:
sell += 1
buy_sell = buy - sell
buyselllist.append(buy_sell)
#print(buy_sell) #
# end programmable bits, begin simulation
if not initialized:
initialized = True
# position_live = Position(start_btc=usd/line[4])
# in_position = False
# returns = position_live.btc * line[4]
# peak_value = returns
if buy_sell > 0: # only executed on first run, from dollars to btc/shorts
position = [usd * .9997, max_exec_price] # store entry price
usd = 0
long = True
# in_position = True
last_trade_time = iteration
if plot:
#global long_enter_x
#global long_enter_y
long_enter_x.append(line[0])
long_enter_y.append(line[1] - .1)
return_graph_x.append(line[0])
return_graph_y.append(position[0])
local_return_graph_x.append(line[0])
local_return_graph_y.append(position[0])
init_trade = "long"
continue
elif buy_sell < 0:
position = [usd * .9997, min_exec_price] # store entry price
usd = 0
long = False
# in_position = True
last_trade_time = iteration
if plot:
#global short_enter_x
#global short_enter_y
short_enter_x.append(line[0])
short_enter_y.append(line[1] + .1)
return_graph_x.append(line[0])
return_graph_y.append(position[0])
local_return_graph_x.append(line[0])
local_return_graph_y.append(position[0])
init_trade = "short"
continue
# time_since_last_trade = iteration - last_trade_time
if in_position and position[0] > peak_value:
peak_value = position[0]
if initialized:
if long:
returns = usd + (line[1] / position[1]) * position[0]
if not long:
returns = usd + (position[1] / line[1]) * position[0]
draw_down = (returns - peak_value) / peak_value
if draw_down < max_draw_down:
max_draw_down = draw_down
#if plot: print("new mdd long from", position[1], "to", line[1])
dd_relative = draw_down
# trailing_stop_max = (line[1] - np.max(data[-size + last_trade_time:-size + iteration, 4])) / np.max(
# data[-size + last_trade_time:-size + iteration, 4])
if dd_relative < mdd_relative:
mdd_relative = dd_relative
# if plot: print("new relative dd long from", position[1], "to", line[1], "at", iteration)
#
# draw_down = (returns - peak_value) / peak_value
# if draw_down < max_draw_down:
# max_draw_down = draw_down
# #if plot: print("new mdd short from", position[1], "to", line[1])
# dd_relative = (returns - position[0]) / position[0]
# trailing_stop_max = (np.min(data[-size + last_trade_time:-size + iteration, 4]) - line[1]) / line[1]
#
# if dd_relative < mdd_relative:
# mdd_relative = dd_relative
# # if plot: print("new rel dd short from", position[1], "to", line[1], "at", iteration)
# if not in_position:
# returns = usd
# if long:
# trailing_stop_max = (line[1] - np.min(data[-size + last_trade_time:-size + iteration, 4])) / np.min(data[-size + last_trade_time:-size + iteration, 4])
# else:
# trailing_stop_max = (np.max(data[-size + last_trade_time:-size + iteration, 4]) - line[1]) / line[1]
# if in_position:
# if long:
# # if adx[-1] > variables[3]:# and line[1] > ema2[-1] - (ema2[-1] * variables[4]): # trailing_stop_max > variables[4]:
# desire_position = True
# # else:
# # desire_position = False
# else:
# # if adx[-1] > variables[3]:# and line[1] < ema2[-1] + (ema2[-1] * variables[4]):
# desire_position = True
# # else:
# # desire_position = False
# if not in_position:
# if long:
# # if adx[-1] > variables[3]:# and line[1] > ema2[-1]: # and trailing_stop_max > -variables[4] * 4:
# desire_position = True
# # else:
# # desire_position = False
# else:
# # if adx[-1] > variables[3]:# and line[1] < ema2[-1]:
# desire_position = True
# # else:
# # desire_position = False
# if not desire_position and in_position: # stop loss section 1
# if not long:
# usd = (position[1] / max_exec_price) * position[0]
# position = 0
# # position = [usd * .9997, max(line[1:5])]
# # usd = 0.0
# #long = False
# in_position = False
# stoploss_triggers += 1
# last_trade_time = iteration
# reversal_flag = True
# if plot:
# #global short_exit_x
# #global short_exit_y
# short_exit_x.append(line[0])
# short_exit_y.append(line[1] + .1)
# return_graph_x.append(line[0])
# return_graph_y.append(returns)
# local_return_graph_x.append(line[0])
# local_return_graph_y.append(returns)
# continue
# if long: # stoploss part 1
# usd = (min_exec_price / position[1]) * position[0] # assume bad execution
# position = 0
# # position = [usd * .9997, min(line[1:5])]
# # usd = 0.0
# #long = True
# in_position = False
# stoploss_triggers += 1
# last_trade_time = iteration
# reversal_flag = True
# if plot:
# #global long_exit_x
# #global long_exit_y
# long_exit_x.append(line[0])
# long_exit_y.append(line[1] - .1)
# return_graph_x.append(line[0])
# return_graph_y.append(returns)
# local_return_graph_x.append(line[0])
# local_return_graph_y.append(returns)
# continue
# upper_bound = ema2[-1] * (1+(variables[2]*(variables[3]-(min(time_since_last_trade, variables[4])/(variables[4]/(variables[3]-1))))))
# lower_bound = ema2[-1] * (1-(variables[2]*(variables[3]-(min(time_since_last_trade, variables[4])/(variables[4]/(variables[3]-1))))))
# if desire_position and in_position: # section 2
# if long: # section where we release control back to buy_sell
# if line[1] < lower_bound:
# reversal_flag = False
#
# else:
# if line[1] > upper_bound:
# reversal_flag = False
#
# if long:
# if buy_sell > 0.0:
# reversal_flag = False
#
# else:
# if buy_sell < 0.0:
# reversal_flag = False
# in_position = position_live.in_position
# if in_position:
# position_live.check_margin_call(line[4])
# in_position = position_live.in_position
# if not in_position:
# desire_position = False
if buy_sell > 0 and not long and initialized: # main buy/sell todo modify this
usd = (position[1] / max_exec_price) * position[0]
position = 0
position = [usd * .9997, max_exec_price]
usd = 0.0
long = True
# in_position = True
trades += 1
last_trade_time = iteration
# if line[1] > upper_bound:
# reversal_flag = True
# stoploss_triggers += 1
# else:
# reversal_flag = False
if plot:
#global long_enter_x
#global long_enter_y
long_enter_x.append(line[0])
long_enter_y.append(line[4])
return_graph_x.append(line[0])
return_graph_y.append(returns)
local_return_graph_x.append(line[0])
local_return_graph_y.append(returns)
continue
if buy_sell < 0 and long and initialized: # main buy/sell 2
# on 20x
usd = (min_exec_price /
position[1]) * position[0] # assume bad execution
position = 0
position = [usd * .9997, min_exec_price]
usd = 0.0
long = False
# in_position = True
trades += 1
last_trade_time = iteration
# if line[1] < lower_bound:
# reversal_flag = True
# stoploss_triggers += 1
# else:
# reversal_flag = False
if plot:
#global short_enter_x
#global short_enter_y
short_enter_x.append(line[0])
short_enter_y.append(line[4])
return_graph_x.append(line[0])
return_graph_y.append(returns)
local_return_graph_x.append(line[0])
local_return_graph_y.append(returns)
continue
# if not desire_position and not in_position: # section 3
# if not long and ((buy_sell > 0.0) ^ (line[1] > upper_bound)): # moves understanding of long/short desire despite not being in position
# #usd = (position[1] / max(line[1:5])) * position[0]
# #position = 0
# #position = [usd * .9997, max(line[1:5])]
# #usd = 0.0
# long = True
# #in_position = True
# #trades += 1
# last_trade_time = iteration
# if line[1] > ema2[-1] * (1 + variables[2]):
# reversal_flag = True
# else:
# reversal_flag = False
# # if plot:
# # #global long_enter_x
# # #global long_enter_y
# # long_enter_x.append(line[0])
# # long_enter_y.append(line[1]-.1)
# # return_graph_x.append(line[0])
# # return_graph_y.append(returns)
# continue
#
# if long and ((buy_sell < 0.0) ^ (line[1] < lower_bound)): # moves understanding of long/short desire despite not being in position
# #usd = (min(line[1:5]) / position[1]) * position[0]
# #position = 0
# # position = [usd * .9997, min(line[1:5])]
# # usd = 0.0
# long = False
# # in_position = True
# # trades += 1
# last_trade_time = iteration
# if line[1] < lower_bound:
# reversal_flag = True
# else:
# reversal_flag = False
# # if plot:
# # #global short_enter_x
# # #global short_enter_y
# # short_enter_x.append(line[0])
# # short_enter_y.append(line[1]+.1)
# # return_graph_x.append(line[0])
# # return_graph_y.append(returns)
# continue
# if desire_position and not in_position: # if adx reverses direction, reenter position section 4
# if not long: #
# #usd = (position[1] / max(line[1:5])) * position[0]
# #position = 0
# position = [usd * .9997, min_exec_price]
# usd = 0.0
# #long = True
# in_position = True
# trades += 1
# last_trade_time = iteration
# reversal_flag = False
# if plot:
# #global short_enter_x
# #global short_enter_y
# short_enter_x.append(line[0])
# short_enter_y.append(line[1]+.1)
# return_graph_x.append(line[0])
# return_graph_y.append(returns)
# local_return_graph_x.append(line[0])
# local_return_graph_y.append(returns)
# continue
#
# if long:
# #usd = (min(line[1:5]) / position[1]) * position[0] # assume bad execution
# #position = 0
# position = [usd * .9997, min_exec_price]
# usd = 0.0
# #long = False
# in_position = True
# trades += 1
# last_trade_time = iteration
# reversal_flag = False
# if plot:
# #global long_enter_x
# #global long_enter_y
# long_enter_x.append(line[0])
# long_enter_y.append(line[1] - .1)
# return_graph_x.append(line[0])
# return_graph_y.append(returns)
# local_return_graph_x.append(line[0])
# local_return_graph_y.append(returns)
# continue
if returns < 50 and not plot: # fail-quick
returns = 0
position = [0, line[1]]
max_draw_down = -.9271
break
# ema1_switches = 0
# for index, item in enumerate(ema1):
# if (item > ema1[index-1]) is not (ema1[index-1] > ema1[index-2]):
# ema1_switches += 1
# ema2_switches = 0
# for index, item in enumerate(ema2):
# if (item > ema2[index - 1]) is not (ema2[index - 1] > ema2[index - 2]):
# ema2_switches += 1
# macd_switches = 0
# for index, item in enumerate(buyselllist):
# if (item > 0) is not (buyselllist[index-1] > 0):
# macd_switches += 1
# buyselllist = []
# longest_time_since_last_high = 0
# for index, tick in enumerate(local_return_graph_y): # TODO TEMPORARY
# if index == 0:
# buyselllist.append(0)
# continue
# #print((tick - local_return_graph_y[index - 1]) / tick)
# buyselllist.append((tick - local_return_graph_y[index - 1]) / tick)
# print(sorted(buyselllist))
if plot:
for leverage in range(1, 101):
max_value = 0
last_value = 0
time_of_last_high = local_return_graph_x[0]
time_since_last_high = 0
for tickindex, tick in enumerate(local_return_graph_y):
if tickindex == 0:
max_value = tick
last_value = tick
continue
delta = (tick - local_return_graph_y[tickindex - 1]) / tick
delta *= leverage
last_value *= delta + 1
if last_value > max_value:
time_since_last_high = local_return_graph_x[
tickindex] - time_of_last_high
time_of_last_high = local_return_graph_x[tickindex]
# if time_since_last_high > longest_time_since_last_high:
# longest_time_since_last_high = time_since_last_high
max_value = last_value
if last_value < max_value / float(2):
break
if last_value < max_value / float(
2
): # when broken out of the inner for by too much leverage
max_leverage = leverage - 1
break
elif leverage == 100:
print("got max leverage 100 somehow")
max_leverage = leverage
break
best_leverage = [0, 0]
best_value = 0
for short_leverage in range(0, 101):
for long_leverage in range(0, 101):
max_value = 0
last_value = 0
for tickindex, tick in enumerate(local_return_graph_y):
if tickindex == 0:
max_value = tick
last_value = tick
continue
delta = (tick - local_return_graph_y[tickindex - 1]) / tick
if (init_trade == "short") ^ tickindex % 2 == 0:
delta *= short_leverage
short_fee = 1 #- .0000025 * short_leverage
last_value *= delta + short_fee
else:
delta *= long_leverage
long_fee = 1 #- .0000025 * long_leverage
last_value *= delta + long_fee
if last_value > max_value:
# if time_since_last_high > longest_time_since_last_high:
# longest_time_since_last_high = time_since_last_high
max_value = last_value
if last_value < max_value / float(4):
last_value = 0
break
if last_value > best_value:
best_leverage = [long_leverage, short_leverage]
best_value = last_value
print("best long/short leverage", best_leverage, best_value)
if try_leverages:
long_leverage = try_leverages[0]
short_leverage = try_leverages[1]
max_value = 0
last_value = 0
for tickindex, tick in enumerate(local_return_graph_y):
if tickindex == 0:
max_value = tick
last_value = tick
continue
delta = (tick - local_return_graph_y[tickindex - 1]) / tick
if (init_trade == "short") ^ tickindex % 2 == 0:
delta *= short_leverage
short_fee = 1 # - .0000025 * short_leverage
last_value *= delta + short_fee
else:
delta *= long_leverage
long_fee = 1 # - .0000025 * long_leverage
last_value *= delta + long_fee
if last_value > max_value:
# if time_since_last_high > longest_time_since_last_high:
# longest_time_since_last_high = time_since_last_high
max_value = last_value
print("for try_leverage", try_leverages, last_value)
# max_leverage = min(math.floor(-1/min(mdd_relative, -.0001)), max_leverage)
# print(max(adx), "avg:", np.average(adx), min(adx))
if plot:
print("MDD%", max_draw_down * 100, "dd_rel%:", mdd_relative * 100,
"max leverage:", max_leverage)
else:
print("MDD%", max_draw_down * 100, "dd_rel%:", mdd_relative * 100)
#print(max(atr), min(atr))
#print("min, max, stddev, avg of stddev", min(stddev), max(stddev), np.std(stddev), np.average(stddev))
if plot:
# global plot_minusdi
# global plot_plusdi
if train:
# plt.plot(data[int(-len(ema1)-(size/10)):int(-(size/10)), 0], ema1)
plt.plot(data[int(-len(ema2) - (size / 10)):int(-(size / 10)), 0],
ema2)
##global plot_adx
# plot_adx += adx
# plot_minusdi += minusdi
# plot_plusdi += plusdi
else:
# plt.plot(data[-len(ema1):, 0], ema1)
plt.plot(data[-len(ema2):, 0], ema2)
# global plot_adx
# plot_adx += adx
# plot_minusdi += minusdi
# plot_plusdi += plusdi
if long:
returns = usd + (min_exec_price / position[1]) * position[0]
if plot:
return_graph_x.append(line[0])
return_graph_y.append(returns)
local_return_graph_x.append(line[0])
local_return_graph_y.append(returns)
print(list(variables), returns, trades)
if plot:
print("Score metric:", returns * (1 + max_draw_down))
else:
print("Score metric:", returns * (1 + max_draw_down))
else:
returns = usd + (position[1] / max_exec_price) * position[0]
if plot:
return_graph_x.append(line[0])
return_graph_y.append(returns)
local_return_graph_x.append(line[0])
local_return_graph_y.append(returns)
if trades < 10 and not plot and train: returns = 0
print(list(variables), returns, trades)
if plot:
print("Score metric:", returns * (1 + max_draw_down))
else:
print("Score metric:", returns * (1 + max_draw_down))
return -(returns * (1 + max_draw_down))
def dataproc_worker(start, end, live, ns, data=None):
while True:
# print(start,end, "gonna call the DB and get:")
start = start.replace(microsecond=0)
end = end.replace(microsecond=0)
flip = False
# if not live:
# if randrange(0, 10) > 4: flip = True
# else: flip = False
if data is None:
globalvar.dbcur.execute(
"SELECT * FROM futures WHERE time BETWEEN (?) AND (?)",
[(start - datetime(1970, 1, 1)) / timedelta(seconds=1),
(end - datetime(1970, 1, 1)) / timedelta(seconds=1)])
data = globalvar.dbcur.fetchall()
# benchstart = datetime.utcnow()
data = [list(elem) for elem in data]
# print("#1:", data[0], data[-1])
# for index, line in enumerate(data):
# # data[index][0] = datetime.strptime(line[0], "%Y-%m-%dT%H:%M:%SZ") #problem 2
# date = line[0] # string of '2016-07-07T10:36:42Z' using explicit slicing:
# data[index][0] = datetime(int(date[:4]), int(date[5:7]), int(date[8:10]), int(date[11:13]),
# int(date[14:16]), int(date[17:19]))
#
averageNumerator = 0.0
# print("#2:",data[0],data[-1])
datalength = len(data)
if not live:
finaltime = len(data) - 120
# print(data[-1][0], "as finaltime", data[-1][1], "as lastlast") # consistently accurate
for index, line in enumerate(data):
if live:
averageNumerator += line[4]
elif index < finaltime:
averageNumerator += line[4]
# if (data[-1][0] == data[-120][0]): break
# here is where we do live adjustments remove 6k seconds at start pad 6k 0's at end
# print("#3", data[0], data[-1], len(data))
averagePrice = averageNumerator / (len(data) - 120)
if live:
del data[0:121]
for index, line in enumerate(
data): # normalize to the 120 mins average price
data[index][1] = line[1] / averagePrice # o
data[index][2] = line[2] / averagePrice # h
data[index][3] = line[3] / averagePrice # l
data[index][4] = line[4] / averagePrice # c
timeperiods = [
10, 100, 1000, 10000, 100000
] # (len(data) - 6000)] is too long, 100k max in C talib
# initlist = [data[0][0]] * 86400
# # print (timeperiods)
if not live:
open = np.array([row[1] for row in data[0:-120]], dtype=np.double)
high = np.array([row[2] for row in data[0:-120]], dtype=np.double)
low = np.array([row[3] for row in data[0:-120]], dtype=np.double)
close = np.array([row[4] for row in data[0:-120]], dtype=np.double)
volume = np.array([row[5] for row in data[0:-120]],
dtype=np.double)
else:
open = np.array([row[1] for row in data[0:-1]], dtype=np.double)
high = np.array([row[2] for row in data[0:-1]], dtype=np.double)
low = np.array([row[3] for row in data[0:-1]], dtype=np.double)
close = np.array([row[4] for row in data[0:-1]], dtype=np.double)
volume = np.array([row[5] for row in data[0:-1]], dtype=np.double)
# print("internal last:", close[-1])
if flip:
open = (open * -1) + 2
high = (high * -1) + 2
low = (low * -1) + 2
close = (close * -1) + 2
data = np.array([row[4] for row in data[0:-1]], dtype=np.double)
data = (data * -1) + 2
# let's do the non-timeperiod indicators first
# print("problem four took " + str(datetime.utcnow() - benchstart))
# print("starting TA")
trange = ta.TRANGE(high, low, close)
obv = ta.OBV(close, volume)
ad = ta.AD(high, low, close, volume)
ht_trendline = ta.HT_TRENDLINE(close)
ht_dcperiod = ta.HT_DCPERIOD(close)
ht_dcphase = ta.HT_DCPHASE(close)
ht_phasor_inphase, ht_phasor_quadrature = ta.HT_PHASOR(close)
ht_sine, ht_leadsine = ta.HT_SINE(close)
ht_trendmode = ta.HT_TRENDMODE(close)
mama, fama = ta.MAMA(close, fastlimit=.5, slowlimit=.05)
sar = ta.SAR(high, low) # could crash, no extended params supplied
sarext = ta.SAREXT(high, low) # this one too
bop = ta.BOP(open, high, low, close)
# print("basic TA took " + str(datetime.utcnow() - benchstart))
# print("starting timeperiod TA")
# setting up timeperiod-requiring indicators
slowk, slowd, fastk, fastd, rsik, rsid, t3, adx, adxr, apo, aroondown, aroonup, aroonosc, cci, cmo, dx, macd, \
macdsignal, macdhist, macdext, macdsignalext, macdhistext, macdfix, macdhistfix, macdsignalfix, mfi, minus_dm, \
minus_di, mom, plus_di, plus_dm, ppo, roc, rocr, rsi, trix, ultosc, willr, beta, correl, linearreg, \
linearreg_angle, linearreg_intercept, linearreg_slope, stddev, tsf, var, atr, natr, adosc, upperband, \
middleband, lowerband, dema, ema, kama, ma, midpoint, midprice, sma, tema, trima, wma = ([] for i in range(
63)) # counted 63 twice
for timeperiod in timeperiods:
benchstart = datetime.utcnow()
fastperiod = int(timeperiod / 2)
slowperiod = timeperiod
stochk = int(timeperiod / 3)
stochd = int(timeperiod / 4)
# n = int(len(close) / slicefactor)
# offset = (len(close)-1) - (n * slicefactor)
# opens= open[offset::slicefactor]
# high= high[offset::slicefactor]
# low= low[offset::slicefactor]
# close= close[offset::slicefactor]
# volumes= volume[offset::slicefactor]
# now for the weird indicators matype=1 for life, ema
stoch1_temp, stoch2_temp = ta.STOCH(high,
low,
close,
fastk_period=stochk,
slowk_period=stochd,
slowk_matype=1,
slowd_period=stochd,
slowd_matype=1)
slowk.append(stoch1_temp)
slowd.append(stoch2_temp)
stoch1_temp, stoch2_temp = ta.STOCHF(high,
low,
close,
fastk_period=stochk,
fastd_period=stochd,
fastd_matype=1)
fastk.append(stoch1_temp)
fastd.append(stoch2_temp)
stoch1_temp, stoch2_temp = ta.STOCHRSI(close,
timeperiod=timeperiod,
fastk_period=stochk,
fastd_period=stochd,
fastd_matype=1)
rsik.append(stoch1_temp)
rsid.append(stoch2_temp)
t3.append(ta.T3(close, timeperiod=timeperiod, vfactor=.7))
# now for the normal indicators
# momentum
adx.append(ta.ADX(high, low, close, timeperiod=timeperiod))
adxr.append(ta.ADXR(high, low, close, timeperiod=timeperiod))
apo.append(
ta.APO(close, fastperiod=fastperiod, slowperiod=slowperiod))
aroondown_temp, aroonup_temp = ta.AROON(high,
low,
timeperiod=timeperiod)
aroondown.append(aroondown_temp)
aroonup.append(aroonup_temp)
aroonosc.append(ta.AROONOSC(high, low, timeperiod=timeperiod))
cci.append(ta.CCI(high, low, close, timeperiod=timeperiod))
cmo.append(ta.CMO(close, timeperiod=timeperiod))
dx.append(ta.DX(high, low, close, timeperiod=timeperiod))
macd_temp, macdsignal_temp, macdhist_temp = ta.MACD(
close,
fastperiod=fastperiod,
slowperiod=slowperiod,
signalperiod=stochk)
macd.append(macd_temp)
macdsignal.append(macdsignal_temp)
macdhist.append(macdhist_temp)
macd_temp, macdsignal_temp, macdhist_temp = ta.MACDEXT(
close,
fastperiod=fastperiod,
fastmatype=1,
slowperiod=slowperiod,
slowmatype=1,
signalperiod=stochk,
signalmatype=1)
macdext.append(macd_temp)
macdsignalext.append(macdsignal_temp)
macdhistext.append(macdhist_temp)
macd_temp, macdsignal_temp, macdhist_temp = ta.MACDFIX(
close, signalperiod=stochk)
macdfix.append(macd_temp)
macdsignalfix.append(macdsignal_temp)
macdhistfix.append(macdhist_temp)
mfi.append(ta.MFI(high, low, close, volume, timeperiod=timeperiod))
minus_di.append(
ta.MINUS_DI(high, low, close, timeperiod=timeperiod))
minus_dm.append(ta.MINUS_DM(high, low, timeperiod=timeperiod))
mom.append(ta.MOM(close, timeperiod=timeperiod))
plus_di.append(ta.PLUS_DI(high, low, close, timeperiod=timeperiod))
plus_dm.append(ta.PLUS_DM(high, low, timeperiod=timeperiod))
ppo.append(
ta.PPO(close,
fastperiod=fastperiod,
slowperiod=slowperiod,
matype=1))
roc.append(ta.ROC(close, timeperiod=timeperiod))
rocr.append(ta.ROCR(close, timeperiod=timeperiod))
rsi.append(ta.RSI(close, timeperiod=timeperiod))
trix.append(ta.TRIX(close, timeperiod=timeperiod))
ultosc.append(
ta.ULTOSC(high,
low,
close,
timeperiod1=stochk,
timeperiod2=fastperiod,
timeperiod3=timeperiod))
willr.append(ta.WILLR(high, low, close, timeperiod=timeperiod))
# end momentum, begin statistics
beta.append(ta.BETA(high, low, timeperiod=timeperiod))
correl.append(ta.CORREL(high, low, timeperiod=timeperiod))
linearreg.append(ta.LINEARREG(close, timeperiod=timeperiod))
linearreg_angle.append(
ta.LINEARREG_ANGLE(close, timeperiod=timeperiod))
linearreg_intercept.append(
ta.LINEARREG_INTERCEPT(close, timeperiod=timeperiod))
linearreg_slope.append(
ta.LINEARREG_SLOPE(close, timeperiod=timeperiod))
stddev.append(ta.STDDEV(close, timeperiod=timeperiod, nbdev=1))
tsf.append(ta.TSF(close, timeperiod=timeperiod))
var.append(ta.VAR(close, timeperiod=timeperiod, nbdev=1))
# end stats, begin vol
atr.append(ta.ATR(high, low, close, timeperiod=timeperiod))
natr.append(ta.NATR(high, low, close, timeperiod=timeperiod))
adosc.append(
ta.ADOSC(high,
low,
close,
volume,
fastperiod=fastperiod,
slowperiod=slowperiod))
# end vol, begin overlaps
upperband_temp, middleband_temp, lowerband_temp = ta.BBANDS(
close, timeperiod=timeperiod, matype=1)
upperband.append(upperband_temp)
middleband.append(middleband_temp)
lowerband.append(lowerband_temp)
dema.append(ta.DEMA(close, timeperiod=timeperiod))
ema.append(ta.EMA(close, timeperiod=timeperiod))
kama.append(ta.KAMA(close, timeperiod=timeperiod))
ma.append(ta.MA(close, timeperiod=timeperiod, matype=0))
midpoint.append(ta.MIDPOINT(close, timeperiod=timeperiod))
midprice.append(ta.MIDPRICE(high, low, timeperiod=timeperiod))
sma.append(ta.SMA(close, timeperiod=timeperiod))
tema.append(ta.TEMA(close, timeperiod=timeperiod))
trima.append(ta.TRIMA(close, timeperiod=timeperiod))
wma.append(ta.WMA(close, timeperiod=timeperiod))
# print("finishing timeperiod" + str(timeperiod))
# print("TA for " + str(timeperiod) + " took " + str(datetime.utcnow() - benchstart))
# 1 min, 10min, 100m, currentprice, indicators
if live:
finishedline = (close[-1])
else:
if not flip:
finishedline = ( # date, flip, 1, 10, 20, 40, 80, 120, current price
(end - datetime(1970, 1, 1)) / timedelta(seconds=1), 0,
data[-120][4], data[-111][4], data[-101][4], data[-81][4],
data[-41][4], data[-1][4], data[-121][4])
if flip:
finishedline = ( # date, flip, 1, 10, 20, 40, 80, 120, current price
(end - datetime(1970, 1, 1)) / timedelta(seconds=1), 1,
data[-120], data[-111], data[-101], data[-81], data[-41],
data[-1], data[-121])
finishedline += (trange, obv, ad, ht_trendline, ht_dcperiod,
ht_dcphase, ht_phasor_inphase, ht_phasor_quadrature,
ht_sine, ht_leadsine, ht_trendmode, mama, fama, sar,
sarext, bop, slowk, slowd, fastk, fastd, rsik, rsid,
t3, adx, adxr, apo, aroondown, aroonup, aroonosc, cci,
cmo, dx, macd, macdsignal, macdhist, macdext,
macdsignalext, macdhistext, macdfix, macdsignalfix,
macdhistfix, mfi, minus_di, minus_dm, mom, plus_di,
plus_dm, ppo, roc, rocr, rsi, trix, ultosc, willr,
beta, correl, linearreg, linearreg_angle,
linearreg_intercept, linearreg_slope, stddev, tsf,
var, atr, natr, adosc, upperband, middleband,
lowerband, dema, ema, kama, ma, midpoint, midprice,
sma, tema, trima, wma)
finishedline = flatten(finishedline)
if live:
finishedline = np.array(finishedline, dtype=np.double)
finishedline = finishedline[~np.isnan(finishedline)] # remove nans
else:
finishedline = np.array(finishedline, dtype=np.double)
finishedline = finishedline[~np.isnan(finishedline)]
# print(pid + " has finished")
if len(finishedline) != 326: break
return finishedline
break