gp-server.git - Gitblit

			@@ -7,9 +7,9 @@
			from http.server import BaseHTTPRequestHandler
			import dask

			from code_attribute.gpcode_manager import BlackListCodeManager
			from log_module.log import logger_system, logger_debug
			from utils import global_util, tool, data_export_util
			from code_attribute.gpcode_manager import BlackListCodeManager, CodePrePriceManager
			from log_module.log import logger_system, logger_debug, logger_kpl_limit_up
			from utils import global_util, tool, data_export_util, init_data_util
			from code_attribute import gpcode_manager
			from log_module import log, log_analyse, log_export
			from l2 import code_price_manager, l2_data_util, l2_data_manager_new, cancel_buy_strategy, transaction_progress
			@@ -49,6 +49,8 @@
			__industry_cache_dict = {}
			__latest_limit_up_codes_set = set()
			__data_process_thread_pool = concurrent.futures.ThreadPoolExecutor(max_workers=10)
			# 代码的涨幅
			__code_limit_rate_dict = {}

			# 禁用日志输出
			def log_message(self, format, *args):
			@@ -302,6 +304,7 @@
			ps_dict = dict([(k, v[0]) for k, v in parse_qs(url.query).items()])
			code = ps_dict['code']
			name = ps_dict.get('name')
			date = ps_dict.get('date')
			try:
			data = code_info_output.get_output_params(code, self.__jingxuan_cache_dict, self.__industry_cache_dict)
			if data["code_name"].find("None") > -1 and name:
			@@ -317,8 +320,23 @@
			logger_debug.exception(e)
			logging.exception(e)

			# 获取评分信息
			pass
			elif url.path == "/get_trade_records":
			# 获取挂撤信息
			ps_dict = dict([(k, v[0]) for k, v in parse_qs(url.query).items()])
			code = ps_dict['code']
			date = ps_dict.get('date')
			local_today_datas = log_export.load_l2_from_log(date)
			total_datas = local_today_datas.get(code)
			trade_info = code_info_output.load_trade_record(code, total_datas, date)
			response_data = json.dumps({"code": 0, "data": {"open_limit_up": trade_info[0], "records": trade_info[2]}})

			elif url.path == "/get_l2_cant_buy_reasons":
			# 获取L2没买的原因
			ps_dict = dict([(k, v[0]) for k, v in parse_qs(url.query).items()])
			code = ps_dict['code']
			fdatas = log_export.get_l2_cant_buy_reasons(code)
			response_data = json.dumps({"code": 0, "data": fdatas})

			elif url.path == "/get_kpl_block_info":
			start_time = time.time()
			ps_dict = dict([(k, v[0]) for k, v in parse_qs(url.query).items()])
			@@ -332,11 +350,22 @@
			logging.exception(e)

			elif url.path == "/get_l2_datas":
			# 获取L2的数据
			ps_dict = dict([(k, v[0]) for k, v in parse_qs(url.query).items()])
			code = ps_dict['code']
			datas = data_export_util.get_l2_datas(code)
			response_data = json.dumps({"code": 0, "data": datas})
			try:
			# 获取L2的数据
			ps_dict = dict([(k, v[0]) for k, v in parse_qs(url.query).items()])
			code = ps_dict['code']
			date = ps_dict.get('date')
			logger_debug.info(f"get_l2_datas:{code} {date}")
			total_datas = l2_data_util.local_today_datas.get(code)
			if date:
			total_datas = None
			else:
			date = tool.get_now_date_str()
			datas = data_export_util.get_l2_datas(code, total_datas, date=date)
			code_name = gpcode_manager.get_code_name(code)
			response_data = json.dumps({"code": 0, "data": {"code": code, "code_name": code_name, "data": datas}})
			except Exception as e:
			logger_debug.exception(e)
			elif url.path == "/get_trade_progress":
			# 获取交易进度
			ps_dict = dict([(k, v[0]) for k, v in parse_qs(url.query).items()])
			@@ -348,10 +377,13 @@
			# 最新的l撤数据
			ps_dict = dict([(k, v[0]) for k, v in parse_qs(url.query).items()])
			code = ps_dict['code']
			date = ps_dict.get('date')
			if not date:
			date = tool.get_now_date_str()
			buy_single_index = ps_dict.get('buy_single_index')
			if buy_single_index is not None:
			buy_single_index = int(buy_single_index)
			records = code_info_output.load_trade_record_cancel_watch_indexes(code)
			records = code_info_output.load_trade_record_cancel_watch_indexes(code, date=date)
			# 获取最新的L上与L下
			records.reverse()
			up_indexes = []
			@@ -442,7 +474,7 @@
			elif url.path == "/kpl/get_plate_codes":
			# 获取涨停原因下面的代码
			ps_dict = dict([(k, v[0]) for k, v in parse_qs(url.query).items()])
			plate = ps_dict["plate"]
			plate = kpl_util.filter_block(ps_dict["plate"])
			# 获取板块下的代码
			# 统计目前为止的代码涨停数量（分涨停原因）
			now_limit_up_codes_info = self.__kplDataManager.get_data(KPLDataType.LIMIT_UP)
			@@ -455,12 +487,23 @@

			codes_info = []
			for d in record_limit_up_datas:
			if d[2] != plate:
			if kpl_util.filter_block(d[2]) != plate:
			continue
			# 代码,名称,涨停时间,是否炸板,是否想买,是否已经下过单
			codes_info.append(
			[d[3], d[4], tool.to_time_str(int(d[5])), 1 if d[3] not in now_limit_up_codes else 0, 0, 0, d[12],
			output_util.money_desc(d[13])])
			output_util.money_desc(d[13]), 1])

			for d in record_limit_up_datas:
			if kpl_util.filter_block(d[2]) == plate:
			continue
			if plate not in [kpl_util.filter_block(k) for k in d[6].split("、")]:
			continue
			# 代码,名称,涨停时间,是否炸板,是否想买,是否已经下过单
			codes_info.append(
			[d[3], d[4], tool.to_time_str(int(d[5])), 1 if d[3] not in now_limit_up_codes else 0, 0, 0, d[12],
			output_util.money_desc(d[13]), 0])

			codes_info.sort(key=lambda x: x[2])
			# 查询是否为想买单
			want_codes = gpcode_manager.WantBuyCodesManager().list_code_cache()
			@@ -472,6 +515,36 @@
			code_info[5] = 1

			response_data = json.dumps({"code": 0, "data": codes_info})
			elif url.path == "/kpl/get_open_limit_up_count_rank":
			# 获取炸板次数排行
			ps_dict = dict([(k, v[0]) for k, v in parse_qs(url.query).items()])
			code = ps_dict.get("code")
			results = log_export.load_kpl_open_limit_up()
			statistic = {}
			for result in results:
			for c in result[1]:
			if not tool.is_shsz_code(c):
			continue
			if code and code != c:
			continue
			if c not in statistic:
			statistic[c] = 0
			statistic[c] += 1
			# 倒序排
			statistic_list = [(k, statistic[k]) for k in statistic]
			statistic_list.sort(key=lambda x: x[1], reverse=True)
			fresults = []
			limit_up_records = KPLLimitUpDataRecordManager.list_all_cache(tool.get_now_date_str())
			limit_up_count_dict = {}
			if limit_up_records:
			for d in limit_up_records:
			limit_up_count_dict[d[3]] = d[12]

			for x in statistic_list:
			fresults.append((x[0], gpcode_manager.get_code_name(x[0]), x[1],limit_up_count_dict.get(x[0])))

			fresults = fresults[:30]
			response_data = json.dumps({"code": 0, "data": fresults})
			elif url.path == "/get_h_cancel_data":
			ps_dict = dict([(k, v[0]) for k, v in parse_qs(url.query).items()])
			code = ps_dict["code"]
			@@ -511,29 +584,86 @@
			response_data = json.dumps({"code": 1, "msg": "请上传code"})

			elif url.path == "/get_last_trade_day_reasons":
			# 获取上个交易日的相同涨停原因的代码信息
			ps_dict = dict([(k, v[0]) for k, v in parse_qs(url.query).items()])
			code = ps_dict["code"]
			day = HistoryKDatasUtils.get_previous_trading_date(tool.get_now_date_str())
			# 获取涨停数据

			# 获取代码的原因
			reasons = kpl_data_manager.KPLLimitUpDataRecordManager.list_by_code(code, day)
			if reasons:
			reasons = list(reasons)
			reasons.sort(key=lambda x: x[9])
			reason = reasons[-1][2]
			datas = self.__kplDataManager.get_from_file(kpl_util.KPLDataType.LIMIT_UP, day)
			# (代码,名称,首次涨停时间,最近涨停时间,几板,涨停原因,板块,实际流通,主力净额,涨停原因代码,涨停原因代码数量)
			result_list = []
			if datas:
			for d in datas:
			if d[5] == reason and d[0] != code:
			# (代码,名称)
			result_list.append((d[0], d[1]))
			response_data = json.dumps({"code": 0, "data": {"reason": reason, "data": result_list}})
			else:
			response_data = json.dumps({"code": 1, "msg": "昨日未涨停"})
			# 计算平均涨幅
			def get_limit_rate_list(codes):
			if not codes:
			return []
			need_request_codes = set()
			if tool.trade_time_sub(tool.get_now_time_str(), "09:30:00") < 0:
			need_request_codes \|= set(codes)
			else:
			now_time = time.time()
			for c in codes:
			if c not in self.__code_limit_rate_dict:
			need_request_codes.add(c)
			elif now_time - self.__code_limit_rate_dict[c][1] > 60:
			need_request_codes.add(c)
			if need_request_codes:
			_limit_rate_list = HistoryKDatasUtils.get_codes_limit_rate(list(need_request_codes))
			for d in _limit_rate_list:
			self.__code_limit_rate_dict[d[0]] = (d[1], time.time())
			return [(c_, self.__code_limit_rate_dict[c_][0]) for c_ in codes]

			try:
			raise Exception("接口暂停使用")
			# 获取上个交易日的相同涨停原因的代码信息
			ps_dict = dict([(k, v[0]) for k, v in parse_qs(url.query).items()])
			code = ps_dict["code"]
			# 获取昨日涨停数据
			day = HistoryKDatasUtils.get_previous_trading_date_cache(tool.get_now_date_str())

			limit_up_records = kpl_data_manager.KPLLimitUpDataRecordManager.list_all_cache(day)
			reasons = []
			for d in limit_up_records:
			if d[3] == code:
			reasons.append(d)
			# 获取代码的原因
			if reasons:
			reasons = list(reasons)
			reasons.sort(key=lambda x: x[9])
			reason = reasons[-1][2]
			# 获取涨停数据
			datas = self.__kplDataManager.get_from_file_cache(kpl_util.KPLDataType.LIMIT_UP, day)
			# (代码,名称,首次涨停时间,最近涨停时间,几板,涨停原因,板块,实际流通,主力净额,涨停原因代码,涨停原因代码数量)
			yesterday_result_list = []
			percent_rate = 0
			if datas:
			yesterday_codes = set()
			for d in datas:
			if d[5] == reason:
			yesterday_codes.add(d[0])
			# 获取涨幅
			limit_rate_list = get_limit_rate_list(yesterday_codes)
			limit_rate_dict = {}
			if limit_rate_list:
			total_rate = 0
			for d in limit_rate_list:
			limit_rate_dict[d[0]] = d[1]
			total_rate += d[1]
			percent_rate = round(total_rate / len(limit_rate_list), 2)

			for d in datas:
			if d[5] == reason:
			yesterday_codes.add(d[0])
			if d[0] != code:
			# (代码,名称, 涨幅)
			yesterday_result_list.append((d[0], d[1], limit_rate_dict.get(d[0])))

			current_limit_up_list = kpl_data_manager.KPLLimitUpDataRecordManager.latest_origin_datas
			current_result_list = []
			if current_limit_up_list:
			for c in current_limit_up_list:
			if c[5] == reason and c[0] != code:
			current_result_list.append((c[0], c[1]))
			response_data = json.dumps({"code": 0, "data": {"reason": reason, "reason_rate": percent_rate,
			"data": {"yesterday": yesterday_result_list,
			"current": current_result_list}}})
			else:
			response_data = json.dumps({"code": 1, "msg": "昨日未涨停"})
			except Exception as e:
			logger_debug.exception(e)
			raise e

			elif url.path == "/pull_kp_client_msg":
			# 拉取客户端消息
			@@ -565,7 +695,7 @@
			result_str = self.__process_kpl_data(params)
			self.__send_response(result_str)

			def __process_kpl_data(self, data):
			def __process_kpl_data(self, data_origin):
			def do_limit_up(result_list_):
			if result_list_:
			# 保存涨停时间
			@@ -622,6 +752,8 @@
			kpl_data_manager.KPLLimitUpDataRecordManager.save_record(tool.get_now_date_str(), result_list_)
			self.__kplDataManager.save_data(type_, result_list_)

			# 将"概念"二字替换掉
			data = data_origin
			type_ = data["type"]
			print("开盘啦type:", type_)
			if type_ == KPLDataType.BIDDING.value:
			@@ -638,8 +770,10 @@

			self.__kplDataManager.save_data(type_, result_list)
			elif type_ == KPLDataType.LIMIT_UP.value:
			result_list = kpl_util.parseDaBanData(data["data"], kpl_util.DABAN_TYPE_LIMIT_UP)
			result_list = kpl_util.parseLimitUpData(data["data"])
			self.__data_process_thread_pool.submit(lambda: do_limit_up(result_list))
			# 记录涨停日志
			logger_kpl_limit_up.info(result_list)
			elif type_ == KPLDataType.OPEN_LIMIT_UP.value:
			result_list = kpl_util.parseDaBanData(data["data"], kpl_util.DABAN_TYPE_OPEN_LIMIT_UP)
			if result_list:
			@@ -719,25 +853,8 @@


			if __name__ == "__main__":
			code = "002676"
			buy_single_index = 716
			records = code_info_output.load_trade_record_cancel_watch_indexes(code)
			# 获取最新的L上与L下
			records.reverse()
			up_indexes = []
			down_indexes = []
			for r in records:
			if buy_single_index and buy_single_index != r[1]:
			continue
			if r[0] == trade_record_log_util.CancelWatchIndexesInfo.CANCEL_TYPE_L_UP:
			up_indexes = r[2]
			break
			for r in records:
			if buy_single_index and buy_single_index != r[1]:
			continue
			if r[0] == trade_record_log_util.CancelWatchIndexesInfo.CANCEL_TYPE_L_DOWN:
			down_indexes = r[2]
			break
			code = "600822"
			records = code_info_output.load_trade_record_cancel_watch_indexes(code, date="2024-03-12")

			response_data = json.dumps(
			{"code": 0, "data": {"up": up_indexes, "down": down_indexes}})
			# data = code_info_output.get_output_params(code, self.__jingxuan_cache_dict, self.__industry_cache_dict,
			# trade_record_date=date)