def get_register_result(req):
"""
处理注册结果
:param req:
:return:
"""
account = req["account"]
password = req["password"]
account_data = DBManager.get_record(DBTableConfig.table_account_data,
{"account": account})
if account_data:
return {"code": code.ACCOUNT_ALREADY_REGISTER}
account_uuid = RedisManager.catch_get(ACCOUNT_UUID_FLAG)
if not account_uuid:
account_uuid = ACCOUNT_INIT_VALUE
account_data = {
"account": account,
"password": password,
"role_id": str(account_uuid),
"ban": 0
}
DBManager.insert_record(DBTableConfig.table_account_data, account_data)
account_uuid += 1
RedisManager.catch_set(ACCOUNT_UUID_FLAG, account_uuid)
return {"code": 0}
class CodeHandler(tornado.web.RequestHandler):
def initialize(self):
self.db_manager = DBManager()
def post(self):
data = tornado.escape.json_decode(self.request.body)
username = data['username']
code = data['code']
response = self.run_code(code, username)
self.db_manager.add_new_session(username, response)
self.update_db_and_response(username, response)
self.finish()
def run_code(self, code, username):
requests.post("http://localhost:4040/api/execute",
json={
"code": code,
"id": username
})
return {"status": "ok", "output": ""}
def update_db_and_response(self, id, state):
self.db_manager.add_new_session(id, state)
current_session = self.db_manager.get_session(id)
self.write(json.dumps(current_session))
class StatusHandler(tornado.web.RequestHandler):
def initialize(self):
self.db_manager = DBManager()
def post(self):
data = tornado.escape.json_decode(self.request.body)
username = data['username']
response = self.get_status_from_server(username)
self.db_manager.add_new_session(username, response)
self.update_db_and_response(username, response)
self.finish()
def get_status_from_server(self, id):
stdout_response = requests.get(
f"http://localhost:4040/api/stdout?id={id}")
status_response = requests.get(
f"http://localhost:4040/api/status?id={id}")
print(status_response)
response = {
"status": str(status_response.text),
"output": str(stdout_response.text)
}
print(response)
return response
def update_db_and_response(self, id, state):
self.db_manager.add_new_session(id, state)
current_session = self.db_manager.get_session(id)
self.write(json.dumps(current_session))
def load(self):
Log.init("logic")
# 初始化数据库
DBManager.connect(self.get_server_data("DBServer"))
# 初始化redis
RedisManager.init(self.get_server_data("RedisServer"))
# 数据映射
MapMethod.init()
def __init__(self):
self.dbm = DBManager.get_instance()
self.host =
self.section_dict = dict()
response = requests.get(self.host + '/main/')
if response.status_code == 200:
soup = BeautifulSoup(response.content, 'html.parser')
section_list = soup.select('ul.default_font li a')
for section in section_list:
if section.text == '빅데이터':
self.section_dict['bigdata_url'] = section['href']
elif section.text == '신기술|미래':
self.section_dict['future_url'] = section['href']
elif section.text == '클라우드':
self.section_dict['cloud_url'] = section['href']
elif section.text == 'IoT':
self.section_dict['iot_url'] = section['href']
elif section.text == 'AI':
self.section_dict['ai_url'] = section['href']
elif section.text == '개발자':
self.section_dict['developer_url'] = section['href']
else:
response.raise_for_status()
class ENDataCrawl:
def __init__(self):
self.dm = DBManager("fcr_w_details")
def start_crawl(self):
bs.login(user_id="anonymous", password="******")
code_list = self.dm.get_code_list_02()
for item in code_list:
ticker = item["ticker"]
max_try = 8
for tries in range(max_try):
rs = bs.query_history_k_data(
ticker,
"date,code,open,high,low,close,volume,amount,adjustflag,turn,pctChg",
frequency="w",
adjustflag="3")
if rs.error_code == '0':
self.parse_pager(rs, ticker)
break
elif tries < (max_try - 1):
sleep(2)
continue
bs.logout()
def parse_pager(self, content, ticker):
timer_list = [
x["date"]
for x in self.dm.find_one_by_key({"ticker": ticker})["price_list"]
]
while content.next():
item_row = content.get_row_data()
__dict = {
"date": item_row[0],
"code": item_row[1],
"open": item_row[2],
"high": item_row[3],
"low": item_row[4],
"close": item_row[5],
"volume": item_row[6],
"amount": item_row[7],
"adjustflag": item_row[8],
"turn": item_row[9],
"pctChg": item_row[10]
}
if __dict["date"] not in timer_list:
self.dm.add_tk_item(ticker, __dict)
print(ticker, "success")
def create_role(role_id):
"""
创建角色
:param role_id:
:return:
"""
role_data = {
"role_id": role_id,
"name": "1",
"lv": 1,
"exp": 0,
"vitality": 100,
"diamond": 0,
"gold": 0
}
DBManager.insert_record(DBTableConfig.table_role_data, role_data)
return role_data
def get_role_data(role_id):
"""
获得角色数据
:param role_id:
:return:
"""
role_data = DBManager.get_record(DBTableConfig.table_role_data,
{"role_id": role_id})
return role_data
class CodeManager:
def __init__(self):
self.db_manager_tk = DBManager("tk_details")
def get_buy_list(self, num=3):
code_list = [x for x in self.db_manager_tk.get_code_list()]
buy_list = list()
for i in range(num):
index = random.randint(0, len(code_list)-1)
if code_list[index] not in buy_list:
buy_list.append(code_list[index]["code"])
return buy_list
class HKDataCrawl:
def __init__(self):
self.dm = DBManager("fcr_details")
def start_crawl(self):
bs.login()
code_list = self.dm.get_code_list_02()
for item in code_list:
ticker = item["ticker"]
max_try = 8
for tries in range(max_try):
rs = bs.query_history_k_data(
ticker,
"date,code,close,peTTM,pbMRQ,psTTM,pcfNcfTTM",
start_date='2016-01-01',
end_date='2017-12-31',
frequency="d",
adjustflag="2")
if rs.error_code == '0':
self.parse_pager(rs, ticker)
break
elif tries < (max_try - 1):
sleep(2)
continue
bs.logout()
def parse_pager(self, content, ticker):
while content.next():
item_row = content.get_row_data()
__dict = {
"date": item_row[0],
"code": item_row[1],
"close": item_row[2],
"peTTM": item_row[3],
"pbMRQ": item_row[4],
"psTTM": item_row[5],
"pcfNcfTTM": item_row[6]
}
self.dm.add_tk_item_k(ticker, __dict)
print(ticker, "success")
def get_login_result(req):
"""
获得登入数据
:param req:
:return:
"""
account = req["account"]
password = req["password"]
account_data = DBManager.get_record(DBTableConfig.table_account_data, {
"account": account,
"password": password
})
if not account_data:
return {"code": code.ACCOUNT_PASSWORD_ERROR}
role_id = account_data["role_id"]
token = ToKenManager.general_token(role_id)
return {"role_id": role_id, "code": 0, "token": token}
def __init__(self):
self.db_manager_tk = DBManager("tk_details")
def initialize(self):
self.db_manager = DBManager()
class EmaManager:
def __init__(self):
self.db_manager_tk = DBManager("fcr_w_details")
def get_buy_list(self, date):
code_list = [x for x in self.db_manager_tk.get_code_list_02()]
buy_list = list()
for code_item in code_list:
ticker = code_item["ticker"]
# 获取数据
close_list = list()
tk_details = self.db_manager_tk.find_one_by_key({"ticker": ticker})
for tk_item in [x for x in tk_details["price_list"]]:
if time_cmp(str(date), tk_item["date"]):
close_list.append(float(tk_item["close"]))
# 执行判断条件
if len(close_list) > 20:
ema_20_1 = np.mean(close_list[-20:])
ema_20_2 = np.mean(close_list[-21:-1])
if close_list[-1] > ema_20_1 and close_list[-2] < ema_20_2:
buy_list.append(ticker)
return buy_list
def get_sell_list(self, date):
code_list = [x for x in self.db_manager_tk.get_code_list_02()]
sell_list = list()
for code_item in code_list:
ticker = code_item["ticker"]
# 获取数据
close_list = list()
tk_details = self.db_manager_tk.find_one_by_key({"ticker": ticker})
for tk_item in [x for x in tk_details["price_list"]]:
if time_cmp(str(date), tk_item["date"]):
close_list.append(float(tk_item["close"]))
# 执行判断条件
if len(close_list) > 20:
ema_10_1 = np.mean(close_list[-10:])
ema_10_2 = np.mean(close_list[-11:-1])
if close_list[-1] < ema_10_1 and close_list[-2] > ema_10_2:
sell_list.append(ticker)
return sell_list
def fun_01(self):
code_list = [x for x in self.db_manager_tk.get_code_list_02()]
result_list = list()
for code_item in code_list:
ticker = code_item["ticker"]
# 获取数据
tk_details = self.db_manager_tk.find_one_by_key({"ticker": ticker})
close_list = [
float(x["close"]) for x in tk_details["price_list"]
if x["close"] != ""
]
open_list = [
float(x["open"]) for x in tk_details["price_list"]
if x["close"] != ""
]
volume_list = [
float(x["volume"]) for x in tk_details["price_list"]
if x["close"] != ""
]
ema_list = list()
for i in range(len(close_list)):
if i >= 20:
ema_list.append(np.mean(close_list[i - 20:i]))
else:
ema_list.append(close_list[i])
# 执行判断条件
for date in range(len(close_list) - 1):
# 均线呈现向上趋势
if ema_list[date] > ema_list[date - 4]:
# K线上穿且连续8周位于均线之下
if close_list[date] > ema_list[date]:
if close_list[date - 1] < ema_list[
date - 1] and close_list[date - 2] < ema_list[
date -
2] and close_list[date - 3] < ema_list[
date - 3] and close_list[
date - 4] < ema_list[date - 4]:
profit_rate = (
close_list[date + 1] -
open_list[date + 1]) / open_list[date + 1]
result_list.append(profit_rate)
print(len(result_list))
result_list_up = [x for x in result_list if x > 0]
result_list_down = [x for x in result_list if x < 0]
print(len(result_list_up), max(result_list_up),
np.mean(result_list_up))
print(len(result_list_down), min(result_list_down),
np.mean(result_list_down))
# 绘图
plt.subplot(111)
lable_x = np.arange(len(result_list))
lable_y = [x * 0 for x in range(len(result_list))]
# 绘制中轴线
plt.plot(lable_x,
lable_y,
color="#404040",
linewidth=1.0,
linestyle="-")
plt.bar(lable_x, result_list, color="g", width=1.0)
plt.xlim(lable_x.min(), lable_x.max() * 1.1)
plt.ylim(min(result_list) * 1.1, max(result_list) * 1.1)
plt.grid(True)
plt.show()
def fun_draw(data_list):
plt.subplot(111)
lable_x = np.arange(len(data_list))
lable_y = [x * 0 for x in range(len(data_list))]
# 绘制中轴线
plt.plot(lable_x, lable_y, color="#404040", linewidth=1.0, linestyle="-")
plt.bar(lable_x, data_list, color="g", width=1.0)
plt.xlim(lable_x.min(), lable_x.max() * 1.1)
plt.ylim(min(data_list) * 1.1, max(data_list) * 1.1)
plt.grid(True)
plt.show()
if __name__ == "__main__":
# 获取数据
db_manager_tk = DBManager("fcr_w_details")
code_list = [x for x in db_manager_tk.get_code_list_02()]
result_list = list()
for item in code_list:
tk_item = db_manager_tk.find_one_by_key({"ticker": item["ticker"]})
# 计算成交量
tk_details = tk_item["price_list"]
close_list = [
float(x["close"]) for x in tk_details if x["close"] != ""
]
open_list = [float(x["open"]) for x in tk_details if x["close"] != ""]
high_list = [float(x["high"]) for x in tk_details if x["close"] != ""]
low_list = [float(x["low"]) for x in tk_details if x["close"] != ""]
volume_list = [
float(x["volume"]) for x in tk_details if x["close"] != ""
]
if open_price != 0 and not np.isnan(open_price):
amount = int(p_stage / open_price / 100) * 100
if amount >= 100:
order_buy(code, date, amount, 1)
def fun_sell_02(date, sell_list):
for item_position in current_position[:]:
if item_position[0] in sell_list:
order_sell(item_position, date, item_position[2])
if __name__ == "__main__":
code_ema = EmaManager()
bp_utils = BPUtils("bp_result_fm_0.txt", "w")
db_manager_tk = DBManager("fcr_details")
# 初始化时间轴
date_list = date_range("2017-01-01", "2017-12-31")
for index in range(len(date_list)):
cur_date = date_list[index]
# 获取待购买的证券列表
if datetime.datetime.strptime(cur_date, "%Y-%m-%d").weekday() == 0:
print(cur_date)
buy_list = code_ema.get_buy_list(cur_date)
print(cur_date, buy_list)
if buy_list:
fun_buy_02(cur_date, buy_list)
if current_position and datetime.datetime.strptime(
cur_date, "%Y-%m-%d").weekday() == 4:
sell_list = code_ema.get_sell_list(cur_date)
fun_sell_02(cur_date, sell_list)
def __init__(self):
self.dm = DBManager("fcr_details")
def load(self):
Log.init("logic")
DBManager.connect(self.get_server_data("DBServer"))
RedisManager.init(self.get_server_data("RedisServer"))
MapMethod.init()
# -*- coding: utf-8 -*-
"""
__title__ = ''
__author__ = 'JN Zhang'
__mtime__ = '2018/6/5'
"""
import os
from db.db_manager import DBManager
base_path = os.path.abspath(os.path.join(os.getcwd(),
"..")) + "/data/data_code.txt"
if __name__ == "__main__":
# dm = DBManager("fcr_details")
dm = DBManager("fcr_w_details")
_file = open(base_path, "r", encoding="utf-8")
tk_list = list()
while True:
line = _file.readline()
if '' == line:
break
str_code = line.split()[0]
str_title = line.split()[1]
if "XSHE" in str_code:
ticker = "sz." + str_code[:6]
elif "XSHG" in str_code:
ticker = "sh." + str_code[:6]
dm.add_one({
"code": str_code,
"ticker": ticker,