def test_recommend_plan():
test_num = int(sys.argv[2])
endpoint = RPC_LOCAL_PROXY
get_fast_transport(endpoint)
protocol = get_service_protocol(service, fast=True)
client = Client(protocol)
from random import shuffle
uids = get_one_day_uid_from_file('log_event_20180122')
shuffle(uids)
selected_uids = uids[:test_num]
total_times = {}
for uid in selected_uids:
input_arg = json.dumps({'user_id': uid, 'top_n': 2})
t1 = time.time()
o = client.recommend_plan(input_arg)
t2 = time.time()
total_times[uid] = t2 - t1
print '==' * 10
print uid
print o
sorted_total_times = sorted(total_times.iteritems(),
key=lambda x: x[1],
reverse=True)
for uid, t in sorted_total_times[:10]:
print uid, t
def test_recommend_list():
print "=========test_recommend_list=========="
endpoint = RPC_LOCAL_PROXY
get_fast_transport(endpoint)
protocol = get_service_protocol(service, fast=True)
client = Client(protocol)
input = json.dumps({'user_id': -1})
output = client.recommend_list(input)
print output
def __init__(self, ForTest=False):
service = 'search'
if ForTest:
endpoint = RPC_LOCAL_PROXY_BIZ
else:
endpoint = RPC_LOCAL_PROXY
get_fast_transport(endpoint)
protocol = get_service_protocol(service, fast=True)
self.client = Search_client(protocol)
def test_get_doctor_topn_diseases():
service1 = 'search'
endpoint = RPC_LOCAL_PROXY
get_fast_transport(endpoint)
protocol = get_service_protocol(service1, fast=True)
client = Search_client(protocol)
id1 = "clinic_web_c383b3a7e6db1f1d"
id2 = "clinic_web_1031d90f8b4de6aa"
o = client.get_doctor_topN_diseases(id1)
print o
def test_recommend_topn_topic():
print "=========test_recommend_topn_topic=========="
# from general_utils.solr_utils import nat_get_title
endpoint = RPC_LOCAL_PROXY
get_fast_transport(endpoint)
protocol = get_service_protocol(service, fast=True)
client = Client(protocol)
input = json.dumps({'user_id': 112885379})
output = client.recommend_topn_topic(input)
output = json.loads(output)['output']
print output
def ar():
print "=========ar=========="
endpoint = RPC_LOCAL_PROXY
get_fast_transport(endpoint)
protocol = get_service_protocol(service, fast=True)
client = Client(protocol)
input = json.dumps([{'user_id': 2585377, 'timestamp': 1512375821.56}])
output = client.article_recommend(input)
print output
return output
def test_problem_triage():
from problem_triage_service.ttypes import TriageParams
service1 = 'problem_triage'
endpoint = RPC_LOCAL_PROXY
get_fast_transport(endpoint)
protocol = get_service_protocol(service1, fast=True)
client = PT_client(protocol)
query = '感冒'
result = client.triage_second(
TriageParams(content=query, has_image=None, problem_id=None))
print result
def test_big_search3_kernel(q):
input_arg = json.dumps({"query":
{"province": "\u5b81\u590f\u56de\u65cf\u81ea\u6cbb\u533a",
"has_topic": False, "text": q, "has_video": False,
"is_force": 0, "ip": "111.111.111.111", "uid": "144178157",
"device_id": "dc4cf9c2ef89ef9","clinic_no":"2"}})
service1 = 'search'
endpoint = RPC_LOCAL_PROXY
get_fast_transport(endpoint)
protocol = get_service_protocol(service1, fast=True)
client = Search_client(protocol)
o = client.big_search3(input_arg)
print o
def get_problem_triage_client():
global _client_problem_triage_service
if not _client_problem_triage_service:
_ = get_fast_transport(RPC_LOCAL_PROXY, timeout=default_timeout)
protocol = get_service_protocol(service="problem_triage", fast=True)
_client_problem_triage_service = ProblemTriageClient(protocol)
return _client_problem_triage_service
def test_search_doctor():
input_arg = json.dumps({"filter": {"is_tel_price_v2": 0,"clinic_no":"ag",},
"query": {"start": "0",
"text": "妇科", "rows": "30", "partner_name": "qiangshengxinpuni"},
"sort": "default"})
service1 = 'search'
endpoint = RPC_LOCAL_PROXY
get_fast_transport(endpoint)
protocol = get_service_protocol(service1, fast=True)
client = Search_client(protocol)
o = json.loads(client.search_doctors(input_arg))
for x in o:print x
def get_medical_service_client():
global _client_medical_service
if not _client_medical_service:
_ = get_fast_transport(RPC_LOCAL_PROXY, timeout=default_timeout)
protocol = get_service_protocol(service='medical_service', fast=True)
_client_medical_service = Medical_client(protocol)
return _client_medical_service
def test_rn_by_uid():
uid = sys.argv[2]
num = int(sys.argv[3])
endpoint = RPC_LOCAL_PROXY
get_fast_transport(endpoint)
protocol = get_service_protocol(service, fast=True)
client = Client(protocol)
input_arg = json.dumps({'user_id': uid, 'top_n': num})
o = json.loads(client.recommend_news(input_arg))
print 'ids', o['ids']
def get_user_profile_client():
global _client_user_profile
if not _client_user_profile:
_ = get_fast_transport(RPC_LOCAL_PROXY, timeout=default_timeout)
protocol = get_service_protocol(service="user_profile", fast=True)
_client_user_profile = UserProfileClient(protocol)
return _client_user_profile
def get_search_service_client():
global _client_search_service
if not _client_search_service:
_ = get_fast_transport(RPC_LOCAL_PROXY, timeout=default_timeout)
protocol = get_service_protocol(service="search", fast=True)
_client_search_service = Search_client(protocol)
return _client_search_service
def get_problem_promotion_service_client():
global _client_qa_promotion_service
if not _client_qa_promotion_service:
_ = get_fast_transport(RPC_LOCAL_PROXY, timeout=default_timeout)
protocol = get_service_protocol(service="qa_promotion_service",
fast=True)
_client_qa_promotion_service = QAPromotionClient(protocol)
return _client_qa_promotion_service
def get_word2vec_service_client():
global _client_word2vec_service
if not _client_word2vec_service:
_ = get_fast_transport(RPC_LOCAL_PROXY_BIZ,
timeout=default_timeout_w2v)
protocol = get_service_protocol(service="cy_word2vec", fast=True)
_client_word2vec_service = Word2vec_client(protocol)
return _client_word2vec_service
def test_recommend_tags():
print "=========test_recommend_tags=========="
endpoint = RPC_LOCAL_PROXY
get_fast_transport(endpoint)
protocol = get_service_protocol(service, fast=True)
client = Client(protocol)
input = json.dumps({'user_id': 112885379})
output = client.recommend_tags(input)
output = json.loads(output)['output']
print output
plan = output['plan']
words = output['words']
for x in plan:
print 'plan', x['name'], x['url']
for x in words:
print 'word', x
def client_test(server):
gevent.sleep(1)
service = ""
endpoint = TEST_SOCKET
if FAST_BINARY:
get_fast_transport(endpoint, timeout=5000)
protocol = get_service_protocol(service, fast=FAST_BINARY)
else:
get_base_protocol(endpoint, timeout=5000)
protocol = get_service_protocol(service, fast=FAST_BINARY)
client = Client(protocol)
print "Begin Request"
try:
t = time.time()
total_times = 10000
for i in xrange(total_times):
client.ping()
t = time.time() - t
print "AVG RT: %.3fms" % (t * 1000 / total_times)
finally:
server.stop()
def client_test(server):
gevent.sleep(1)
service = ""
endpoint = TEST_SOCKET
if FAST_BINARY:
get_fast_transport(endpoint, timeout=5000)
protocol = get_service_protocol(service, fast=FAST_BINARY)
else:
get_base_protocol(endpoint, timeout=5000)
protocol = get_service_protocol(service, fast=FAST_BINARY)
client = Client(protocol)
print "Begin Request"
try:
t = time.time()
total_times = 10000
for i in xrange(total_times):
client.ping()
t = time.time() - t
print "AVG RT: %.3fms" % (t * 1000 / total_times)
finally:
server.stop()
def test_many():
file_name = sys.argv[2]
num = int(sys.argv[3])
qs = []
uids = set()
with open(file_name, 'r') as f:
for l in f:
ll = l.strip('\n').split(',')
# print ll
if len(ll) != 12:
continue
if ll[0] == 'uid':
continue
uid = int(ll[0])
if uid in uids:
continue
uids.add(uid)
ts = float(ll[5])
info = ll[4].decode('gbk')
qs.append([uid, ts, info])
endpoint = RPC_LOCAL_PROXY
get_fast_transport(endpoint)
protocol = get_service_protocol(service, fast=True)
client = Client(protocol)
times_ar = {}
times_topic = {}
times_tags = {}
times_list = {}
times_news = {}
ar_ecps = []
rl_ecps = []
# begin = True
print len(qs)
shuffle(qs)
for uid, ts, info in qs[:num]:
time.sleep(1) # 防止接口累着
# if uid == 3024070:
# begin = True
# if not begin:
# continue
# test article_recommend
input = json.dumps([{'user_id': uid, 'timestamp': ts}])
t1 = time.time()
if True:
# try:
output = client.article_recommend(input)
# except Exception, e:
# ar_ecps.append([uid, e])e
t2 = time.time()
times_ar[uid] = t2 - t1
print "========ar============"
print uid, ts, info
try:
print json.loads(output)["output"][0]["title"]
except:
pass
# test recommend_topn_topcs
input = json.dumps({'user_id': uid})
t1 = time.time()
output = json.loads(client.recommend_topn_topic(input))['output']
t2 = time.time()
times_topic[uid] = t2 - t1
if output:
print "==========recommend topics========"
for id in output:
title = nat_get_title('topic_' + str(id))
print uid, id, title
# test recommend_list
input = json.dumps({'user_id': uid, 'timestamp': ts})
t1 = time.time()
if True:
# try:
output = client.recommend_list(input)
# except Exception,e:
# output = json.dumps({'output':[]})
# rl_ecps.append([uid,e])
t2 = time.time()
times_list[uid] = t2 - t1
output = json.loads(output)['output']
if output:
print "========recommend_list=========="
for item in output:
print uid, item['id'], item['type'], item['title']
# test recommend tags
input = json.dumps({
'user_id': uid,
})
t1 = time.time()
output = client.recommend_tags(input)
t2 = time.time()
times_tags[uid] = t2 - t1
output = json.loads(output)['output']
words = output['words']
plan = output['plan']
print "=======recommend tags=========="
print uid
last_query = user_last_query(uid)
print "last_query", last_query
print "words", '-'.join(words)
for item in plan:
print item['name'], item['url']
# test recommend_news
input = json.dumps({'user_id': uid, 'top_n': 2})
t1 = time.time()
output = client.recommend_news(input)
t2 = time.time()
times_news[uid] = t2 - t1
output = json.loads(output)
ids = output['ids']
titles = [nat_get_title('news_' + str(id)) for id in ids]
print "=======recommend news=========="
print uid
for i, id in enumerate(ids):
print id, titles[i]
print "mean time ar", sum(times_ar.values()) / len(times_ar)
s_times = sorted(times_ar.iteritems(), key=lambda x: x[1], reverse=True)
for uid, t in s_times[:10]:
print uid, t
print '---------'
print "mean time recommend topic", sum(
times_topic.values()) / len(times_topic)
s_times = sorted(times_topic.iteritems(), key=lambda x: x[1], reverse=True)
for uid, t in s_times[:10]:
print uid, t
print '---------'
print "mean time recommend list", sum(
times_list.values()) / len(times_list)
s_times = sorted(times_list.iteritems(), key=lambda x: x[1], reverse=True)
for uid, t in s_times[:10]:
print uid, t
print '---------'
print "mean time recommend tags", sum(
times_tags.values()) / len(times_tags)
s_times = sorted(times_tags.iteritems(), key=lambda x: x[1], reverse=True)
for uid, t in s_times[:10]:
print uid, t
print '---------'
print "mean time recommend news", sum(
times_news.values()) / len(times_news)
s_times = sorted(times_news.iteritems(), key=lambda x: x[1], reverse=True)
for uid, t in s_times[:10]:
print uid, t
print '---------'
for u, e in ar_ecps:
print " ar exceptions", u, e
for u, e in rl_ecps:
print "rl exceptions", u, e
