def update(self):
if self.simulation == False:
self.changed = self.files.update()
if self.changed:
self.load_config()
self.logger.update()
self.prediction.update(self.logger)
self.state.update(self.prediction.prediction)
GloVar.set("actual_price", self.prediction.prediction.event_price)
GloVar.set("actual_time", time.strftime("%H:%M:%S"))
return self.changed
from logic.TradeGlobals import GloVar
import time
from numpy import dtype
# play ground development of fft analysis
np = numpy
if __name__ == "__main__":
os.chdir(os.path.abspath("../"))
symbols = ["XVGETH", "BNBETH", "TRXETH"]
for symbol in symbols:
GloVar.set("trade_symbol", symbol)
_path = "./data_storage/{0}".format(symbol)
_res = TradeGroundControl.FileName.find_file_ids(_path, 'logger')
_keys = sorted(_res.keys())
_X = numpy.array([], dtype=np.float)
_Y = numpy.array([], dtype=np.float)
_min = -1e10
_max = 1e10
print(symbol)
def update(self, logger):
_trades_time = numpy.concatenate((logger.ring_trades_time[logger.ring_pos:],
logger.ring_trades_time[:logger.ring_pos]))
numpy.copyto(self.trades_time, _trades_time)
_trades_raw = numpy.concatenate((logger.ring_value_mean_quantity[logger.ring_pos:],
logger.ring_value_mean_quantity[:logger.ring_pos]))
numpy.copyto(self.trades_raw, _trades_raw)
# predic raising or fallin global tendencies
b, a = scipy.signal.butter(2, GloVar.get("filt1_hz"))
_trades_filt1 = scipy.signal.filtfilt(b, a, (self.trades_raw, self.trades_time), axis=1)
numpy.copyto(self.trades_filt1, _trades_filt1[0])
_trades_filt1_diff = scipy.diff((self.trades_filt1, self.trades_time), axis=1)[0]
GloVar.set("filt1_grad", numpy.mean(_trades_filt1_diff[-1 * abs(GloVar.get("filt1_grad_range")):]) * self.time_delta)
# predic raising or fallin global tendencies
b, a = scipy.signal.butter(2, GloVar.get("filt2_hz"))
_trades_filt2 = scipy.signal.filtfilt(b, a, (self.trades_raw, self.trades_time), axis=1)
numpy.copyto(self.trades_filt2, _trades_filt2[0])
_trades_filt2_diff = scipy.diff((self.trades_filt2, self.trades_time), axis=1)[0]
numpy.copyto(self.trades_filt2_diff[1:], _trades_filt2_diff)
GloVar.set("filt2_grad", numpy.mean(_trades_filt2_diff[-1 * abs(GloVar.get("filt2_grad_range")):]) * self.time_delta)
# calc median deviation
_trades_err = (self.trades_filt1 - self.trades_filt2)
numpy.copyto(self.trades_err, _trades_err)
b, a = scipy.signal.butter(2, 0.001)
self.trades_err_filt = scipy.diff((self.trades_err, self.trades_time), axis=1)[0]
# steigung trades error
_trades_err_diff = scipy.diff(_trades_err)
# predicted trade level, zc zero crossings
_trades_err_diff_zc = (_trades_err_diff[:-1] * _trades_err_diff[1:]) < 0.
_trades_err_diff_zc_value = _trades_err_diff_zc * self.trades_err[1:-1]
numpy.copyto(self.trades_err_diff_zc[2:], _trades_err_diff_zc_value)
# calculate buy and sell limits
_v = numpy.mean(self.trades_filt2[-11:-1])
# min +- 0.2 %
_trade_level_buy = _v * ((100 - max(0.2, GloVar.get("factor_buy_offset"))) / 100.) - _v
_trade_level_sell = _v * ((100 + max(0.2, GloVar.get("factor_sell_offset"))) / 100.) - _v
numpy.copyto(self.trades_sell[:-1], self.trades_sell[1:])
self.trades_sell[len(self.trades_sell) - 1] = _trade_level_sell
numpy.copyto(self.trades_buy[:-1], self.trades_buy[1:])
self.trades_buy[len(self.trades_buy) - 1] = _trade_level_buy
pdata = PredictionData()
pdata.event_price = numpy.mean(self.trades_raw[-6:-1])
pdata.event_buy = _trades_err[-1:][0] < _trade_level_buy
pdata.event_sell = _trades_err[-1:][0] > _trade_level_sell
pdata.event_zc = True in _trades_err_diff_zc[-20:]
pdata.event_rising = (self.trades_filt2_diff[-1:][0]) >= 0
pdata.event_time = self.trades_time[-1:][0]
self.prediction = pdata
def update(self, prediction_data):
if self.trade_interface == None:
raise TradeInterfaceNotInitialised
def _add_event(events_arr, event, value):
if event:
numpy.copyto(events_arr[:-1], events_arr[1:])
events_arr[len(events_arr) - 1] = value
if (GloVar.get("state") == "START"):
GloVar.set("state", "start")
self.state = "start"
if (GloVar.get("state") == "STOP"):
GloVar.set("state", "STOPPED")
self.state = "STOPPED"
self.state_z = "STOPPED"
if self.state == "week_buy":
self.week_buy_cnt += 1
else:
self.week_buy_cnt = 0
if self.state == "week_sell" and prediction_data.event_sell == False:
self.week_sell_cnt += 1
else:
self.week_sell_cnt = 0
if prediction_data.event_zc:
self.zc_cnt = min(3, self.zc_cnt + 1)
else:
self.zc_cnt = max(0, self.zc_cnt - 1)
prediction_data.event_zc = False
if self.zc_cnt >= 3:
prediction_data.event_zc = True
_add_event(self.events_zc_time, True, prediction_data.event_time)
_add_event(self.events_zc, True, prediction_data.event_price)
GloVar.set("state_zero_crossing_price", prediction_data.event_price)
GloVar.set("state_zero_crossing_time", prediction_data.event_time)
print("zero crossing")
if (
(self.state == "start" or
self.state == "stro_sell") and
prediction_data.event_buy == True):
self.state = "week_buy"
self.price_week = prediction_data.event_price
GloVar.set("filt1_hz", 0.025)
elif (self.state == "week_buy" and
(prediction_data.event_zc == True and prediction_data.event_buy == True)):
self.state = "stro_buy"
self.trade_interface.create_buy_order()
_add_event(self.events_buy_time, True, prediction_data.event_time)
_add_event(self.events_buy, True, prediction_data.event_price)
GloVar.set("state_buy_price", prediction_data.event_price)
GloVar.set("state_buy_time", prediction_data.event_time)
GloVar.set("state_sell_lost_limit", prediction_data.event_price * 0.925)
GloVar.set("state_sell_win_limit", prediction_data.event_price * 1.025)
GloVar.set("filt1_hz", 0.01)
elif (self.state == "stro_buy" and prediction_data.event_price < GloVar.get("state_sell_lost_limit")):
self.state = "sell_now_stop_lost"
elif (self.state == "stro_buy" and prediction_data.event_price > GloVar.get("state_sell_win_limit") and GloVar.get("filt1_grad") < 0):
self.state = "sell_now_take_win"
elif (self.state == "stro_buy" and
prediction_data.event_sell == True):
self.state = "week_sell"
self.price_week = prediction_data.event_price
GloVar.set("filt1_hz", 0.025)
elif (self.state == "week_sell" and
(prediction_data.event_zc == True or
(prediction_data.event_sell == False and self.week_sell_cnt >= 6))
):
self.state = "sell_now_zero_crossing"
if (self.state != self.state_z):
GloVar.set("state", self.state)
self.state_z = self.state
print(self.state, time.ctime(time.time()), prediction_data.event_price)
if (self.state.startswith("sell_now")):
self.state = "stro_sell"
self.trade_interface.create_sell_order()
_add_event(self.events_sell_time, True, prediction_data.event_time)
_add_event(self.events_sell, True, prediction_data.event_price)
GloVar.set("state_sell_price", prediction_data.event_price)
GloVar.set("state_sell_time", prediction_data.event_time)
GloVar.set("order_delta_price", self.events_sell[-1:][0] - self.events_buy[-1:][0])
GloVar.set("filt1_hz", 0.01)
if (self.state != self.state_z):
GloVar.set("state", self.state)
self.state_z = self.state
print(self.state, time.ctime(time.time()), prediction_data.event_price)
return data
return None
def create_buy_order(self):
_ret = self.binance_api.create_order(
symbol=GloVar.get("trade_symbol"),
side=binance.client.Client.SIDE_BUY,
type=binance.client.Client.ORDER_TYPE_MARKET,
quantity=GloVar.get("trade_quantity"))
print(_ret)
def create_sell_order(self):
_ret = self.binance_api.create_order(
symbol=GloVar.get("trade_symbol"),
side=binance.client.Client.SIDE_SELL,
type=binance.client.Client.ORDER_TYPE_MARKET,
quantity=GloVar.get("trade_quantity"))
print(_ret)
if __name__ == "__main__":
GloVar.set("trade_symbol", "TRXETH")
api = Api("../data/config.xml")
print(api.getTradeData(int(time.time() * 1000 - 10000), endTime=int(time.time() * 1000)))
# api.create_buy_order()
# api.create_sell_order()
