买入策略修改

Administrator

2024-11-18 dd76d8dc94da81299d796b5b90ae54c072454e86

买入策略修改

 constant.py

@@ -108,7 +108,8 @@
BUY_SCORE_RANK_3 = 260

# 开盘啦
KPL_INVALID_BLOCKS = {"一季报增长", "二季报增长", "三季报增长", "四季报增长", "业绩增长", "中报增长", "年报增长", "年报预增", "无", "次新股", "ST摘帽", "ST板块", "超跌",
KPL_INVALID_BLOCKS = {"一季报增长", "二季报增长", "三季报增长", "四季报增长", "业绩增长", "中报增长", "年报增长", "年报预增", "无", "次新股", "ST摘帽", "ST板块",
                      "超跌",
                      "股权转让", "并购重组", "再融资", "年报预增", " 专精特新", "壳资源", "行业龙头", "科创板", "实控人变更"}
# 是否开启API交易
API_TRADE_ENABLE = True
@@ -206,3 +207,9 @@

# 可买入的金额
AVAILABLE_BUY_MONEYS = [5000, 20000, 30000, 40000, 50000]

# 板上放量是否可扫入
CAN_RADICAL_BUY_AT_LIMIT_UP = False

# 每次扫入是否都需要大单
CAN_RADICAL_BUY_NEED_BIG_ORDER_EVERYTIME = True

 l2/l2_data_manager_new.py

@@ -17,6 +17,7 @@
from l2.place_order_single_data_manager import L2TradeSingleDataProcessor
from log_module import async_log_util, log_export
from third_data import kpl_data_manager, block_info
from trade.buy_radical.radical_buy_data_manager import EveryLimitupBigDealOrderManager
from utils import global_util, tool, buy_condition_util, buy_strategy_util, trade_util
import l2_data_util
from db import redis_manager_delegate as redis_manager
@@ -2030,11 +2031,28 @@
            bigger_money = l2_data_util.get_big_money_val(limit_up_price, tool.is_ge_code(code))
            min_num = int(bigger_money / limit_up_price / 100)
            # 如果有大单成交就不需要看大单
            total_deal_money = BigOrderDealManager().get_total_buy_money(code)

            if constant.CAN_RADICAL_BUY_NEED_BIG_ORDER_EVERYTIME:
                # 每次下单都需要大单
                total_deal_money = EveryLimitupBigDealOrderManager.get_big_buy_deal_order_money(code)
            else:
                # 只需要总成交的大单
                total_deal_money = BigOrderDealManager().get_total_buy_money(code)
            refer_sell_data = L2MarketSellManager().get_refer_sell_data(code, radical_data[3])
            # 参考总卖额
            refer_sell_money = 0
            if refer_sell_data:
                refer_sell_money = refer_sell_data[1]
            THRESHOLD_MONEY = 2990000
            if total_deal_money >= THRESHOLD_MONEY:
            if refer_sell_money >= 1e7:
                THRESHOLD_MONEY = 2990000 * 2
            else:
                THRESHOLD_MONEY = 2990000
            if  total_deal_money >= THRESHOLD_MONEY:
                min_num = int(5000 / limit_up_price)

            # 总委托大单金额
            total_delegating_big_money = 0
            single_index = None
            for i in range(start_index, end_index + 1):
                data = total_datas[i]
@@ -2050,17 +2068,17 @@
                        # 判断是否为大单
                        order_money = dealing_active_order_info[2] + round(val["price"], 2) * val["num"] * 100
                        if order_money >= bigger_money:
                            total_deal_money += order_money
                if total_deal_money >= THRESHOLD_MONEY:
                    single_index = i
                    break
                            total_delegating_big_money += order_money
                            if total_delegating_big_money + total_deal_money >= THRESHOLD_MONEY:
                                single_index = i
                                break

                if int(val["orderNo"]) <= radical_data[1]:
                    # 主动买单后的数据不算
                    continue

                total_deal_money += round(val["price"], 2) * val["num"] * 100
                if total_deal_money >= THRESHOLD_MONEY:
                total_delegating_big_money += round(val["price"], 2) * val["num"] * 100
                if total_delegating_big_money + total_deal_money >= THRESHOLD_MONEY:
                    single_index = i
                    break
            if single_index is not None:
@@ -2074,14 +2092,22 @@

        if not radical_data:
            return False, None, "不满足激进买的条件"
        if t.time() > radical_data[0] and not is_radical_buy:
            # 没扫入过才需要判断时间
            return False, None, "超过生效时间"

        if constant.CAN_RADICAL_BUY_AT_LIMIT_UP:
            # 板上放量可扫入
            if t.time() > radical_data[0] and not is_radical_buy:
                # 没扫入过才需要判断时间
                return False, None, "超过生效时间"
        else:
            # 板上放量不可扫入
            if t.time() > radical_data[0]:
                return False, None, "超过生效时间"

        result = __can_order()
        l2_log.debug(code, f"L2扫入判断：{result}")
        if result[0]:
            # 已经扫入下过单的就需要判断板上放量的距离
            if is_radical_buy:
            # 已经扫入下过单且允许板上放量扫入的就需要判断板上放量的距离
            if is_radical_buy and constant.CAN_RADICAL_BUY_AT_LIMIT_UP:
                is_limit_up_buy = cls.__is_at_limit_up_buy(code)
                if is_limit_up_buy:
                    # 判断成交进度到当前数据的笔数，如果少于10笔且还有未成交的大单（>=299）就可以下单
@@ -2098,6 +2124,9 @@
                                                                                       deal_codes)
                        if not buy_blocks:
                            return False, result[1], f"板块代码已有成交：{radical_data[2]}"
            # 如果板上放量不可买入就需要删除信号
            if not constant.CAN_RADICAL_BUY_AT_LIMIT_UP and code in RadicalBuyDealCodesManager.buy_by_l2_delegate_expire_time_dict:
                RadicalBuyDealCodesManager.buy_by_l2_delegate_expire_time_dict.pop(code)
            return True, result[1], radical_data[2]
        return result


 l2/l2_transaction_data_processor.py

