"""
|
三方板块管理
|
"""
|
from itertools import combinations
|
|
from db.mysql_data_delegate import Mysqldb
|
from utils import middle_api_protocol
|
from utils.kpl_data_db_util import KPLLimitUpDataUtil
|
from utils.ths_industry_util import ThsCodeIndustryManager
|
|
SOURCE_TYPE_KPL = 1 # 开盘啦
|
SOURCE_TYPE_TDX = 2 # 通达信
|
SOURCE_TYPE_THS = 3 # 同花顺
|
SOURCE_TYPE_EASTMONEY = 4 # 东方财富
|
SOURCE_TYPE_KPL_RECORD = 5 # 开盘啦历史数据
|
|
|
class CodeThirdBlocksManager:
|
__instance = None
|
__mysql = Mysqldb()
|
"""
|
代码的三方板块管理
|
"""
|
# 代码板块：{code:{1:{"b1","b2"},2:{"c1","c2"}}}
|
__code_source_blocks_dict = {}
|
__code_source_blocks_dict_origin = {}
|
__ths_industry = ThsCodeIndustryManager()
|
|
def __new__(cls, *args, **kwargs):
|
if not cls.__instance:
|
cls.__instance = super(CodeThirdBlocksManager, cls).__new__(cls, *args, **kwargs)
|
cls.__load_data()
|
return cls.__instance
|
|
@classmethod
|
def __load_data(cls):
|
results = cls.__mysql.select_all("select _code, _source, _blocks from code_third_blocks")
|
cls.__code_source_blocks_dict.clear()
|
for result in results:
|
if result[0] not in cls.__code_source_blocks_dict:
|
cls.__code_source_blocks_dict[result[0]] = {}
|
cls.__code_source_blocks_dict_origin[result[0]] = {}
|
blocks = set(result[2].split("、"))
|
if result[1] == SOURCE_TYPE_THS:
|
# 同花顺加入2级分类
|
industry = cls.__ths_industry.get_industry(result[0])
|
if industry:
|
blocks.add(industry)
|
|
cls.__code_source_blocks_dict_origin[result[0]][result[1]] = blocks
|
cls.__code_source_blocks_dict[result[0]][result[1]] = BlockMapManager().filter_blocks(blocks)
|
# 加载开盘啦历史涨停原因
|
kpl_results = KPLLimitUpDataUtil.get_latest_block_infos()
|
code_blocks = {}
|
for r in kpl_results:
|
if r[0] not in code_blocks:
|
code_blocks[r[0]] = set()
|
code_blocks[r[0]].add(r[2])
|
if r[3]:
|
code_blocks[r[0]] |= set(r[3].split("、"))
|
for code in code_blocks:
|
if code not in cls.__code_source_blocks_dict:
|
cls.__code_source_blocks_dict[code] = {}
|
cls.__code_source_blocks_dict_origin[code] = {}
|
blocks = code_blocks[code]
|
cls.__code_source_blocks_dict_origin[code][SOURCE_TYPE_KPL_RECORD] = blocks
|
cls.__code_source_blocks_dict[code][SOURCE_TYPE_KPL_RECORD] = BlockMapManager().filter_blocks(blocks)
|
|
|
def get_source_blocks(self, code):
|
"""
|
根据代码获取到来源板块映射
|
@param code:
|
@return:
|
"""
|
return self.__code_source_blocks_dict.get(code)
|
|
def get_source_blocks_origin(self, code):
|
"""
|
根据代码获取到来源板块映射
|
@param code:
|
@return:
|
"""
|
return self.__code_source_blocks_dict_origin.get(code)
|
|
def get_intersection_blocks_info(self, code, blocks, same_count=2):
|
# 获取交集
|
bs = []
|
b1 = BlockMapManager().filter_blocks(blocks)
|
if b1:
|
bs.append(b1)
|
sb_dict = self.__code_source_blocks_dict.get(code)
|
if sb_dict:
|
for s in sb_dict:
|
if sb_dict[s]:
|
bs.append(sb_dict[s])
|
if len(bs) < same_count:
|
return set(), bs
|
s_count = len(bs)
|
fblocks = set()
|
|
# 求2个平台的交集
|
for ces in combinations(bs, same_count):
|
ic = None
|
for c in ces:
|
if ic is None:
|
ic = set(c)
|
ic &= c
|
if ic:
|
fblocks |= ic
|
return fblocks, bs
|
|
def set_blocks(self, code, blocks, source_type):
|
"""
|
设置代码来源的板块
|
@param code:
|
@param blocks:
|
@param source_type:
|
@return:
|
"""
|
# 更新缓存数据
|
if code not in self.__code_source_blocks_dict:
|
self.__code_source_blocks_dict[code] = {}
|
if code not in self.__code_source_blocks_dict_origin:
|
self.__code_source_blocks_dict_origin[code] = {}
|
|
if blocks:
|
self.__code_source_blocks_dict[code][source_type] = BlockMapManager().filter_blocks(set(blocks))
|
self.__code_source_blocks_dict_origin[code][source_type] = set(blocks)
|
|
_id = f"{code}_{source_type}"
|
blocks = "、".join(blocks)
|
results = self.__mysql.select_one(f"select * from code_third_blocks where _id ='{_id}'")
|
if results:
|
# 更新数据
|
self.__mysql.execute(
|
f"update code_third_blocks set _blocks = '{blocks}', _update_time = now() where _id ='{_id}'")
|
else:
|
self.__mysql.execute(
|
"insert into code_third_blocks(_id, _code, _source, _blocks,_create_time) values('{}','{}',{},'{}',now())".format(
|
_id, code, source_type, blocks))
|
|
def list(self, code=None, source_type=None, max_update_time=None):
|
sql = f"select * from code_third_blocks where 1=1 "
|
if code:
|
sql += f" and _code = '{code}'"
|
if source_type is not None:
|
sql += f" and _source={source_type}"
|
|
if max_update_time:
|
sql += f" and (_update_time is null or _update_time<'{max_update_time}')"
|
|
return self.__mysql.select_all(sql)
|
|
def list_all_blocks(self, source_type):
|
sql = f"select _blocks from code_third_blocks where _source = '{source_type}'"
|
return self.__mysql.select_all(sql)
|
|
|
class BlockMapManager:
|
"""
|
板块映射管理
|
"""
|
__mysql = Mysqldb()
|
__instance = None
|
__block_map = {}
|
|
def __new__(cls, *args, **kwargs):
|
if not cls.__instance:
|
cls.__instance = super(BlockMapManager, cls).__new__(cls, *args, **kwargs)
|
cls.__load_data()
|
return cls.__instance
|
|
@classmethod
|
def __load_data(cls):
|
results = cls.__mysql.select_all("select origin_block,blocks from block_map")
|
cls.__block_map.clear()
|
for result in results:
|
cls.__block_map[result[0]] = set(result[1].split("、"))
|
|
def set_block_map(self, origin_block, blocks):
|
if not blocks:
|
blocks = {origin_block}
|
blocks_str = "、".join(blocks)
|
result = self.__mysql.select_one(f"select * from block_map where origin_block='{origin_block}'")
|
if result:
|
# 更新
|
self.__mysql.execute(
|
f"update block_map set blocks='{blocks_str}', update_time=now() where origin_block='{origin_block}'")
|
else:
|
self.__mysql.execute(
|
f"insert into block_map(origin_block, blocks, create_time) values('{origin_block}','{blocks_str}', now())")
|
|
def get_map_blocks_cache(self, block):
|
"""
|
获取映射好的板块
|
@param block:
|
@return:
|
"""
|
return self.__block_map.get(block)
|
|
def filter_blocks(self, blocks):
|
"""
|
批量过滤板块
|
@param blocks:
|
@return:
|
"""
|
if blocks is None or len(blocks) == 0:
|
return set()
|
fbs = set()
|
invalid_blocks = InvalidBlockManager().get_invalid_blocks()
|
for block in blocks:
|
if block.endswith("概念"):
|
block = block[:-2]
|
b = self.get_map_blocks_cache(block)
|
if b:
|
fbs |= b
|
if block in invalid_blocks:
|
continue
|
fbs.add(block)
|
return fbs
|
|
def get_all_blocks(self):
|
return self.__block_map.keys()
|
|
|
class InvalidBlockManager:
|
"""
|
无效板块管理
|
"""
|
__mysql = Mysqldb()
|
__instance = None
|
__block = set()
|
|
def __new__(cls, *args, **kwargs):
|
if not cls.__instance:
|
cls.__instance = super(InvalidBlockManager, cls).__new__(cls, *args, **kwargs)
|
cls.__load_data()
|
return cls.__instance
|
|
@classmethod
|
def __load_data(cls):
|
results = cls.__mysql.select_all("select _block from invalid_block")
|
cls.__block.clear()
|
for result in results:
|
if result[0]:
|
cls.__block.add(result[0])
|
|
def get_invalid_blocks(self):
|
"""
|
获取无效的板块
|
@return:
|
"""
|
return self.__block
|
|
def set_incalid_blocks(self, blocks):
|
"""
|
设置无效的板块
|
@param blocks:
|
@return:
|
"""
|
# 先删除所有，然后再添加
|
self.__mysql.execute("delete from invalid_block")
|
for b in blocks:
|
self.__mysql.execute(f"insert into invalid_block(_block) values('{b}')")
|
self.__block = set(blocks)
|
|
|
def load_if_less(codes):
|
"""
|
加载
|
@param codes:
|
@return:
|
"""
|
for code in codes:
|
source_blocks = CodeThirdBlocksManager().get_source_blocks_origin(code)
|
if source_blocks is None:
|
source_blocks = {}
|
all_source = {SOURCE_TYPE_EASTMONEY, SOURCE_TYPE_TDX, SOURCE_TYPE_THS}
|
sources = all_source - source_blocks.keys()
|
for source in sources:
|
try:
|
blocks = middle_api_protocol.request(middle_api_protocol.get_third_blocks(code, source))
|
if blocks:
|
CodeThirdBlocksManager().set_blocks(code, blocks, source)
|
except:
|
pass
|
|
|
def __add_invlaid_blocks():
|
blocks_str = """
|
昨日连板
|
昨日连板_含一字
|
昨日涨停
|
昨日涨停_含一字
|
"""
|
blocks = set()
|
for x in blocks_str.split("\n"):
|
if x.strip():
|
blocks.add(x.strip())
|
print(len(blocks))
|
InvalidBlockManager().set_incalid_blocks(blocks)
|
|
|
if __name__ == '__main__':
|
pass
|
