def __init__(self, parent=None):
PySide.QtGui.QWidget.__init__(self, parent)
self.GroundControl = GroundControl()
self.GroundControl.load_config()
self.layout = PySide.QtGui.QVBoxLayout(self)
self.createPlotInterface()
self.setLayout(self.layout)
# init task timer
self.cyclic_task_timer_main = GloVar.get(
"cyclic_task_main") + time.time()
self.cyclic_task_timer_plotting = GloVar.get(
"cyclic_task_plotting") + time.time()
self.cyclic_task_timer_store = GloVar.get(
"cyclic_task_store") + time.time()
self.qtimer1 = PySide.QtCore.QTimer()
self.qtimer1.timeout.connect(self.CyclicTasks)
self.qtimer1.start(1000 * GloVar.get("cyclic_task_main"))
self.qtimer3 = PySide.QtCore.QTimer()
self.qtimer3.setSingleShot(True)
self.qtimer3.timeout.connect(self.timeout_sync_x_aches)
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)
def __init__(self, parent=None):
PySide.QtGui.QWidget.__init__(self, parent)
self.layout = PySide.QtGui.QHBoxLayout(self)
self.layout.addWidget(gui.GlobalVariables.GlobalVariables(self), 1)
_w = gui.LivePlotter.TraidingWidget(self)
self.layout.addWidget(_w, 4)
self.setLayout(self.layout)
GloVar.emit_all()
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
def __init__(self, file_path):
_data = TradeData()
self.ring_size = int(60 * 60 * 24 / GloVar.get("trade_sample_time"))
self.ring_data_filepath = file_path
self.ring_pos = int(0)
self.ring_trades_count = numpy.array([_data.trades_count] *
self.ring_size,
dtype=numpy.int)
self.ring_trades_time = numpy.array([_data.trades_time] *
self.ring_size,
dtype=numpy.double)
self.ring_value_mean_quantity = numpy.array(
[_data.value_mean_quantity] * self.ring_size, dtype=numpy.double)
self.ring_value_max = numpy.array([_data.value_max] * self.ring_size,
dtype=numpy.double)
self.ring_value_min = numpy.array([_data.value_min] * self.ring_size,
dtype=numpy.double)
self.ring_value_close = numpy.array([_data.value_open] *
self.ring_size,
dtype=numpy.double)
self.ring_value_open = numpy.array([_data.value_close] *
self.ring_size,
dtype=numpy.double)
self.ring_quantity = numpy.array([_data.quantity] * self.ring_size,
dtype=numpy.double)
if not os.path.isfile(self.ring_data_filepath):
self.save_storage(self.ring_data_filepath)
self.load_storage(self.ring_data_filepath)
def __init__(self, file_path="./data/config.xml"):
self.trade_interface = None
self.time_delta = GloVar.get("trade_sample_time")
self.time_last_update = 0
self.ring_size = int(60 * 60 * 24 / self.time_delta)
self.ring_data_filepath = file_path
self.ring_pos = int(0)
self.ring_trades_count = numpy.array([0] * self.ring_size,
dtype=numpy.int)
self.ring_trades_time = numpy.array([time.time()] * self.ring_size,
dtype=numpy.double)
self.ring_value_mean_quantity = numpy.array([0.] * self.ring_size,
dtype=numpy.double)
self.ring_value_max = numpy.array([0.] * self.ring_size,
dtype=numpy.double)
self.ring_value_min = numpy.array([0.] * self.ring_size,
dtype=numpy.double)
self.ring_value_close = numpy.array([0.] * self.ring_size,
dtype=numpy.double)
self.ring_value_open = numpy.array([0.] * self.ring_size,
dtype=numpy.double)
self.ring_quantity = numpy.array([0.] * self.ring_size,
dtype=numpy.double)
if not os.path.isfile(self.ring_data_filepath):
self.save_storage()
self.load_storage()
def __init__(self, file_path):
self.ring_data_filepath = file_path
self.state = GloVar.get("state")
self.state_z = GloVar.get("state")
self.zc_cnt = 0
self.ring_size = int(60 * 60 * 24 / GloVar.get("trade_sample_time"))
self.events_buy = numpy.array([numpy.NaN] * self.ring_size, dtype=numpy.double)
self.events_sell = numpy.array([numpy.NaN] * self.ring_size, dtype=numpy.double)
self.events_zc = numpy.array([numpy.NaN] * self.ring_size, dtype=numpy.double)
self.events_buy_time = numpy.array([numpy.NaN] * self.ring_size, dtype=numpy.double)
self.events_sell_time = numpy.array([numpy.NaN] * self.ring_size, dtype=numpy.double)
self.events_zc_time = numpy.array([numpy.NaN] * self.ring_size, dtype=numpy.double)
if not os.path.isfile(self.ring_data_filepath):
self.save_storage()
self.load_storage()
def CyclicTasks(self):
# 1. priority
# update trade data
_changed = self.GroundControl.update()
if _changed:
self.updatePlotInterface()
# 2. priority
# sotre trade data
if self.cyclic_task_timer_store < time.time():
self.cyclic_task_timer_store = GloVar.get(
"cyclic_task_store") + time.time()
self.GroundControl.save()
# 3. priority
# update gui
if self.cyclic_task_timer_plotting < time.time():
self.cyclic_task_timer_plotting = GloVar.get(
"cyclic_task_plotting") + time.time()
self.updateTradePlots()
def find_file_ids(path, file_key):
_results = {}
for _path, _folder, _files in os.walk(path):
for _file in _files:
_m = FileName.find_file_id_in_str(_file)
_m_dict = _m.groupdict()
if _m_dict:
if (_m_dict['symbol'] == GloVar.get("trade_symbol")
and int(_m_dict['cycle_time'])
== GloVar.get("trade_sample_time")
and _m_dict['file_key'] == file_key):
_year = int(_m_dict['year'])
_mon = int(_m_dict['mon'])
_day = int(_m_dict['day'])
_str = "{0:04d}{1:02d}{2:02d}".format(
_year, _mon, _day)
_val = int(_str, 10)
_results[_val] = _m_dict
return _results
def getTradeData(self, startTime, endTime):
try:
_trades = self.binance_api.get_aggregate_trades(
symbol=GloVar.get("trade_symbol"), startTime=startTime, endTime=endTime)
except:
_trades = []
traceback.print_exc()
names = {"id": "a", "price": "p", "quantity": "q", "time": "T"}
if _trades != []:
_id = []
_price = []
_quantity = []
_time = []
for _trade in _trades:
_id.append(_trade[names['id']])
_price.append(_trade[names['price']])
_quantity.append(_trade[names['quantity']])
_time.append(_trade[names['time']] / 1000)
_price = numpy.array(_price, numpy.double)
_quantity = numpy.array(_quantity, numpy.double)
data = ApiData()
data.value_open = _price[0]
data.value_close = _price[-1:]
data.value_mean_quantity = numpy.sum(_price * _quantity) / numpy.sum(_quantity)
data.value_max = numpy.max(_price)
data.value_min = numpy.min(_price)
data.quantity = numpy.sum(_quantity)
data.trades_count = len(_price)
data.trades_time = (min(_time) + max(_time)) / 2.
return data
return None
def getTradeData(self, startTime, endTime):
_pos = self._simulator.ring_pos
data = TradeData()
data.value_open = self._simulator.ring_value_open[_pos]
data.value_close = self._simulator.ring_value_close[_pos]
data.value_mean_quantity = self._simulator.ring_value_mean_quantity[
_pos]
data.value_max = self._simulator.ring_value_max[_pos]
data.value_min = self._simulator.ring_value_min[_pos]
data.quantity = self._simulator.ring_quantity[_pos]
data.trades_count = self._simulator.ring_trades_count[_pos]
data.trades_time = self.start_time
self.start_time += GloVar.get("trade_sample_time")
if int(self._simulator.ring_size - 1) == int(_pos):
self._simulator.ring_pos = 0
else:
self._simulator.ring_pos += 1
return data
def __init__(self, file_path="./data"):
PySide.QtCore.QObject.__init__(self)
self.time_delta = GloVar.get("trade_sample_time") # s
self.ring_size = int(60 * 60 * 24 / self.time_delta)
self.trades_time = numpy.array([0] * self.ring_size, dtype=numpy.double)
self.trades_err_ana = numpy.array([0] * self.ring_size, dtype=numpy.double)
self.trades_raw = numpy.array([0] * self.ring_size, dtype=numpy.double)
self.trades_median = numpy.array([0] * self.ring_size, dtype=numpy.double)
self.trades_filt1 = numpy.array([0] * self.ring_size, dtype=numpy.double)
self.trades_filt2 = numpy.array([0] * self.ring_size, dtype=numpy.double)
self.trades_err_diff_zc = numpy.array([0] * self.ring_size, dtype=numpy.double)
self.trades_filt2_diff = numpy.array([0] * self.ring_size, dtype=numpy.double)
self.trades_err = numpy.array([0] * self.ring_size, dtype=numpy.double)
self.trades_buy = numpy.array([numpy.NaN] * self.ring_size, dtype=numpy.double)
self.trades_sell = numpy.array([numpy.NaN] * self.ring_size, dtype=numpy.double)
self.prediction = PredictionData()
self.ring_data_filepath = file_path
if not os.path.isfile(self.ring_data_filepath):
self.save_storage()
self.load_storage()
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()
def update(self):
self.changed = False
# update pathes
_path_storage = "{0}/{1}".format(GloVar.get("path_storage"),
GloVar.get("trade_symbol"))
_path_temp = "{0}/{1}".format(GloVar.get("path_temp"),
GloVar.get("trade_symbol"))
_path_config = GloVar.get("path_config")
def _inline_update_pathes(old, new):
if old == new:
_return = old
else:
self.changed = True
if not os.path.isdir(new):
os.makedirs(new)
_return = new
return _return
self.path_config = _inline_update_pathes(self.path_config,
_path_config)
self.path_storage = _inline_update_pathes(self.path_storage,
_path_storage)
self.path_temp = _inline_update_pathes(self.path_temp, _path_temp)
# update file_pathes
_file_path_sim = "{0}/{1}".format(self.path_temp,
FileName.create_new_file_id("sim"))
_file_path_logger = "{0}/{1}".format(
self.path_temp, FileName.create_new_file_id("logger"))
_file_path_prediction = "{0}/{1}".format(
self.path_temp, FileName.create_new_file_id("prediction"))
_file_path_states = "{0}/{1}".format(
self.path_temp, FileName.create_new_file_id("states"))
def _inline_update_files(old, new, file_key):
if old == new:
_return = old
else:
_return = new
self.changed = True
# distiguish between temp and sotrage necessary because of git and copy possiblilties during runntime
# copy latest from storge if new file does not exists
_file_match1, _time_stamp1 = FileName.find_latest_file_id(
self.path_storage, file_key)
_file_match2, _time_stamp2 = FileName.find_latest_file_id(
self.path_temp, file_key)
# for code robustness
_match = False
# ToDo: CleanUp
# file only in storage path
if isinstance(_file_match1, dict) and _file_match2 == False:
_match = _file_match1
_path = self.path_storage
# file only in temp path
elif isinstance(_file_match2, dict) and _file_match1 == False:
_match = _file_match2
_path = self.path_temp
# No File Fond
elif _file_match2 == False and _file_match1 == False:
_match = False
_path = False
# file in temp folder newer than in storage folder
elif _time_stamp2 >= _time_stamp1:
_match = _file_match2
_path = self.path_temp
# file of storage folder found
else:
_match = _file_match1
_path = self.path_storage
if _match != False:
_match["file_key"] = file_key
_storage_path = "{0}/{1}".format(
_path, FileName.create_file_id(_match))
if os.path.isfile(_storage_path):
try:
shutil.copy(_storage_path, new)
except shutil.SameFileError:
pass
return _return
self.file_path_sim = _inline_update_files(self.file_path_sim,
_file_path_sim, "sim")
self.file_path_logger = _inline_update_files(self.file_path_logger,
_file_path_logger,
"logger")
self.file_path_prediction = _inline_update_files(
self.file_path_prediction, _file_path_prediction, "prediction")
self.file_path_states = _inline_update_files(self.file_path_states,
_file_path_states,
"states")
self.file_path_config = "{0}/{1}".format(self.path_config,
"config.xml")
return self.changed
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 __init__(self):
self.simulation = GloVar.get("trade_simulation")
self.files = FilePathes()
self.changed = False
def create_new_file_id(key):
_t = time.gmtime(FileName.offset_time())
return "{3}_{0:02d}_{1:02d}_{2:02d}_{4}s-{5}.hdf".format(
_t.tm_year, _t.tm_mon, _t.tm_mday, GloVar.get("trade_symbol"),
int(GloVar.get("trade_sample_time")), key)
def offset_time():
return time.time() + GloVar.get("SaveTimeOffset")
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)
import PySide.QtGui from logic.TradeGlobals import GloVar import gui.MainWindow import sys import re GloVar.loadArguments(sys.argv) app = PySide.QtGui.QApplication([]) MainWidget = gui.MainWindow.Main(parent=None) MainWidget.resize(800, 800) MainWidget.show() app.exec_()