@@ -55,7 +55,7 @@
        buy_datas, bigger_buy_datas = HuaXinBuyOrderManager.statistic_big_buy_data(code, datas, limit_up_price)
        if buy_datas:
            BigOrderDealManager().add_buy_datas(code, buy_datas)
            EveryLimitupBigDealOrderManager.add_big_buy_order_deal(code, [x[0] for x in buy_datas])
            EveryLimitupBigDealOrderManager.add_big_buy_order_deal(code, [(x[0], x[2]) for x in buy_datas])
        try:
            is_placed_order = l2_data_manager.TradePointManager.is_placed_order(order_begin_pos)
            if is_placed_order:

 servers/huaxin_trade_server.py

@@ -930,9 +930,10 @@
                            if buy_result:
                                # 下单成功
                                radical_buy_data_manager.BlockPlaceOrderRecordManager().add_record(code, buy_blocks)
                                radical_buy_strategy.clear_latest_deal_active_buy_order(code)
                        else:
                            RadicalBuyDealCodesManager.buy_by_l2_delegate_expire_time_dict[code] = (
                                time.time() + 30, transaction_datas[-1][6], buy_blocks)
                                time.time() + 30, transaction_datas[-1][6], buy_blocks, l2_huaxin_util.convert_time(transaction_datas[-1][3]))
                    else:
                        async_log_util.info(logger_l2_radical_buy, f"不能下单：{code}-{result_by_volume}")
                else:

 third_data/kpl_api.py

@@ -276,18 +276,18 @@
    return None


if __name__ == "__main__":
    # print(getLimitUpInfoNew())
def getZLJECodesRank(index):
    """
    获取主力金额的排行
    @return:
    """
    data = f"Order=1&a=RealRankingInfo_W8&st=50&c=NewStockRanking&PhoneOSNew=1&RStart=0925&DeviceID=d6f20ce9-fa08-31c9-a493-536ebb8e9773&VerSion=5.13.0.0&Isst=0&index={index}&Date=&REnd=1420&apiv=w35&Type=1&FilterMotherboard=0&Filter=0&Ratio=6&FilterTIB=1&FilterGem=0&"
    result = __base_request("https://apphwhq.longhuvip.com/w1/api/index.php", data=data, timeout=3)
    result = json.loads(result)
    return result

    # __getConceptBK("300564")
    data = getMarketJingXuanRealRankingInfoByTimeRange("0925", "1000", "2024-11-12")
    data = json.loads(data)
    print(json.loads(data))
    data = getMarketJingXuanRealRankingInfoByTimeRange("0925", "1500", "2024-11-13")
    print(json.loads(data))
    data = getMarketJingXuanRealRankingInfoByTimeRange("0925", "1000", "2024-11-13")
    print(json.loads(data))
    # data=json.loads(data)
    # print(len(data["list"]))
    # data = json.loads(getCodesByPlate("801235"))
    # print(data)

