def __trans_apply(self): trans_success = False buy_cny = self.__price_base.sell_cny sell_cny = self.__price_vs.buy_cny rounding_num = self.get_rounding_num(self.__trans_coin_code) trans_units = round(self.__std_amount / buy_cny, rounding_num) self.__order_base = ordermanage.OrderManage(self.__market_base) self.__order_vs = ordermanage.OrderManage(self.__market_vs) # 调用买入操作 buy_success = self.twin_trans(self.__order_base, 'buy', self.__trans_coin_code, trans_units, buy_cny) if buy_success: sell_success = self.twin_trans(self.__order_vs, 'sell', self.__trans_coin_code, trans_units, sell_cny) #目前的方案只要买入成功,则卖出订单不取消,只是检查状态当时有没有成交 self.__trans_log() if sell_success: trans_success = True else: # 买入成功但是卖出失败的次数不能超过一定的数量,防止由于程序错误过度买入,消耗完全部的CNY,2017.7.7号发生过一次 self.__sell_fail_times = self.__sell_fail_times + 1 # 检查帐户的仓位并调整相应的盈利比例,使得下一次交易按新的盈利比例处理 self.__update_profit_rate((self.__order_vs)) return trans_success
def __check_coin_pool(self,market_base,market_vs,coin_code): try: order_base= ordermanage.OrderManage(market_base) order_vs=ordermanage.OrderManage(market_vs) #返回标志 result_flag=False #只检查两个市场的RMB金额,默认coin是足够交易的 bal_base=float(order_base.getMyBalance('cny')) bal_vs=float(order_vs.getMyBalance('cny')) #检查coin的数量是不是满足当前市场是总市场容量的一半 bal_coin_base=float(order_base.getMyBalance(coin_code)) bal_coin_vs=float(order_vs.getMyBalance(coin_code)) #大概的交易价格 # vs的市场价格 price_vs = pricemanage.PriceManage(market_vs, coin_code).get_coin_price() #币种 的阀值倍数 coiin_bal_times=5 #每次交易的单位数 trans_unit_per_time=self.__std_amount/price_vs.buy_cny money_pool_amt=float(self.__std_amount*self.__money_pool_size) total_coin_bal=(bal_coin_base+bal_coin_vs) #资金量在3成以上才进行同步 if float(bal_base/(bal_base+bal_vs))>0.3 or float(bal_base)>float(money_pool_amt*0.8): # 帐户低于总数的30%时进行均衡,只有总的币数大于每次交易的10倍 以上才进行均衡 if bal_coin_base/total_coin_bal<0.3 and total_coin_bal>trans_unit_per_time*10: result_flag=True except Exception as e: print(str(e)) print('获取资金池状态是否需要均衡时出错') return result_flag pass
def single_balance_market(self,market_base,market_vs,coin_code,money_pool_bal_indi=None): #如果需要均衡时则循环进行帐户均衡 need_balance_flag=True single_bal_status=False order_base= ordermanage.OrderManage(market_base) order_vs=ordermanage.OrderManage(market_vs) self.__order_base=order_base self.__order_vs=order_vs # 检查两个市场的帐户状态 try: status_comment='fail' #检查帐户状态,是不是需要均衡市场 if money_pool_bal_indi: need_balance_flag = self.__check_money_pool(market_base, market_vs, coin_code) else: need_balance_flag = self.__check_coin_pool(market_base, market_vs, coin_code) exch_open_order_num=self.check_open_order_num(coin_code+'_cny') #买和卖方均衡ORDER的总数量不能超过X个,超过X个则等成交后再来生成 if need_balance_flag and exch_open_order_num<=self.__max_open_num: single_bal_status=self.exch_balance(market_base,market_vs,coin_code) if single_bal_status: status_comment = 'success' else: status_comment = 'fail' #logging.info('%s: 已经自动对@%s增加RMB,对%s减少RMB进行了操作,状态:%s!' \ # % (self.__get_curr_time(), market_vs, market_base, status_comment)) #同步一次失败后10分钟后再进行同步,以确定这个交易能完成,如果完不成同步也确保不会有频繁的多次同步 #time.sleep(10*30) return status_comment except: pass return 'fail'
def __check_money_pool(self,market_base,market_vs,coin_code): try: order_base= ordermanage.OrderManage(market_base) order_vs=ordermanage.OrderManage(market_vs) #返回标志 result_flag=False #只检查两个市场的RMB金额,默认coin是足够交易的 bal_base=order_base.getMyBalance('cny') bal_vs=order_vs.getMyBalance('cny') #检查coin的数量是不是满足当前市场是总市场容量的一半 #bal_coin_base=float(order_base.getMyBalance(coin_code)) bal_coin_vs=float(order_vs.getMyBalance(coin_code)) #大概的交易价格 # vs的市场价格 price_vs = pricemanage.PriceManage(market_vs, coin_code).get_coin_price() #币种 的阀值倍数 coiin_bal_times=5 #每次交易的单位数 trans_unit_per_time=self.__std_amount/price_vs.buy_cny money_pool_amt=self.__std_amount*self.__money_pool_size #帐户标准交易额的X倍,如果低于这个金额则进行两个市场的平衡 if bal_vs<money_pool_amt: #只有待均衡的COIN的金额在资金池的3成以上才进行均衡 if bal_coin_vs*price_vs.buy_cny/money_pool_amt>0.3: result_flag=True except Exception as e: print(str(e)) print('获取资金池状态是否需要均衡时出错') return result_flag pass
def start(self): # 当前均衡的次数,即使是失败也计算在内 bal_times = 0 while(True): # 循环处理市场 for market_base in self.__market_list: market_vs_list=list(self.__market_list) #移除作为base 的市场 market_vs_list.remove(market_base) #对比每一个其它的市场 for market_vs in market_vs_list: #对每个coin进行分析 for coin in self.__coin_list: #当前处理的市场 self.__market_base=market_base self.__market_vs=market_vs self.__order_base = ordermanage.OrderManage(self.__market_base) self.__order_vs = ordermanage.OrderManage(self.__market_vs) #开始处理帐户对倒, if coin in self.__money_pool_coin: #对资金池进行均衡 exch_status = self.single_balance_market(market_base, market_vs, coin,'Y') else: #对COIN进行均衡 exch_status = self.single_balance_market(market_base,market_vs,coin) bal_times=bal_times+1 #time.sleep(10) if bal_times%10==0: print('%s: 执行了%d次均衡同步' % (self.__get_curr_time(), bal_times)) pass
def test_check_exch_bal_status(self): order_base= ordermanage.OrderManage('bter') order_vs=ordermanage.OrderManage('btc38') self.__order_base=order_base self.__order_vs=order_vs open_num=self.check_open_order_num('doge_cny') print('当前市场的均衡保单数量为:%d'%open_num)
def gen_money_summary(): # 市场的交易处理器 order_market = ordermanage.OrderManage('btc38') # 所有的余额 mybal = order_market.getMyBalance() mybaldate = common.get_curr_time_str() # 计算当前时间的评估价格 currallprice_btc = order_market.getMarketPrice('all_btc') currallprice_cny = order_market.getMarketPrice('all_bitcny') currallprice_usd = order_market.getMarketPrice('all_usdt') total_bal_cny = 0 # RMB价格 btcprice_cny = currallprice_cny.get('btc').get('ticker').get('buy') # USD价格 btcprice_usd = currallprice_usd.get('btc').get('ticker').get('buy') for coin in mybal: coinbal = mybal.get(coin).get('available') + mybal.get(coin).get( 'locked') if coinbal == 0: continue if coin == 'bitcny': total_bal_cny = total_bal_cny + coinbal pass elif coin == 'usdt': # 把USD转换成btc后再转换成cny来计算 total_bal_cny = total_bal_cny + coinbal / btcprice_usd * btcprice_cny pass elif coin == 'btc': total_bal_cny = total_bal_cny + coinbal * btcprice_cny else: # btc定价的价格 try: if currallprice_btc.get(coin) is not None: coinprice_btc = currallprice_btc.get(coin).get( 'ticker').get('buy') # 转换成btc的数量 coinbal_btc = coinbal * coinprice_btc # 转换成RMB的价格 total_bal_cny = total_bal_cny + coinbal_btc * btcprice_cny else: # 对于没有btc定价的币种则用bitcny来查找计算余额 coinprice_cny = order_market.getMarketPrice( coin + '_bitcny').get('ticker').get('buy') total_bal_cny = total_bal_cny + coinbal * coinprice_cny except Exception as e: # 不再支持交易的coin if coin == 'ybc' or coin == 'nss': pass else: print('{0} price error:{1}'.format(coin, str(e))) total_bal_cny = round(total_bal_cny, 2) print('{0}: balance_cny: {1}'.format(mybaldate, total_bal_cny)) # 保存结果到文件 balfile = open(summary_file, 'a') mybalancesummary = '{0}:{1}\n'.format(mybaldate, total_bal_cny) balfile.write(mybalancesummary) balfile.close() return total_bal_cny pass
def getpriceitem(self, market, coin_pair): try: order_market = ordermanage.OrderManage(market) price_depth = order_market.getMarketDepth(coin_pair) buy_depth = 0 sell_depth = 0 priceitem = None coin = coin_pair.split('_')[0] # use the sell price as buy_price buy_price = price_depth.sell[0][0] # use the buy orderprice as sell price sell_price = price_depth.buy[0][0] # 尝试列表中所有的买入和 for buy_item in price_depth.buy: buy_depth = buy_depth + buy_item[1] for sell_item in price_depth.sell: sell_depth = sell_depth + sell_item[1] buy_depth = round(buy_depth, 2) sell_depth = round(sell_depth, 2) # 把价格日期保存成字符串 priceitem = priceupdate.PriceItem(common.get_curr_time_str(), coin_pair, buy_price, buy_depth, sell_price, sell_depth) except Exception as e: # print('取得[{1}]价格列表时错误:{0}'.format(str(e), coin_pair)) return None return priceitem
def __init__(self, market): self.__market = market # 定期投资的相关参数 # self.__regular_param = config.regular_invest_param # self.__regular_param2 = config.regular_invest_param2 # 每次买入的金额 # self.__trans_amount_per_trans = self.__regular_param.get('buy_amt') # 每次买入的时间 # self.__buy_time = self.__regular_param.get('buy_time') # 买入的频率,以小时为单位 # self.__buy_freq = self.__regular_param.get('buy_freq') # 一个COIN的总共投资上限 # self.__buy_max_amt = self.__regular_param.get('buy_max_amt') # 止盈比例 # self.__sell_profit_rate = self.__regular_param.get('sell_profit_rate') # 止损比例 # self.__stop_lost_rate = self.__regular_param.get('stop_lost_rate') # 操作的coin list # self.__coin_list = self.__regular_param.get('coin_list').split(',') self.__coin_list = self.get_coinfig_coinlist() # 订单状态 const.ORDER_STATUS_OPEN = 'open' const.ORDER_STATUS_CLOSED = 'closed' const.ORDER_STATUS_CANCEL = 'cancelled' const.TRANS_TYPE_BUY = 'buy' const.TRANS_TYPE_SELL = 'sell' # 取消订单状态 const.CANCEL_STATUS_SUCC = 'success' const.CANCEL_STATUS_FAIL = 'fail' # 市场的交易处理器 self.order_market = ordermanage.OrderManage(market)
def __check_balance_flag(self,market_base, market_vs,coin_code): order_base= ordermanage.OrderManage(market_base) order_vs=ordermanage.OrderManage(market_vs) #只检查两个市场的RMB金额,默认coin是足够交易的 bal_base=order_base.getMyBalance('cny') bal_vs=order_vs.getMyBalance('cny') #检查coin的数量是不是满足当前市场是总市场容量的一半 bal_coin_base=float(order_base.getMyBalance(coin_code)) bal_coin_vs=float(order_vs.getMyBalance(coin_code)) total_coin_bal=bal_coin_base+bal_coin_vs #大概的交易价格 # base的市场价格 price_base = pricemanage.PriceManage(market_base, coin_code).get_coin_price() # 需要对比的市场价格 #price_vs = pricemanage.PriceManage(market_vs, coin_code).get_coin_price() need_exchange=False #均衡市场是标准交易的多少倍 bal_times=100 #币种 的阀值倍数 coiin_bal_times=5 #每次交易的单位数 trans_unit_per_time=self.__std_amount/price_base.sell_cny #帐户标准交易额的100倍,如果低于这个金额则进行两个市场的平衡 if bal_vs<float(self.__std_amount*bal_times): #需要卖出市场的COIN的比例是不是占总COIN的X成以上并且余额是交易单位的指定倍数以上 if float(bal_coin_vs)>float(total_coin_bal*0.3): # Coin is enough and need sell coin to get money, the estimated amount is greater than 1000 if float(bal_coin_vs)>float(total_coin_bal*0.3) and (price_base.sell_cny*bal_coin_vs)>1000: need_exchange=True else: need_exchange=False else: # 对于COIN来说,只要是小于总量的30%才需要进行均衡 if bal_coin_vs<float(trans_unit_per_time*coiin_bal_times) and bal_coin_vs<float(total_coin_bal*0.3): need_exchange=True else: # 对于COIN来说,只要是小于总量的30%才需要进行均衡 if bal_coin_vs < float(trans_unit_per_time * coiin_bal_times) and bal_coin_vs < float(total_coin_bal * 0.3): need_exchange = True else: need_exchange=False return need_exchange
def __coin_rearch(self): # 比较多个市场之间的价格 for market_base in self.__market_list: market_vs_list = list(self.__market_list) # 移除作为base 的市场 market_vs_list.remove(market_base) # 对比每一个其它的市场 for market_vs in market_vs_list: # 对每个coin进行分析 for coin in self.__coin_list: # base的市场价格 price_base = pricemanage.PriceManage( market_base, coin).get_coin_price() # 需要对比的市场价格 price_vs = pricemanage.PriceManage(market_vs, coin).get_coin_price() price_check_result = self.__price_check( coin, price_base, price_vs) # 如果价格可以进行买卖刚返回 if price_check_result: # 对于达到要求的保存到类变量中,交易函数进行处理 self.__market_base = market_base self.__market_vs = market_vs self.__price_base = price_base self.__price_vs = price_vs # 满足交易的coin code self.__trans_coin_code = coin # 把交易实例保存起来 # Base account的交易实例 self.__order_base = ordermanage.OrderManage( self.__market_base) # VS市场 self.__order_vs = ordermanage.OrderManage( self.__market_vs) # 预期盈利金额 profitamt = (self.__std_amount / price_base.sell_cny ) * (price_vs.buy_cny - price_base.sell_cny) currtime = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())) print('Date:%s,Coin:%s,BaseMarket(Buy):%s, VSmarket(Sell):%s,Buy price:%f,Sell price:%f,投资%f预期盈利:%f' \ % (currtime,coin, market_base, market_vs, price_base.sell_cny, price_vs.buy_cny, self.__std_amount, profitamt))
def exch_balance(self,market_base, market_vs, coin_code): order_base = ordermanage.OrderManage(market_base) order_vs = ordermanage.OrderManage(market_vs) # base的市场价格 price_base = pricemanage.PriceManage(market_base, coin_code).get_coin_price() # 需要对比的市场价格 price_vs = pricemanage.PriceManage(market_vs, coin_code).get_coin_price() #trans_price = float(self.__get_trans_price(price_base, price_vs, coin_code)) match_price_flag=self.__price_check(coin_code,price_base,price_vs) #在约定的范围价格变动范围之内 if match_price_flag: trans_price_buy=price_base.sell_cny trans_price_sell=price_vs.buy_cny else: return False #TODO test purpose #trans_price=0.01598 # 价格两个市场变动范围不在约定的范围 内则不返回价格,不需要进行交易 #if trans_price == None: # return False trans_amount=self.__std_amount*self.__exch_times # 交易的单位是每次交易的X倍, # 要非常 小心 这里面的小数位,需要BTC38的接口小数位数太长会报错,接口太SB了, 不知道自己处理一下 robot=traderobot.TradeRobot() trans_units = round(float(self.__std_amount / trans_price_buy * self.__exch_times),robot.get_rounding_num(coin_code)) tradeapi=robot trans_status=False # 调用买入操作 buy_success = tradeapi.twin_trans(order_base, 'buy', coin_code, trans_units, trans_price_buy) if buy_success: sell_success = tradeapi.twin_trans(order_vs, 'sell', coin_code, trans_units, trans_price_sell) # 目前的方案只要买入成功,则卖出订单不取消,只是检查状态当时有没有成交 if sell_success: trans_status = True print('%s:均衡交易:成功,已经成功卖出:%s@%s,金额:%f,从市场@%s同样买入:当前成交!' \ % (self.__get_curr_time(), coin_code, market_vs, trans_amount, market_base)) logging.info('%s:均衡交易:成功,已经成功卖出:%s@%s,金额:%f,从市场@%s同样买入:当前成交!' \ % (self.__get_curr_time(), coin_code, market_vs, trans_amount, market_base)) else: logging.warning('%s:均衡交易:在途,已经成功卖出:%s@%s,金额:%f,从市场@%s同样买入:当前未成交!' \ % (self.__get_curr_time(), coin_code, market_vs, trans_amount, market_base)) return trans_status pass
def test_twin_trans_sell_overtime(self): self.__order_base = ordermanage.OrderManage('bter') order_market = self.__order_base sell_order = order_market.submitOrder('doge_cny', 'sell', 0.03, 150) sell_order_id = sell_order.order_id resell_status = self.__twin_trans_sell_overtime_process( order_market, sell_order_id, 'doge', 0.01735, 100) pass
def test_twin_trans(self): # VS市场 #测试卖出操作 test_market = 'bter' self.__order_vs = ordermanage.OrderManage(test_market) self.__order_base = ordermanage.OrderManage(test_market) status_bter = False status_bter = self.twin_trans(self.__order_base, 'buy', 'doge', 100, 0.05) print('test trans(SELL) exec result @%s:' % test_market) if status_bter: print('transaction done successfully!') else: print('transaction failed!') test_market = 'btc38' """ self.__order_vs = ordermanage.OrderManage(test_market) status_btc38 = self.twin_trans(self.__order_vs,'sell', 'doge', 1000, 0.05) print('test trans(SELL) exec result @%s:' % test_market) if status_btc38: print('transaction done successfully!') else: print('transaction failed!') """ #测试买入操作 test_market = 'bter' self.__order_base = ordermanage.OrderManage(test_market) status_bter = self.twin_trans(self.__order_base, 'buy', 'doge', 200, 0.012) print('test trans(BUY) exec result @%s:' % test_market) if status_bter: print('transaction done successfully!') else: print('transaction failed!') test_market = 'btc38' self.__order_base = ordermanage.OrderManage(test_market) status_btc38 = self.twin_trans(self.__order_base, 'buy', 'doge', 200, 0.012) print('test trans(BUY) exec result @%s:' % test_market) if status_btc38: print('transaction done successfully!') else: print('transaction failed!')
def __init__(self, market): # 订单状态 const.ORDER_STATUS_OPEN = 'open' const.ORDER_STATUS_CLOSED = 'closed' const.ORDER_STATUS_CANCEL = 'cancelled' const.TRANS_TYPE_BUY='buy' const.TRANS_TYPE_SELL='sell' # 取消订单状态 const.CANCEL_STATUS_SUCC = 'success' const.CANCEL_STATUS_FAIL= 'fail' # 最大的交易订单数, self.__max_open_order_pool = publicparameters.MAX_OPEN_ORDER_POOL # 每次交易的金额 self.__trans_amount_per_trans = publicparameters.TRANS_AMOUNT_PER_ORDER # 止盈比例 self.__sell_profit_rate = publicparameters.SELL_PROFIT_RATE # 市场的交易处理器 self.order_market = ordermanage.OrderManage(market) # 市场 self.market = market pass
def __init__(self, market): self.__market = market #交易市场,用来执行查询及提交订单的处理 self.__order_market = ordermanage.OrderManage(market) #市场研究的coin list self.__coin_list = ['ltc', 'doge', 'btc']
def get_balance(self): for market in self.__market_list: order_market = ordermanage.OrderManage(market) market_bal = order_market.getMyBalance()
def output_summary(self, filename): file = open(filename, 'a') #每个市场的明细 file_detail = open( filename.split('.')[0] + '_detail.' + filename.split('.')[1], 'a') all_market_bal = {} all_coin_list = [] for market in self.__market_list: order_market = ordermanage.OrderManage(market) market_bal = order_market.getMyBalance() all_market_bal[market] = market_bal all_coin_list = all_coin_list + list(market_bal.keys()) # 所有市场的COIN列表 all_coin_list = list(set(all_coin_list)) all_output = {} all_coin_bal = {} # 按币种循环生成各个市场的帐户的情况 for coin in all_coin_list: all_coin_bal[coin] = [] for market in self.__market_list: if coin in all_market_bal[market].keys(): coin_bal = all_market_bal[market][coin]['available'] coin_bal_lock = all_market_bal[market][coin]['locked'] coin_total_bal = round(coin_bal + coin_bal_lock, 4) all_coin_bal[coin].append({ 'market': market, 'available': coin_total_bal }) else: all_coin_bal[coin].append({ 'market': market, 'available': 0 }) # 按币种输出 all_coin_list.sort() for coin in all_coin_list: need_output = False all_market_values = 0 coin_value = all_coin_bal[coin] for item in coin_value: if float(item['available']) > 0: need_output = True #市场之间的总和,针对同一币种 all_market_values = round( all_market_values + item['available'], 4) pass if need_output: coin_value = all_coin_bal[coin] for item in coin_value: coin_bal = str(round(item['available'], 4)) market = item['market'] all_output[market] = all_output.get( market, '') + '%s|%s|' % (coin.ljust(6), coin_bal.rjust(12)) all_output['ALL'] = all_output.get('ALL', '') + '%s|%s|' % ( coin.ljust(6), str(all_market_values).rjust(12)) # 输出每个市场的余额 currtime = common.CommonFunction.get_curr_time() for market in self.__market_list: output = '%s|%s|%s|\n' % (currtime, market.ljust(6), all_output[market]) file_detail.write(output) summary_output = '%s|%s|%s|\n' % (currtime, 'ALL'.ljust(6), all_output['ALL']) file.write(summary_output) file.close() file_detail.close()
def get_balance(self): all_market_bal = {} all_coin_list = [] for market in self.__market_list: order_market = ordermanage.OrderManage(market) market_bal = order_market.getMyBalance() all_market_bal[market] = market_bal all_coin_list = all_coin_list + list(market_bal.keys()) # 所有市场的COIN列表 all_coin_list = list(set(all_coin_list)) all_coin_bal = {} # 当前价格的评估总价 total_est_cny = 0 # 除了open order之外的当前价格评估 total_est_cny_ori = 0 # 总的open order buy amount total_open_buy_amt = 0 # 总的open order 估算amount total_open_est_cny = 0 # 所有COIN的明细余额 open_bal_list = [] currdate = common.get_curr_time_str() # 按币种循环生成各个市场的帐户的情况 for coin in all_coin_list: # time.sleep(0.5) for market in self.__market_list: if coin in all_market_bal[market].keys(): coin_bal = all_market_bal[market][coin]['available'] coin_bal_lock = all_market_bal[market][coin]['locked'] if coin == 'cny': total_cny_bal = round(coin_bal + coin_bal_lock, 4) continue coin_total_bal = round(coin_bal + coin_bal_lock, 4) pricebuff = priceupdate.PriceBuffer(market, save_log_flag=False) max_num = 5 run_time = 0 priceitem = None # 循环取价格,防止中间出现取价格异常 while (run_time < max_num and priceitem is None): priceitem = pricebuff.getpriceitem( market, coin + '_btc') run_time = run_time + 1 if priceitem is None: print('coin:{0} has error to get price'.format(coin)) continue currprice = priceitem.sell_price coin_total_est_cny = round(coin_total_bal * currprice, 4) # 根据自己的记录得到的balance和直接查询 得到的最终lock balance可能有差异,如果lock<open order balance则是有问题的,需要查询 coin_open_bal = self.get_open_bal(coin).get( 'total_units', 0) # open订单的买入价格 coin_open_buy_amt = self.get_open_bal(coin).get( 'total_amount', 0) # open订单的评估价格 coin_est_cny_open = round( self.get_open_bal(coin).get('total_units', 0) * currprice, 4) # 检查OPEN order的UNIT和实际LOCK的UNIT是不是一致 if coin_bal_lock != coin_open_bal: print( 'coin:{2},open bal:{0} is different from lock bal:{1})' .format(coin_open_bal, coin_bal_lock, coin)) # 实际价格评估的资产 coin_est_cny_all = round(coin_total_bal * currprice, 4) # open订单按实际买入的价格来计划金额,这个金额在每日比较会比较有用,排除价格变动造成的影响 coin_est_without_open = round( (coin_total_bal - coin_open_bal) * currprice, 4) # 总的金额,正在OPEN的卖单按买入价格计算 coin_est_cny_ori = coin_est_without_open + coin_open_buy_amt # final result coin_bal_item = { 'date': currdate, 'coin': coin, 'coin_est_cny_all': coin_est_cny_all, 'coin_est_cny_ori': coin_est_cny_ori, 'coin_total_bal': coin_total_bal, 'coin_open_bal': coin_open_bal, 'coin_bal_locked': coin_bal_lock, 'coin_open_buy_amt': coin_open_buy_amt, 'coin_est_cny_open': coin_est_cny_open, } coin_bal_item_str = json.dumps(coin_bal_item, sort_keys=True) open_bal_list.append(coin_bal_item_str) # ----------各个COIN总的计算金额-------------------- # 所有COIN的总的估算金额 total_est_cny = round(total_est_cny + coin_est_cny_all, 4) # 所有的估算金额,OPEN订单按买入金额计算 total_est_cny_ori = round( total_est_cny_ori + coin_est_cny_ori, 4) # open的总共买入金额 total_open_buy_amt = round( total_open_buy_amt + coin_open_buy_amt, 4) # open的总估算金额 total_open_est_cny = round( total_open_est_cny + coin_est_cny_open, 4) # 所有COIN的结果 total_bal = { 'date': currdate, 'total_est_cny': total_est_cny, 'total_est_cny_ori': total_est_cny_ori, 'total_cny_bal': total_cny_bal, 'total_open_buy_amt': total_open_buy_amt, 'total_cny_with_open': round(total_cny_bal + total_open_buy_amt, 4), 'total_open_est_cny': total_open_est_cny } total_bal_str = json.dumps(total_bal, sort_keys=True) # 保存数据到文件 # save summary data fsumary = open('daillySummary.txt', 'a') fsumary.write(total_bal_str + '\n') fsumary.close() # save detail fdetail = open('daillyDetail.txt', 'a') for openitem in open_bal_list: fdetail.write(openitem + '\n') fdetail.close() # print(total_bal) return total_bal
#!/usr/bin/env python3 # -*- coding: utf-8 -*- __author__ = 'Owen_Study/[email protected]' # Create date: 17-8-5 上午11:50 import ordermanage, ormmysql '''注释''' if __name__ == '__main__': order_market = ordermanage.OrderManage('btc38') open_order_list_web = order_market.getOpenOrderList('zcc') open_order_list_db = ormmysql.allopenorderlist() for openorder in open_order_list_web: coin = openorder.coin_code_pair order_id_web = int(openorder.order_id) order_units_web = float(openorder.trans_unit) for dbopenorder in open_order_list_db: order_id_db = dbopenorder.sell_order_id order_units_db = dbopenorder.sell_units if order_id_web == order_id_db: if order_units_web == order_units_db: break else: print( '{0}, order_id:{1}, order_unts_web:{2}, order_units_db{3}' .format(coin, order_id_db, order_units_web, order_units_db)) break else:
def exch_balanceX(self,market_base, market_vs, coin_code): order_base= ordermanage.OrderManage(market_base) order_vs=ordermanage.OrderManage(market_vs) # base的市场价格 price_base = pricemanage.PriceManage(market_base, coin_code).get_coin_price() # 需要对比的市场价格 price_vs = pricemanage.PriceManage(market_vs, coin_code).get_coin_price() trans_price=self.__get_trans_price(price_base,price_vs,coin_code) #价格两个市场变动范围不在约定的范围 内则不返回价格,不需要进行交易 if trans_price==None: return False sell_status=None buy_status=None #交易的单位是每次交易的X倍, TODO test trans_units=self.__std_amount/trans_price*self.__exch_times #同步交易,先卖后买 sell_trans=order_vs.submitOrder(coin_code+'_cny','sell',trans_price,trans_units) sell_order_id=sell_trans.order_id if sell_order_id==1111111: sell_status='closed' #买入交易 #buy_trans=order_base.submitOrder(coin_code+'_cny','buy',trans_price,trans_units) #buy_order_id=buy_trans.order_id #if buy_order_id == 1111111: # buy_status = 'closed' #循环检查状态,直至交易成功后才结束返回 trans_status=False waiting_seconds=0 #最多待时间,持续检查均衡订单的状态 max_waiting_seconds=5 #按每次交易金额的X倍来进行帐户之间平衡 trans_amount=self.__std_amount*self.__exch_times while(not trans_status and waiting_seconds<max_waiting_seconds): try: if sell_status!='closed': sell_status = order_vs.getOrderStatus(sell_order_id, coin_code) else: # 成功后再开始买入操作 if buy_status==None: buy_trans = order_base.submitOrder(coin_code + '_cny', 'buy', trans_price, trans_units) buy_order_id = buy_trans.order_id time.sleep(0.1) if sell_order_id == 1111111: sell_status = 'closed' else: buy_status = order_base.getOrderStatus(buy_order_id, coin_code) elif buy_status!='closed': buy_status = order_base.getOrderStatus(buy_order_id, coin_code) except Exception as e: print(str(e)) pass finally: time.sleep(1) waiting_seconds = waiting_seconds + 1 if sell_status=='closed' and buy_status=='closed': logging.info('%s:均衡交易:成功,已经成功卖出:%s@%s,金额:%f,从市场@%s同样买入:当前成交!'\ %(self.__get_curr_time(),coin_code,market_vs,trans_amount,market_base)) trans_status=True waiting_seconds=max_waiting_seconds+5 if waiting_seconds== max_waiting_seconds: #卖出一直未成功,则取消本次的操作 if sell_status!='closed' and buy_status==None: cancel_status=order_base.cancelOrder(sell_order_id,coin_code) if cancel_status=='fail': logging.warning('%s:取消卖单状态:失败,均衡交易中卖出%s@%s,金额:%f在指定时间未内成交!'%(self.__get_curr_time(),coin_code),market_vs,trans_amount) else: logging.info('%s:取消卖单状态:成功,均衡交易中卖出%s@%s,金额:%f在指定时间未内成交!' % (self.__get_curr_time(), coin_code), market_vs, trans_amount) else: logging.warning('%s:均衡交易(buyOrderId:%s):在途,已经成功卖出:%s@%s,金额:%f,从市场@%s同样买入:当前未成交!' \ % (self.__get_curr_time(),buy_order_id, coin_code, market_vs, trans_amount, market_base)) return trans_status pass
def test_check_account(self): self.__order_base = ordermanage.OrderManage('bter') self.__order_vs = ordermanage.OrderManage('btc38') self.__trans_coin_code = 'ppc'
def price_analyze(self): #比较多个市场之间的价格 for market_base in self.__market_list: market_vs_list = list(self.__market_list) #移除作为base 的市场 market_vs_list.remove(market_base) #对比每一个其它的市场 for market_vs in market_vs_list: #对每个coin进行分析 for coin in self.__coin_list: #base的市场价格 #print('%s:is requesting price@%s' % (self.__get_curr_time(),market_base)) price_base = pricemanage.PriceManage( market_base, coin).get_coin_price() #需要对比的市场价格 #print('%s:is requesting price@%s' % (self.__get_curr_time(),market_vs)) price_vs = pricemanage.PriceManage(market_vs, coin).get_coin_price() # print('%s:is comparing price'%self.__get_curr_time()) price_check_result = self.__price_check( coin, price_base, price_vs) self.__check_price_num = self.__check_price_num + 1 if self.__check_price_num % 10 == 0: print('%s: 已经检查了%d次的价格' % (self.__get_curr_time(), self.__check_price_num)) # TODO for testing #price_check_result=True #如果价格可以进行买卖刚返回 if price_check_result: #对于达到要求的保存到类变量中,交易函数进行处理 self.__market_base = market_base self.__market_vs = market_vs self.__price_base = price_base self.__price_vs = price_vs # 满足交易的coin code self.__trans_coin_code = coin #把交易实例保存起来 # Base account的交易实例 self.__order_base = ordermanage.OrderManage( self.__market_base) # VS市场 self.__order_vs = ordermanage.OrderManage( self.__market_vs) #预期盈利金额 profitamt = (self.__std_amount / price_base.sell_cny ) * (price_vs.buy_cny - price_base.sell_cny) print('%s: Coin:%s,BaseMarket(Buy):%s, VSmarket(Sell):%s,Buy price:%f,Sell price:%f,投资%f预期盈利:%f'\ %(self.__get_curr_time(),coin,market_base,market_vs,price_base.sell_cny,price_vs.buy_cny,self.__std_amount,profitamt)) #开始处理交易 # 检查帐户的仓位并调整相应的盈利比例 #print('%s: is checking account balance'%self.__get_curr_time()) account_balance = self.__check_account() # 如果过多的买入成功,卖出失败则停止进行自动交易,防止异常的一直出现买入的情况 if account_balance and self.__sell_fail_times < self.__max_sell_fail_times: #检查帐户的仓位并调整相应的盈利比例 #print('%s: is doing transaction.'%self.__get_curr_time()) trans_status = self.__trans_apply() if trans_status: print('交易成功!') else: print('交易失败/或卖出当时未成功!') else: print('帐户余额不足!')