def testReadScoring(self):
self.maxDiff = None
exp_scoring = {'passing_yds': .04,
'passing_tds': 4,
'passing_int': -2,
'passing_twoptm': 2,
'rushing_yds': .1,
'rushing_tds': 6,
'rushing_att': 0,
'rushing_twoptm': 2,
'receiving_yds': .1,
'receiving_tds': 6,
'receiving_rec': 0,
'receiving_twoptm': 2,
"puntret_tds": 6,
"kickret_tds": 6,
'fumbles_tot': -2,
'kicking_fgm': 3,
'kicking_fgmissed': -1,
'kicking_xpmade': 1,
'kicking_xpmissed': -1}
scoring = STD
self.assertEqual(scoring, exp_scoring)
exp_scoring['receiving_rec'] = 0.5
scoring = Trade.extend_scoring_file(TestData('standard.json'), TestData('halfppr_ext.json'))
self.assertEqual(scoring, exp_scoring)
with self.assertRaises(Trade.NotEnoughRulesError):
Trade.read_scoring_file(TestData('notenoughrules.json'))
def make_trade(trade):
num_teams = len(trade)
teams = []
for i in range(0, num_teams):
team_name = trade[i][0]
players_out = trade[i][1]
players_in = trade[i][2]
team = Team(team_name)
team.players_out = players_out
team.players_in = players_in
teams.append(team)
trade = Trade(teams)
for t in trade.teams:
t.calc_money_in()
t.calc_money_out()
decisions = []
for t in trade.teams:
decision, msg = trade.check_trade(t)
decisions.append(decision)
final_decision = trade.finalize_trade(decisions)
print(final_decision)
def testAverageLists(self):
a = [1.0, 2.0, 3.0]
b = [5.0, 4.0, 3.0]
c = [3.0, 8.0, 3.0]
self.assertEqual(Trade.average_lists(a, b, c), [3.0, 4.0, 3.0])
lists = [[10, 20], [30, 5], [8, 6], [9, 9], [1, 50]]
self.assertEqual(Trade.average_lists(*lists), [9.0, 11.67])
a = [2.5, 3.0, 3.5]
b = [20, 30]
self.assertEqual(Trade.average_lists(a, b), [11.25, 16.5])
def getSchedule(self, sid, ordersize, alg):
if hd.updateStock(str(sid)) != 0:
self.sidNotExsist.emit()
return
trade_style = 0 # not implemented yet
self.schedPrepared.emit(td.tradeStock(sid, int(ordersize), trade_style, alg))
def parse_trades(trade_path):
trade_list = []
with open(trade_path, 'r') as f:
# Throw away first 36 lines
for num in range(1, 37):
f.readline()
for line in f:
open_data = line.split()
side = open_data[2]
if open_data[3] == 'Close':
open_price = float(open_data[9])
else:
open_price = float(open_data[6])
close_data = f.readline().split()
if len(close_data) < 4:
break
if close_data[2] == 'Close':
close_price = float(close_data[8])
else:
close_price = float(close_data[5])
trade_list.append(
Trade.Trade(side=side,
open_price=open_price,
close_price=close_price))
return trade_list
def run(self):
self.model_history = np.empty((self.n_periods, ), dtype=Model)
for i in range(self.n_periods):
sequence = self.ts[i:i + self.n_train]
self.__fit_model_to_sequence(
sequence, None) if i == 0 else self.__fit_model_to_sequence(
sequence, self.model_history[i - 1].params.to_array())
self.model_history[i] = deepcopy(self.model)
self.trade_logic.update_logic(self.model_history[i], sequence)
if self._is_trade_open():
self.trade_history[-1].add_position(
i, sequence[-1]
) # 'sequence' must be the log_return of the original TS !
if self.trade_logic.close_trade():
self.trade_history[-1].close()
else:
if self.trade_logic.open_trade():
self.trade_history.append(
Trade(i + 1)
) # '+1' since the trade is actually opened the next period
# Check if last 'Trade' is empty
self.__compute_PnL()
self.PnL_statistics = Statistics(self.PnL)
def setUp(self):
'''登录followme系统'''
#生产 十年一剑1688
self.login = '******'
self.brokerID = 5
curr_tiem = datetime.datetime.now() + datetime.timedelta(days=-1)
self.yesterDay = curr_tiem.strftime('%Y-%m-%d 00:00:00.000')
mongoDB = FMCommon.mongoDB_operater_data(host=statisticData["mongo_host"], port=statisticData["mongo_port"],)
for i in mongoDB.fm.mg_test_result_all.find({"login":self.login}):
self.mongoList = {}
for key in statisticData["mongoKeyListAll"]:
try:
value = i[key]
# print("88888888888888888")
# print(i,'>>>>>>>>>>>>>>>>>>',i[key])
except KeyError:
value = statisticData["keyErr"]
self.mongoList[key]=value
# print(self.mongoList[key],value)
params = {"time":7,"pageField":"Score","pageSort":"DESC"}
self.rankTraders = Trade.getRankTraders(webAPIData['hostName_dev'] + tradeData['getRankTraders_url'],params=params,printLogs=1)
self.assertEqual(self.rankTraders.status_code, webAPIData['status_code_200'])
# key = []
#遍历items里面所有的数据
for i in json.loads(self.rankTraders.text)["data"]["items"]:
# 遍历items里面所有的key，value
if i["NickName"] =="萬丈豪情":
def setUpClass(cls):
time = datetime.datetime.strptime("2012-07-02T12:03:22",
"%Y-%m-%dT%H:%M:%S")
cls.faketrade = Trade.Trade(time, 13.97, 137)
cls.fakestart = datetime.datetime.strptime("2005-07-02T12:03:22",
"%Y-%m-%dT%H:%M:%S")
cls.fakeend = datetime.datetime.strptime("2030-07-02T12:03:22",
"%Y-%m-%dT%H:%M:%S")
cls.fakefile = "2017-03-01T13:37:89Z 21.37 100\n" + \
"2017-04-25T17:11:55Z 20.18 55\n" + \
"2017-05-19T05:49:34Z 23.09 21\n" + \
"2017-06-12T09:51:21Z 17.21 80000"
cls.otherfakefile = "2010-03-01T13:37:12Z 11 19\n" + \
"2011-04-25T17:11:55Z 12 47\n" + \
"2011-13-25T17:11:55Z 23 89\n" + \
"2012-05-19T05:49:34Z 13 56\n" + \
"2013-05-19T05:49:34Z 14 65\n" + \
"2013-05-19T05:49:63Z 14 65\n" + \
"2014-05-19T05:49:34Z 15 47\n" + \
"2015-05-19T05:49:34Z 16 36\n" + \
"2016-05-19T05:49:34Z 17 20\n" + \
"2017-05-19T05:49:34Z 18 10\n" + \
"2019-05-19T05:49:34Z 19 10\n" + \
"2019-06-12T09:51:21Z 20 6"
def startBacktest(self):
for index, datapoint in enumerate(self.relevantData):
self.setDataChunk(index, self.strat_args['period'])
if self.currTrade:
indication, study = self.strategy.main(
self.relDataChunk, self.currTrade.getIsOpen(),
self.currTrade.getIsLong(), self.strat_args)
else:
indication, study = self.strategy.main(self.relDataChunk,
False, None,
self.strat_args)
if indication:
if indication.startswith("enter"):
self.studies.append(study)
self.currTrade = Trade.Trade(index)
self.trade(indication, index)
else:
self.studies.append(study)
self.trade(indication, index)
elif self.currTrade:
self.studies.append(study)
if self.currTrade.getIsOpen() and self.hitStopLevel(index):
if self.currTrade.getIsLong():
self.trade(self.EXIT_LONG, index)
else:
self.trade(self.EXIT_SHORT, index)
else:
self.studies.append(study)
def test_BatchClose(self):
'''登录->切换到MT4账号->获取交易token->创建多个开仓订单>批量平仓->退出登录'''
userData['headers'][userData['Authorization']] = userData['Bearer'] + self.token
# 获取交易员的accountindex
self.tradeAccountIndex= Account.getSpecialAccountIndex(headers=userData['headers'], brokerID=5)
# 切换到MT4账号
switchAccountRes = Account.switchAccount(userData['hostName'] + userDataAccount['switchAccount'],
userData['headers'], self.tradeAccountIndex[0])
self.assertEqual(switchAccountRes.status_code, userData['status_code_200'])
# 获取交易token
getTokenRes = Trade.getToken(userData['hostName'] + userDataAccount["getToken_url"], userData['headers'])
FMCommon.printLog('getTokenRes: ' + getTokenRes.text)
self.assertEqual(getTokenRes.status_code, userData['status_code_200'])
tradeToken = str(json.loads(getTokenRes.content)["data"]["Token"]).replace("=", "@")
# 开仓500张单
openOrderList = []
count = 0
while count < 2:
openParam = {userDataWebSocket['orderParam_code']: userDataWebSocket['ws_code_210'],
userDataWebSocket['orderParam_symbol']: "AUDCAD",
userDataWebSocket['orderParam_volume']: 1}
openPositionRes = TradeOnline.OnlineTradeEvent.tradeEvent(
self, userDataWebSocket['ws_host'], userDataWebSocket['ws_port'], {'token': "" + tradeToken}, openParam)
if(openPositionRes["code"]==userDataWebSocket['ws_code_0']):
self.assertEqual(openPositionRes["rcmd"], userDataWebSocket['ws_code_210'])
self.assertEqual(openPositionRes["order"]["volume"], 1)
self.assertEqual(openPositionRes["order"]["symbol"], "AUDCAD")
self.orderID = openPositionRes["order"]["order_id"]
openOrderList.append(self.orderID)
if (openPositionRes["code"] == 4):
print("保证金不足！")
if (openPositionRes["code"] == 10):
print("市场关闭！")
if (openPositionRes["code"] == 300):
print("服务器内部错误！")
if (openPositionRes["code"] == 3):
print("客户不存在！")
if (openPositionRes["code"] == 7):
print("获取价格失败！")
if (openPositionRes["code"] == 9):
print("手数错误！")
if (openPositionRes["code"] == 18):
print("此品种不能交易！")
count = count + 1
time.sleep(2)
#批量平仓
closeOrder = {userDataWebSocket['orderParam_code']: userDataWebSocket['ws_code_219'],
userDataWebSocket['orderParam_tickets']: openOrderList}
closeOrderRes = TradeOnline.OnlineTradeEvent.tradeEvent(self, userDataWebSocket['ws_host'], userDataWebSocket['ws_port'], {'token': "" + tradeToken}, closeOrder)
self.assertEqual(closeOrderRes["code"], userDataWebSocket['ws_code_0'])
self.assertEqual(closeOrderRes["rcmd"], userDataWebSocket['ws_code_219'])
self.assertEqual(closeOrderRes["tickets"], None)
def test_DeleteOrdersByFxcm(self):
'''登录->切换到福汇账号->获取交易token->检查持仓单列表是否有单，如果有单批量平仓>退出登录'''
userData['headers'][
userData['Authorization']] = userData['Bearer'] + self.token
# 获取交易员的accountindex
self.tradeAccountIndex_fxcm = Account.getSpecialAccountIndex(
headers=userData['headers'], brokerID=4)
# 切换到MT4账号
switchAccountRes = Account.switchAccount(
userData['hostName'] + userDataAccount['switchAccount'],
userData['headers'], self.tradeAccountIndex_fxcm[0])
self.assertEqual(switchAccountRes.status_code,
userData['status_code_200'])
# 获取交易token
getTokenRes = Trade.getToken(
userData['hostName'] + userDataAccount["getToken_url"],
userData['headers'])
FMCommon.printLog('getTokenRes: ' + getTokenRes.text)
self.assertEqual(getTokenRes.status_code, userData['status_code_200'])
tradeToken = str(json.loads(
getTokenRes.content)["data"]["Token"]).replace("=", "@")
'''获取当前用户的所有交易订单，并平掉'''
params = {
userData['orderStatus']: userData['orderStatus_open'],
"view": "TRADER"
}
getOrders = Order.getOrders(userData['hostName'] +
orderData['getOrders_url'],
userData['headers'],
params=params)
# 获取订单成功，返回200 ok
self.assertEqual(getOrders.status_code, userData['status_code_200'])
ordersIDList = Order.getOrdersID(getOrders)
print("ordersIDList:", ordersIDList)
time.sleep(2)
# 平掉当前用户所有订单,如果有
# #web sockets批量平仓
closeParam = {
userDataWebSocket['orderParam_code']:
userDataWebSocket['ws_code_219'],
userDataWebSocket['orderParam_tickets']: ordersIDList
}
closePositionRes = TradeOnline.OnlineTradeEvent.tradeEvent(
self, userDataWebSocket['ws_host'], userDataWebSocket['ws_port'],
{'token': tradeToken}, closeParam)
if (closePositionRes["code"] == userDataWebSocket['ws_code_0']):
# 校验code等于0，为及时单平仓成功
# 校验rcmd等于210，为及时单开仓
self.assertEqual(closePositionRes["rcmd"],
userDataWebSocket['ws_code_219'])
# 校验平掉的单号，为本测试及时单开仓的单号
self.assertEqual(closePositionRes['success_tickets'], ordersIDList)
if (closePositionRes["code"] == 13):
print("订单不存在!")
def testCheck(self):
return
db = nfldb.connect()
calc = Trade.Calculator(PURE)
q = nfldb.Query(db)
q.game(season_year=2009, season_type='Regular')
rushers = q.sort('rushing_yds').limit(100).as_aggregate()
receivers = q.sort('receiving_yds').limit(100).as_aggregate()
passers = q.sort('passing_yds').limit(35).as_aggregate()
players = Trade.aggpps_to_players(rushers + receivers + passers)
for rec,yds in calc.sort_position_more(players, 'TE'):
print "{} {}".format(rec,yds)
def test_Trade_initialization(self):
time = datetime.datetime.strptime("2017-04-25T17:11:55",
"%Y-%m-%dT%H:%M:%S")
price = 27.36
quantity = 73
trade = Trade.Trade(time, price, quantity)
self.assertEqual(
trade.time,
datetime.datetime.strptime("2017-04-25T17:11:55",
"%Y-%m-%dT%H:%M:%S"),
"The date does not match")
self.assertEqual(trade.price, price, "The price does not match")
self.assertEqual(trade.quantity, quantity,
"The quantity does not match")
def trade():
resp = flask.request.json
to_give = resp['give'] if 'give' in resp else []
they_bench = resp['they_bench'] if 'they_bench' in resp else []
to_receive = resp['receive'] if 'receive' in resp else []
i_bench = resp['i_bench'] if 'i_bench' in resp else []
scoring = resp['scoring']
for player in to_give + they_bench + to_receive + i_bench:
player['expected'] = Trade.fast_guess_points(scoring.lower(),
player['name'].lower(),
player['position'].lower())
resp['my_net'] = round(sum_expected(to_receive) - sum_expected(i_bench), 2)
resp['their_net'] = round(sum_expected(to_give) - sum_expected(they_bench), 2)
resp['net'] = resp['my_net'] - resp['their_net']
return flask.jsonify(**resp)
def process_trade(record):
""" Returns a Trade object from a string of trade data (only accepts UTC 'Z' region code or none)
Returns None if bad date data
Also prints bad date to console
Keyword Arguments:
record - A string in the format 2017-04-25T17:11:55Z 20.18 55
"""
# Takes out the Zulu region code
tradeline = record.split("Z")
try:
time = datetime.datetime.strptime(tradeline[0], "%Y-%m-%dT%H:%M:%S")
except ValueError:
print("Cannot format Date/Time from " + record)
return
trades = tradeline[1].strip().split(" ")
trade = Trade.Trade(time, float(trades[0]), int(trades[1]))
return trade
def test_AnalogAccountTotalvolume(self):
'''验证模拟账号最大持仓为3手'''
userData['headers'] = dict(
userData['headers'],
**{'Authorization': userData['Bearer'] + self.token})
# 获取模拟账户的accountindex
self.tradeAccountIndex = Account.getSpecialAccountIndex(
headers=userData['headers'], brokerID=3, accountType=0)
#模拟账号切换账户
Account.switchAccount(
userData['hostName'] + userDataAccount['switchAccount'],
userData['headers'], self.tradeAccountIndex[0])
# 获取模拟账号交易token
traderTokenRes = Trade.getToken(
userData['hostName'] + userDataAccount["getToken_url"],
userData['headers'])
self.assertEqual(traderTokenRes.status_code,
userData['status_code_200'])
tradeToken = str(json.loads(
traderTokenRes.content)["data"]["Token"]).replace("=", "@")
# 模拟账号开仓
openParam = {
userDataWebSocket['orderParam_code']:
userDataWebSocket['ws_code_210'],
userDataWebSocket['orderParam_symbol']:
userDataWebSocket['broker_EURCAD'],
userDataWebSocket['orderParam_volume']:
3100
}
openPositionRes = TradeOnline.OnlineTradeEvent.tradeEvent(
self, userDataWebSocket['ws_host'], userDataWebSocket['ws_port'],
{'token': "" + tradeToken}, openParam)
self.assertEqual(openPositionRes["code"], 19)
print("模拟账号最大持仓为3手!")
def testTest(self):
return
db = nfldb.connect()
q = nfldb.Query(db)
uplayers = set()
for year in range(2009, 2015):
q = nfldb.Query(db)
q.game(season_year=year, season_type='Regular')
for stat in ['receiving_yds']:
aggpps = q.sort(stat).limit(85).as_aggregate()
for aggpp in aggpps:
if str(aggpp.player.position) == 'UNK':
uplayers.add(aggpp.player.full_name)
d = collections.OrderedDict()
for player in uplayers:
if not Trade.get_position(player):
first_name = player.split(' ')[0]
last_name = player.split(' ')[1]
print 'http://www.pro-football-reference.com/players/{}/{}{}00.htm'.format(last_name[0], last_name[:4], first_name[:2])
d[player] = 'WR'
print json.dumps(d)
def EveryMarketOpen(self):
for ticker in self.tickers:
# Initialize
model_name = "HMM_" + str(ticker)
model = self.models[model_name]
data_point = self.Securities[ticker].Price
if data_point > 0:
# HMM Prediction Results
regime = model.predict_regime(data_point)
mean = model.get_regime_mean(regime)
transition_probabilities = model.get_transition_probabilities(
regime)
current_stock_price = data_point
self.ratio[model_name] = self.predicted_price[
model_name] / current_stock_price
# Prediction
trading = Trade(regime, mean, current_stock_price,
self.cash_amount[model_name],
transition_probabilities,
self.risk[model_name],
self.Portfolio[ticker].Invested)
self.predicted_price[model_name] = trading.predicted_price
amount_to_trade = 0
number_of_shares = 0
# Buying/Selling
if trading.should_buy():
amount_to_trade = trading.bullish()
number_of_shares = amount_to_trade // self.Securities[
ticker].Price
elif trading.should_sell():
amount_to_trade = trading.bearish()
number_of_shares = -amount_to_trade // self.Securities[
ticker].Price
else:
print("For 3 Regime System - Stationary Regime")
# Order
self.MarketOrder(ticker, number_of_shares)
# symbol = LTCBTC & type = LIMIT & side = BUY & timeInForce = GTC & quantity = 1 & price = 0.1 & recvWindow = 5000
response = bApi.testNewOrder(symbol="BTCUSDT",
type="MARKET",
side="BUY",
quantity="0.0002",
recvWindow="5000")
# response = bApi.accountInformation(recvWindow="5000")
print(json.loads(response.text))
# infoList = json.loads(response.text)
# print(infoList[1])
# for key in infoList:
# print(key)
# print(infoList[key])
# print("----")
# print(len(json.loads(response.text)["balances"]))
# print(len(json.loads(response.text)))
trade = Trade()
# curTradeTime = trade.getLatest15Min(time.time())
# print(curTradeTime)
# response = bApi.Kline(symbol="BNBUSDT", interval="15m", startTime=str(1618805700) + "000", limit="2")
# kLineInfoList = json.loads(response.text)
# print(response)
# print(json.loads(response.text))
while (1):
trade.tradeAsPolicy03("BNB", 20, 0)
# print(trade.tradeAsPolicy03("BNB", 10))
"Trade Price": [100, 1000, 150, 299, 478, 3874, 4000, 4100],
"Trade Time": [datetime.now(), '2019-09-18 00:01:10.790865', datetime.now(), datetime.now(), datetime.now(),
datetime.now(), datetime.now(), datetime.now()]
}
trade_data_df = pd.DataFrame(trade_data)
mytrade_list = [] # this will have all of the trade objects class as list.
object_count = 0 # No of trade class objects. Initializing to 0.
# Iterating over trade data dataframe. Creating trade objects and adding to object lists.
# Below loop will dynamically setup trade class objects and add data present in the trade_data_df dataframe to stocks class.
for index, rows in trade_data_df.iterrows():
my_trade = Trade.Trade(rows['Stocks'])
mytrade_list.append(my_trade)
mytrade_list[object_count].set_quantity(rows['Quantity'])
mytrade_list[object_count].set_bs_indicator(rows['BS Indicator'])
mytrade_list[object_count].set_trade_price(rows['Trade Price'])
mytrade_list[object_count].set_trade_time(rows['Trade Time'])
object_count += 1
all_stock_trades = TradingOutputs.TradingOutputs()
all_stock_trades.record_trades(mytrade_list)
print('Trades Recorded:\n', all_stock_trades.trade_df)
stocks_traded = list(all_stock_trades.trade_df['StockSymbol'].unique())
print('Stocks Traded:', stocks_traded)
def testSuffix(self):
self.assertEqual(Trade.suffix(1), 'st')
self.assertEqual(Trade.suffix(8), 'th')
self.assertEqual(Trade.suffix(22), 'nd')
self.assertEqual(Trade.suffix(133), 'rd')
self.assertEqual(Trade.suffix(1891), 'st')
def test_CreateProductToEndProduct(self):
'''场景步骤：1，交易员登录2，交易员创建产品并验证产品信息3，登录OA4，OA审核产品通过5，获取产品信息,并验证产品状态6，跟随者登录
7，跟随者参与产品（2个跟随者）8，OA修改产品开始时间 9，交易员开仓10，交易员平仓11，OA结束产品12，获取交易员的订单列表，验证交易员
的收益和盈亏点数13，获取跟随者的订单列表，验证跟随者的收益和盈亏点数14，验证产品状态为已结束15，验证产品的结算数据16，退出登录 '''
# 获取今天
today = datetime.date.today()
# 获取3天后转为时间戳
tomorrow = today + datetime.timedelta(days=3)
timeArray_tomorrow = time.strptime(str(tomorrow), "%Y-%m-%d")
timeStamp_tomorrow = int(time.mktime(timeArray_tomorrow))
# 获得6天后转为时间戳
after_tomorrow = today + datetime.timedelta(days=6)
timeArray_after_tomorrow = time.strptime(str(after_tomorrow),
"%Y-%m-%d")
timeStamp_after_tomorrow = int(time.mktime(timeArray_after_tomorrow))
userData['headers'][
userData['Authorization']] = userData['Bearer'] + self.traderToken
self.followHeaders = dict(
userData['headers'],
**{'Authorization': userData['Bearer'] + self.token})
# 获取交易员的accountindex
self.tradekvbminiAccountIndex = Account.getSpecialAccountIndex(
headers=userData['headers'], brokerID=6, accountType=3)
# 获取跟随者的accountindex
self.followerkvbminiAccountIndex = Account.getSpecialAccountIndex(
headers=self.followHeaders, brokerID=6, accountType=3)
#交易员创建产品
datas = {
"accountIndex": self.tradekvbminiAccountIndex[0],
"name": "testCI" + str(int(time.time())),
"description": "testmamonci",
"profitModeID": 1,
"retreatModeID": 2,
"expectROI": 0.3,
"expectFollowerCount": 2,
"expectDays": 1,
"expectStartTime": timeStamp_tomorrow,
"expectEndTime": timeStamp_after_tomorrow,
"isShowHistoryOrder": True,
"signature": "test"
}
CreateProductRes = MAM.createProduct(
userData['hostName'] + userDataMam['createProduct_url'],
userData['headers'], datas)
self.assertEqual(CreateProductRes.status_code,
userData['status_code_200'])
#返回产品ID
self.product_id = json.loads(CreateProductRes.text)['data']['ID']
#返回创建人的UserID
self.createrUserId = int(
json.loads(CreateProductRes.text)['data']['Trader']['UserID'])
# 返回产品Name
self.product_name = json.loads(CreateProductRes.text)['data']['Name']
self.headerOA = {
'content-type': 'application/json',
'Accept': 'application/json',
'Authorization': 'Bearer ' + str(self.tokenOA)
}
#查询产品自增长ID
select_id_sql = 'SELECT id from t_product_propose WHERE product_id=' + str(
self.product_id)
idRES = FMCommon.mysql_operater(userData['beta_mysql_host'],
userData['beta_mysql_port'],
userData['beta_mysql_db'],
userData['beta_mysql_user'],
userData['beta_mysql_passwd'],
select_id_sql)
for mtuple in idRES:
for item in mtuple:
id = item
time.sleep(10)
#OA审核产品通过
ProductProposeActiondatas = {
"Action": 0,
"ProductProposeID": id,
"DeclineReason": "",
"ProposerUserID": self.createrUserId
}
ProductProposeActionRes = MAM.ProductProposeAction(
userData['hostNameOA'] + userDataMam['ProductProposeAction_url'],
self.headerOA, ProductProposeActiondatas)
self.assertEqual(ProductProposeActionRes.status_code,
userData['status_code_200'])
time.sleep(5)
#获取产品信息
GetProductRES = MAM.GetProduct(
userData['hostName'] + userDataMam['getProduct_url'] +
str(self.product_id), userData['headers'])
self.assertEqual(GetProductRES.status_code,
userData['status_code_200'])
#验证产品状态为"发布中"
self.product_status = json.loads(GetProductRES.text)['data']['Status']
self.assertEqual(self.product_status, "Pending")
#跟随者参与产品(第一个跟随者)
datas = {
"accountIndex": self.followerkvbminiAccountIndex[0],
"signature": "test1"
}
joinProductRES = MAM.JoinProduct(
userData['hostName'] + userDataMam['joinProduct_url'] +
str(self.product_id) + userDataMam['joinProduct_join_url'],
self.followHeaders, datas)
self.assertEqual(joinProductRES.status_code,
userData['status_code_200'])
#跟随者参与产品(第二个跟随者)
datas = {
"accountIndex": self.followerkvbminiAccountIndex[1],
"signature": "test2"
}
joinProductRES = MAM.JoinProduct(
userData['hostName'] + userDataMam['joinProduct_url'] +
str(self.product_id) + userDataMam['joinProduct_join_url'],
self.followHeaders, datas)
self.assertEqual(joinProductRES.status_code,
userData['status_code_200'])
time.sleep(5)
# 获取一分钟后
TimeNowAfterOneMinute = (
datetime.datetime.now() +
datetime.timedelta(minutes=1)).strftime("%Y-%m-%d %H:%M:%S")
# 切换到交易员账户
switchAccountRes = Account.switchAccount(
userData['hostName'] + userDataAccount['switchAccount'],
userData['headers'], self.tradekvbminiAccountIndex[0])
self.assertEqual(switchAccountRes.status_code,
userData['status_code_200'])
# 获取交易token
getTokenRes = Trade.getToken(
userData['hostName'] + userDataAccount["getToken_url"],
userData['headers'])
self.assertEqual(getTokenRes.status_code, userData['status_code_200'])
tradeToken = str(json.loads(
getTokenRes.content)["data"]["Token"]).replace("=", "@")
traderMT4Account = str(
json.loads(getTokenRes.content)["data"]["MT4Account"])
# 人数达标后，修改产品开始时间
updatePendingProductdatas = {
"Account":
self.traderNickName + traderMT4Account + "#" +
self.tradekvbminiAccountIndex[0],
"Description":
"testmamonci",
"ExpectDays":
1,
"ExpectFollowerCount":
2,
"ExpectROI":
0.3,
"ExpectStartTime":
TimeNowAfterOneMinute,
"IsShowHistoryOrder":
True,
"Mt4Account":
traderMT4Account,
"Name":
self.product_name,
"ProductID":
self.product_id,
"Productstatus":
"1",
"ProfitModeID":
1,
"RetreatModeID":
2
}
updatePendingProductRES = MAM.updatePendingProduct(
userData['hostNameOA'] + userDataMam['UpdatePendingProduct_url'],
self.headerOA, updatePendingProductdatas)
self.assertEqual(updatePendingProductRES.status_code,
userData['status_code_200'])
time.sleep(100)
openOrderList = []
count = 0
while count < 3:
#交易员开仓
openParam = {
userDataWebSocket['orderParam_code']:
userDataWebSocket['ws_code_210'],
userDataWebSocket['orderParam_symbol']:
"AUDCAD",
userDataWebSocket['orderParam_volume']:
1
}
openPositionRes = TradeOnline.OnlineTradeEvent.tradeEvent(
self, userDataWebSocket['ws_host'],
userDataWebSocket['ws_port'], {'token': "" + tradeToken},
openParam)
self.assertEqual(openPositionRes["code"],
userDataWebSocket['ws_code_0'])
self.assertEqual(openPositionRes["rcmd"],
userDataWebSocket['ws_code_210'])
self.orderID = openPositionRes["order"]["order_id"]
openOrderList.append(self.orderID)
count = count + 1
time.sleep(15)
# 批量平仓10张
closeOrder = {
userDataWebSocket['orderParam_code']:
userDataWebSocket['ws_code_219'],
userDataWebSocket['orderParam_tickets']: openOrderList
}
closeOrderRes = TradeOnline.OnlineTradeEvent.tradeEvent(
self, userDataWebSocket['ws_host'], userDataWebSocket['ws_port'],
{'token': "" + tradeToken}, closeOrder)
self.assertEqual(closeOrderRes["code"], userDataWebSocket['ws_code_0'])
self.assertEqual(closeOrderRes["rcmd"],
userDataWebSocket['ws_code_219'])
time.sleep(15)
#在OA里结束产品
ProductEnddatas = {
"ProductID":
self.product_id,
"Name":
self.product_name,
"Account":
self.traderNickName + traderMT4Account + "#" +
self.tradekvbminiAccountIndex[0],
"Mt4Account":
traderMT4Account,
"BrokerID":
6,
"Productstatus":
2,
"Remark":
"end"
}
productEndOARES = MAM.productEndOA(
userData['hostNameOA'] + userDataMam['ProductEnd_url'],
self.headerOA, ProductEnddatas)
self.assertEqual(productEndOARES.status_code,
userData['status_code_200'])
time.sleep(3)
#获取产品的交易员的订单列表
getTraderProductOrdersRES = MAM.getProductOrders(
userData['hostName'] + userDataMam['getProductOrders_url'] +
str(self.product_id) + userDataMam['getProductOrders_orders_url'] +
"?my=" + "false", userData['headers'])
#获取交易员的收益和盈亏点数
self.assertEqual(getTraderProductOrdersRES.status_code,
userData['status_code_200'])
self.traderProfit = json.loads(
getTraderProductOrdersRES.text)['data']['summary']['Profit']
self.traderPips = json.loads(
getTraderProductOrdersRES.text)['data']['summary']['Pips']
#切换到第一个跟随者，获取跟随者收益
switchAccountRes = Account.switchAccount(
userData['hostName'] + userDataAccount['switchAccount'],
self.followHeaders, self.followerkvbminiAccountIndex[0])
self.assertEqual(switchAccountRes.status_code,
userData['status_code_200'])
getFollowerProductOrdersRES = MAM.getProductOrders(
userData['hostName'] + userDataMam['getProductOrders_url'] +
str(self.product_id) + userDataMam['getProductOrders_orders_url'] +
"?my=" + "true", self.followHeaders)
self.assertEqual(getFollowerProductOrdersRES.status_code,
userData['status_code_200'])
self.followerProfit_first = json.loads(
getFollowerProductOrdersRES.text)['data']['summary']['Profit']
self.followerPips_first = json.loads(
getFollowerProductOrdersRES.text)['data']['summary']['Pips']
#切换到第二个跟随者，获取跟随者的收益
switchAccountRes = Account.switchAccount(
userData['hostName'] + userDataAccount['switchAccount'],
self.followHeaders, self.followerkvbminiAccountIndex[1])
self.assertEqual(switchAccountRes.status_code,
userData['status_code_200'])
getFollowerProductOrdersRES = MAM.getProductOrders(
userData['hostName'] + userDataMam['getProductOrders_url'] +
str(self.product_id) + userDataMam['getProductOrders_orders_url'] +
"?my=" + "true", self.followHeaders)
self.assertEqual(getFollowerProductOrdersRES.status_code,
userData['status_code_200'])
self.followerProfit_second = json.loads(
getFollowerProductOrdersRES.text)['data']['summary']['Profit']
self.followerPips_second = json.loads(
getFollowerProductOrdersRES.text)['data']['summary']['Pips']
#如果是亏损的，交易员百分百赔付跟随者
if self.followerProfit_first <= 0:
self.traderProfit = self.traderProfit + self.followerProfit_first
self.followerProfit_first = 0
if self.followerProfit_second <= 0:
self.traderProfit = self.traderProfit + self.followerProfit_second
self.followerProfit_second = 0
#如果是盈利，交易员二八分成
if self.followerProfit_first > 0:
self.traderProfit = self.traderProfit + self.followerProfit_first * 0.8
self.followerProfit_first = self.followerProfit_first * 0.2
if self.followerProfit_second > 0:
self.traderProfit = self.traderProfit + self.followerProfit_second * 0.8
self.followerProfit_second = self.followerProfit_second * 0.2
#验证产品状态为已结束getProduct,并验证产品的结算数据
GetProductRES = MAM.GetProduct(
userData['hostName'] + userDataMam['getProduct_url'] +
str(self.product_id), userData['headers'])
self.assertEqual(GetProductRES.status_code,
userData['status_code_200'])
# 验证产品状态为"已结束"
self.product_status = json.loads(GetProductRES.text)['data']['Status']
self.assertEqual(self.product_status, "Settled")
# 验证参与人数
self.assertEqual(
json.loads(GetProductRES.text)['data']['FollowerCount'], 2)
# 验证发起产品人的身份
self.assertEqual(
json.loads(GetProductRES.text)['data']['Trader']['Type'], "Trader")
# 验证发起产品人的用户ID
self.assertEqual(
json.loads(GetProductRES.text)['data']['Trader']['UserID'],
self.createrUserId)
# 验证发起产品人的AccountIndex
self.assertEqual(
str(
json.loads(
GetProductRES.text)['data']['Trader']['AccountIndex']),
self.tradekvbminiAccountIndex[0])
# 验证发起产品人的经纪商ID
self.assertEqual(
json.loads(GetProductRES.text)['data']['Trader']['BrokerID'], 6)
# 验证交易员的分成收益
self.assertAlmostEqual(json.loads(
GetProductRES.text)['data']['MyProfit'],
self.traderProfit,
delta=100)
# 验证跟随者的分成收益
self.assertAlmostEqual(json.loads(
GetProductRES.text)['data']['FollowerProfit'],
self.followerProfit_first,
delta=100)
self.assertAlmostEqual(json.loads(
GetProductRES.text)['data']['FollowerProfit'],
self.followerProfit_second,
delta=100)
def write_latest():
for position in Trade.POSITIONS:
for name, link in create_all_links(position):
tsv_str = download_rankings(link)
Trade.write_resource(get_filepath(name, position), tsv_str)
def get_ranking(scoring, player_name, position):
tsv_str = Trade.get_resource(get_filepath(scoring, position))
rankings = read_rankings(tsv_str)
return rankings.index(player_name)
def test_1_getCustomers(self):
'''获取近一周有交易的跟随大师信息'''
params = {"time": 7, "pageField": "FollowProfit"}
customers = Trade.getCustomers(webAPIData['hostName'] +
tradeData['getCustomers_url'],
params=params,
printLogs=1)
self.assertEqual(customers.status_code, webAPIData['status_code_200'])
print("Customers_oneWeek:")
table = PrettyTable([
"预期/实际", "NickName", "UserID", "mt4Account", "AccountIndex",
"近一日跟随获利", "近一日盈亏点数", "收益率", "平均获利点数", "交易笔数", "交易周期"
])
try:
for item in json.loads(customers.text)["data"]["items"]:
mt4Account = Statistic.getMt4Account(
userID=str(item["UserId"]),
accountIndex=str(item["AccountCurrentIndex"]))
moneyFollowCloseDay = Statistic.moneyFollowCloseDay(
mt4Account=mt4Account, brokerID=item["BrokerId"])
pointCloseDay = Statistic.pointCloseDay(
mt4Account=mt4Account, brokerID=item["BrokerId"])
rateProfit = Statistic.rateProfit(mt4Account=mt4Account,
brokerID=item["BrokerId"])
pointProfitCloseMean = Statistic.pointProfitCloseMean(
mt4Account=mt4Account, brokerID=item["BrokerId"])
ordersCount = Statistic.ordersCount(mt4Account=mt4Account,
brokerID=item["BrokerId"])
tradePeriod = Statistic.tradePeriod(mt4Account=mt4Account,
brokerID=item["BrokerId"])
table.add_row([
"预期结果", item["NickName"], item["UserId"], mt4Account,
item["AccountCurrentIndex"], moneyFollowCloseDay,
pointCloseDay, rateProfit, pointProfitCloseMean,
ordersCount, tradePeriod
])
table.add_row([
"实际结果", item["NickName"], item["UserId"], mt4Account,
item["AccountCurrentIndex"], item["BizFollowProfit"],
item["BizPoint"], item["BizROIex"], item["BizAVGPoint"],
item["Orders"], item["Weeks"]
])
table.add_row(["", "", "", "", "", "", "", "", "", "", ""])
#由于非实时统计数据，实际结果存在误差。预期和实际正负差值小于等于DELTA都算断言通过
self.assertAlmostEqual(moneyFollowCloseDay,
float(item["BizFollowProfit"]),
delta=1000000)
self.assertAlmostEqual(pointCloseDay,
float(item["BizPoint"]),
delta=1000000)
self.assertAlmostEqual(rateProfit,
float(item["BizROIex"]),
delta=1000000)
self.assertAlmostEqual(pointProfitCloseMean,
float(item["BizAVGPoint"]),
delta=1000000)
self.assertAlmostEqual(ordersCount,
item["Orders"],
delta=1000000)
self.assertAlmostEqual(tradePeriod,
item["Weeks"],
delta=1000000)
finally:
table.reversesort = True
print(table)
def test_UpdatePendingOrder(self):
'''登录->切换到MT4账号->获取交易token->新建一个挂单->修改挂单的止损止盈->退出登录'''
userData['headers'][
userData['Authorization']] = userData['Bearer'] + self.token
# 获取交易员的accountindex
self.tradeAccountIndex = Account.getSpecialAccountIndex(
headers=userData['headers'], brokerID=5)
# 切换到MT4账号
switchAccountRes = Account.switchAccount(
userData['hostName'] + userDataAccount['switchAccount'],
userData['headers'], self.tradeAccountIndex[0])
self.assertEqual(switchAccountRes.status_code,
userData['status_code_200'])
# 获取交易token
getTokenRes = Trade.getToken(
userData['hostName'] + userDataAccount["getToken_url"],
userData['headers'])
FMCommon.printLog('getTokenRes: ' + getTokenRes.text)
self.assertEqual(getTokenRes.status_code, userData['status_code_200'])
tradeToken = str(json.loads(
getTokenRes.content)["data"]["Token"]).replace("=", "@")
# 开仓获取开仓价格
openParam = {
userDataWebSocket['orderParam_cmd']:
userDataWebSocket['order_cmd'],
userDataWebSocket['orderParam_code']:
userDataWebSocket['ws_code_210'],
userDataWebSocket['orderParam_symbol']: "AUDCAD",
userDataWebSocket['orderParam_volume']: 1
}
openPositionRes = TradeOnline.OnlineTradeEvent.tradeEvent(
self, userDataWebSocket['ws_host'], userDataWebSocket['ws_port'],
{'token': "" + tradeToken}, openParam)
self.assertEqual(openPositionRes["code"],
userDataWebSocket['ws_code_0'])
self.assertEqual(openPositionRes["rcmd"],
userDataWebSocket['ws_code_210'])
self.orderID = openPositionRes["order"]["order_id"]
self.price = openPositionRes["order"]["price"]
# 建立挂单
createPendParam = {
userDataWebSocket['orderParam_code']:
userDataWebSocket['ws_code_213'],
userDataWebSocket['pendingParam_price']:
self.price + userDataWebSocket['points'],
userDataWebSocket['orderParam_symbol']:
"AUDCAD",
userDataWebSocket['pendingParam_volume']:
1
}
createPendingRes = TradeOnline.OnlineTradeEvent.tradeEvent(
self, userDataWebSocket['ws_host'], userDataWebSocket['ws_port'],
{'token': "" + tradeToken}, createPendParam)
self.assertEqual(createPendingRes["code"],
userDataWebSocket['ws_code_0'])
self.assertEqual(createPendingRes["rcmd"],
userDataWebSocket['ws_code_213'])
self.assertEqual(createPendingRes["order"]["symbol"], "AUDCAD")
self.assertEqual(createPendingRes["order"]["volume"], 1)
self.pending = createPendingRes["order"]["order_id"]
time.sleep(2)
# 修改挂单(修改止损止盈)
updatePendingParam = {
userDataWebSocket['orderParam_code']:
userDataWebSocket['ws_code_215'],
userDataWebSocket['orderParam_sl']:
self.price - userDataWebSocket['points'],
userDataWebSocket['orderParam_sub_cmd']:
userDataWebSocket['orderParam_subcmd'],
userDataWebSocket['orderParam_symbol']:
"AUDCAD",
userDataWebSocket['orderParam_ticket']:
self.pending,
userDataWebSocket['orderParam_tp']:
self.price + userDataWebSocket['tp_points'],
userDataWebSocket['orderParam_volume']:
userDataWebSocket['pending_volume']
}
createPendingRes = TradeOnline.OnlineTradeEvent.tradeEvent(
self, userDataWebSocket['ws_host'], userDataWebSocket['ws_port'],
{'token': "" + tradeToken}, updatePendingParam)
self.assertEqual(createPendingRes["code"],
userDataWebSocket['ws_code_0'])
self.assertEqual(createPendingRes["rcmd"],
userDataWebSocket['ws_code_215'])
self.assertEqual(createPendingRes["order"]["order_id"], self.pending)
self.assertEqual(createPendingRes["order"]["volume"], 1)
self.assertEqual(createPendingRes["order"]["symbol"], "AUDCAD")
self.assertEqual(createPendingRes["order"]["cmd"],
userDataWebSocket['pending_cmd'])
time.sleep(2)
# 删除挂单
deletePendParam = {
userDataWebSocket['orderParam_code']:
userDataWebSocket['ws_code_214'],
userDataWebSocket['orderParam_ticket']: self.pending
}
deletePendRes = TradeOnline.OnlineTradeEvent.tradeEvent(
self, userDataWebSocket['ws_host'], userDataWebSocket['ws_port'],
{'token': "" + tradeToken}, deletePendParam)
self.assertEqual(deletePendRes["code"], userDataWebSocket['ws_code_0'])
self.assertEqual(deletePendRes["rcmd"],
userDataWebSocket['ws_code_214'])
self.assertEqual(deletePendRes["order"]["order_id"], self.pending)
# 平仓
closeOrder = {
userDataWebSocket['orderParam_code']:
userDataWebSocket['ws_code_211'],
userDataWebSocket['orderParam_ticket']: self.orderID,
userDataWebSocket['orderParam_volume']: 1
}
closeOrderRes = TradeOnline.OnlineTradeEvent.tradeEvent(
self, userDataWebSocket['ws_host'], userDataWebSocket['ws_port'],
{'token': "" + tradeToken}, closeOrder)
self.assertEqual(closeOrderRes["code"], userDataWebSocket['ws_code_0'])
self.assertEqual(closeOrderRes["rcmd"],
userDataWebSocket['ws_code_211'])
self.assertEqual(closeOrderRes['order']["order_id"], self.orderID)
self.assertEqual(closeOrderRes["order"]["volume"], 1)
# -*- coding: utf-8 -*-
import os, sys, io, time
import pandas
import urllib
import re
import shutil
import numpy
import datetime
from numpy import *
INTERVAL_MINUTE = 5 #this number should be a divisor of 60
INTERVAL_NUM = 240 / INTERVAL_MINUTE
Train_day_num = 10
Read_data_day_num = 40
import HistoricalData
import Trade
import MySQL
if __name__ == '__main__':
#stockID = raw_input("Enter the stockID you want to buy : ")
stockID = 'sh601988'
buy_num = 50
trading_style = 0 #style: 0:normal 1:aggressive 2:passive
HistoricalData.updateStock(stockID)
Trade.tradeStock(stockID, buy_num, trading_style)
#trainVWAP(stockID)
def test_CheckFullStop(self):
'''及时价开仓买入带止损止盈'''
#sl返回时字符编码问题
userData['headers'][
userData['Authorization']] = userData['Bearer'] + self.token
# 获取交易员的accountindex
self.tradeAccountIndex = Account.getSpecialAccountIndex(
headers=userData['headers'], brokerID=5)
# 切换到MT4账号
switchAccountRes = Account.switchAccount(
userData['hostName'] + userDataAccount['switchAccount'],
userData['headers'], self.tradeAccountIndex[0])
self.assertEqual(switchAccountRes.status_code,
userData['status_code_200'])
# 获取交易token
getTokenRes = Trade.getToken(
userData['hostName'] + userDataAccount["getToken_url"],
userData['headers'])
FMCommon.printLog('getTokenRes: ' + getTokenRes.text)
self.assertEqual(getTokenRes.status_code, userData['status_code_200'])
tradeToken = str(json.loads(
getTokenRes.content)["data"]["Token"]).replace("=", "@")
# 订单止损止盈 取audcad的l,a,b
tpspParamRes_sl = TradeOnline.OnlineTradeEvent_sl.tradeEvent_sl(
self, userDataWebSocket['ws_host'], userDataWebSocket['ws_port'],
{'token': "" + tradeToken})
l = tpspParamRes_sl['AUDCAD']['l']
a = tpspParamRes_sl['AUDCAD']['a']
b = tpspParamRes_sl['AUDCAD']['b']
# 止盈 止盈值>= bid价格 + stop_level
setTP = round(b + l * 0.00001, 5)
setSL = round(b - l * 0.00001, 5)
print("setTP:", setTP)
print("setTP:", setSL)
# 开仓买入,现价带止损止盈
openParam = {
userDataWebSocket['orderParam_code']:
userDataWebSocket['ws_code_210'],
userDataWebSocket['orderParam_symbol']: "AUDCAD",
userDataWebSocket['orderParam_volume']: 1,
userDataWebSocket['orderParam_cmd']: 0,
userDataWebSocket['orderParam_sl']: setSL,
userDataWebSocket['orderParam_tp']: setTP
}
openPositionRes = TradeOnline.OnlineTradeEvent.tradeEvent(
self, userDataWebSocket['ws_host'], userDataWebSocket['ws_port'],
{'token': "" + tradeToken}, openParam)
if (openPositionRes["code"] == userDataWebSocket['ws_code_0']):
self.assertEqual(openPositionRes["rcmd"],
userDataWebSocket['ws_code_210'])
self.assertEqual(openPositionRes["order"]["volume"], 1)
self.assertEqual(openPositionRes["order"]["symbol"], "AUDCAD")
self.orderID = openPositionRes["order"]["order_id"]
self.price = openPositionRes["order"]["price"]
self.tp = openPositionRes["order"]["tp"]
self.sl = openPositionRes["order"]["sl"]
self.assertNotEqual(0, self.tp, "止盈设置不成功")
self.assertNotEqual(0, self.sl, "止损设置不成功")
if (openPositionRes["code"] == 4):
print("保证金不足！")
if (openPositionRes["code"] == 10):
print("市场关闭！")
if (openPositionRes["code"] == 300):
print("服务器内部错误！")
if (openPositionRes["code"] == 3):
print("客户不存在！")
if (openPositionRes["code"] == 7):
print("获取价格失败！")
if (openPositionRes["code"] == 9):
print("手数错误！")
if (openPositionRes["code"] == 18):
print("此品种不能交易！")
if (openPositionRes["code"] == 8):
print("止损止盈价格错误！")
import nfldb
import os
import unittest
import mock
import collections
import Trade
import json
def TestData(path):
data = ''
with open(os.path.join('testdata', path), 'r') as f:
data = f.read()
return data
STD = Trade.read_scoring_file(TestData('standard.json'))
PURE = Trade.read_scoring_file(TestData('pure.json'))
class PlayerDBTests(unittest.TestCase):
def setUp(self):
self.test_player1 = createQB(363, 1, 2, rushing_yds=3, rushing_att=1)
self.test_player2 = createRB(57, 0, 11, receiving_rec=1, rushing_att=15)
self.test_aggpps = [createPP('QB'), createPP('RB'), createPP('WR'),
createPP('TE'), createPP('RB'), createPP('RB')]
def testAggPPToPlayer(self):
playerDB = Trade.PlayerDB()
db = nfldb.connect()
q = nfldb.Query(db)
q.game(gsis_id='2009091000')
def testGetAverage(self):
averages = Trade.get_averages('Standard', 'RB')
self.assertEqual(averages[7], 200.2)
def test_StandardVolumeConversion(self):
'''KVB标准手转换,XAGCNY，XAGUSD，HSI43'''
userData['headers'] = dict(
userData['headers'],
**{'Authorization': userData['Bearer'] + self.token})
# 获取accountindex
self.tradeAccountIndex = Account.getSpecialAccountIndex(
headers=userData['headers'], brokerID=5)
# 切换到MT4账号
switchAccountRes = Account.switchAccount(
userData['hostName'] + userDataAccount['switchAccount'],
userData['headers'], self.tradeAccountIndex[0])
self.assertEqual(switchAccountRes.status_code,
userData['status_code_200'])
# 获取交易token
getTokenRes = Trade.getToken(
userData['hostName'] + userDataAccount["getToken_url"],
userData['headers'])
FMCommon.printLog('getTokenRes: ' + getTokenRes.text)
self.assertEqual(getTokenRes.status_code, userData['status_code_200'])
tradeToken = str(json.loads(
getTokenRes.content)["data"]["Token"]).replace("=", "@")
print("tradeToken:", tradeToken)
# 开仓XAGCNY
openParam = {
userDataWebSocket['orderParam_code']:
userDataWebSocket['ws_code_210'],
userDataWebSocket['orderParam_symbol']: "XAGCNY",
userDataWebSocket['orderParam_volume']: 50
}
openPositionRes = TradeOnline.OnlineTradeEvent.tradeEvent(
self, userDataWebSocket['ws_host'], userDataWebSocket['ws_port'],
{'token': "" + tradeToken}, openParam)
if (openPositionRes["code"] == userDataWebSocket['ws_code_0']):
self.assertEqual(openPositionRes["code"],
userDataWebSocket['ws_code_0'])
self.assertEqual(openPositionRes["rcmd"],
userDataWebSocket['ws_code_210'])
self.assertEqual(openPositionRes["order"]["volume"], 50)
self.assertEqual(openPositionRes["order"]["fm_volume"], 7.5)
self.orderID = openPositionRes["order"]["order_id"]
elif (openPositionRes["code"] == 4):
print("保证金不足！")
elif (openPositionRes["code"] == 10):
print("市场关闭！")
elif (openPositionRes["code"] == 300):
print("服务器内部错误！")
elif (openPositionRes["code"] == 3):
print("客户不存在！")
elif (openPositionRes["code"] == 7):
print("获取价格失败！")
elif (openPositionRes["code"] == 9):
print("手数错误！")
elif (openPositionRes["code"] == 18):
print("此品种不能交易！")
else:
print("其它错误")
# 获取当前用户的交易订单
time.sleep(3)
params = {userData['orderStatus']: userData['orderStatus_open']}
getOrders = Order.getOrders(userData['hostName'] +
order['getOrders_url'],
userData['headers'],
params=params)
self.assertEqual(getOrders.status_code, userData['status_code_200'])
ordersIDList = Order.getOrdersID(getOrders)
self.assertIn(self.orderID, ordersIDList)
# 平仓
closeOrder = {
userDataWebSocket['orderParam_code']:
userDataWebSocket['ws_code_211'],
userDataWebSocket['orderParam_ticket']: self.orderID,
userDataWebSocket['orderParam_volume']: 50
}
closeOrderRes = TradeOnline.OnlineTradeEvent.tradeEvent(
self, userDataWebSocket['ws_host'], userDataWebSocket['ws_port'],
{'token': "" + tradeToken}, closeOrder)
if (closeOrderRes["code"] == userDataWebSocket['ws_code_0']):
self.assertEqual(closeOrderRes["rcmd"],
userDataWebSocket['ws_code_211'])
self.assertEqual(closeOrderRes['order']["order_id"], self.orderID)
self.assertEqual(closeOrderRes["order"]["volume"], 50)
self.assertEqual(closeOrderRes["order"]["fm_volume"], 7.5)
if (closeOrderRes["code"] == 13):
print("订单不存在！")
# 品种：XAGUSD
# 开仓
openParam = {
userDataWebSocket['orderParam_code']:
userDataWebSocket['ws_code_210'],
userDataWebSocket['orderParam_symbol']: "XAGUSD",
userDataWebSocket['orderParam_volume']: 50
}
openPositionRes = TradeOnline.OnlineTradeEvent.tradeEvent(
self, userDataWebSocket['ws_host'], userDataWebSocket['ws_port'],
{'token': "" + tradeToken}, openParam)
if (openPositionRes["code"] == userDataWebSocket['ws_code_0']):
self.assertEqual(openPositionRes["code"],
userDataWebSocket['ws_code_0'])
self.assertEqual(openPositionRes["rcmd"],
userDataWebSocket['ws_code_210'])
self.assertEqual(openPositionRes["order"]["volume"], 50)
self.assertEqual(openPositionRes["order"]["fm_volume"], 0.01)
self.orderID = openPositionRes["order"]["order_id"]
if (openPositionRes["code"] == 4):
print("保证金不足！")
if (openPositionRes["code"] == 10):
print("市场关闭！")
if (openPositionRes["code"] == 300):
print("服务器内部错误！")
if (openPositionRes["code"] == 3):
print("客户不存在！")
if (openPositionRes["code"] == 7):
print("获取价格失败！")
if (openPositionRes["code"] == 9):
print("手数错误！")
if (openPositionRes["code"] == 18):
print("此品种不能交易！")
# 获取当前用户的交易订单
time.sleep(3)
params = {userData['orderStatus']: userData['orderStatus_open']}
getOrders = Order.getOrders(userData['hostName'] +
order['getOrders_url'],
userData['headers'],
params=params)
self.assertEqual(getOrders.status_code, userData['status_code_200'])
ordersIDList = Order.getOrdersID(getOrders)
self.assertIn(self.orderID, ordersIDList)
# 平仓
closeOrder = {
userDataWebSocket['orderParam_code']:
userDataWebSocket['ws_code_211'],
userDataWebSocket['orderParam_ticket']: self.orderID,
userDataWebSocket['orderParam_volume']: 50
}
closeOrderRes = TradeOnline.OnlineTradeEvent.tradeEvent(
self, userDataWebSocket['ws_host'], userDataWebSocket['ws_port'],
{'token': "" + tradeToken}, closeOrder)
if (closeOrderRes["code"] == userDataWebSocket['ws_code_0']):
self.assertEqual(closeOrderRes["rcmd"],
userDataWebSocket['ws_code_211'])
self.assertEqual(closeOrderRes['order']["order_id"], self.orderID)
self.assertEqual(closeOrderRes["order"]["volume"], 50)
self.assertEqual(closeOrderRes["order"]["fm_volume"], 0.01)
if (closeOrderRes["code"] == 13):
print("订单不存在！")
# 品种：HSI43
# 开仓
openParam = {
userDataWebSocket['orderParam_code']:
userDataWebSocket['ws_code_210'],
userDataWebSocket['orderParam_symbol']: "HSI43",
userDataWebSocket['orderParam_volume']: 100
}
openPositionRes = TradeOnline.OnlineTradeEvent.tradeEvent(
self, userDataWebSocket['ws_host'], userDataWebSocket['ws_port'],
{'token': "" + tradeToken}, openParam)
if (openPositionRes["code"] == userDataWebSocket['ws_code_0']):
self.assertEqual(openPositionRes["code"],
userDataWebSocket['ws_code_0'])
self.assertEqual(openPositionRes["rcmd"],
userDataWebSocket['ws_code_210'])
self.assertEqual(openPositionRes["order"]["volume"], 100)
self.assertEqual(openPositionRes["order"]["fm_volume"], 0.02)
self.orderID = openPositionRes["order"]["order_id"]
if (openPositionRes["code"] == 4):
print("保证金不足！")
if (openPositionRes["code"] == 10):
print("市场关闭！")
if (openPositionRes["code"] == 300):
print("服务器内部错误！")
if (openPositionRes["code"] == 3):
print("客户不存在！")
if (openPositionRes["code"] == 7):
print("获取价格失败！")
if (openPositionRes["code"] == 9):
print("手数错误！")
if (openPositionRes["code"] == 18):
print("此品种不能交易！")
# 获取当前用户的交易订单
time.sleep(3)
params = {userData['orderStatus']: userData['orderStatus_open']}
getOrders = Order.getOrders(userData['hostName'] +
order['getOrders_url'],
userData['headers'],
params=params)
self.assertEqual(getOrders.status_code, userData['status_code_200'])
ordersIDList = Order.getOrdersID(getOrders)
self.assertIn(self.orderID, ordersIDList, ordersIDList)
# 平仓
closeOrder = {
userDataWebSocket['orderParam_code']:
userDataWebSocket['ws_code_211'],
userDataWebSocket['orderParam_ticket']: self.orderID,
userDataWebSocket['orderParam_volume']: 100
}
closeOrderRes = TradeOnline.OnlineTradeEvent.tradeEvent(
self, userDataWebSocket['ws_host'], userDataWebSocket['ws_port'],
{'token': "" + tradeToken}, closeOrder)
if (closeOrderRes["code"] == userDataWebSocket['ws_code_0']):
self.assertEqual(closeOrderRes["rcmd"],
userDataWebSocket['ws_code_211'])
self.assertEqual(closeOrderRes['order']["order_id"], self.orderID)
self.assertEqual(closeOrderRes["order"]["volume"], 100)
self.assertEqual(closeOrderRes["order"]["fm_volume"], 0.02)
if (closeOrderRes["code"] == 13):
print("订单不存在！")
def test_OpenAndCloseByKVB(self):
'''切换KVB账户，获取任意交易品种，及时开仓，及时平仓，查询历史订单'''
userData['headers'][
userData['Authorization']] = userData['Bearer'] + self.token
# 获取品种
# getSymbolsRes = Trade.getAllSymbols(userData['hostName'] + userDataSocial["getAllSymbolsUrl"],userData['headers'],userData['full'])
# FMCommon.printLog("getSymbolsRes", getSymbolsRes.text)
# self.assertEqual(getSymbolsRes.status_code, userData['status_code_200'])
# SymbolsItems = len(json.loads(getSymbolsRes.content)["data"]["items"])
# self.assertTrue(SymbolsItems > userData['number'])
# Symbols = json.loads(getSymbolsRes.content)["data"]["items"][userData['number']]["brokerSymbol"]
# 获取交易员的accountindex
self.tradeAccountIndex = Account.getSpecialAccountIndex(
headers=userData['headers'], brokerID=5)
# 切换到MT4账号
switchAccountRes = Account.switchAccount(
userData['hostName'] + userDataAccount['switchAccount'],
userData['headers'], self.tradeAccountIndex[0])
self.assertEqual(switchAccountRes.status_code,
userData['status_code_200'])
# 获取交易token
getTokenRes = Trade.getToken(
userData['hostName'] + userDataAccount["getToken_url"],
userData['headers'])
FMCommon.printLog('getTokenRes: ' + getTokenRes.text)
self.assertEqual(getTokenRes.status_code, userData['status_code_200'])
tradeToken = str(json.loads(
getTokenRes.content)["data"]["Token"]).replace("=", "@")
# 开仓
openParam = {
userDataWebSocket['orderParam_code']:
userDataWebSocket['ws_code_210'],
userDataWebSocket['orderParam_symbol']: "AUDCAD",
userDataWebSocket['orderParam_volume']: 1
}
openPositionRes = TradeOnline.OnlineTradeEvent.tradeEvent(
self, userDataWebSocket['ws_host'], userDataWebSocket['ws_port'],
{'token': "" + tradeToken}, openParam)
if (openPositionRes["code"] == userDataWebSocket['ws_code_0']):
self.assertEqual(openPositionRes["rcmd"],
userDataWebSocket['ws_code_210'])
self.assertEqual(openPositionRes["order"]["volume"], 1)
self.orderID = openPositionRes["order"]["order_id"]
elif (openPositionRes["code"] == 4):
print("保证金不足！")
elif (openPositionRes["code"] == 10):
print("市场关闭！")
elif (openPositionRes["code"] == 300):
print("服务器内部错误！")
elif (openPositionRes["code"] == 3):
print("客户不存在！")
elif (openPositionRes["code"] == 7):
print("获取价格失败！")
elif (openPositionRes["code"] == 9):
print("手数错误！")
elif (openPositionRes["code"] == 18):
print("此品种不能交易！")
else:
print("其它错误")
time.sleep(10)
# 获取当前用户的交易订单
params = {userData['orderStatus']: userData['orderStatus_open']}
getOrders = Order.getOrders(userData['hostName'] +
order['getOrders_url'],
userData['headers'],
params=params)
self.assertEqual(getOrders.status_code, userData['status_code_200'])
ordersIDList = Order.getOrdersID(getOrders)
self.assertIn(self.orderID, ordersIDList)
# 平仓
closeOrder = {
userDataWebSocket['orderParam_code']:
userDataWebSocket['ws_code_211'],
userDataWebSocket['orderParam_ticket']: self.orderID,
userDataWebSocket['orderParam_volume']: 1
}
closeOrderRes = TradeOnline.OnlineTradeEvent.tradeEvent(
self, userDataWebSocket['ws_host'], userDataWebSocket['ws_port'],
{'token': "" + tradeToken}, closeOrder)
if (closeOrderRes["code"] == userDataWebSocket['ws_code_0']):
self.assertEqual(closeOrderRes["rcmd"],
userDataWebSocket['ws_code_211'])
self.assertEqual(closeOrderRes['order']["order_id"], self.orderID)
self.assertEqual(closeOrderRes["order"]["volume"], 1)
if (closeOrderRes["code"] == 13):
print("订单不存在！")
def tradeForStar(self, myaccount, mypassword, myvolume):
# 登录
datas = {
"account": myaccount,
"password": mypassword,
"remember": "false"
}
traderLoginRes = Auth.signin(
userData['hostName'] + userDataAuth['signin_url'],
userData['headers'], datas)
token = json.loads(traderLoginRes.text)['data']['token']
userData['headers'][
userData['Authorization']] = userData['Bearer'] + token
time.sleep(1)
print('Account: ' + myaccount)
# 切换到交易员账户
Account.switchAccount(
userData['hostName'] + userDataAccount['switchAccount'],
userData['headers'], '2')
time.sleep(1)
print('switchAccount ！！！' + userData['hostName'] +
userDataAccount['switchAccount'])
# 获取交易token
getTokenRes = Trade.getToken(
userData['hostName'] + userDataAccount["getToken_url"],
userData['headers'])
tradeToken = str(json.loads(
getTokenRes.content)["data"]["Token"]).replace("=", "@")
# 开仓
openPositionRes = ''
openParam = {
userDataWebSocket['orderParam_code']:
userDataWebSocket['ws_code_210'],
userDataWebSocket['orderParam_symbol']:
userDataWebSocket['broker_EURCAD'],
userDataWebSocket['orderParam_volume']:
myvolume
}
openPositionRes = TradeOnline.OnlineTradeEvent.tradeEvent(
self, userDataWebSocket['ws_host'], userDataWebSocket['ws_port'],
{'token': "" + tradeToken}, openParam)
#time.sleep(20)
orderID = openPositionRes["order"]["order_id"]
print('订单号： ' + str(orderID))
# 平仓
closeOrder = {
userDataWebSocket['orderParam_code']:
userDataWebSocket['ws_code_211'],
userDataWebSocket['orderParam_ticket']: orderID,
userDataWebSocket['orderParam_volume']: myvolume
}
closePositionRes = TradeOnline.OnlineTradeEvent.tradeEvent(
self, userDataWebSocket['ws_host'], userDataWebSocket['ws_port'],
{'token': "" + tradeToken}, closeOrder)
#time.sleep(20)
# print('xxxxxx',closePositionRes)
return orderID
def test_BatchFollowTrade(self):
'''建立批量跟随->跟随下单->跟随平仓->查看跟随交易历史订单->取消跟随'''
account = '500383407' # 跟随者身份
brokerID = 106
symbol = 'AUDCAD'
cmd = 0
lots = 0.1
userData['headers'] = dict(
userData['headers'],
**{'Authorization': userData['Bearer'] + self.token})
self.traderHeaders = dict(
userData['headers'],
**{'Authorization': userData['Bearer'] + self.traderToken})
# 获取交易员的accountindex
self.tradeAccountIndex = Account.getSpecialAccountIndex(
headers=self.traderHeaders, accountType=2, brokerID=106)
# 获取跟随者的accountindex
self.followerAccountIndex = Account.getSpecialAccountIndex(
headers=userData['headers'], accountType=2, brokerID=106)
# 建立多个跟随
createfollowList = []
for i in self.followerAccountIndex:
follower = FollowOperation.Operation.createFollow(
self.traderUserId, self.tradeAccountIndex[0],
userData['headers'], i)
createfollowList.append(follower)
print("创建跟随者：", createfollowList)
# 交易员切换账户
switchAccountRes = Account.switchAccount(
userData['hostName'] + userDataAccount['switchAccount'],
self.traderHeaders, self.tradeAccountIndex[0])
self.assertEqual(switchAccountRes.status_code,
userData['status_code_200'])
# 获取交易员MT4Account
traderTokenRes = Trade.getToken(
userData['hostName'] + userDataAccount["getToken_url"],
self.traderHeaders)
self.assertEqual(traderTokenRes.status_code,
userData['status_code_200'])
TraderAccount = str(
json.loads(traderTokenRes.content)["data"]["MT4Account"])
# 循环开仓
TradeIDList = []
for i in range(0, 10):
openRes = TradeSAM.TradeSAMStream.OpenPosition(stub=self.stub,
account=account,
brokerID=brokerID,
symbol=symbol,
cmd=cmd,
lots=lots)
print(openRes)
self.assertEqual(openRes.Signal.Symbol, symbol)
tradeID = openRes.Signal.TradeID
TradeIDList.append(tradeID)
print(TradeIDList)
# 循环平仓
for i in TradeIDList:
closeRes = TradeSAM.TradeSAMStream.ClosePosition(stub=self.stub,
account=account,
brokerID=brokerID,
tradeID=i,
lots=lots)
print(closeRes)
self.assertEqual(closeRes.Signal.TradeID, i)
self.assertEqual(closeRes.Signal.Symbol, symbol)
# 批量取消跟随者的跟随
deletefollowList = []
for j in self.followerAccountIndex:
follower = FollowOperation.Operation.deleteFollow(
self.traderUserId, self.tradeAccountIndex[0],
userData['headers'], j)
deletefollowList.append(follower)
print("取消跟随者：", deletefollowList)
# 验证交易员的跟随者订单
followTraderid = []
for i in TradeIDList:
sql = "SELECT TradeID from t_followorder where TraderAccount=" + TraderAccount + " and TraderTradeID=" + str(
i)
row = FollowOperation.Operation.operationCopytradingDB(sql)
self.assertIsNotNone(row['TradeID'], '跟随者订单号为空')
followTraderid.append(str(row['TradeID']))
self.assertTrue(
len(followTraderid) >= len(self.followerAccountIndex))
print("Passed test trade" + str(i))
else:
print("Failed test trade" + str(i))
#TEST 1: TOR [JV, LN] - MIA [GD] = successful
tor = Team("TOR")
mia = Team("MIA")
tor.players_out = [Player(8055, "TOR"), Player(13329, "TOR")]
mia.players_out = [Player(6146, "MIA")]
tor.players_in = mia.players_out
mia.players_in = tor.players_out
trade_teams = [tor, mia]
trade = Trade(trade_teams)
test_trade(1, trade, success)
#TEST 2: TOR[KL] - BOS[AH] = not successful (lowry resign restriction *as of 2017-09-08*)
tor = Team("TOR")
bos = Team("BOS")
tor.players_out = [Player(2536, "TOR")]
bos.players_out = [Player(2199, "BOS")]
tor.players_in = bos.players_out
bos.players_in = tor.players_out
trade_teams = [tor, bos]
trade = Trade(trade_teams)
test_trade(2, trade, fail)
def test_1_getCustomers(self):
'''获取近一周有交易的跟随大师信息'''
params = {"time": 7, "pageField": "FollowProfit"}
customers = Trade.getCustomers(webAPIData['hostName'] +
followData['getRankFollowers_url'],
params=params,
printLogs=0)
print(customers)
self.assertEqual(customers.status_code, webAPIData['status_code_200'])
# print("Customers_oneWeek:")
table = PrettyTable([
"预期/实际", "NickName", "UserID", "mt4Account", "AccountIndex",
"近一周跟随获利", "近一周盈亏点数", "收益率", "平均获利点数", "交易笔数", "交易周期"
])
try:
for item in json.loads(customers.text)["data"]["items"]:
print(item["UserID"], item["AccountIndex"])
mt4Account = Statistic.getMt4Account(
userID=str(item["UserID"]),
accountIndex=str(item["AccountIndex"]))
print("mt4Account", mt4Account)
for mongoList in self.mongoDB.datastatistic.mg_result_all.find(
{"login": mt4Account}):
key = []
for j in self.mongoDB.datastatistic.mg_result_sorted_all.find(
{
"login": mt4Account,
"statName": "money_cf_week"
}):
print("7777777777777")
key.append(j["statValue"])
table.add_row([
"预期结果", item["NickName"], item["UserID"], mt4Account,
item["AccountIndex"], j["statValue"],
mongoList["point_close_week"],
mongoList["rate_ss_profit_balance_close"],
mongoList["point_close_avg"],
mongoList["deal_close_week"], mongoList["period_trade"]
])
table.add_row([
"实际结果", item["NickName"], item["UserID"], mt4Account,
item["AccountIndex"], item["FollowMoney"],
item["Pips"], item["Roi"], item["AveragePips"],
item["Orders"], item["Weeks"]
])
table.add_row(["", "", "", "", "", "", "", "", "", "", ""])
# #由于非实时统计数据，实际结果存在误差。预期和实际正负差值小于等于DELTA都算断言通过
self.assertAlmostEqual(j["statValue"],
float(item["FollowMoney"]),
delta=0.01)
self.assertAlmostEqual(mongoList["point_close_week"],
float(item["Pips"]),
delta=0.01)
self.assertAlmostEqual(
mongoList["rate_ss_profit_balance_close"],
float(item["Roi"]),
delta=0.01)
self.assertAlmostEqual(mongoList["point_close_avg"],
float(item["AveragePips"]),
delta=0.01)
self.assertAlmostEqual(mongoList["deal_close_week"],
float(item["Orders"]),
delta=0)
self.assertAlmostEqual(mongoList["period_trade"],
float(item["Weeks"]),
delta=1)
finally:
table.reversesort = True
print(table)
resultfm5 = dm.cr_df(bvalues,t_codes)
for each in resultfm30.sort(columns='bvalues', ascending=False).head(300).index:
print each
if each in resultfm20.sort(columns='bvalues', ascending=False).head(300).index:
if each in resultfm10.sort(columns='bvalues', ascending=False).head(300).index:
if each in resultfm5.sort(columns='bvalues', ascending=False).head(300).index:
final[each] = [resultfm5['bvalues'].loc[each], resultfm10['bvalues'].loc[each], resultfm20['bvalues'].loc[each], resultfm30['bvalues'].loc[each]]
print 'get'
finfm = pd.DataFrame(final)
finfm1=finfm.T
finfm1.to_csv('fin_0504.csv')
fm = td.get_i_ma(20.0, '20160303','2016-05-04', 300)
# 取两融数据
df = ts.sh_margins(start='2015-01-01',end='2016-05-04')
df = ts.sh_margin_details(start='2016-01-01',end='2016-05-04')
df = ts.sh_margin_details(start='2015-01-01', end='2015-04-19', symbol='601989')
df = ts.sz_margins(start='2015-06-01',end='2016-05-04')
# 只能一天天取
df = ts.sz_margin_details('2015-04-20')
# 取 沪深 日，周，分钟
df = ts.get_hist_data('sh', ktype='W')
df = ts.get_hist_data('sz', ktype='60')
df = ts.get_hist_data('cyb')
df = ts.get_hist_data('zxb')
# 龙虎榜
def test_KVBFollowSam(self):
'''Sam账户跟随福汇交易员'''
userData['headers'] = dict(
userData['headers'],
**{'Authorization': userData['Bearer'] + self.token})
self.traderHeaders = dict(
userData['headers'],
**{'Authorization': userData['Bearer'] + self.traderToken})
# 获取交易员账户的AccountIndex
self.tradeAccountIndex = Account.getSpecialAccountIndex(
headers=self.traderHeaders, brokerID=5)
# 获取sam账户的AccountIndex
self.followerSamAccountIndex = Account.getSpecialAccountIndex(
headers=userData['headers'], accountType=2, brokerID=106)
# 新建一个跟随,固定手数跟随
params = {
"accountIndex": int(self.followerSamAccountIndex[0]),
"strategy": "fixed",
"setting": 1.5,
"direction": "positive"
}
getFollowsRes = Follow.createFollow(
userData['hostName'] + userDataFollow["Follow_Url"] +
str(self.traderUserId) + "_" + self.tradeAccountIndex[0],
headers=userData['headers'],
datas=params)
FMCommon.printLog('getFollowsRes: ' + getFollowsRes.text)
self.assertEqual(getFollowsRes.status_code,
userData['status_code_200'])
#交易员切换账户
Account.switchAccount(
userData['hostName'] + userDataAccount['switchAccount'],
self.traderHeaders, self.tradeAccountIndex[0])
# 获取交易员交易token
traderTokenRes = Trade.getToken(
userData['hostName'] + userDataAccount["getToken_url"],
self.traderHeaders)
self.assertEqual(traderTokenRes.status_code,
userData['status_code_200'])
tradeToken = str(json.loads(
traderTokenRes.content)["data"]["Token"]).replace("=", "@")
# 交易员开仓
openParam = {
userDataWebSocket['orderParam_code']:
userDataWebSocket['ws_code_210'],
userDataWebSocket['orderParam_symbol']: "EURCAD",
userDataWebSocket['orderParam_volume']: 1000
}
openPositionRes = TradeOnline.OnlineTradeEvent.tradeEvent(
self, userDataWebSocket['ws_host'], userDataWebSocket['ws_port'],
{'token': "" + tradeToken}, openParam)
FMCommon.printLog(openPositionRes)
self.assertEqual(openPositionRes["code"],
userDataWebSocket['ws_code_0'])
self.assertEqual(openPositionRes["rcmd"],
userDataWebSocket['ws_code_210'])
self.assertEqual(openPositionRes["order"]["volume"], 1000)
self.orderID = openPositionRes["order"]["order_id"]
# 交易员平仓
closeOrder = {
userDataWebSocket['orderParam_code']:
userDataWebSocket['ws_code_211'],
userDataWebSocket['orderParam_ticket']: self.orderID,
userDataWebSocket['orderParam_volume']: 1000
}
closeOrderRes = TradeOnline.OnlineTradeEvent.tradeEvent(
self, userDataWebSocket['ws_host'], userDataWebSocket['ws_port'],
{'token': "" + tradeToken}, closeOrder)
FMCommon.printLog(closeOrderRes)
self.assertEqual(closeOrderRes["code"], userDataWebSocket['ws_code_0'])
self.assertEqual(closeOrderRes["rcmd"],
userDataWebSocket['ws_code_211'])
self.assertEqual(closeOrderRes['order']["order_id"], self.orderID)
self.assertEqual(closeOrderRes["order"]["volume"], 1000)
# 查询交易员的历史订单
time.sleep(userDataWebSocket['waitTime'])
historyOrdersRes = Trade.getOrders(
userData['hostName'] + userDataTrade["getOrders"],
self.traderHeaders, userData['orderStatus_close'])
self.assertEqual(historyOrdersRes.status_code,
userData['status_code_200'])
self.assertIn(
str(self.orderID),
str(json.loads(historyOrdersRes.content)["data"]["items"]))
FMCommon.printLog('historyOrdersRes: ' + historyOrdersRes.text)
# 跟随者切换账户
Account.switchAccount(
userData['hostName'] + userDataAccount['switchAccount'],
userData['headers'], self.followerSamAccountIndex[0])
# 获取跟随者交易token
followertokenRES = Trade.getToken(
userData['hostName'] + userDataAccount["getToken_url"],
userData['headers'])
self.assertEqual(followertokenRES.status_code,
userData['status_code_200'])
MT4Account = str(
json.loads(followertokenRES.content)["data"]["MT4Account"])
# 验证跟随者跟单成功
sql = "SELECT TradeID from t_followorder where Account=" + MT4Account + " and TraderTradeID=" + str(
self.orderID)
row = FollowOperation.Operation.operationCopytradingDB(sql)
# 查询跟随者的历史订单
followerHistoryOrdersRes = Trade.getOrders(
userData['hostName'] + userDataTrade["getOrders"],
userData['headers'], userData['orderStatus_close'])
self.assertEqual(followerHistoryOrdersRes.status_code,
userData['status_code_200'])
self.assertIn(
str(row['TradeID']),
str(json.loads(followerHistoryOrdersRes.content)["data"]["items"]))
# 取消跟随
cancelFollowRes = Follow.DeleteFollow(
userData['hostName'] + userDataFollow["Follow_Url"] +
str(self.traderUserId) + "_" + self.tradeAccountIndex[0] +
"?accountIndex=" + self.followerSamAccountIndex[0],
userData['headers'])
FMCommon.printLog('cancelFollowRes: ' + cancelFollowRes.text)
self.assertEqual(cancelFollowRes.status_code,
userData['status_code_200'])
def test_PartClosePositionByPico(self):
'''验证部分平仓，交易员开仓，部分平仓，检查持仓单，检查历史订单'''
userData['headers'] = dict(
userData['headers'],
**{'Authorization': userData['Bearer'] + self.token})
# 获取交易员的accountindex
self.tradeAccountIndex = Account.getSpecialAccountIndex(
headers=userData['headers'], brokerID=6)
# 切换到MT4账号
switchAccountRes = Account.switchAccount(
userData['hostName'] + userDataAccount['switchAccount'],
userData['headers'], self.tradeAccountIndex[0])
self.assertEqual(switchAccountRes.status_code,
userData['status_code_200'])
# 获取交易token
getTokenRes = Trade.getToken(
userData['hostName'] + userDataAccount["getToken_url"],
userData['headers'])
FMCommon.printLog('getTokenRes: ' + getTokenRes.text)
self.assertEqual(getTokenRes.status_code, userData['status_code_200'])
tradeToken = str(json.loads(
getTokenRes.content)["data"]["Token"]).replace("=", "@")
MT4Account = str(json.loads(getTokenRes.content)["data"]["MT4Account"])
# 开仓
openParam = {
userDataWebSocket['orderParam_code']:
userDataWebSocket['ws_code_210'],
userDataWebSocket['orderParam_symbol']: "AUDCAD",
userDataWebSocket['orderParam_volume']: 2
}
openPositionRes = TradeOnline.OnlineTradeEvent.tradeEvent(
self, userDataWebSocket['ws_host'], userDataWebSocket['ws_port'],
{'token': "" + tradeToken}, openParam)
if (openPositionRes["code"] == userDataWebSocket['ws_code_0']):
self.assertEqual(openPositionRes["rcmd"],
userDataWebSocket['ws_code_210'])
self.assertEqual(openPositionRes["order"]["volume"], 2)
self.assertEqual(openPositionRes["order"]["symbol"], "AUDCAD")
self.orderID = openPositionRes["order"]["order_id"]
elif (openPositionRes["code"] == 4):
print("保证金不足！")
elif (openPositionRes["code"] == 10):
print("市场关闭！")
elif (openPositionRes["code"] == 300):
print("服务器内部错误！")
elif (openPositionRes["code"] == 3):
print("客户不存在！")
elif (openPositionRes["code"] == 7):
print("获取价格失败！")
elif (openPositionRes["code"] == 9):
print("手数错误！")
elif (openPositionRes["code"] == 18):
print("此品种不能交易！")
else:
print("其它错误")
time.sleep(5)
# 获取开仓单
params = {userData['orderStatus']: userData['orderStatus_open']}
getOrders = Order.getOrders(userData['hostName'] +
order['getOrders_url'],
userData['headers'],
params=params)
self.assertEqual(getOrders.status_code, userData['status_code_200'])
self.assertIn(str(self.orderID),
str(json.loads(getOrders.content)["data"]["items"]),
"持仓列表中没有包含此订单")
# 部分平仓
closeOrder = {
userDataWebSocket['orderParam_code']:
userDataWebSocket['ws_code_211'],
userDataWebSocket['orderParam_ticket']: self.orderID,
userDataWebSocket['orderParam_volume']: 1
}
closeOrderRes = TradeOnline.OnlineTradeEvent.tradeEvent(
self, userDataWebSocket['ws_host'], userDataWebSocket['ws_port'],
{'token': "" + tradeToken}, closeOrder)
self.assertEqual(closeOrderRes["code"], userDataWebSocket['ws_code_0'])
self.assertEqual(closeOrderRes["rcmd"],
userDataWebSocket['ws_code_223'])
self.assertEqual(closeOrderRes['order']["order_id"], self.orderID)
self.assertEqual(closeOrderRes["order"]["volume"], 1)
self.assertEqual(openPositionRes["order"]["symbol"], "AUDCAD")
# 查询历史订单
time.sleep(5)
getHistoryOrderRes = Trade.getOrders(
userData['hostName'] + userDataTrade["getOrders"],
userData['headers'], userData['orderStatus_close'])
FMCommon.printLog('getHistoryOrderRes: ' + getHistoryOrderRes.text)
self.assertEqual(getHistoryOrderRes.status_code,
userData['status_code_200'])
self.assertIn(
str(self.orderID),
str(json.loads(getHistoryOrderRes.content)["data"]["items"]),
"历史订单列表中不包含此订单")
#验证此历史订单的手数是否与部分平仓手数一致
sql = 'SELECT StandardLots,BrokerLots from t_trades WHERE TradeID=' + str(
self.orderID) + 'and Account=' + MT4Account
row = FollowOperation.Operation.operationCopytradingDB(sql)
self.assertEqual(1, int(row['StandardLots']), "部分平仓手数错误")
self.assertEqual(1, int(row['BrokerLots']), "部分平仓手数错误")
def test_Follows(self):
'''登录->新建一个跟随->获取指定交易员存在的跟随关系->修改一个跟随->取消跟随'''
userData['headers'] = dict(
userData['headers'],
**{'Authorization': userData['Bearer'] + self.token})
self.traderHeaders = dict(
userData['headers'],
**{'Authorization': userData['Bearer'] + self.traderToken})
# 获取交易员的accountindex
self.tradeAccountIndex = Account.getSpecialAccountIndex(
headers=self.traderHeaders, brokerID=5)
# 获取跟随者的accountindex
self.followerAccountIndex = Account.getSpecialAccountIndex(
headers=userData['headers'], brokerID=5)
# 新建一个跟随,固定手数跟随
params = {
"accountIndex": int(self.followerAccountIndex[0]),
"strategy": "fixed",
"setting": 1.5,
"direction": "positive"
}
getFollowsRes = Follow.createFollow(
userData['hostName'] + userDataFollow["Follow_Url"] +
str(self.traderUserId) + "_" + self.tradeAccountIndex[0],
headers=userData['headers'],
datas=params)
FMCommon.printLog('getFollowsRes: ' + getFollowsRes.text)
self.assertEqual(getFollowsRes.status_code,
userData['status_code_200'])
# 跟随者切换账户
Account.switchAccount(
userData['hostName'] + userDataAccount['switchAccount'],
userData['headers'], self.followerAccountIndex[0])
# 获取跟随者交易token
demotoken = Trade.getToken(
userData['hostName'] + userDataAccount["getToken_url"],
userData['headers'])
self.assertEqual(demotoken.status_code, userData['status_code_200'])
followerMT4Account = str(
json.loads(demotoken.content)["data"]["MT4Account"])
# 获取指定交易员存在的跟随关系
getTraderFollowRes = Follow.getFollow(
userData['hostName'] + userDataFollow["Follow_Url"],
str(self.traderUserId) + "_" + self.tradeAccountIndex[0],
self.followerAccountIndex[0], userData['headers'])
FMCommon.printLog('getTraderFollowRes: ' + getTraderFollowRes.text)
self.assertEqual(getTraderFollowRes.status_code,
userData['status_code_200'])
FollowAccount = json.loads(
getTraderFollowRes.text)['data']['follow']['FollowAccount']
self.assertEqual(FollowAccount, followerMT4Account, "没有包含此跟随者")
# 修改一个跟随(修改跟随策略)
params = {
"accountIndex": int(self.followerAccountIndex[0]),
"strategy": "ratio",
"setting": 2,
"direction": "positive"
}
updateFollowRes = Follow.updateFollow(
userData['hostName'] + userDataFollow["Follow_Url"] +
str(self.traderUserId) + "_" + self.tradeAccountIndex[0],
userData['headers'],
datas=params)
FMCommon.printLog('updateFollowRes: ' + updateFollowRes.text)
self.assertEqual(updateFollowRes.status_code,
userData['status_code_200'])
# 取消跟随
cancelFollowRes = Follow.DeleteFollow(
userData['hostName'] + userDataFollow["Follow_Url"] +
str(self.traderUserId) + "_" + self.tradeAccountIndex[0] +
"?accountIndex=" + self.followerAccountIndex[0],
userData['headers'])
FMCommon.printLog('cancelFollowRes: ' + cancelFollowRes.text)
self.assertEqual(cancelFollowRes.status_code,
userData['status_code_200'])
def create_trade():
team1_abbr = raw_input("Team 1: ")
team1 = Team(team1_abbr)
while team1.get_salary() is None:
print("Unable to find team " + team1_abbr + ". Try again")
team1_abbr = raw_input("Team 1: ")
team1 = Team(team1_abbr)
team1_players = team1.get_players()
team2_abbr = raw_input("Team 2: ")
team2 = Team(team2_abbr)
while team2.get_salary() is None:
print("Unable to find team " + team2_abbr + ". Try again")
team2_abbr = raw_input("Team 2: ")
team2 = Team(team2_abbr)
team2_players = team2.get_players()
teams = [team1, team2]
while 1:
ans = raw_input(
"Would you like to include more teams? Include them now, or type 'no' if you are done adding teams: "
)
if ans == "no":
break
new_team = Team(ans)
while new_team.get_salary() is None:
print("Unable to find team " + ans + ". Try again")
ans = raw_input("Team: ")
if ans == "no":
break
new_team = Team(ans)
teams.append(Team(ans))
print("")
console_print.print_players_together(
team1_players, team2_players,
max(len(team1_players), len(team2_players)))
print(
"----------------------------------------------------------------------------------------------------------------------------------------------"
)
print("TEAM SALARY: \t\t\t\t\t" + str(currency(team1.salary)) + "\t\t|\t" +
"TEAM SALARY: \t\t\t\t\t" + str(currency(team2.salary)))
print(
"----------------------------------------------------------------------------------------------------------------------------------------------"
)
tpes1 = team1.get_trade_exceptions()
tpes2 = team2.get_trade_exceptions()
console_print.print_exceptions_together(tpes1, tpes2,
max(len(tpes1), len(tpes2)))
print("")
for i in range(2, len(teams)):
print(teams[i].get_players())
print("TEAM SALARY: " + currency.currency(teams[i].salary))
if teams[i].get_trade_exceptions() != []:
print("Trade Exceptions: ")
print(teams[i].get_trade_exceptions())
for i in range(0, len(teams)):
finished = False
while not finished:
player_id = raw_input(
"Type the Player ID of a player you wish to trade from " +
teams[i].name + ". Type done when you have finished: ")
if player_id == "Done" or player_id == "done":
finished = True
break
player = Player(player_id, teams[i].name)
if player.name is not None:
teams[i].players_out.append(player)
if len(teams) == 2:
if i == 0:
teams[1].players_in.append(player)
else:
teams[0].players_in.append(player)
else:
match = False
while not match:
destination = raw_input(
"What team would you like to trade " +
player.name + " to? ").upper()
for q in range(0, len(teams)):
if destination == teams[
q].name and destination != player.team.name:
match = True
print("You are trading " + player.name +
" to " + destination)
teams[q].players_in.append(player)
print(
"**************************************************************************************************"
)
for i in range(0, len(teams)):
print(teams[i].name + " OUT:", end=' ')
for p in teams[i].players_out:
print(p.name, end=', ', flush=True)
print("")
print(teams[i].name + " IN:", end=' ')
for p in teams[i].players_in:
print(p.name, end=', ', flush=True)
print("")
trade = Trade(teams)
for i in teams:
i.calc_money_in()
i.calc_money_out()
trade.summary()
decisions = []
for team in teams:
decision, msg = trade.check_trade(team)
print(msg)
decisions.append(decision)
if not decision:
break
print(trade.finalize_trade(decisions))