if __name__ == "__main__":
    result = getZLJECodesRank(0)
    for d in result['list']:
        print(d)

 third_data/kpl_data_constant.py

@@ -123,7 +123,9 @@
        @param code:
        @return:
        """
        return self.__radical_buy_reasons_dict.get(code)
        if code in self.__radical_buy_reasons_dict:
            return set(self.__radical_buy_reasons_dict.get(code))
        return None


class TodayLimitUpReasonChangeManager:

 trade/buy_radical/radical_buy_data_manager.py

@@ -84,7 +84,7 @@
                volume_rate = 0.5
            big_order_deal_enough = True, "", True
            if not constant.TEST:
                big_order_deal_enough = is_big_order_deal_enough(code, volume_rate)
                big_order_deal_enough = is_big_order_deal_enough(code, volume_rate, 0)
            if not big_order_deal_enough[0] and big_order_deal_enough[2]:
                return False, "交易前两分钟大单不足"

@@ -116,7 +116,8 @@
        if volume_rate is None:
            volume_rate = 0.5
        big_order_deal_enough = is_big_order_deal_enough(code,
                                                         volume_rate)  # BigOrderDealManager().get_total_buy_count(code)
                                                         volume_rate,
                                                         0)  # BigOrderDealManager().get_total_buy_count(code)
        if big_order_deal_enough[0]:
            gpcode_manager.MustBuyCodesManager().add_code(code)

@@ -853,9 +854,11 @@
        return self.__codes


def is_big_order_deal_enough(code, volume_rate):
def is_big_order_deal_enough(code, volume_rate, refer_total_sell_money, delegating_big_order_money=0):
    """
    大单成交是否足够
    @param delegating_big_order_money: 正在委托的大单金额
    @param refer_total_sell_money: 引用的总卖额
    @param code:
    @param volume_rate:
    @return: 大单是否足够, 原因, 是否是短时生效
@@ -871,11 +874,15 @@
    before_time = tool.get_now_time_as_int() < 93200
    # 计算大单参考数量
    threshold_count = 1  # int(round(0.4 * money_y))
    if refer_total_sell_money >= 1e7:
        threshold_count = 2
    else:
        threshold_count = 1
    if before_time:
        threshold_count = int(round(0.4 * money_y * 1.5))
    threshold_money = threshold_count * 299 * 10000

    if volume_rate >= 0.5 or True:
    if volume_rate >= 0.5 and False:
        # 按量大于50%算
        # 当换手量＞50%时，则，不需要每次扫入时需要≥2笔大单，而是累计需要≥2笔大单即可
        deal_big_order_money = BigOrderDealManager().get_total_buy_money(code)
@@ -894,11 +901,11 @@
        else:
            return False, f"量比-{volume_rate}, 总大单成交金额({deal_big_order_money})<{threshold_money}", before_time
    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}", before_time
        current_big_order_deal_money = EveryLimitupBigDealOrderManager.get_big_buy_deal_order_money(code)
        if current_big_order_deal_money + delegating_big_order_money >= threshold_money:
            return True, f"量比-{volume_rate}, 本次大单成交金额({current_big_order_deal_money})+委托大单金额({delegating_big_order_money})>={threshold_money}", before_time
        else:
            return False, f"量比-{volume_rate}, 本次大单成交数量({current_big_order_deal_count})<{threshold_count}", before_time
            return False, f"量比-{volume_rate}, 本次大单成交金额({current_big_order_deal_money}) + 委托大单金额({delegating_big_order_money}) <{threshold_money}", before_time


