blame | 历史 | 补丁 | 提交 | 提交对比 | ignore whitespace
Administrator
18 小时以前 3a87b1c89a76d858e8e7e4e54ff360dc0b8670f5 
 cancel_strategy/s_l_h_cancel_strategy.py


@@ -618,7 +618,7 @@


                                # if deal_big_order_info and deal_big_order_info[5] > 5000e4:


                                #     temp_rate = round(deal_big_order_info[1] / deal_big_order_info[5], 2)


                                #     threshold_rate = min(max(temp_rate, 0.3), 0.7)


                                volume_rate = code_volumn_manager.CodeVolumeManager().get_volume_rate(code)*0.9


                                volume_rate = code_volumn_manager.CodeVolumeManager().get_volume_rate(code) * 0.9


                                threshold_rate = min(max(volume_rate, 0.3), 0.6)


                        except:


                            pass


@@ -821,6 +821,9 @@


    # 总大卖单成交列表


    __total_big_sell_order_list_cache = {}




    # L后重新囊括的时间


    __recompute_l_down_time_dict = {}




    __instance = None




    def __new__(cls, *args, **kwargs):


@@ -921,39 +924,6 @@


        @return:


        """


        self.__set_watch_indexes(code, buy_single_index, re_compute, indexes)




    def __set_near_by_trade_progress_indexes(self, code, buy_single_index, indexes):


        if indexes:


            trade_record_log_util.add_cancel_watch_indexes_log(code,


                                                               trade_record_log_util.CancelWatchIndexesInfo(


                                                                   trade_record_log_util.CancelWatchIndexesInfo.CANCEL_TYPE_L_UP,


                                                                   buy_single_index,


                                                                   list(indexes)))


        self.__near_by_trade_progress_index_cache[code] = indexes


        RedisUtils.setex_async(self.__db, f"l_cancel_near_by_index-{code}", tool.get_expire(),


                               json.dumps(list(indexes)))




    def __get_near_by_trade_progress_indexes(self, code):


        val = RedisUtils.get(self.__get_redis(), f"l_cancel_near_by_index-{code}")


        if val is None:


            return None


        return set(json.loads(val))




    def __get_near_by_trade_progress_indexes_cache(self, code):


        cache_result = CodeDataCacheUtil.get_cache(self.__near_by_trade_progress_index_cache, code)


        if cache_result[0]:


            return cache_result[1]


        return None




    def __set_cancel_l_down_after_place_order_index(self, code, watch_index, index):


        if code not in self.__cancel_l_down_after_place_order_index_cache:


            self.__cancel_l_down_after_place_order_index_cache[code] = {}


        self.__cancel_l_down_after_place_order_index_cache[code][str(watch_index)] = index


        RedisUtils.setex_async(self.__db, f"l_cancel_down_after_place_order_index-{code}", tool.get_expire(),


                               json.dumps(self.__cancel_l_down_after_place_order_index_cache[code]))




    def __get_cancel_l_down_after_place_order_index_dict(self, code):


        return self.__cancel_l_down_after_place_order_index_cache.get(code)




    def del_watch_index(self, code):


        CodeDataCacheUtil.clear_cache(self.__cancel_watch_index_info_cache, code)


@@ -1197,173 +1167,17 @@


                            logger_debug.exception(e)




                    # 获取真实下单位后面10笔大单


                    if not is_human:


                        # 人为不需要设置


                        watch_indexes_after = self.__compute_l_down_watch_index_after_real_place_order_index(code)


                        if watch_indexes_after:


                            watch_indexes |= watch_indexes_after


                    # if not is_human:


                    #     # 人为不需要设置


                    #     watch_indexes_after = self.__compute_l_down_watch_index_after_real_place_order_index(code)


                    #     if watch_indexes_after:


                    #         watch_indexes |= watch_indexes_after


                    self.__set_watch_indexes(code, buy_single_index, re_compute, watch_indexes)


                    l2_log.l_cancel_debug(code,


                                          f"设置监听范围({msg}){'(重新计算)' if re_compute else ''}， 数据范围：{re_start_index}-{end_index} 监听范围-{watch_indexes}")


        except Exception as e:


            l2_log.l_cancel_debug(code, f"计算L后囊括范围出错：{str(e)}")


            async_log_util.exception(logger_l2_l_cancel, e)




    def __need_update_l_down_after(self, code, start_index, end_index):


        """


        是否需要更新l后真实下单位置之后的囊括范围


        @param code:


        @return:


        """


        real_place_order_info = self.__real_place_order_index_dict.get(code)


        if not real_place_order_info or real_place_order_info[1]:


            return False


        # 判断L后是否包含后面的数据


        watch_indexes_info = self.__get_watch_indexes_cache(code)


        if not watch_indexes_info:


            # 没有囊括


            return False


        watch_indexes = set([int(i) for i in watch_indexes_info[2]])


        real_place_order_index = real_place_order_info[0]


        for index in watch_indexes:


            if index > real_place_order_index:


                # L后后段已经囊括


                return False


        # 下单位置之后数10笔买单


        watch_indexes = set()


        total_datas = local_today_datas.get(code)


        MIN_NUM = int(5000 / gpcode_manager.get_limit_up_price_as_num(code))


        MAX_COUNT = 10


        for i in range(real_place_order_index + 1, end_index):


            data = total_datas[i]


            val = data['val']


            if not L2DataUtil.is_limit_up_price_buy(val):


                continue


            if val['num'] < MIN_NUM:


                continue


            watch_indexes.add(i)


            if len(watch_indexes) >= MAX_COUNT:


                break


        # 看里面的撤单率是否


        if len(watch_indexes) < MAX_COUNT:


            # 数量不够


            return False


        # 计算撤单比例是否足够


        canceled_buyno_map = local_today_canceled_buyno_map.get(code)


        cancel_count = 0


        for index in watch_indexes:


            # 是否撤单


            left_count = l2_data_source_util.L2DataSourceUtils.get_limit_up_buy_no_canceled_count_v2(


                code, index,


                total_datas,


                canceled_buyno_map)


            if left_count <= 0:


                cancel_count += 1


        if cancel_count > len(watch_indexes) * 0.5:


            return True


        return False




    def __compute_l_down_watch_index_after_real_place_order_index(self, code):


        """


        计算L后真实下单位置之后的监控索引


        @return:


        """


        watch_indexes = set()


        total_datas = local_today_datas.get(code)


        is_ge_code = tool.is_ge_code(code)


        try:


            # 真实下单位置后面的数据就只看大单


            MIN_NUM = int(5000 / gpcode_manager.get_limit_up_price_as_num(code))


            real_place_order_info = self.__real_place_order_index_dict.get(code)


            if real_place_order_info and not real_place_order_info[1]:


                # 从真实下单位往后找


                after_count = 0


                for i in range(real_place_order_info[0] + 1, total_datas[-1]['index'] + 1):


                    if after_count > 10:


                        break


                    data = total_datas[i]


                    val = data['val']


                    # 涨停买，且未撤单


                    if not L2DataUtil.is_limit_up_price_buy(val):


                        continue


                    # 小金额过滤


                    if val['num'] < MIN_NUM:


                        continue


                    left_count = l2_data_source_util.L2DataSourceUtils.get_limit_up_buy_no_canceled_count_v2(


                        code, i,


                        total_datas,


                        local_today_canceled_buyno_map.get(


                            code))


                    if left_count > 0:


                        after_count += 1


                        if l2_data_util.is_big_money(val, is_ge_code):


                            watch_indexes.add(i)


                            # 记录索引的位置


                            self.__set_cancel_l_down_after_place_order_index(code, i, after_count - 1)


        except Exception as e:


            pass


        return watch_indexes




    def __compute_l_down_watch_index_after_by(self, code):


        """


        计算L后后半段大单备用


        @param code:


        @return:


        """


        if self.__l_down_after_by_big_order_dict.get(code):


            # 不用重复计算


            return


        real_place_order_info = self.__real_place_order_index_dict.get(code)


        if not real_place_order_info or real_place_order_info[1]:


            return


        real_place_order_index = real_place_order_info[0]


        total_datas = local_today_datas.get(code)


        limit_up_price = gpcode_manager.get_limit_up_price(code)


        limit_up_price = round(float(limit_up_price), 2)


        bigger_num = l2_data_util.get_big_money_val(limit_up_price, tool.is_ge_code(code)) // (limit_up_price * 100)


        min_num = 500000 // (limit_up_price * 100)


        index = -1


        watch_indexes = set()


        if code not in self.__l_down_after_by_big_order_weight_dict:


            self.__l_down_after_by_big_order_weight_dict[code] = {}


        for i in range(real_place_order_index + 1, total_datas[-1]["index"]):


            data = total_datas[i]


            val = data["val"]


            if not L2DataUtil.is_limit_up_price_buy(val):


                continue


            if val["num"] < min_num:


                continue




            left_count = l2_data_source_util.L2DataSourceUtils.get_limit_up_buy_no_canceled_count_v2(code, i,


                                                                                                     total_datas,


                                                                                                     local_today_canceled_buyno_map.get(


                                                                                                         code))


            if left_count > 0:


                if val["num"] >= bigger_num:


                    if index < 0:


                        # 开始计数


                        index = 0


                    # 加入大单监听


                    self.__l_down_after_by_big_order_weight_dict[code][str(i)] = int(str(index))


                    watch_indexes.add(i)


                if index >= 0:


                    index += 1


                    if index > 10:


                        break


        self.__l_down_after_by_big_order_dict[code] = watch_indexes


        l2_log.l_cancel_debug(code, f"L后后半段大单备用囊括范围：{watch_indexes}")




        try:


            watch_indexes_info = self.get_l_down_watch_indexes_cache(code)


            if watch_indexes_info:


                total_watch_indexes = set(watch_indexes) | set(watch_indexes_info[2])


                trade_record_log_util.add_cancel_watch_indexes_log(code,


                                                                   trade_record_log_util.CancelWatchIndexesInfo(


                                                                       trade_record_log_util.CancelWatchIndexesInfo.CANCEL_TYPE_L_DOWN,


                                                                       watch_indexes_info[0],


                                                                       list(total_watch_indexes)))


        except:


            pass




    # 设置真实下单位置


    def set_real_place_order_index(self, code, index, buy_single_index=None, is_default=False):


@@ -1395,53 +1209,11 @@




    # 计算范围内的成交位临近未撤大单


    def __compute_trade_progress_near_by_indexes(self, code, buy_single_index, start_index, end_index):


        if start_index is None or end_index is None:


            return


        total_datas = local_today_datas.get(code)


        MIN_MONEY = 99 * 100


        MAX_COUNT = 15


        watch_indexes = set()


        total_num = 0


        # thresh_hold_money = l2_trade_factor.L2PlaceOrderParamsManager.get_base_m_val(code)


        # threshold_num = thresh_hold_money // (float(gpcode_manager.get_limit_up_price(code)) * 100)


        for i in range(start_index, end_index):


            data = total_datas[i]


            val = data['val']


            if not L2DataUtil.is_limit_up_price_buy(val):


                continue


            # 小金额过滤


            if float(val['price']) * val['num'] < MIN_MONEY:


                continue


            left_count = l2_data_source_util.L2DataSourceUtils.get_limit_up_buy_no_canceled_count_v2(code, i,


                                                                                                     total_datas,


                                                                                                     local_today_canceled_buyno_map.get(


                                                                                                         code))


            if left_count > 0:


                total_num += val['num'] * left_count


                watch_indexes.add(i)


                if len(watch_indexes) >= MAX_COUNT:


                    break




        changed = True


        l_up_compute_info = self.__last_l_up_compute_info.get(code)


        if l_up_compute_info:


            if l_up_compute_info[1] == watch_indexes:


                changed = False


        # 保存数据


        if changed:


            threshold_time = 1 if tool.is_sz_code(code) else 2


            if l_up_compute_info and l_up_compute_info[1]:


                if time.time() - l_up_compute_info[0] < threshold_time:


                    l2_log.l_cancel_debug(code, f"L前监控更新太频繁：{threshold_time}")


                    return


            l2_log.l_cancel_debug(code, f"L前监控范围：{watch_indexes} 计算范围：{start_index}-{end_index}")


            self.__set_near_by_trade_progress_indexes(code, buy_single_index, watch_indexes)


        self.__last_l_up_compute_info[code] = (time.time(), watch_indexes)


        pass




    # 计算L后还没成交的手数


    def __compute_total_l_down_not_deal_num(self, code):


        # 只有真实获取到下单位置后才开始计算




        try:


            if code in self.__total_l_down_not_deal_num_dict and time.time() - \


                    self.__total_l_down_not_deal_num_dict[code][


@@ -1498,17 +1270,6 @@


        if total_datas is None:


            return




        if not self.__is_l_down_can_cancel(code, buy_single_index):


            # L后已经不能守护


            l2_log.l_cancel_debug(code, f"L后已经无法生效：buy_single_index-{buy_single_index}")




            HourCancelBigNumComputer().start_compute_watch_indexes(code, buy_single_index)


            try:


                # 计算L后后半段大单监控范围


                self.__compute_l_down_watch_index_after_by(code)


            except Exception as e:


                l2_log.l_cancel_debug(code, "__compute_l_down_watch_index_after_by出错")




        real_place_order_index_info = self.__real_place_order_index_dict.get(code)


        real_place_order_index = None


        if real_place_order_index_info:


@@ -1536,7 +1297,6 @@


            return


        # 重新囊括1笔


        real_place_order_info = self.__real_place_order_index_dict.get(code)


        is_ge_code = tool.is_ge_code(code)


        if real_place_order_info and real_place_order_info[0] > index:


            total_datas = local_today_datas.get(code)


            min_num = int(5000 / gpcode_manager.get_limit_up_price_as_num(code))


@@ -1559,33 +1319,6 @@


                    watch_indexes.add(data["index"])


                    l2_log.l_cancel_debug(code, f"L后有成交重新囊括：成交索引-{index} 囊括索引-{data['index']}")


                    break


            # 从真实下单位置往后囊括大单


            try:


                left_count_after = 0


                for j in range(real_place_order_info[0] + 1, total_datas[-1]["index"]):


                    data = total_datas[j]


                    val = data['val']


                    if left_count_after > 10:


                        break


                    if not L2DataUtil.is_limit_up_price_buy(val):


                        continue


                    if val["num"] < min_num:


                        continue


                    left_count = l2_data_source_util.L2DataSourceUtils.get_limit_up_buy_no_canceled_count_v2(code,


                                                                                                             j,


                                                                                                             total_datas,


                                                                                                             local_today_canceled_buyno_map.get(


                                                                                                                 code))


                    if left_count > 0:


                        left_count_after += 1


                        if l2_data_util.is_big_money(val, is_ge_code) and j not in watch_indexes:


                            watch_indexes.add(j)


                            l2_log.l_cancel_debug(code, f"L后有成交后半段增加囊括：{j}")


                            self.__set_cancel_l_down_after_place_order_index(code, j, left_count_after - 1)


                            break


            except:


                pass




        self.__set_watch_indexes(code, watch_indexes_info[0], watch_indexes_info[1], watch_indexes)




    def __compute_l_down_canceled_rate(self, code, total_data):


@@ -1598,31 +1331,7 @@


        if not watch_indexes_info:


            return 0, []




        # 这是下单位置之后的索引: key为字符串


        after_place_order_index_dict = self.__get_cancel_l_down_after_place_order_index_dict(code)


        if after_place_order_index_dict is None:


            after_place_order_index_dict = {}


        after_place_order_index_by_dict = self.__l_down_after_by_big_order_weight_dict.get(code)


        if after_place_order_index_by_dict is None:


            after_place_order_index_by_dict = {}




        watch_indexes = set([int(i) for i in watch_indexes_info[2]])


        try:


            # 将备用订单加进去


            watch_indexes_by = self.__l_down_after_by_big_order_dict.get(code)


            if watch_indexes_by:


                # 是否是下单30分钟内


                real_place_order_info = self.__real_place_order_index_dict.get(code)


                if real_place_order_info and tool.trade_time_sub(total_data[-1]["val"]["time"],


                                                                 total_data[real_place_order_info[0]]["val"][


                                                                     "time"]) < 30 * 60:


                    # 下单30分钟内有效


                    watch_indexes |= watch_indexes_by


                else:


                    # 清除备用大单


                    watch_indexes_by.clear()


        except Exception as e:


            l2_log.l_cancel_debug(code, "将L2后后半段备用大单加入计算出错：{}", str(e))


        # 计算监听的总条数


        total_num = 0


        # 超大单的手数


@@ -1631,17 +1340,6 @@




        thresh_hold_rate, must_buy, cancel_rate_info = LCancelRateManager.get_cancel_rate(code)


        for wi in watch_indexes:


            if str(wi) in after_place_order_index_dict:


                # 如果加红就需要计算分母


                if must_buy:


                    total_num += total_data[wi]["val"]["num"] * (


                            10 - after_place_order_index_dict[str(wi)]) // 10


                continue


            elif str(wi) in after_place_order_index_by_dict:


                if must_buy:


                    total_num += total_data[wi]["val"]["num"] * (


                            10 - after_place_order_index_by_dict[str(wi)]) // 10


                continue


            # 超过超大单就算超大单


            if total_data[wi]["val"]["num"] < super_big_num_thresold:


                total_num += total_data[wi]["val"]["num"]


@@ -1676,20 +1374,11 @@


            cancel_data = L2DataComputeUtil.is_canceled(code, wi, total_data, canceled_buyno_map,


                                                        dealing_info[0] if dealing_info else None,


                                                        deal_order_nos)


            if str(wi) in after_place_order_index_dict:


                # 真实下单位置之后的按照权重比例来计算


                if cancel_data:


                    canceled_num += total_data[wi]["val"]["num"] * (


                            10 - after_place_order_index_dict[str(wi)]) // 10


            elif str(wi) in after_place_order_index_by_dict:


                if cancel_data:


                    canceled_num += total_data[wi]["val"]["num"] * (


                            10 - after_place_order_index_by_dict[str(wi)]) // 10


            else:


                before_nums_info.append((wi, val["num"]))


                if cancel_data:


                    before_canceled_nums_info.append((wi, val['num']))


                    canceled_num += total_data[wi]["val"]["num"]




            before_nums_info.append((wi, val["num"]))


            if cancel_data:


                before_canceled_nums_info.append((wi, val['num']))


                canceled_num += total_data[wi]["val"]["num"]


            if cancel_data:


                canceled_data_indexes.append(cancel_data["index"])


        rate = round(canceled_num / total_num, 3)


@@ -1712,41 +1401,13 @@


        if not watch_indexes_info:


            return False, None




        # 这是下单位置之后的索引: key为字符串


        after_place_order_index_dict = self.__get_cancel_l_down_after_place_order_index_dict(code)


        if after_place_order_index_dict is None:


            after_place_order_index_dict = {}


        after_place_order_index_by_dict = self.__l_down_after_by_big_order_weight_dict.get(code)


        if after_place_order_index_by_dict is None:


            after_place_order_index_by_dict = {}




        watch_indexes = set([int(i) for i in watch_indexes_info[2]])


        try:


            # 将备用订单加进去


            watch_indexes_by = self.__l_down_after_by_big_order_dict.get(code)


            if watch_indexes_by:


                # 是否是下单30分钟内


                real_place_order_info = self.__real_place_order_index_dict.get(code)


                if real_place_order_info and tool.trade_time_sub(total_data[-1]["val"]["time"],


                                                                 total_data[real_place_order_info[0]]["val"][


                                                                     "time"]) < 30 * 60:


                    # 下单30分钟内有效


                    watch_indexes |= watch_indexes_by


                else:


                    # 清除备用大单


                    watch_indexes_by.clear()


        except Exception as e:


            l2_log.l_cancel_debug(code, "将L2后后半段备用大单加入计算出错：{}", str(e))


        # 计算监听的总条数


        total_num = 0


        max_num, max_num_count = 0, 0


        thresh_hold_rate, must_buy, cancel_rate_info = LCancelRateManager.get_cancel_rate(code)


        super_big_num_thresold = int(2e7 / gpcode_manager.get_limit_up_price_as_num(code) / 100)


        for wi in watch_indexes:


            if str(wi) in after_place_order_index_dict:


                continue


            elif str(wi) in after_place_order_index_by_dict:


                continue


            if total_data[wi]["val"]["num"] < super_big_num_thresold:


                total_num += total_data[wi]["val"]["num"]


            else:


@@ -1805,9 +1466,6 @@


                trade_index = None


            canceled_buyno_map = local_today_canceled_buyno_map.get(code)




            # 如果撤单比例设置为100%就不需要计算下单位后面的订单


            need_compute_after = False if thresh_hold_rate - 1.00 >= -0.0001 else True




            dealing_info = HuaXinBuyOrderManager.get_dealing_order_info(code)


            canceled_watch_indexes = set()


            for wi in watch_indexes:


@@ -1815,47 +1473,19 @@


                                                            dealing_info[0] if dealing_info else None,


                                                            deal_order_nos)


                if cancel_data:


                    if str(wi) in after_place_order_index_dict:


                        if not need_compute_after:


                            continue


                        # 真实下单位置之后的按照权重比例来计算


                        canceled_num += total_data[wi]["val"]["num"] * (


                                10 - after_place_order_index_dict[str(wi)]) // 10


                    elif str(wi) in after_place_order_index_by_dict:


                        if not need_compute_after:


                            continue


                        canceled_num += total_data[wi]["val"]["num"] * (


                                10 - after_place_order_index_by_dict[str(wi)]) // 10


                    else:


                        canceled_num += total_data[wi]["val"]["num"]


                    canceled_num += total_data[wi]["val"]["num"]


                    canceled_watch_indexes.add(wi)


                    canceled_indexes.append(cancel_data["index"])


                # if wi == watch_indexes_list[-1] and left_count == 0:


                #     # 离下单位置最近的一个撤单，必须触发撤单


                #     l2_log.l_cancel_debug(code, f"计算范围：{start_index}-{end_index},临近撤单：{wi}")


                #     return True, total_data[-1]




            rate = round(canceled_num / total_num, 3)


            if rate > 1:


                rate = 1


            # 除开最大单的影响权重


            # if not must_buy:


            #     temp_thresh_hold_rate = round((total_num - max_num * max_num_count) * 0.8 / total_num, 2)


            #     if thresh_hold_rate > temp_thresh_hold_rate:


            #         if cancel_rate_info and cancel_rate_info[1] > 0:


            #             pass


            #         else:


            #             # 没有人为设置


            #             # 目标撤单比例大于大单撤单比例就取比例均值


            #             thresh_hold_rate = round((thresh_hold_rate + temp_thresh_hold_rate) / 2, 2)




            real_place_order_info = self.__real_place_order_index_dict.get(code)


            is_default_place_order_index = real_place_order_info[1] if real_place_order_info else False


            if is_default_place_order_index and not cancel_rate_info[1]:


                # 人为设置的不能取最小


                thresh_hold_rate = min(0.49, thresh_hold_rate)


            l2_log.l_cancel_debug(code,


                                  f"L后计算范围：{start_index}-{end_index},已撤单比例：{rate}/{thresh_hold_rate},  下单位之后的索引：{after_place_order_index_dict}, 最大单-({max_num}，{max_num_count}), 人为设置-{cancel_rate_info}, 真实下单位-{real_place_order_info}, 大卖单成交：{total_sell_nums}手")


                                  f"L后计算范围：{start_index}-{end_index},已撤单比例：{rate}/{thresh_hold_rate}, 最大单-({max_num}，{max_num_count}), 人为设置-{cancel_rate_info}, 真实下单位-{real_place_order_info}, 大卖单成交：{total_sell_nums}手")


            l2_log.l_cancel_debug(code, f"L后已撤手数：{canceled_num}/{total_num} 撤单索引：{canceled_watch_indexes}")


            if rate >= thresh_hold_rate:


                canceled_indexes.sort()


@@ -1863,106 +1493,6 @@


                return True, total_data[canceled_indexes[-1]]




        return False, None




    def __compute_near_by_trade_progress_need_cancel(self, code, buy_exec_index, start_index, end_index, total_data,


                                                     is_first_code):


        # L前守护时间为3分钟


        if tool.trade_time_sub(total_data[-1]['val']['time'],


                               total_data[buy_exec_index]['val']['time']) > constant.L_CANCEL_UP_EXPIRE_TIME:


            return False, None




        watch_indexes = self.__get_near_by_trade_progress_indexes_cache(code)


        if not watch_indexes:


            return False, None




        # 监听范围小于5笔不生效


        if len(watch_indexes) < 5:


            return False, None




        # 计算监听的总条数


        # 权重


        WATCH_INDEX_WEIGHTS = [3, 2, 1]


        total_count_weight = 0


        for wi in range(0, len(watch_indexes)):


            if wi < len(WATCH_INDEX_WEIGHTS):


                total_count_weight += WATCH_INDEX_WEIGHTS[wi]


            else:


                total_count_weight += WATCH_INDEX_WEIGHTS[-1]


        # 判断撤单中是否有监听中的索引


        need_compute = False


        for i in range(start_index, end_index + 1):


            data = total_data[i]


            val = data["val"]


            if L2DataUtil.is_limit_up_price_buy_cancel(val):


                # 查询买入位置


                buy_index = l2_data_source_util.L2DataSourceUtils.get_buy_index_with_cancel_data_v2(data,


                                                                                                    local_today_buyno_map.get(


                                                                                                        code))


                if buy_index is not None and buy_index in watch_indexes:


                    need_compute = True


                    break


        if need_compute:


            watch_indexes_list = list(watch_indexes)


            watch_indexes_list.sort()


            # 计算撤单比例


            canceled_count_weight = 0


            canceled_indexes = []


            for wi in watch_indexes:


                canceled_data = l2_data_source_util.L2DataSourceUtils.get_limit_up_buy_canceled_data_v2(code,


                                                                                                        wi,


                                                                                                        total_data,


                                                                                                        local_today_canceled_buyno_map.get(


                                                                                                            code))


                if canceled_data:


                    canceled_indexes.append(canceled_data["index"])


                    # 获取索引权重


                    pos_index = watch_indexes_list.index(wi)


                    if pos_index < len(WATCH_INDEX_WEIGHTS):


                        canceled_count_weight += WATCH_INDEX_WEIGHTS[pos_index]


                    else:


                        canceled_count_weight += WATCH_INDEX_WEIGHTS[-1]


            rate = round(canceled_count_weight / total_count_weight, 3)


            thresh_cancel_rate, must_buy, cancel_rate_info = LCancelRateManager.get_cancel_rate(code, is_up=True)


            l2_log.l_cancel_debug(code, f"计算范围：{start_index}-{end_index},L前已撤单比例：{rate}/{thresh_cancel_rate}")


            if rate >= thresh_cancel_rate:


                # 计算成交进度位置到当前下单位置的纯买额


                real_place_order_index_info = self.__real_place_order_index_dict.get(code)


                trade_progress_index, is_default = TradeBuyQueue().get_traded_index(code)


                if trade_progress_index is None:


                    trade_progress_index = 0


                if real_place_order_index_info and trade_progress_index:


                    total_num = 0


                    thresh_hold_money = l2_trade_factor.L2PlaceOrderParamsManager.get_base_m_val(code)


                    thresh_hold_money = thresh_hold_money * 3


                    # 阈值为2倍m值


                    thresh_hold_num = thresh_hold_money // (gpcode_manager.get_limit_up_price_as_num(code) * 100)


                    for i in range(trade_progress_index + 1, real_place_order_index_info[0]):


                        data = total_data[i]


                        val = data['val']


                        if not L2DataUtil.is_limit_up_price_buy(val):


                            continue


                        canceled_data = l2_data_source_util.L2DataSourceUtils.get_limit_up_buy_canceled_data_v2(code,


                                                                                                                i,


                                                                                                                total_data,


                                                                                                                local_today_canceled_buyno_map.get(


                                                                                                                    code))


                        if not canceled_data:


                            # 没有撤单


                            total_num += val["num"] * data["re"]


                            if total_num > thresh_hold_num:


                                # 成交位到下单位还有足够的单没撤


                                l2_log.l_cancel_debug(code,


                                                      f"L前撤阻断： 成交位-{trade_progress_index} 真实下单位-{real_place_order_index_info[0]} 阈值-{thresh_hold_money}")


                                return False, None




                canceled_indexes.sort()


                l2_log.l_cancel_debug(code, f"L前撤单,撤单位置：{canceled_indexes[-1]}")


                return True, total_data[canceled_indexes[-1]]




        return False, None




    # L后重新囊括的时间


    __recompute_l_down_time_dict = {}




    def add_big_sell_order_deal_list(self, code, deal_order_list):


        """


