bug修复

Administrator

2024-09-30 99684540b2c6d05ebb3b21163da0a5e314a07052

bug修复

 inited_data.py

@@ -32,6 +32,7 @@
from log_module.log import logger_juejin_tick, logger_system
from trade.trade_data_manager import CodeActualPriceProcessor, PlaceOrderCountManager, AccountMoneyManager
from trade.trade_queue_manager import JueJinBuy1VolumnManager
from utils.ths_industry_util import ThsCodeIndustryManager

redisManager = redis_manager.RedisManager(0)
__jueJinBuy1VolumnManager = JueJinBuy1VolumnManager()
@@ -76,6 +77,8 @@
    # 初始化载入
    AutoCancelSellModeManager()

    ThsCodeIndustryManager()

    # 9点25之前删除所有代码
    if tool.trade_time_sub(tool.get_now_time_str(), "09:25:00") <= 0:
        # 删除L2监听代码

 servers/huaxin_trade_server.py

@@ -779,8 +779,8 @@
            # 判断昨日是否涨停过
            async_log_util.info(logger_l2_radical_buy, f"涨停主动买：{code}-{transaction_datas[-1]}")
            deal_codes = RadicalBuyDealCodesManager().get_deal_codes()
            if len(deal_codes) >= 2:
                async_log_util.info(logger_l2_radical_buy, f"成交代码个数大于2个：{code}-{deal_codes}")
            if len(deal_codes) >= 4:
                async_log_util.info(logger_l2_radical_buy, f"扫入成交代码个数大于4个：{code}-{deal_codes}")
                return
            if code in deal_codes:
                async_log_util.info(logger_l2_radical_buy, f"该代码已经成交：{code}")

 third_data/code_plate_key_manager.py

