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, 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): 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 __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")
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)
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