@@ -1982,43 +1512,6 @@


        total_datas = local_today_datas.get(code)


        return self.__compute_need_cancel(code, 0, total_datas[-1]["index"], total_datas[-1]["index"], total_datas,


                                          True, force_compute=True)




    # L后是否还有可能撤单


    def __is_l_down_can_cancel(self, code, buy_exec_index):


        watch_indexes_info = self.__get_watch_indexes_cache(code)


        if not watch_indexes_info:


            return True


        trade_index, is_default = TradeBuyQueue().get_traded_index(code)


        if trade_index is None:


            trade_index = 0


        if trade_index is None:


            return True


        real_place_order_index_info = self.__real_place_order_index_dict.get(code)


        if not real_place_order_index_info:


            return True




        # 计算已经成交的比例


        total_datas = local_today_datas.get(code)


        total_deal_nums = 0


        total_nums = 1


        for index in watch_indexes_info[2]:


            # 不能计算L后后半段


            if index > real_place_order_index_info[0]:


                continue


            data = total_datas[index]


            val = data["val"]


            left_count = l2_data_source_util.L2DataSourceUtils.get_limit_up_buy_no_canceled_count_v2(code,


                                                                                                     index,


                                                                                                     total_datas,


                                                                                                     local_today_canceled_buyno_map.get(


                                                                                                         code))


            total_nums += val["num"]


            if left_count > 0 and index < trade_index:


                total_deal_nums += val["num"]


        thresh_hold_rate, must_buy, cancel_rate_info = LCancelRateManager.get_cancel_rate(code)


        if total_deal_nums / total_nums > 1 - thresh_hold_rate - 0.05:


            return False


        return True




    def need_cancel(self, code, buy_exec_index, start_index, end_index, total_data, is_first_code):


        if buy_exec_index is None:


@@ -2042,35 +1535,6 @@


            logger_l2_l_cancel.exception(e)


            raise e


        extra_msg = "L后"


        # 不需要计算L前


        # if not can_cancel:


        #     # 成交位临近撤


        #     try:


        #         can_cancel, cancel_data = self.__compute_near_by_trade_progress_need_cancel(code, buy_exec_index,


        #                                                                                     start_index, end_index,


        #                                                                                     total_data,


        #                                                                                     is_first_code)


        #         if can_cancel:


        #             cancel_type = trade_constant.CANCEL_TYPE_L_UP


        #         extra_msg = "L前"


        #     except Exception as e:


        #         logger_l2_l_cancel.exception(e)


        #         raise e




        try:


            if self.__need_update_l_down_after(code, start_index, end_index):


                # 更新后半段


                watch_indexes = self.__compute_l_down_watch_index_after_real_place_order_index(code)


                if watch_indexes:


                    l2_log.l_cancel_debug(code, "L后后半段囊括：{}", watch_indexes)


                    watch_indexes_info = self.__get_watch_indexes_cache(code)


                    if watch_indexes_info and watch_indexes_info[2]:


                        # 没有囊括


                        watch_indexes |= set(watch_indexes_info[2])


                        self.__set_watch_indexes(code, watch_indexes_info[0], watch_indexes_info[1], watch_indexes)


        except Exception as e:


            l2_log.l_cancel_debug(code, "L后后半段计算出错：{}", str(e))




        return can_cancel, cancel_data, extra_msg, cancel_type




    def place_order_success(self, code):