@@ -1349,8 +1349,8 @@
    def __is_radical_buy_with_block_up(cls, code, block, yesterday_limit_up_codes):
        """
        是否激进买（板块突然涨起来）
        1.老大和老二的涨停时间相差5分钟内
        2.老三的涨停时间距离老大涨停在10分钟内就买
        1.老二和老三的涨停时间相差5分钟内
        2.老三不能买顺位到老四（老四与老三相差10分钟内）
        3.前2个票不能炸板（历史身位与现在身位一致）
        4.除开前两个代码可买老1与老2
        5.买老2的情况：老1不满足买入条件
@@ -1367,47 +1367,100 @@
        if len(current_before_codes_info) < 2:
            return False, f"前排代码小于2个：{current_before_codes_info}"


        # 老大，老二必须相隔5分钟内
        # if current_before_codes_info[1][1] - current_before_codes_info[0][1] >= 5 * 60:
        #     return False, f"老大老二涨停时间必须间隔5分钟内"

        # 获取当前代码的涨停时间
        limit_up_timestamp = LimitUpDataConstant.get_first_limit_up_time(code)
        if not limit_up_timestamp:
            limit_up_timestamp = time.time()
        if limit_up_timestamp - current_before_codes_info[0][1] >= 15 * 60:
            return False, f"距离老大涨停已过去15分钟（{current_before_codes_info[0]}）"

        # 当前代码开1不能买
        if limit_up_timestamp < kpl_block_util.open_limit_up_time_range[1]:
            return False, f"当前代码开1"

        if tool.trade_time_sub(tool.timestamp_format(limit_up_timestamp, '%H:%M:%S'),
                               tool.timestamp_format(current_before_codes_info[-1][1], '%H:%M:%S')) >= 10 * 60:
            return False, f"距离上个代码涨停已过去10分钟（{current_before_codes_info[0]}）"

        history_index, history_before_codes_info = cls.__get_history_index(code, block, set())
        history_before_codes = [x[0] for x in history_before_codes_info]

        # 判断是否是老3且与老二间隔5分钟以内
        if current_index == 2 and history_index == 2:
            if limit_up_timestamp - current_before_codes_info[-1][1] <= 5 * 60:
                if RedicalBuyDataManager.can_buy(code)[0]:
                    return True, f"老二老三间隔5分钟内：前排代码-{current_before_codes_info}"

        if current_before_codes_info[0][1] < kpl_block_util.open_limit_up_time_range[1]:
            return False, f"有开1：{current_before_codes_info}"

        # 前两个代码是否有炸板
        dif_codes = set(history_before_codes[:2]) - set(current_before_codes[:2])
        if dif_codes:
            return False, f"前2代码有炸板：{dif_codes}"
        # 不计算前2的代码
        exclude_codes = set(current_before_codes[:2])

        exclude_codes = set()
        for x in current_before_codes:
            if x[1] < kpl_block_util.open_limit_up_time_range[1]:
                exclude_codes.add(x[0])
        # 除去前二代码与开1代码之后是否为首板老大：所有开1的视为1个
        open_count = len(exclude_codes)
        if open_count > 0 and open_count + 1 <= len(current_before_codes):
            # 前排有开1
            exclude_codes |= set(current_before_codes[open_count:open_count + 1])
        else:
            exclude_codes |= set(current_before_codes[:2])

        open_limit_up_code_dict = kpl_data_constant.open_limit_up_code_dict_for_radical_buy
        if open_limit_up_code_dict:
            exclude_codes |= set(open_limit_up_code_dict.keys())
        history_index, history_before_codes_info = cls.__get_history_index(code, block, yesterday_limit_up_codes,
                                                                           exclude_codes)
        if history_index > 1:
            return False, f"排除前2，目标代码位于历史身位-{history_index + 1}，前排代码：{history_before_codes_info}"
        if history_index == 1:
        elif history_index == 1:
            # 首板老2，判断前面的老大是否是属于不能买的范畴
            pre_code = history_before_codes_info[0][0]
            # pre_code不能买，才能买
            if RedicalBuyDataManager.can_buy(pre_code)[0]:
                return False, f"前排代码可买：{pre_code}"
            # 距离前一个是否在10分钟内
            if tool.trade_time_sub(tool.timestamp_format(limit_up_timestamp, '%H:%M:%S'),
                                   tool.timestamp_format(history_before_codes_info[-1][1], '%H:%M:%S')) >= 10 * 60:
                return False, f"距离上个不能买的代码涨停已过去10分钟（{history_before_codes_info[0]}）"
        else:
            # 距离上个代码涨停5分钟以内
            if tool.trade_time_sub(tool.timestamp_format(limit_up_timestamp, '%H:%M:%S'),
                                   tool.timestamp_format(current_before_codes_info[-1][1], '%H:%M:%S')) >= 5 * 60:
                return False, f"距离上个代码涨停已过去5分钟（{current_before_codes_info[-1]}）"

        return True, f"满足买入需求: 前排代码-{current_before_codes_info}"

    @classmethod
    def __is_re_limit_up(cls, code, block):
        # 获取身位
        current_index, current_before_codes_info = cls.__get_current_index(code, block, set())
        history_index, history_before_codes_info = cls.__get_history_index(code, block, set())
        if current_index != history_index:
            return False, f"有其他炸板"
        if current_index > 1:
            return False, f"不是前2的板块"
        history_codes = set()
        # 获取板块炸板情况
        for k in LimitUpDataConstant.history_limit_up_datas:
            _code = k[3]
            blocks = LimitUpDataConstant.get_blocks_with_history(_code)
            blocks = BlockMapManager().filter_blocks(blocks)
            # 不是这个板块
            if block in blocks:
                history_codes.add(_code)
        if len(history_codes) <= 4:
            return False, f"板块历史涨停小于4个：{history_codes}"
        # 获取当前涨停数量
        current_codes = set()
        for k in LimitUpDataConstant.current_limit_up_datas:
            _code = k[0]
            blocks = LimitUpDataConstant.get_blocks_with_history(_code)
            if not blocks:
                blocks = set()
            blocks = BlockMapManager().filter_blocks(blocks)
            # 不是这个板块
            if block in blocks:
                current_codes.add(_code)
        current_codes.add(code)
        diff = history_codes - current_codes
        if diff:
            return False, f"板块炸板不止当前票：{diff}"
        return True, ""

    @classmethod
    def is_radical_buy(cls, code, yesterday_limit_up_codes):
@@ -1455,6 +1508,13 @@
                    can_buy_blocks.add(b)
                msges.append(f"【{b}】:{result[1]}")
            fmsges.append("板块快速启动判断##" + ",".join(msges))

        if not can_buy_blocks:
            for b in keys_:
                result = cls.__is_re_limit_up(code, b)
                if result[0]:
                    can_buy_blocks.add(b)

        return can_buy_blocks, " **** ".join(fmsges)



 third_data/third_blocks_manager.py

@@ -5,6 +5,7 @@

from db.mysql_data_delegate import Mysqldb
from utils import middle_api_protocol
from utils.ths_industry_util import ThsCodeIndustryManager

SOURCE_TYPE_KPL = 1  # 东方财富
SOURCE_TYPE_TDX = 2  # 通达信
@@ -21,6 +22,7 @@
    # 代码板块：{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:
@@ -37,6 +39,11 @@
                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:
                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)

@@ -94,6 +101,9 @@
        # 更新缓存数据
        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)

 utils/ths_industry_util.py

@@ -6,10 +6,35 @@
import time

from code_attribute import global_data_loader
from db.mysql_data_delegate import Mysqldb
from utils import global_util, tool
from db import mysql_data_delegate as mysql_data


# 获取行业映射

class ThsCodeIndustryManager:
    __instance = None
    __mysql = Mysqldb()
    __code_industry = {}

    def __new__(cls, *args, **kwargs):
        if not cls.__instance:
            cls.__instance = super(ThsCodeIndustryManager, cls).__new__(cls, *args, **kwargs)
            cls.__load_data()
        return cls.__instance

    @classmethod
    def __load_data(cls):
        results = cls.__mysql.select_all("select _id,second_industry from ths_industry_codes")
        if results:
            for r in results:
                code = r[0]
                industry = r[1]
                cls.__code_industry[code] = industry

    def get_industry(self, code):
        return self.__code_industry.get(code)


def get_code_industry_maps():
@@ -122,7 +147,7 @@
        else:
            mysqldb.execute(
                "update ths_industry_codes set second_industry='{}',zyltgb='{}',zyltgb_unit={} where _id='{}'".format(
                     industry_name, zyltgb, zyltgb_unit, code))
                    industry_name, zyltgb, zyltgb_unit, code))


# 保存行业代码
@@ -135,6 +160,10 @@
            # 保存
            code = data["code"]
            __save_code_industry(code, code_names.get(code), industry_name, data["zyltgb"], data["zyltgb_unit"])


def save_code_industry(code, code_name, industry):
    __save_code_industry(code, code_name, industry, 0, 0)


# 根据名称获取代码
@@ -155,6 +184,7 @@
    else:
        return None


if __name__ == "__main__":
    _code_map, _industry_map = get_code_industry_maps()
    print(_code_map, _industry_map)