融入每日新增板块/深圳买入逻辑修改

Administrator

2025-01-23 6de59d6e4274ce9ae1ffb154c622da7c1b7144b1

融入每日新增板块/深圳买入逻辑修改

 servers/data_server.py

@@ -8,6 +8,7 @@
import dask
import requests

import constant
from code_attribute.gpcode_manager import BlackListCodeManager
from l2.huaxin import huaxin_target_codes_manager
from l2.l2_transaction_data_manager import HuaXinBuyOrderManager
@@ -924,22 +925,33 @@
                        deal_big_order_detail_info = None
                        try:
                            # 获取成交大单：(参考大单金额,已成交大单金额,大单要求金额, 已成交涨停买金额, 已成交涨停卖金额)
                            th_buy, is_temp = BeforeSubDealBigOrderManager().get_big_order_threshold_info(code)
                            th_temp_buy_info = BeforeSubDealBigOrderManager().get_temp_deal_big_order_threshold_info(
                                code)
                            th_buy, th_buy_default = BeforeSubDealBigOrderManager().get_big_order_threshold(code)
                            th_sell = BeforeSubDealBigOrderManager().get_big_sell_order_threshold(code)
                            deal_big_money_info = radical_buy_data_manager.get_total_deal_big_order_info(
                                code, gpcode_manager.get_limit_up_price_as_num(code))
                            # 大单成交信息
                            deal_big_order_info = [
                                (output_util.money_desc(th_buy), output_util.money_desc(th_sell)), output_util.money_desc(deal_big_money_info[1]),
                                (output_util.money_desc(th_temp_buy_info[0] if th_temp_buy_info else 0), # 临时买大单阈值
                                 output_util.money_desc(th_buy), # 买大单阈值
                                 output_util.money_desc(th_sell)
                                 ), # 卖单阈值
                                output_util.money_desc(deal_big_money_info[1]),
                                output_util.money_desc(deal_big_money_info[2])]
                            if len(codes) == 1:
                                # 加载大单详情
                                deal_big_order_detail_info = radical_buy_data_manager.get_l2_big_order_deal_info(code)
                                # 加载涨停大单详情
                                limit_up_big_order_detail = radical_buy_data_manager.get_total_detal_big_order_details(code)
                                deal_big_order_info.append(output_util.money_desc(limit_up_big_order_detail[0]+limit_up_big_order_detail[1]))
                                limit_up_big_order_detail = radical_buy_data_manager.get_total_detal_big_order_details(
                                    code)
                                deal_big_order_info.append(
                                    output_util.money_desc(limit_up_big_order_detail[0] + limit_up_big_order_detail[1]))
                                deal_big_order_info.append(
                                    output_util.money_desc(limit_up_big_order_detail[2] + limit_up_big_order_detail[3]))
                                deal_big_order_info.append(
                                    radical_buy_data_manager.TotalDealBigOrderInfoManager().get_big_order_rate(code))

                        except Exception as e:
                            logger_debug.error(f"可能没有获取到涨停价：{code}")
                            logger_debug.exception(e)
@@ -947,7 +959,7 @@
                        code_name = gpcode_manager.get_code_name(code)
                        fresults.append((code, code_name, deal_big_order_info, deal_big_order_detail_info))
                response_data = json.dumps({"code": 0, "data": fresults})
            except  Exception as e:
            except Exception as e:
                response_data = json.dumps({"code": 1, "data": str(1)})

        elif url.path == "/get_all_special_codes":
@@ -1060,6 +1072,26 @@
                    except:
                        pass

                    try:
                        records = KPLLimitUpDataRecordManager.total_datas

                        # 计算今日新增的题材概念
                        block_codes = {}
                        for x in records:
                            b = kpl_util.filter_block(x[2])
                            if b not in block_codes:
                                block_codes[b] = set()
                            block_codes[b].add(x[3])
                        reasons = set(block_codes.keys())
                        reasons -= constant.KPL_INVALID_BLOCKS
                        reasons -= LimitUpCodesBlockRecordManager().get_total_before_blocks()
                        if reasons:
                            for r in reasons:
                                for c in block_codes[r]:
                                    LimitUpCodesBlockRecordManager().add_new_blocks(c, r)
                    except:
                        pass

                    self.__kplDataManager.save_data(type_, result_list_)
            except Exception as e:
                logger_debug.exception(e)

 third_data/kpl_data_constant.py

@@ -2,6 +2,8 @@
import constant
from db import redis_manager_delegate as redis_manager
from db.redis_manager_delegate import RedisUtils
from log_module import async_log_util
from log_module.log import logger_debug
from third_data import kpl_util
from third_data.third_blocks_manager import BlockMapManager

@@ -68,6 +70,12 @@
    # 原始数据
    __radical_buy_reasons_origin_data_dict = {}

    # 所有的涨停原因
    __all_limit_up_reasons = set()

    # 今日的新概念
    __new_blocks = set()

    __instance = None

    __day = tool.get_now_date_str()
@@ -83,6 +91,7 @@
        limit_up_reasons_dict = {}
        limit_up_recommend_block_dict = {}
        for r in kpl_results:
            cls.__all_limit_up_reasons.add(kpl_util.filter_block(r[2]))
            code = r[0]
            if code not in limit_up_reasons_dict:
                limit_up_reasons_dict[code] = []
@@ -190,6 +199,39 @@
            return set(self.__radical_buy_reasons_dict.get(code))
        return None

    def add_new_blocks(self, code, block):
        """
        添加新题材的板块
        @param code:
        @param block:
        @return:
        """
        if block in constant.KPL_INVALID_BLOCKS:
            return
        old_blocks = self.__radical_buy_reasons_dict.get(code)
        if old_blocks is None:
            old_blocks = set()
        if block in old_blocks:
            return
        self.__new_blocks.add(block)
        old_blocks.add(block)
        async_log_util.info(logger_debug, f"今日新增概念：{code} - {block}")
        self.__radical_buy_reasons_dict[code] = old_blocks

    def get_total_before_blocks(self):
        """
        获取所有之前的板块
        @return:
        """
        return self.__all_limit_up_reasons

    def get_new_blocks(self):
        """
        获取新概念
        @return:
        """
        return self.__new_blocks


class TodayLimitUpReasonChangeManager:
    """

 trade/buy_radical/block_special_codes_manager.py

@@ -3,6 +3,7 @@
"""
import constant
from db import mysql_data_delegate as mysql_data
from third_data import kpl_util
from third_data.history_k_data_util import HistoryKDatasUtils
from utils import tool

@@ -149,7 +150,7 @@
        limit_up_info_map = self.__get_limit_up_info(min_day)
        fdatas = []
        for b in block_codes_dict:
            # if b != '人工智能':
            # if b != '机器人':
            #     continue

            if b in constant.KPL_INVALID_BLOCKS:
