"""
|
代码行业关键词管理
|
"""
|
|
# 涨停代码关键词板块管理
|
import json
|
|
import constant
|
from db.redis_manager_delegate import RedisUtils
|
from third_data import kpl_block_util
|
from utils import global_util, tool
|
from log_module import log
|
from db import redis_manager_delegate as redis_manager
|
|
from log_module.log import logger_kpl_limit_up, logger_kpl_block_can_buy, logger_kpl_debug
|
from third_data.kpl_util import KPLPlatManager
|
from trade import trade_manager, l2_trade_util
|
|
|
# 代码精选板块管理
|
class KPLCodeJXBlockManager:
|
__db = 3
|
__redisManager = redis_manager.RedisManager(3)
|
__code_blocks = {}
|
# 备用
|
__code_by_blocks = {}
|
|
__instance = None
|
|
def __new__(cls, *args, **kwargs):
|
if not cls.__instance:
|
cls.__instance = super(KPLCodeJXBlockManager, cls).__new__(cls, *args, **kwargs)
|
return cls.__instance
|
|
def __get_redis(self):
|
return self.__redisManager.getRedis()
|
|
def save_jx_blocks(self, code, blocks, by=False):
|
if blocks is None:
|
return
|
if len(blocks) > 2:
|
blocks = blocks[:2]
|
|
# 保存前2条数据
|
if by:
|
RedisUtils.setex_async(self.__db, f"kpl_jx_blocks_by-{code}", tool.get_expire(), json.dumps(blocks))
|
self.__code_by_blocks[code] = blocks
|
else:
|
RedisUtils.setex_async(self.__db, f"kpl_jx_blocks-{code}", tool.get_expire(), json.dumps(blocks))
|
self.__code_blocks[code] = blocks
|
|
# 获取精选板块
|
def get_jx_blocks(self, code, by=False):
|
if by:
|
if code in self.__code_by_blocks:
|
return self.__code_by_blocks[code]
|
val = RedisUtils.get(self.__get_redis(), f"kpl_jx_blocks_by-{code}")
|
if val is None:
|
return None
|
else:
|
val = json.loads(val)
|
self.__code_by_blocks[code] = val
|
return self.__code_by_blocks[code]
|
else:
|
if code in self.__code_blocks:
|
return self.__code_blocks[code]
|
val = RedisUtils.get(self.__get_redis(), f"kpl_jx_blocks-{code}")
|
if val is None:
|
return None
|
else:
|
val = json.loads(val)
|
self.__code_blocks[code] = val
|
return self.__code_blocks[code]
|
|
def get_jx_blocks_cache(self, code, by=False):
|
if by:
|
return self.__code_by_blocks.get(code)
|
else:
|
return self.__code_blocks.get(code)
|
|
|
# 开盘啦禁止交易板块管理
|
class KPLPlateForbiddenManager:
|
__redisManager = redis_manager.RedisManager(3)
|
__kpl_forbidden_plates_cache = set()
|
|
__instance = None
|
|
def __new__(cls, *args, **kwargs):
|
if not cls.__instance:
|
cls.__instance = super(KPLPlateForbiddenManager, cls).__new__(cls, *args, **kwargs)
|
cls.__load_datas()
|
return cls.__instance
|
|
@classmethod
|
def __load_datas(cls):
|
__redis = cls.__get_redis()
|
try:
|
__kpl_forbidden_plates_cache = RedisUtils.smembers(__redis, "kpl_forbidden_plates")
|
finally:
|
RedisUtils.realse(__redis)
|
|
@classmethod
|
def __get_redis(cls):
|
return cls.__redisManager.getRedis()
|
|
def save_plate(self, plate):
|
self.__kpl_forbidden_plates_cache.add(plate)
|
RedisUtils.sadd(self.__get_redis(), "kpl_forbidden_plates", plate)
|
RedisUtils.expire(self.__get_redis(), "kpl_forbidden_plates", tool.get_expire())
|
|
def list_all(self):
|
return RedisUtils.smembers(self.__get_redis(), "kpl_forbidden_plates")
|
|
def list_all_cache(self):
|
return self.__kpl_forbidden_plates_cache
|
|
|
class LimitUpCodesPlateKeyManager:
|
# 今日涨停原因
|
today_limit_up_reason_dict = {}
|
today_total_limit_up_reason_dict = {}
|
total_code_keys_dict = {}
|
total_key_codes_dict = {}
|
__redisManager = redis_manager.RedisManager(1)
|
|
def __get_redis(self):
|
return self.__redisManager.getRedis()
|
|
# 获取今日涨停数据，格式：[(代码,涨停原因)]
|
def set_today_limit_up(self, datas):
|
temp_dict = {}
|
if datas:
|
for item in datas:
|
temp_dict[item[0]] = item[1]
|
self.today_limit_up_reason_dict = temp_dict
|
if datas:
|
for item in datas:
|
self.__set_total_keys(item[0])
|
self.set_today_total_limit_up(datas)
|
|
# 设置今日历史涨停数据
|
def set_today_total_limit_up(self, datas):
|
for item in datas:
|
code = item[0]
|
self.today_total_limit_up_reason_dict[code] = item[1]
|
|
# 今日涨停原因变化
|
def set_today_limit_up_reason_change(self, code, from_reason, to_reason):
|
RedisUtils.sadd(self.__get_redis(), f"kpl_limit_up_reason_his-{code}", from_reason)
|
RedisUtils.expire(self.__get_redis(), f"kpl_limit_up_reason_his-{code}", tool.get_expire())
|
self.__set_total_keys(code)
|
|
# 设置代码的今日涨停原因
|
def __set_total_keys(self, code):
|
keys = set()
|
# keys_his = self.__get_redis().smembers(f"kpl_limit_up_reason_his-{code}")
|
# keys |= keys_his
|
if code in self.today_limit_up_reason_dict:
|
if self.today_limit_up_reason_dict.get(code) not in constant.KPL_INVALID_BLOCKS:
|
keys.add(self.today_limit_up_reason_dict.get(code))
|
self.total_code_keys_dict[code] = keys
|
for k in keys:
|
if k not in self.total_key_codes_dict:
|
self.total_key_codes_dict[k] = set()
|
self.total_key_codes_dict[k].add(code)
|
|
logger_kpl_limit_up.info("{}板块关键词:{}", code, keys)
|
|
# 根据传入的关键词与涨停代码信息匹配身位
|
|
def get_codes_by_key_without_mine(self, key, code):
|
# 只比较今日涨停原因
|
codes_set = set()
|
if key in self.total_key_codes_dict:
|
codes_set |= self.total_key_codes_dict[key]
|
codes_set.discard(code)
|
return codes_set
|
|
# 涨停原因匹配关键字(和涨停列表中的涨停原因做对比),返回:{关键词:代码集合}
|
def match_limit_up_reason_keys(self, code, keys):
|
fresult = {}
|
for k in keys:
|
if k in self.total_key_codes_dict:
|
codes = set(self.total_key_codes_dict[k])
|
codes.discard(code)
|
if codes:
|
fresult[k] = codes
|
return fresult
|
|
|
# 实时开盘啦市场数据
|
class RealTimeKplMarketData:
|
# 精选前5
|
top_5_reason_list = []
|
# 行业前5
|
top_5_industry_list = []
|
#
|
top_5_key_dict = {}
|
total_reason_dict = {}
|
total_industry_dict = {}
|
__KPLPlateForbiddenManager = KPLPlateForbiddenManager()
|
__LimitUpCodesPlateKeyManager = LimitUpCodesPlateKeyManager()
|
__KPLPlatManager = KPLPlatManager()
|
|
@classmethod
|
def set_top_5_reasons(cls, datas):
|
temp_list = []
|
for d in datas:
|
cls.total_reason_dict[d[1]] = d
|
# 排序
|
for i in range(0, len(datas)):
|
if datas[i][1] not in constant.KPL_INVALID_BLOCKS:
|
# （名称,净流入金额,排名）
|
temp_list.append((datas[i][1], datas[i][3], len(temp_list)))
|
# 只获取前10个
|
if len(temp_list) > 10:
|
break
|
if datas[i][3] < 3 * 10000 * 10000:
|
break
|
|
for temp in temp_list:
|
names = cls.__KPLPlatManager.get_same_plat_names_by_id(temp[0])
|
for name in names:
|
if name == temp[1]:
|
continue
|
temp_list.append((name, temp[1], temp[2]))
|
cls.top_5_reason_list = temp_list
|
cls.__reset_top_5_dict()
|
|
@classmethod
|
def set_top_5_industry(cls, datas):
|
for d in datas:
|
cls.total_industry_dict[d[1]] = d
|
temp_list = []
|
for i in range(0, len(datas)):
|
if datas[i][1] in constant.KPL_INVALID_BLOCKS:
|
continue
|
temp_list.append((datas[i][1], datas[i][2], len(temp_list)))
|
if len(temp_list) > 10:
|
break
|
if datas[i][2] < 3 * 10000 * 10000:
|
break
|
cls.top_5_industry_list = temp_list
|
cls.__reset_top_5_dict()
|
|
@classmethod
|
def __reset_top_5_dict(cls):
|
temp_dict = {}
|
for t in cls.top_5_industry_list:
|
temp_dict[t[0]] = t
|
for t in cls.top_5_reason_list:
|
temp_dict[t[0]] = t
|
cls.top_5_key_dict = temp_dict
|
|
# 获取能够买的行业关键字set
|
@classmethod
|
def get_can_buy_key_set(cls):
|
temp_set = cls.top_5_key_dict.keys()
|
return temp_set
|
|
# 通过关键字判断能买的代码数量
|
@classmethod
|
def get_can_buy_codes_count(cls, code, key):
|
# 判断行业涨停票数量，除开自己必须大于1个
|
temp_codes = LimitUpCodesPlateKeyManager.total_key_codes_dict.get(key)
|
if temp_codes is None:
|
temp_codes = set()
|
else:
|
temp_codes = set(temp_codes)
|
temp_codes.discard(code)
|
if len(temp_codes) < 1:
|
# 后排才能挂单
|
return 0, "身位不为后排"
|
|
forbidden_plates = cls.__KPLPlateForbiddenManager.list_all_cache()
|
if key in forbidden_plates:
|
return 0, "不买该板块"
|
|
# 10:30以前可以挂2个单
|
if int(tool.get_now_time_str().replace(':', '')) < int("100000"):
|
return 2, "10:00以前可以挂2个单"
|
# 10:30以后
|
if key not in cls.top_5_key_dict:
|
return 0, "净流入没在前5"
|
if cls.top_5_key_dict[key][1] > 3 * 10000 * 10000:
|
return 2, "净流入在前5且大于3亿"
|
else:
|
return 1, "净流入在前5"
|
|
@classmethod
|
def is_in_top(cls, keys):
|
reasons = cls.get_can_buy_key_set()
|
log.logger_kpl_debug.debug("市场流入前5:{}", reasons)
|
forbidden_plates = cls.__KPLPlateForbiddenManager.list_all_cache()
|
reasons = reasons - forbidden_plates
|
temp_set = keys & reasons
|
log.logger_kpl_debug.debug("市场流入前5匹配结果:{}", temp_set)
|
if temp_set:
|
return True, temp_set
|
else:
|
return False, None
|
|
|
# 代码历史涨停原因与板块管理
|
class CodesHisReasonAndBlocksManager:
|
__redisManager = redis_manager.RedisManager(1)
|
# 历史涨停原因
|
__history_limit_up_reason_dict = {}
|
# 板块
|
__blocks_dict = {}
|
|
def __get_redis(self):
|
return self.__redisManager.getRedis()
|
|
def set_history_limit_up_reason(self, code, reasons):
|
self.__history_limit_up_reason_dict[code] = set(reasons)
|
RedisUtils.setex(self.__get_redis(), f"kpl_his_limit_up_reason-{code}", tool.get_expire(),
|
json.dumps(list(reasons)))
|
logger_kpl_debug.debug(f"设置历史涨停原因：{code}-{reasons}")
|
|
# 如果返回值不为None表示已经加载过历史原因了
|
def get_history_limit_up_reason(self, code):
|
reasons = self.__history_limit_up_reason_dict.get(code)
|
if reasons is None:
|
# 从内存中加载
|
val = RedisUtils.get(self.__get_redis(), f"kpl_his_limit_up_reason-{code}")
|
if val is not None:
|
val = set(json.loads(val))
|
self.__history_limit_up_reason_dict[code] = val
|
if code in self.__history_limit_up_reason_dict:
|
return self.__history_limit_up_reason_dict.get(code)
|
else:
|
return None
|
else:
|
return reasons
|
|
def get_history_limit_up_reason_cache(self, code):
|
reasons = self.__history_limit_up_reason_dict.get(code)
|
return reasons
|
|
def set_blocks(self, code, blocks):
|
self.__blocks_dict[code] = set(blocks)
|
RedisUtils.setex(self.__get_redis(), f"kpl_blocks-{code}", tool.get_expire(), json.dumps(list(blocks)))
|
|
def get_blocks(self, code):
|
reasons = self.__blocks_dict.get(code)
|
if reasons is None:
|
# 从内存中加载
|
val = RedisUtils.get(self.__get_redis(), f"kpl_blocks-{code}")
|
if val is not None:
|
val = set(json.loads(val))
|
self.__blocks_dict[code] = val
|
if code in self.__blocks_dict:
|
return self.__blocks_dict.get(code)
|
else:
|
return None
|
else:
|
return reasons
|
|
def get_total_keys(self, code):
|
reasons = self.get_history_limit_up_reason(code)
|
if reasons is None:
|
reasons = set()
|
blocks = self.get_blocks(code)
|
if blocks is None:
|
blocks = set()
|
return reasons | blocks
|
|
|
# 目标代码板块关键词管理
|
class TargetCodePlateKeyManager:
|
__redisManager = redis_manager.RedisManager(1)
|
__CodesPlateKeysManager = CodesHisReasonAndBlocksManager()
|
__KPLCodeJXBlockManager = KPLCodeJXBlockManager()
|
|
def __get_redis(self):
|
return self.__redisManager.getRedis()
|
|
# 返回key集合(排除无效板块),今日涨停原因,今日历史涨停原因,历史涨停原因,二级,精选板块
|
def get_plate_keys(self, code):
|
keys = set()
|
k1 = set()
|
if code in LimitUpCodesPlateKeyManager.today_total_limit_up_reason_dict:
|
k1 = {LimitUpCodesPlateKeyManager.today_total_limit_up_reason_dict[code]}
|
# 加载今日历史原因,暂时不需要历史原因了
|
k11 = set() # RedisUtils.smembers(self.__get_redis(), f"kpl_limit_up_reason_his-{code}")
|
k2 = self.__CodesPlateKeysManager.get_history_limit_up_reason_cache(code)
|
if k2 is None:
|
k2 = set()
|
k3 = set()
|
industry = global_util.code_industry_map.get(code)
|
if industry:
|
k3 = {industry}
|
|
k4 = set()
|
jingxuan_blocks = self.__KPLCodeJXBlockManager.get_jx_blocks_cache(code)
|
if not jingxuan_blocks:
|
jingxuan_blocks = self.__KPLCodeJXBlockManager.get_jx_blocks_cache(code, by=True)
|
if jingxuan_blocks:
|
jingxuan_blocks = jingxuan_blocks[:2]
|
k4 |= set([x[1] for x in jingxuan_blocks])
|
for k in [k1, k11, k2, k3, k4]:
|
keys |= k
|
|
# 排除无效的涨停原因
|
keys = keys - set(constant.KPL_INVALID_BLOCKS)
|
|
return keys, k1, k11, k2, k3, k4
|
|
|
class CodePlateKeyBuyManager:
|
# 无板块
|
BLOCK_TYPE_NONE = -1
|
# 一般板块
|
BLOCK_TYPE_COMMON = 0
|
# 强势板块
|
BLOCK_TYPE_STRONG = 1
|
# 猛拉板块
|
BLOCK_TYPE_SOON_LIMIT_UP = 2
|
# 潜伏板块
|
BLOCK_TYPE_START_UP = 3
|
|
__TargetCodePlateKeyManager = TargetCodePlateKeyManager()
|
__LimitUpCodesPlateKeyManager = LimitUpCodesPlateKeyManager()
|
__CodesHisReasonAndBlocksManager = CodesHisReasonAndBlocksManager()
|
__CodesTradeStateManager = trade_manager.CodesTradeStateManager()
|
__can_buy_compute_result_dict = {}
|
|
@classmethod
|
def __remove_from_l2(cls, code, msg):
|
# 根据身位移除代码
|
# return
|
# 下过单的代码不移除
|
if trade_manager.CodesTradeStateManager().get_trade_state_cache(code) != trade_manager.TRADE_STATE_NOT_TRADE:
|
# 只要下过单的就不移除
|
return
|
l2_trade_util.forbidden_trade(code, msg=msg)
|
logger_kpl_block_can_buy.info(msg)
|
|
@classmethod
|
def __is_block_can_buy(cls, code, block, current_limit_up_datas, code_limit_up_reason_dict,
|
yesterday_current_limit_up_codes, limit_up_record_datas):
|
# log.logger_kpl_debug.info(f"判断板块是否可买：{block}")
|
# is_top_8_record, top_8_record = kpl_block_util.is_record_top_block(code, block, limit_up_record_datas,
|
# yesterday_current_limit_up_codes, 50)
|
# is_top_4_current, top_4_current = kpl_block_util.is_current_top_block(code, block, current_limit_up_datas,
|
# yesterday_current_limit_up_codes, 50)
|
# is_top_4 = is_top_8_record and is_top_4_current
|
# msg_list.append(f"\n实时top10(涨停数量：{len(current_limit_up_datas)})")
|
# msg_list.append(f"历史top20(涨停数量：{len(top_8_record)})")
|
|
# 获取主板实时身位,剔除高位板
|
current_shsz_rank, front_current_shsz_rank_codes = kpl_block_util.get_code_current_rank(code, block,
|
current_limit_up_datas,
|
code_limit_up_reason_dict,
|
yesterday_current_limit_up_codes,
|
shsz=True)
|
record_shsz_rank, record_shsz_rank_codes = kpl_block_util.get_code_record_rank(code, block,
|
limit_up_record_datas,
|
code_limit_up_reason_dict,
|
yesterday_current_limit_up_codes,
|
shsz=True)
|
# 获取主板历史身位
|
|
open_limit_up_codes = kpl_block_util.get_shsz_open_limit_up_codes(code, block, limit_up_record_datas,
|
code_limit_up_reason_dict)
|
if open_limit_up_codes:
|
# 主板开1
|
if current_shsz_rank < len(open_limit_up_codes) + 1 and record_shsz_rank < len(open_limit_up_codes) + 2:
|
# 属于龙1,龙2
|
return True, f"{tool.get_now_time_str()} {block}：top10涨停板块，主板开1({open_limit_up_codes}),属于主板前龙{len(open_limit_up_codes) + 1}(实时身位-{current_shsz_rank}/{len(current_limit_up_datas)})"
|
else:
|
if record_shsz_rank >= len(open_limit_up_codes) + 1:
|
cls.__remove_from_l2(code, f"{code}根据身位禁止买入：【{block}】历史身位{record_shsz_rank}")
|
return False, f"板块-{block}: top4涨停板块，主板开1（{open_limit_up_codes}）,不为主板前龙{len(open_limit_up_codes) + 1}（实时身位-{current_shsz_rank}:{front_current_shsz_rank_codes},历史身位-{record_shsz_rank}）"
|
else:
|
if current_shsz_rank == 0 and record_shsz_rank < 2:
|
return True, f"{tool.get_now_time_str()} {block}：top4涨停板块，非主板开1，属于龙1，实时涨停列表数量({len(current_limit_up_datas)})"
|
else:
|
if record_shsz_rank >= 2:
|
cls.__remove_from_l2(code, f"{code}根据身位禁止买入：【{block}】历史身位{record_shsz_rank}")
|
|
return False, f"板块-{block}: top4涨停板块，非主板开1,不为主板龙1（实时身位-{current_shsz_rank}:{front_current_shsz_rank_codes},历史身位-{record_shsz_rank}）"
|
|
# 获取可以买的板块
|
# current_limit_up_datas: 今日实时涨停
|
# latest_2_day_limit_up_datas：最近2天的实时涨停（不含今日）
|
# limit_up_record_datas：今日历史涨停
|
# yesterday_current_limit_up_codes ： 昨日涨停代码
|
# before_blocks_dict：历史涨停原因
|
@classmethod
|
def get_can_buy_block(cls, code, current_limit_up_datas, limit_up_record_datas, yesterday_current_limit_up_codes,
|
before_blocks_dict):
|
# 加载涨停代码的目标板块
|
def load_code_block():
|
for d in limit_up_record_datas:
|
if d[2] in constant.KPL_INVALID_BLOCKS and d[3] in before_blocks_dict:
|
code_limit_up_reason_dict[d[3]] = list(before_blocks_dict.get(d[3]))[0]
|
else:
|
code_limit_up_reason_dict[d[3]] = d[2]
|
return code_limit_up_reason_dict
|
|
if current_limit_up_datas is None:
|
current_limit_up_datas = []
|
|
# 获取目标代码板块
|
keys, k1, k11, k2, k3, k4 = cls.__TargetCodePlateKeyManager.get_plate_keys(code)
|
# log.logger_kpl_debug.info("{}关键词：今日-{},今日历史-{},历史-{},二级行业-{},代码板块-{}", code, k1, k11, k2, k3, k4)
|
keys = set()
|
if k1:
|
for k in k1:
|
if k not in constant.KPL_INVALID_BLOCKS:
|
keys.add(k)
|
# 始终获取精选板块
|
if True:
|
# 获取
|
if k4:
|
keys |= k4
|
keys = keys - constant.KPL_INVALID_BLOCKS
|
|
log.logger_kpl_debug.info("{}最终关键词：{}", code, keys)
|
|
# 涨停列表中匹配关键词，返回（板块:代码集合），代码集合中已经排除自身
|
if not keys:
|
return None, "尚未找到涨停原因"
|
code_limit_up_reason_dict = {}
|
load_code_block()
|
msg_list = []
|
|
can_buy_blocks = []
|
for block in keys:
|
|
can_buy, msg = cls.__is_block_can_buy(code, block, current_limit_up_datas, code_limit_up_reason_dict,
|
yesterday_current_limit_up_codes, limit_up_record_datas)
|
if can_buy:
|
can_buy_blocks.append((block, msg))
|
else:
|
msg_list.append(msg)
|
if len(can_buy_blocks) == len(keys):
|
blocks = [x[0] for x in can_buy_blocks]
|
blocks_msg = "\n".join([x[1] for x in can_buy_blocks])
|
return blocks, blocks_msg
|
|
return None, "\n".join(msg_list)
|
|
# 是否可以下单
|
# 返回：是否可以下单,消息,板块类型
|
@classmethod
|
def can_buy(cls, code):
|
if constant.TEST:
|
return True, cls.BLOCK_TYPE_NONE
|
# if True:
|
# # 测试
|
# return True, "不判断板块身位"
|
return cls.__can_buy_compute_result_dict.get(code)
|
|
@classmethod
|
def __compute_can_buy_blocks(cls, code, current_limit_up_datas, limit_up_record_datas,
|
yesterday_current_limit_up_codes, before_blocks_dict):
|
|
blocks, block_msg = cls.get_can_buy_block(code, current_limit_up_datas,
|
limit_up_record_datas, yesterday_current_limit_up_codes,
|
before_blocks_dict)
|
if not blocks:
|
return False, block_msg
|
codes_delegate = set(cls.__CodesTradeStateManager.get_codes_by_trade_states_cache(
|
{trade_manager.TRADE_STATE_BUY_DELEGATED, trade_manager.TRADE_STATE_BUY_PLACE_ORDER}))
|
codes_success = set(cls.__CodesTradeStateManager.get_codes_by_trade_states_cache(
|
{trade_manager.TRADE_STATE_BUY_SUCCESS}))
|
|
codes = codes_delegate | codes_success
|
|
# 统计成交代码的板块
|
trade_codes_blocks_dict = {}
|
# 已经成交的板块
|
trade_success_blocks_count = {}
|
for c in codes:
|
keys_, k1_, k11_, k2_, k3_, k4_ = cls.__TargetCodePlateKeyManager.get_plate_keys(c)
|
# 实时涨停原因
|
trade_codes_blocks_dict[c] = k1_ | k4_
|
# 统计板块中的代码
|
trade_block_codes_dict = {}
|
for c in trade_codes_blocks_dict:
|
for b in trade_codes_blocks_dict[c]:
|
if c in codes_success:
|
if b not in trade_success_blocks_count:
|
trade_success_blocks_count[b] = set()
|
trade_success_blocks_count[b].add(c)
|
if b not in trade_block_codes_dict:
|
trade_block_codes_dict[b] = set()
|
trade_block_codes_dict[b].add(c)
|
|
# ---------------------------------加载已经下单/成交的代码信息------------end-------------
|
msg_list = []
|
for key in blocks:
|
# 板块中已经有成交的就不下单了
|
if key in trade_success_blocks_count:
|
success_codes_count = len(trade_success_blocks_count[key])
|
if success_codes_count >= 1:
|
msg_list.append(f"【{key}】中已经有{success_codes_count}个成交代码")
|
log.logger_kpl_debug.debug(f"{code}：板块（{key}）已经有成交【{trade_success_blocks_count[key]}】")
|
continue
|
return True, block_msg
|
|
return False, ",".join(msg_list)
|
|
# 更新代码板块判断是否可以买的结果
|
@classmethod
|
def update_can_buy_blocks(cls, code, current_limit_up_datas, limit_up_record_datas,
|
yesterday_current_limit_up_codes,
|
before_blocks_dict):
|
can_buy, msg = cls.__compute_can_buy_blocks(code, current_limit_up_datas, limit_up_record_datas,
|
yesterday_current_limit_up_codes,
|
before_blocks_dict)
|
# 保存板块计算结果
|
cls.__can_buy_compute_result_dict[code] = (can_buy, msg)
|
|
# 判断是否为真老大
|
@classmethod
|
def __is_real_first_limit_up(cls, code, block, current_limit_up_datas, limit_up_record_datas,
|
yesterday_current_limit_up_codes,
|
before_blocks_dict):
|
# 加载涨停代码的目标板块
|
def load_code_block():
|
if limit_up_record_datas:
|
for d in limit_up_record_datas:
|
if d[2] in constant.KPL_INVALID_BLOCKS and d[3] in before_blocks_dict:
|
code_limit_up_reason_dict[d[3]] = list(before_blocks_dict.get(d[3]))[0]
|
else:
|
code_limit_up_reason_dict[d[3]] = d[2]
|
return code_limit_up_reason_dict
|
|
if current_limit_up_datas is None:
|
current_limit_up_datas = []
|
if limit_up_record_datas is None:
|
limit_up_record_datas = []
|
code_limit_up_reason_dict = {}
|
load_code_block()
|
can_buy, msg = cls.__is_block_can_buy(code, block, current_limit_up_datas, code_limit_up_reason_dict,
|
yesterday_current_limit_up_codes, limit_up_record_datas)
|
return can_buy, msg
|
|
@classmethod
|
def is_need_cancel(cls, code, limit_up_reason, current_limit_up_datas, limit_up_record_datas,
|
yesterday_current_limit_up_codes,
|
before_blocks_dict):
|
can_buy, msg = cls.__is_real_first_limit_up(code, limit_up_reason, current_limit_up_datas,
|
limit_up_record_datas,
|
yesterday_current_limit_up_codes,
|
before_blocks_dict)
|
if not can_buy:
|
logger_kpl_block_can_buy.warning(f"{code} 根据涨停原因（{limit_up_reason}）匹配不能买")
|
return not can_buy
|
|
|
if __name__ == "__main__":
|
pass
|