class EveryLimitupBigDealOrderManager:
@@ -906,24 +913,44 @@
    每次上板的大单管理
    """
    # 成交大单的订单号：{"code":{"order_no",...}}
    __deal_big_order_nos_dict = {}
    __deal_big_order_infos_dict = {}
    # 成交大单号
    __deal_big_order_no_dict = {}

    @classmethod
    def open_limit_up(cls, code):
        if code in cls.__deal_big_order_nos_dict:
            cls.__deal_big_order_nos_dict[code].clear()
        if code in cls.__deal_big_order_infos_dict:
            cls.__deal_big_order_infos_dict[code].clear()

    @classmethod
    def add_big_buy_order_deal(cls, code, order_nos: list):
        if code not in cls.__deal_big_order_nos_dict:
            cls.__deal_big_order_nos_dict[code] = set()
        for order_no in order_nos:
            cls.__deal_big_order_nos_dict[code].add(order_no)
    def add_big_buy_order_deal(cls, code, order_infos: list):
        """
        加入大单成交
        @param code:
        @param order_infos:[(订单号,金额)]
        @return:
        """
        if code not in cls.__deal_big_order_infos_dict:
            cls.__deal_big_order_infos_dict[code] = []

        if code not in cls.__deal_big_order_no_dict:
            cls.__deal_big_order_no_dict[code] = set()

        for order_info in order_infos:
            if order_info[0] not in cls.__deal_big_order_no_dict[code]:
                cls.__deal_big_order_infos_dict[code].append(order_info)
                cls.__deal_big_order_no_dict[code].add(order_info[0])

    @classmethod
    def get_big_buy_deal_order_count(cls, code):
        if code in cls.__deal_big_order_nos_dict:
            return len(cls.__deal_big_order_nos_dict[code])
        if code in cls.__deal_big_order_infos_dict:
            return len(cls.__deal_big_order_infos_dict[code])
        return 0

    @classmethod
    def get_big_buy_deal_order_money(cls, code):
        if code in cls.__deal_big_order_infos_dict:
            return sum([x[1] for x in cls.__deal_big_order_infos_dict[code]])
        return 0



 trade/buy_radical/radical_buy_strategy.py

@@ -77,6 +77,16 @@
        return BUY_MODE_NONE, "尚未获取到总卖额（备用）"


def clear_latest_deal_active_buy_order(code):
    """
    清除最近主动成交的订单信息
    @param code:
    @return:
    """
    if code in __latest_deal_active_buy_order:
        __latest_deal_active_buy_order.pop(code)


def process_limit_up_active_buy_deal(code, transaction_datas):
    async_log_util.info(hx_logger_l2_transaction, f"板上成交：{code}-{transaction_datas}")
    """
@@ -100,7 +110,7 @@
        money = transaction_data[1] * transaction_data[2]
        price = transaction_data[1]

        # 统计当前的买单
        # 统计成交的买单
        if __latest_deal_active_buy_order[code][0] == transaction_data[6]:
            __latest_deal_active_buy_order[code][1] += transaction_data[2]
            __latest_deal_active_buy_order[code][2] += money
@@ -131,6 +141,19 @@

    price = transaction_datas[-1][1]
    huaxin_timestamp = transaction_datas[-1][3]

    # 获取参考总卖额
    refer_sell_data = L2MarketSellManager().get_refer_sell_data(code, l2_huaxin_util.convert_time(
        huaxin_timestamp))
    async_log_util.info(logger_l2_radical_buy, f"参考总卖额（备用）：{code}-{refer_sell_data}")

    # 参考总卖额
    refer_sell_money = 0

    if refer_sell_data:
        refer_sell_money = refer_sell_data[1]


    # 处于涨停卖的委托订单总手数
    selling_num = L2LimitUpSellDataManager.get_delegating_sell_num(code)
    if selling_num is None:
@@ -152,7 +175,7 @@
        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)
            big_order_deal_result = radical_buy_data_manager.is_big_order_deal_enough(code, volume_rate, refer_sell_money)
            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}"
            else:
@@ -166,7 +189,7 @@
        if volume_rate is None:
            volume_rate = 0.5
        # 根据大单判断是否可以扫
        big_order_deal_result = radical_buy_data_manager.is_big_order_deal_enough(code, volume_rate)
        big_order_deal_result = radical_buy_data_manager.is_big_order_deal_enough(code, volume_rate, refer_sell_money)
        result = __get_deal_rate_by(code, huaxin_timestamp)
        if result[0] == BUY_MODE_DIRECT:
            if big_order_deal_result[0]:

 trade/trade_data_manager.py

@@ -469,7 +469,7 @@
    __deal_codes_cache = set()
    __instance = None
    __mysqldb = Mysqldb()
    # 根据L2数据来激进买入的有效时间:{"code":(有效截至时间, 买单号, 扫入的板块)}
    # 根据L2数据来激进买入的有效时间:{"code":(有效截至时间, 买单号, 扫入的板块, 最近成交时间)}
    buy_by_l2_delegate_expire_time_dict = {}
    # 仅仅买的板块
    radical_buy_blocks_dict = {}