扫入参考代码板块优化

Administrator

2024-11-04 8ffb521f738254038d85bbade839b2e30456e525

扫入参考代码板块优化

 l2/l2_data_manager_new.py

@@ -483,7 +483,8 @@
            total_sell_volume = 0
            if current_sell and len(current_sell) > 2:
                total_sell_volume = current_sell[2]
            volume_rate = code_volumn_manager.CodeVolumeManager().get_volume_rate(code, total_sell_volume=total_sell_volume)
            volume_rate = code_volumn_manager.CodeVolumeManager().get_volume_rate(code,
                                                                                  total_sell_volume=total_sell_volume)
            volume_rate_index = code_volumn_manager.CodeVolumeManager().get_volume_rate_index(volume_rate)
            # 计算分值
            limit_up_time = cls.__LimitUpTimeManager.get_limit_up_time_cache(code)
@@ -733,8 +734,6 @@
                    code) and not gpcode_manager.GreenListCodeManager().is_in_cache(code):
                return False, True, f"只买想买：没在想买单和绿单", True



        return True, False, f"", False

    @classmethod
@@ -947,6 +946,33 @@
        return is_limit_up_buy

    @classmethod
    def __is_big_order_deal_enough(cls, code):
        """
        大单成交是否足够
        @param code:
        @param volume_rate:
        @return:
        """
        limit_up_price = gpcode_manager.get_limit_up_price_as_num(code)
        refer_volume = code_volumn_manager.CodeVolumeManager().get_max_volume_in_5days(code)
        if refer_volume is None:
            refer_volume = 0

        money_y = int(refer_volume * limit_up_price / 1e8)
        money_y = min(money_y, 50)
        money_y = max(money_y, 5)
        # 计算大单参考数量
        threshold_count = int(round(0.4 * money_y)) * 2
        threshold_money = threshold_count * 299 * 10000
        volume_rate_info = cls.volume_rate_info.get(code)

        deal_big_order_money = BigOrderDealManager().get_total_buy_money(code)
        if deal_big_order_money >= threshold_money:
            return True, f"量比-{volume_rate_info}, 总大单成交金额({deal_big_order_money})>={threshold_money}"
        else:
            return False, f"量比-{volume_rate_info}, 总大单成交金额({deal_big_order_money})<{threshold_money}"

    @classmethod
    def __can_buy_first(cls, code):
        """
        是否可以下单
@@ -1104,6 +1130,11 @@
                                                                                                          min_money=min_money)
                    if left_count < 1:
                        return False, False, f"没有已挂或者成交的大单", False

            big_deal_order_info = cls.__is_big_order_deal_enough(code)
            if not big_deal_order_info[0]:
                return False, False, big_deal_order_info[1], False

            place_order_count = trade_data_manager.PlaceOrderCountManager().get_place_order_count(code)
            # ------------------第一和第二次下单都必须要有至少一笔未成交的大单--------------------------
            # 计算大单

 servers/huaxin_trade_server.py

@@ -368,7 +368,7 @@
        for d in datas:
            if gpcode_manager.BuyOpenLimitUpCodeManager().is_in_cache(d[0]):
                # 09:19:50 到 09:20:00判断是否要撤单
                if int("09:19:50") <= tool.get_now_time_as_int() < int("09:20:00"):
                if int("091950") <= tool.get_now_time_as_int() < int("092000"):
                    async_log_util.info(logger_debug, f"排1撤单：{d}")
                    if d[8]*d[5] < 1e8:
                        code = d[0]

 third_data/code_plate_key_manager.py

@@ -293,12 +293,6 @@
    def get_today_limit_up_reason(cls, code):
        return cls.__today_total_limit_up_reason_dict.get(code)

    # 今日涨停原因变化
    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()
@@ -335,6 +329,8 @@
                if codes:
                    fresult[k] = codes
        return fresult




# 实时开盘啦市场数据
@@ -1110,7 +1106,7 @@

class RadicalBuyBlockManager:
    """
    激进买板块管理
    扫入买板块管理
    """
    __TargetCodePlateKeyManager = TargetCodePlateKeyManager()
    # 上次的涨停代码
@@ -1371,8 +1367,8 @@
            if RedicalBuyDataManager.can_buy(history_before_codes_info[0][0],
                                             DealAndDelegateWithBuyModeDataManager().get_deal_codes())[0]:
                return False, f"开1数量：{count}，前排代码可买：{history_before_codes_info[0]}"
            return True, f"开1数量：{count}，前排代码不可买：{history_before_codes_info[0]}"
        return True, f"开1数量：{count}，历史-{history_index + 1} 实时-{current_index + 1}"
            return True, f"开1数量：{count}，前排代码不可买：{history_before_codes_info[0]}，历史前排-{history_before_codes_info}"
        return True, f"开1数量：{count}，历史-{history_index + 1} 实时-{current_index + 1}， 前排代码-{current_before_codes_info}"

    @classmethod
    def __is_radical_buy_with_block_up(cls, code, block, yesterday_limit_up_codes):

 third_data/kpl_data_constant.py

@@ -1,9 +1,119 @@
# 当前涨停数据
import constant
from third_data import kpl_block_util
from db import redis_manager_delegate as redis_manager
from db.redis_manager_delegate import RedisUtils

# 用于计算激进买开1的板数：{"代码":(几版,{板块})}
from utils import tool
from utils.kpl_data_db_util import KPLLimitUpDataUtil

open_limit_up_code_dict_for_radical_buy = None


class LimitUpCodesBlockRecordManager:
    """
    历史涨停代码的板块管理
    """
    # 涨停原因
    __limit_up_reasons_dict = {}
    # 涨停推荐原因
    __limit_up_recommend_reasons_dict = {}

    __instance = None

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

    @classmethod
    def __load_data(cls):
        kpl_results = KPLLimitUpDataUtil.get_latest_block_infos()
        limit_up_reasons_dict = {}
        limit_up_recommend_block_dict = {}
        for r in kpl_results:
            code = r[0]
            if code not in limit_up_reasons_dict:
                limit_up_reasons_dict[code] = []
            if code not in limit_up_recommend_block_dict:
                limit_up_recommend_block_dict[code] = []
            if len(limit_up_reasons_dict[code]) >= 2:
                continue
            limit_up_reasons_dict[code].append(r[2])
            if r[3]:
                limit_up_recommend_block_dict[code].extend(r[3].split("、"))
        for code in limit_up_reasons_dict:
            cls.__limit_up_reasons_dict[code] = set(limit_up_reasons_dict[code])

        for code in limit_up_recommend_block_dict:
            cls.__limit_up_recommend_reasons_dict[code] = set(limit_up_recommend_block_dict[code])

    def get_limit_up_reasons(self, code):
        """
        获取涨停原因
        @param code:
        @return:
        """
        if code in self.__limit_up_reasons_dict:
            return set(self.__limit_up_reasons_dict[code])
        return set()

    def get_limit_up_reasons_with_recommend(self, code):
        """
        获取涨停原因与推荐原因
        @param code:
        @return:
        """
        blocks = set()
        if code in self.__limit_up_reasons_dict:
            blocks |= self.__limit_up_reasons_dict[code]
        if code in self.__limit_up_recommend_reasons_dict:
            blocks |= self.__limit_up_recommend_reasons_dict[code]
        return blocks


class TodayLimitUpReasonChangeManager:
    """
    今日涨停原因变化
    """
    # 涨停原因
    __today_change_reasons_dict = {}
    # 涨停
    __instance = None
    __db = 1
    __redisManager = redis_manager.RedisManager(1)

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

    @classmethod
    def __get_redis(cls):
        return cls.__redisManager.getRedis()

    @classmethod
    def __load_data(cls):
        keys = RedisUtils.keys(cls.__get_redis(), "kpl_limit_up_reason_his-*")
        if keys:
            for key in keys:
                code = key.split("-")[1]
                reasons = RedisUtils.smembers(cls.__get_redis(), key)
                cls.__today_change_reasons_dict[code] = reasons

    def set_today_limit_up_reason_change(self, code, from_reason, to_reason):
        if code not in self.__today_change_reasons_dict:
            self.__today_change_reasons_dict[code] = set()
        self.__today_change_reasons_dict[code].add(from_reason)
        RedisUtils.sadd_async(self.__db, f"kpl_limit_up_reason_his-{code}", from_reason)
        RedisUtils.expire_async(self.__db, f"kpl_limit_up_reason_his-{code}", tool.get_expire())

    def get_changed_reasons(self, code):
        if code in self.__today_change_reasons_dict:
            return self.__today_change_reasons_dict[code]
        return set()


class LimitUpDataConstant:
@@ -25,14 +135,22 @@
            return
        cls.history_limit_up_datas = history_limit_up_datas_
        for d in cls.history_limit_up_datas:
            # 参考原因：当前涨停原因+当日变化之前的原因+180天最近2条涨停原因
            code = d[3]
            blocks = {d[2]}
            history_reasons = LimitUpCodesBlockRecordManager().get_limit_up_reasons(code)
            if history_reasons:
                blocks |= history_reasons
            today_changed_reasons = TodayLimitUpReasonChangeManager().get_changed_reasons(code)
            if today_changed_reasons:
                blocks |= today_changed_reasons
            # 开1才能包含推荐原因
            if d[6] and kpl_block_util.open_limit_up_time_range[0] <= int(d[5]) < \
                    kpl_block_util.open_limit_up_time_range[1]:
                blocks |= set(d[6].split("、"))
            # if d[6] and kpl_block_util.open_limit_up_time_range[0] <= int(d[5]) < \
            #         kpl_block_util.open_limit_up_time_range[1]:
            #     blocks |= set(d[6].split("、"))
            blocks -= constant.KPL_INVALID_BLOCKS
            cls.__history_code_blocks_dict[d[3]] = blocks
            cls.__history_code_data_dict[d[3]] = d
            cls.__history_code_blocks_dict[code] = blocks
            cls.__history_code_data_dict[code] = d

    @classmethod
    def get_blocks_with_history(cls, code):

 third_data/kpl_data_manager.py

@@ -10,7 +10,7 @@
import constant
from db.redis_manager_delegate import RedisUtils
from log_module import async_log_util, log
from third_data.kpl_data_constant import LimitUpDataConstant
from third_data.kpl_data_constant import LimitUpDataConstant, TodayLimitUpReasonChangeManager
from utils import tool

# 开盘啦历史涨停数据管理
@@ -161,8 +161,7 @@
                        # 板块更改过
                        mysqldb.execute(
                            f"update kpl_limit_up_record set _hot_block_change = f'{dd[2]}' where _day='{dd[1]}' and _code='{code}'")

                        cls.__LimitUpCodesPlateKeyManager.set_today_limit_up_reason_change(code, dd[2],
                        TodayLimitUpReasonChangeManager().set_today_limit_up_reason_change(code, dd[2],
                                                                                           code_block_dict[code])

                        if dd[0] in cls.latest_datas:

 trade/radical_buy_strategy.py

@@ -188,16 +188,18 @@
    money_y = max(money_y, 5)
    # 计算大单参考数量
    threshold_count = int(round(0.4 * money_y))
    current_big_order_deal_count = EveryLimitupBigDealOrderManager.get_big_buy_deal_order_count(code)
    threshold_money = threshold_count * 299 * 10000

    if volume_rate >= 0.5 or True:
        # 按量大于50%算
        # 当换手量＞50%时，则，不需要每次扫入时需要≥2笔大单，而是累计需要≥2笔大单即可
        deal_big_order_count = BigOrderDealManager().get_total_buy_count(code)
        if deal_big_order_count >= threshold_count:
            return True, f"量比-{volume_rate}, 总大单成交数量({deal_big_order_count})>={threshold_count}"
        deal_big_order_money = BigOrderDealManager().get_total_buy_money(code)
        if deal_big_order_money >= threshold_money:
            return True, f"量比-{volume_rate}, 总大单成交金额({deal_big_order_money})>={threshold_money}"
        else:
            return False, f"量比-{volume_rate}, 总大单成交数量({deal_big_order_count})<{threshold_count}"
            return False, f"量比-{volume_rate}, 总大单成交金额({deal_big_order_money})<{threshold_money}"
    else:
        current_big_order_deal_count = EveryLimitupBigDealOrderManager.get_big_buy_deal_order_count(code)
        if current_big_order_deal_count >= threshold_count:
            return True, f"量比-{volume_rate}, 本次大单成交数量({current_big_order_deal_count})>={threshold_count}"
        else: