blame | 历史 | 补丁 | 提交 | 提交对比 | ignore whitespace
Administrator
2022-11-03 f03eb72394a3fac097bb3ab1f956a83f99f7bd0e 
 l2_data_manager_new.py


@@ -226,7 +226,8 @@


                    __start_time = l2_data_log.l2_time(code, round(t.time() * 1000) - __start_time, "l2数据处理时间")


                # 保存数据


                l2_data_manager.save_l2_data(code, datas, add_datas)


                __start_time = l2_data_log.l2_time(code, round(t.time() * 1000) - __start_time, "保存数据时间")


                __start_time = l2_data_log.l2_time(code, round(t.time() * 1000) - __start_time,


                                                   "保存数据时间（{}）".format(len(add_datas)))




        finally:


            if code in cls.unreal_buy_dict:


@@ -235,23 +236,10 @@


    # 处理未挂单


    @classmethod


    def __process_not_order(cls, code, start_index, end_index, capture_time):


        _start_time = t.time()


        # 获取阈值


        threshold_money, msg = cls.__get_threshmoney(code)


        cls.__start_compute_buy(code, start_index, end_index, threshold_money, capture_time)




    @classmethod


    def __statistic_count_l2_data_for_cancel(cls, code, start_index, end_index, has_cancel_single=False):


        index, old_buy_count, old_cancel_count = l2_data_manager.TradePointManager.get_count_info_for_cancel_buy(code)


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


            buy_count, buy_cancel_count = cls.__count_l2_data_for_cancel(code, i, i)


            old_buy_count += buy_count




            old_cancel_count += buy_cancel_count


            if old_buy_count > 0 and (old_buy_count - old_cancel_count) / old_buy_count < 0.3 and has_cancel_single:


                return i, True


        l2_data_manager.TradePointManager.set_count_info_for_cancel_buy(code, end_index, old_buy_count,


                                                                        old_cancel_count)


        return end_index, False




    # 处理已挂单


    @classmethod


@@ -274,7 +262,7 @@


        if cancel_data:


            cls.debug(code, "触发撤单，撤单位置：{} ，撤单原因：{}", cancel_data["index"], cancel_msg)


            # 撤单


            cls.cancel_buy(code)


            cls.cancel_buy(code,cancel_msg)


            # 继续计算下单


            cls.__process_not_order(code, cancel_data["index"] + 1, end_index, capture_time)


        else:


@@ -338,12 +326,12 @@


            if codes_index.get(code) != 0:


                return False, "水下捞,不是老大，是老{}".format(codes_index.get(code))




        # 13:00后涨停，本板块中涨停票数<29不能买


        # 13:30后涨停，本板块中涨停票数<29不能买


        limit_up_time = limit_up_time_manager.get_limit_up_time(code)


        if limit_up_time is not None:


            if int(limit_up_time.replace(":", "")) >= 130000 and global_util.industry_hot_num.get(industry) is not None:


                if global_util.industry_hot_num.get(industry) < 29:


                    return False, "13:00后涨停，本板块中涨停票数<29不能买"


            if int(limit_up_time.replace(":", "")) >= 133000 and global_util.industry_hot_num.get(industry) is not None:


                if global_util.industry_hot_num.get(industry) < 16:


                    return False, "13:30后涨停，本板块中涨停票数<16不能买"




        if codes_index.get(code) is not None and codes_index.get(code) == 1:


            # 如果老大已经买成功了，老二就不需要买了


@@ -392,11 +380,8 @@


            cls.debug(code, "执行撤单异常：{}", str(e))




    @classmethod


    def cancel_buy(cls, code):


        # 删除大群撤事件的大单


        l2_data_manager.L2BetchCancelBigNumProcessor.del_recod(code)


    def cancel_buy(cls, code, msg=None):


        l2_data_manager.L2ContinueLimitUpCountManager.del_data(code)




        if code in cls.unreal_buy_dict:


            cls.unreal_buy_dict.pop(code)


            # 取消买入标识


@@ -404,22 +389,22 @@


            l2_data_manager.TradePointManager.delete_buy_cancel_point(code)


            l2_data_manager.TradePointManager.delete_compute_info_for_cancel_buy(code)


            l2_data_manager.TradePointManager.delete_count_info_for_cancel_buy(code)


            # 删除大群撤事件的大单


            l2_data_manager.L2BetchCancelBigNumProcessor.del_recod(code)


        else:


            cls.__cancel_buy(code)




        l2_data_manager.L2BigNumProcessor.del_big_num_pos(code)


        cls.debug(code, "执行撤单成功，原因：{}", msg)




    @classmethod


    def __start_compute_buy(cls, code, compute_start_index, compute_end_index, threshold_money, capture_time,


                            new_add=True):


        if compute_end_index < compute_start_index:


            return




        _start_time = t.time()


        total_datas = local_today_datas[code]


        # 获取买入信号计算起始位置


        buy_single_index, buy_exec_index, buy_compute_index, num, count = cls.__get_order_begin_pos(code)




        # 是否为新获取到的位置


        if buy_single_index is None:


            # 有买入信号