@@ -194,7 +195,7 @@
                    continue
                # [(板块, 代码名称, 代码, 涨停次数, 自由市值)]
                fdatas.append(
                    (b, limit_up_info_map[code][1], code, code_block_dict[code][b],
                    (kpl_util.filter_block(b), limit_up_info_map[code][1], code, code_block_dict[code][b],
                     int(float(limit_up_info_map[code][2]))))
                if index >= 10:
                    break
@@ -212,4 +213,5 @@

if __name__ == "__main__":
    # print(datas)
    print(BlockSpecialCodesManager().get_code_blocks("002582"))
    datas = AnalysisBlockSpecialCodesManager().get_block_special_codes()
    # print(BlockSpecialCodesManager().get_code_blocks("002582"))

 trade/buy_radical/radical_buy_data_manager.py

@@ -48,7 +48,7 @@
    # 已经成交的累计大卖单金额：用于初次上板尚未订阅的情况
    __already_total_sell_deal_big_order_money = {}
    __redis_manager = redis_manager.RedisManager(3)
    # 临时大单阈值，初次上板使用
    # 临时大单阈值，初次上板使用: {"代码":(金额,更新时间)}
    __temp_big_order_threshold = {}

    def __init__(self):
@@ -197,10 +197,12 @@
        if not is_first_limit_up_buy(code):
            return self.get_big_order_threshold(code)[0], False
        else:
            money = self.get_temp_deal_big_order_threshold(code)
            if not money:
            money_info = self.get_temp_deal_big_order_threshold_info(code)
            if not money_info or money_info[1] < time.time():
                # 默认阈值为 1个亿
                money = int(round(1e8))
            else:
                money = money_info[0]
            return money, True

    def __get_base_big_order_threshold(self, code):
@@ -273,13 +275,17 @@
        @param money_info_list: 成交的大买单:[(订单号，总股数，成交金额,成交开始时间,成交结束时间, 最近的成交价格, 最近的卖单号, 涨停价成交金额)]
        @return:
        """
        if code in self.__temp_big_order_threshold:
        if code in self.__temp_big_order_threshold and time.time() < self.__temp_big_order_threshold[code][1]:
            return
        if not money_info_list or len(money_info_list) < 2:
            return
        fmoney_list = []
        min_money = l2_data_util.get_big_money_val(gpcode_manager.get_limit_up_price_as_num(code), tool.is_ge_code(code))
        min_money = l2_data_util.get_big_money_val(gpcode_manager.get_limit_up_price_as_num(code),
                                                   tool.is_ge_code(code))
        for info in money_info_list:
            # 要求是10s之内成交的
            if tool.trade_time_sub(tool.get_now_time_str(), l2_huaxin_util.convert_time(info[3])) > 10:
                continue
            if info[7] >= min_money:
                # 涨停价成交部分是大单
                fmoney_list.append((info[7], info[0]))
@@ -287,12 +293,13 @@
            return
        money_list = [x[0] for x in fmoney_list]
        # 计算大单: 前2个大单的均值
        self.__temp_big_order_threshold[code] = int(sum(money_list[:2]) // 2)
        self.__temp_big_order_threshold[code] = (int(sum(money_list[:2]) // 2), time.time()+10)
        async_log_util.info(logger_l2_radical_buy_data,
                            f"首次上板临时买大单：{code}-{self.__temp_big_order_threshold[code]}-{fmoney_list[:2]}")

    def get_temp_deal_big_order_threshold(self, code):
        return self.__temp_big_order_threshold.get(code)
    def get_temp_deal_big_order_threshold_info(self, code):
        data = self.__temp_big_order_threshold.get(code)
        return data


@tool.singleton
@@ -1191,25 +1198,6 @@
        @param code:
        @return: 过滤后的板块,过滤前的板块
        """
        # blocks = cls.get_code_kpl_blocks(code)
        # match_blocks, info = CodeThirdBlocksManager().get_intersection_blocks_info(code, blocks)
        # match_blocks -= constant.KPL_INVALID_BLOCKS
        # fblocks = match_blocks & RealTimeKplMarketData.get_top_market_jingxuan_blocks()
        # if not fblocks:
        #     fblocks = set()
        # match_blocks_3, info = CodeThirdBlocksManager().get_intersection_blocks_info(code, blocks, same_count=3)
        # if match_blocks_3:
        #     match_blocks_3 -= constant.KPL_INVALID_BLOCKS
        #     fblocks |= match_blocks_3
        # # 获取开盘啦历史涨停原因
        # kpl_history_blocks = CodesHisReasonAndBlocksManager().get_history_blocks_cache(code)
        # if kpl_history_blocks:
        #     fblocks |= BlockMapManager().filter_blocks(kpl_history_blocks)
        # jx_out_blocks = RealTimeKplMarketData.get_top_market_jingxuan_out_blocks()
        # if jx_out_blocks:
        #     fblocks -= jx_out_blocks
        #
        # return fblocks, match_blocks

        # 新版本
        before_fblocks = LimitUpCodesBlockRecordManager().get_radical_buy_blocks(code)
@@ -1234,6 +1222,11 @@
        jx_in_blocks = RealTimeKplMarketData.get_top_market_jingxuan_blocks()
        if jx_in_blocks and block in jx_in_blocks:
            return True, False

        if block in LimitUpCodesBlockRecordManager().get_new_blocks():
            # 今日新板块不考虑净流入
            return True, False

        # 获取当前板块涨停数量
        codes = LimitUpDataConstant.get_current_limit_up_block_codes(block)
        if codes and len(codes) >= 5:
@@ -1481,7 +1474,7 @@
            cls.__l2_big_order_deal_info_dict[code] = (deal_big_order_detail_info, tool.get_now_time_str())
            if total_trade_value == 0:
                total_trade_value = 1
            cls.__l2_big_order_deal_rate_dict[code] = round(deal_big_order_detail_info[1][0]/total_trade_value, 2)
            cls.__l2_big_order_deal_rate_dict[code] = round(deal_big_order_detail_info[1][0] / total_trade_value, 2)

    @classmethod
    def get_big_order_info(cls, code):
@@ -1491,7 +1484,6 @@
        """
        return cls.__l2_big_order_deal_info_dict.get(code)


    @classmethod
    def get_big_order_rate(cls, code):
        """
@@ -1500,8 +1492,6 @@
        @return:
        """
        return cls.__l2_big_order_deal_rate_dict.get(code)




def get_total_detal_big_order_details(code):
@@ -1833,6 +1823,7 @@
        return datas
    return None


def is_first_limit_up_buy(code):
    """
    是否是首封下单: （下单次数为0+没在涨停代码中） 或者 （处于下单状态 + 下单次数为1，且下单为首次下单）

 trade/buy_radical/radical_buy_strategy.py

@@ -152,31 +152,48 @@
    selling_num = L2LimitUpSellDataManager.get_delegating_sell_num(code)
    if selling_num is None:
        selling_num = 0
    # 总卖 = 涨停主动买成交的累计金额 + 处于委托状态的涨停卖金额
    total_sell = __deal_active_buy_total_money[code] + selling_num * price
    if total_sell == 0:
        total_sell = 1
    rate = round(__deal_active_buy_total_money[code] / total_sell, 2)
    # 获取当前的成交量比
    limit_up_price = gpcode_manager.get_limit_up_price_as_num(code)
    volume_rate = code_volumn_manager.CodeVolumeManager().get_volume_rate_refer_in_5days(code,
                                                                                         total_sell_volume=int(
                                                                                             total_sell / limit_up_price))
    if volume_rate is None:
        volume_rate = 0.5
    # 剩余涨停卖金额
    left_limit_up_sell_money = selling_num * price

    THRESHOLD_RATE = radical_buy_data_manager.get_volume_rate_threshold(code, volume_rate)
    if rate >= THRESHOLD_RATE:
        # 根据大单判断是否可以扫
        big_order_deal_result = radical_buy_data_manager.is_big_order_deal_enough(code, volume_rate,
                                                                                  refer_sell_money, for_buy=True)
        if big_order_deal_result[0]:
            return BUY_MODE_DIRECT, f"剩余涨停总卖额-{selling_num * price}，原涨停总卖-{total_sell}，已成交额-{__deal_active_buy_total_money[code]}，成交比例-{rate}/{THRESHOLD_RATE}, 大单信息-{big_order_deal_result}"
        else:
            # 无大单成交就只能通过L2下单
            return BUY_MODE_BY_L2, f"无大单成交-{big_order_deal_result}，原涨停总卖-{total_sell}，已成交额-{__deal_active_buy_total_money[code]}，成交比例-{rate}/{THRESHOLD_RATE} "
    # 如果剩余总卖小于100w直接根据L2买入
    if left_limit_up_sell_money < 100e4:
        return BUY_MODE_BY_L2, f"剩余总卖小于100w({left_limit_up_sell_money})"

    big_order_count = radical_buy_data_manager.EveryLimitupBigDealOrderManager().get_big_buy_deal_order_count(code)
    big_order_money = radical_buy_data_manager.EveryLimitupBigDealOrderManager().get_big_buy_deal_order_money(code)
    if big_order_count >= 2:
        average_big_order_money = int(big_order_money / big_order_count)
        if average_big_order_money > left_limit_up_sell_money:
            # 剩余总卖小于均大单才能下单
            return BUY_MODE_DIRECT, f"剩余涨停总卖额-{left_limit_up_sell_money}，均大单-{average_big_order_money}"
    else:
        return BUY_MODE_NONE, f"被动卖成交比例未达到：剩余涨停总卖额-{selling_num * price}，原涨停总卖-{total_sell}，已成交额-{__deal_active_buy_total_money[code]}，成交比例-{rate}/{THRESHOLD_RATE}"
        average_big_order_money = 0
    return BUY_MODE_NONE, f"均大单-{average_big_order_money}（{big_order_money}/{big_order_count}），剩余涨停卖：{left_limit_up_sell_money}"
    # #总卖 = 涨停主动买成交的累计金额 + 处于委托状态的涨停卖金额
    # total_sell = __deal_active_buy_total_money[code] + left_limit_up_sell_money
    # if total_sell == 0:
    #     total_sell = 1
    # rate = round(__deal_active_buy_total_money[code] / total_sell, 2)
    # # 获取当前的成交量比
    # limit_up_price = gpcode_manager.get_limit_up_price_as_num(code)
    # volume_rate = code_volumn_manager.CodeVolumeManager().get_volume_rate_refer_in_5days(code,
    #                                                                                      total_sell_volume=int(
    #                                                                                          total_sell / limit_up_price))
    # if volume_rate is None:
    #     volume_rate = 0.5
    #
    # THRESHOLD_RATE = radical_buy_data_manager.get_volume_rate_threshold(code, volume_rate)
    # if rate >= THRESHOLD_RATE:
    #     # 根据大单判断是否可以扫
    #     big_order_deal_result = radical_buy_data_manager.is_big_order_deal_enough(code, volume_rate,
    #                                                                               refer_sell_money, for_buy=True)
    #     if big_order_deal_result[0]:
    #         return BUY_MODE_DIRECT, f"剩余涨停总卖额-{selling_num * price}，原涨停总卖-{total_sell}，已成交额-{__deal_active_buy_total_money[code]}，成交比例-{rate}/{THRESHOLD_RATE}, 大单信息-{big_order_deal_result}"
    #     else:
    #         # 无大单成交就只能通过L2下单
    #         return BUY_MODE_BY_L2, f"无大单成交-{big_order_deal_result}，原涨停总卖-{total_sell}，已成交额-{__deal_active_buy_total_money[code]}，成交比例-{rate}/{THRESHOLD_RATE} "
    # else:
    #     return BUY_MODE_NONE, f"被动卖成交比例未达到：剩余涨停总卖额-{selling_num * price}，原涨停总卖-{total_sell}，已成交额-{__deal_active_buy_total_money[code]}，成交比例-{rate}/{THRESHOLD_RATE}"


def is_can_buy_with_open_price(code, open_price):