@@ -2134,56 +1598,6 @@


            fdatas.append(item)


        fdatas.sort(key=lambda x: x[0])


        return fdatas




    # def statistic_total_big_order_info(self, code):


    #     """


    #     统计L后的大单信息


    #     @param code:


    #     @return: 囊括金额列表, 成交金额列表, 撤单金额列表, 待成交列表


    #     """


    #     trade_index, is_default = TradeBuyQueue().get_traded_index(code)


    #     if trade_index is None:


    #         trade_index = 0


    #     real_place_order_index_info = self.__real_place_order_index_dict.get(code)


    #     if not real_place_order_index_info:


    #         return None


    #     total_datas = local_today_datas.get(code)


    #     # 统计囊括，已成，已撤，待成交


    #     all_indexes = set()


    #     deal_indexes = set()


    #     canceled_indexes = set()


    #     not_deal_indexes = set()


    #     big_money_threshold = l2_data_util.get_big_money_val(gpcode_manager.get_limit_up_price_as_num(code), tool.is_ge_code(code))


    #     big_num_threshold = int(big_money_threshold/gpcode_manager.get_limit_up_price_as_num(code)/100)


    #     for index in range(0,total_datas[-1]):


    #         data = total_datas[index]


    #         val = data["val"]


    #         if val['num']<big_num_threshold:


    #             continue


    #         if not L2DataUtil.is_limit_up_price_buy(val):


    #             continue


    #         all_indexes.add(index)


    #         left_count = l2_data_source_util.L2DataSourceUtils.get_limit_up_buy_no_canceled_count_v2(code,


    #                                                                                                  index,


    #                                                                                                  total_datas,


    #                                                                                                  local_today_canceled_buyno_map.get(


    #                                                                                                      code))


    #         if left_count == 0:


    #             canceled_indexes.add(index)


    #             continue


    #         if index < trade_index:


    #             deal_indexes.add(index)


    #             continue


    #         not_deal_indexes.add(index)


    #     all_money_list = [int(float(total_datas[x]['val']['price'] * total_datas[x]['val']['num'] * 100)) for x in


    #                       all_indexes]


    #     deal_money_list = [int(float(total_datas[x]['val']['price'] * total_datas[x]['val']['num'] * 100)) for x in


    #                        deal_indexes]


    #     canceled_money_list = [int(float(total_datas[x]['val']['price'] * total_datas[x]['val']['num'] * 100)) for x in


    #                            canceled_indexes]


    #     not_deal_money_list = [int(float(total_datas[x]['val']['price'] * total_datas[x]['val']['num'] * 100)) for x in


    #                            not_deal_indexes]


    #     return all_money_list, deal_money_list, canceled_money_list, not_deal_money_list




    def statistic_l_down_watch_indexes_info(self, code):


        """