@@ -436,10 +421,16 @@


        if buy_single_index is None:


            # 未获取到买入信号，终止程序


            return None




        _start_time = t.time()




        # 计算m值大单


        cls.l2BigNumForMProcessor.process(code, max(buy_single_index, compute_start_index), compute_end_index,


                                          gpcode_manager.get_limit_up_price(code))


        _start_time = t.time()




        threshold_money, msg = cls.__get_threshmoney(code)


        _start_time = t.time()


        # 买入纯买额统计


        compute_index, buy_nums, buy_count, rebegin_buy_pos = cls.__sum_buy_num_for_order_3(code, max(buy_single_index,


                                                                                                      compute_start_index),


@@ -447,8 +438,10 @@


                                                                                            count, threshold_money,


                                                                                            buy_single_index,


                                                                                            capture_time)




        cls.debug(code, "m值-{} m值因子-{}", threshold_money, msg)




        _start_time = t.time()


        # 买入信号位与计算位置间隔2s及以上了


        if rebegin_buy_pos is not None:


            # 需要重新计算纯买额


@@ -485,6 +478,8 @@


            # 未达到下单条件，保存纯买额，设置纯买额


            # 记录买入信号位置


            cls.__save_order_begin_data(code, buy_single_index, -1, compute_end_index, buy_nums, buy_count)


            print("保存大单时间", round((t.time() - _start_time) * 1000))


            _start_time = t.time()


        pass




    # 获取下单起始信号


@@ -551,6 +546,7 @@


    @classmethod


    def __sum_buy_num_for_order_3(cls, code, compute_start_index, compute_end_index, origin_num, origin_count,


                                  threshold_money, buy_single_index, capture_time):


        _start_time = t.time()


        total_datas = local_today_datas[code]


        buy_nums = origin_num


        buy_count = origin_count


@@ -563,6 +559,7 @@


        threshold_count = l2_trade_factor.L2TradeFactorUtil.get_safe_buy_count(code)




        buy_single_time_seconds = L2DataUtil.get_time_as_second(total_datas[buy_single_index]["val"]["time"])




        for i in range(compute_start_index, compute_end_index + 1):


            data = total_datas[i]


            _val = total_datas[i]["val"]


@@ -617,14 +614,16 @@


        cls.buy_debug(code, "尚未获取到买入执行点，起始计算位置：{} 统计纯买手数：{} 目标纯买手数：{}  统计纯买单数：{} 目标纯买单数：{}", compute_start_index,


                      buy_nums,


                      threshold_num, buy_count, threshold_count)




        return None, buy_nums, buy_count, None




    @classmethod


    def test(cls):


        code = "002898"


        code = "002556"


        l2_trade_test.clear_trade_data(code)


        load_l2_data(code, True)




        _start = t.time()


        if True:


            state = trade_manager.get_trade_state(code)


            cls.random_key[code] = random.randint(0, 100000)


@@ -632,15 +631,15 @@


            try:


                if state == trade_manager.TRADE_STATE_BUY_DELEGATED or state == trade_manager.TRADE_STATE_BUY_PLACE_ORDER:


                    # 已挂单


                    cls.__process_order(code, 0, 140, capture_timestamp)


                    cls.__process_order(code, 1552, 1641, capture_timestamp)


                else:


                    # 未挂单


                    cls.__process_not_order(code, 0, 140, capture_timestamp)


                    cls.__process_not_order(code, 1552, 1641, capture_timestamp)


            except Exception as e:


                logging.exception(e)


            print("处理时间", round((t.time() - _start) * 1000))


            return




        _start = t.time()


        # 按s批量化数据


        total_datas = local_today_datas[code]


        start_time = total_datas[0]["val"]["time"]


@@ -671,6 +670,20 @@




        print("时间花费:", round((t.time() - _start) * 1000))




    @classmethod


    def test1(cls):


        code = "002556"


        l2_trade_test.clear_trade_data(code)


        l2_data_manager.local_latest_datas[code] = []


        load_l2_data(code, True)


        _start = t.time()


        capture_timestamp = 1999999999


        cls.process(code, l2_data_manager.local_today_datas[code][1552:1641], capture_timestamp)


        print("时间花费:", round((t.time() - _start) * 1000))


        pass






if __name__ == "__main__":


    L2TradeDataProcessor.test()


    print("----------------------")


    L2TradeDataProcessor.test()