blame | 历史 | 补丁 | 提交 | 提交对比 | ignore whitespace
Administrator
4 天以前 48fb7a00951f91bdc707e5dd2d196e5bccb752c3 
 test/l2_trade_test.py


@@ -17,14 +17,14 @@


from l2.l2_sell_manager import L2MarketSellManager


from l2.l2_transaction_data_manager import HuaXinSellOrderStatisticManager


from log_module import log, log_export, async_log_util


from trade.huaxin import huaxin_trade_api


from utils import tool


from trade.buy_radical.radical_buy_data_manager import RadicalBuyDataManager, RadicalBuyBlockManager


from utils import tool, init_data_util


from db import redis_manager_delegate as redis_manager


from l2 import l2_log, l2_data_manager, transaction_progress, l2_data_manager_new, l2_transaction_data_processor, \


    cancel_buy_strategy


from l2.transaction_progress import TradeBuyQueue


from third_data import kpl_util, kpl_data_manager, block_info


from third_data.code_plate_key_manager import LimitUpCodesPlateKeyManager, CodePlateKeyBuyManager


from third_data.code_plate_key_manager import LimitUpCodesPlateKeyManager


from third_data.kpl_data_manager import KPLDataManager


from trade import trade_data_manager, current_price_process_manager, l2_trade_util, trade_manager


import l2.l2_data_manager_new, l2.l2_data_manager, l2.l2_data_util, l2.cancel_buy_strategy


@@ -92,7 +92,7 @@


        constant.TEST = True


        trade_manager.TradeStateManager().open_buy()


        threading.Thread(target=async_log_util.run_sync, daemon=True).start()


        code = "000691"


        code = "000590"


        clear_trade_data(code)


        l2.l2_data_util.load_l2_data(code)


        total_datas = deepcopy(l2.l2_data_util.local_today_datas[code])


@@ -154,11 +154,13 @@


            KPLDataManager().get_from_file(kpl_util.KPLDataType.LIMIT_UP, tool.get_now_date_str()))




        kpl_data_manager.KPLLimitUpDataRecordManager.load_total_datas()




        current_price_process_manager.set_trade_price(code, round(float(gpcode_manager.get_limit_up_price(code)), 2))


        limit_up_price = gpcode_manager.get_limit_up_price(code)


        if limit_up_price is None:


            init_data_util.re_set_price_pre(code)


        current_price_process_manager.set_trade_price(code, gpcode_manager.get_limit_up_price_as_num(code))




        pss_server, pss_strategy = multiprocessing.Pipe()


        huaxin_trade_api.run_pipe_trade(pss_server, None, None)


        # huaxin_trade_api.run_pipe_trade(pss_server, None, None)




        for indexs in pos_list:


            l2_log.threadIds[code] = mock.Mock(


@@ -235,31 +237,50 @@




    # @unittest.skip("跳过此单元测试")


    def test_block(self):


        code = "001376"


        # KPLCodeJXBlockManager().load_jx_blocks(code, 23.52,23.62,


        #                                        kpl_data_manager.KPLLimitUpDataRecordManager.get_current_reasons())


        #


        block_info.init_code(code)


        codes_str = "300390"


        codes = codes_str.split(",")  # ["002889", "300337", "001298", "002771"]


        kpl_data_manager.KPLLimitUpDataRecordManager.load_total_datas()


        latest_current_limit_up_records = kpl_data_manager.get_latest_current_limit_up_records()


        kpl_data_manager.KPLLimitUpDataRecordManager.save_record(tool.get_now_date_str(),


                                                                 kpl_data_manager.KPLDataManager.get_data(


                                                                     kpl_util.KPLDataType.LIMIT_UP))


        limit_up_data = kpl_data_manager.KPLLimitUpDataRecordManager.record_code_dict.get(code)


        if limit_up_data:


            limit_up_time = tool.to_time_str(limit_up_data[2])


        CodePlateKeyBuyManager.update_can_buy_blocks(code,


                                                     kpl_data_manager.KPLLimitUpDataRecordManager.latest_origin_datas,


                                                     kpl_data_manager.KPLLimitUpDataRecordManager.total_datas,


                                                     latest_current_limit_up_records,


                                                     block_info.get_before_blocks_dict(),


                                                     kpl_data_manager.KPLLimitUpDataRecordManager.get_current_limit_up_reason_codes_dict())


        can_buy_result = CodePlateKeyBuyManager.can_buy(code)


        print(can_buy_result)


        if can_buy_result:


            if can_buy_result[0]:


                blocks = ",".join([f"{x[0]}-{x[1] + 1}({x[2]}&{x[3] - x[2]})" for x in can_buy_result[0]])


                print(blocks)


        for code in codes:


            # KPLCodeJXBlockManager().load_jx_blocks(code, 23.52,23.62,


            #                                        kpl_data_manager.KPLLimitUpDataRecordManager.get_current_reasons())


            #


            block_info.init_code(code)


            # latest_current_limit_up_records = kpl_data_manager.get_latest_current_limit_up_records()




            init_data_util.re_set_price_pre(code, True)




            limit_up_data = kpl_data_manager.KPLLimitUpDataRecordManager.record_code_dict.get(code)


            if limit_up_data:


                limit_up_time = tool.to_time_str(limit_up_data[2])


            RadicalBuyBlockManager.set_current_limit_up_datas(


                kpl_data_manager.KPLLimitUpDataRecordManager.latest_origin_datas)


            # CodePlateKeyBuyManager.update_can_buy_blocks(code,


            #                                              kpl_data_manager.KPLLimitUpDataRecordManager.latest_origin_datas,


            #                                              kpl_data_manager.KPLLimitUpDataRecordManager.total_datas,


            #                                              latest_current_limit_up_records,


            #                                              block_info.get_before_blocks_dict(),


            #                                              kpl_data_manager.KPLLimitUpDataRecordManager.get_current_limit_up_reason_codes_dict())


            # can_buy_result = CodePlateKeyBuyManager.can_buy(code)


            # print(can_buy_result)


            # if can_buy_result:


            #     if can_buy_result[0]:


            #         blocks = ",".join([f"{x[0]}-{x[1] + 1}({x[2]}&{x[3] - x[2]})" for x in can_buy_result[0]])


            #         print(blocks)




            yesterday_codes = kpl_data_manager.get_yesterday_limit_up_codes()


            if yesterday_codes is None:


                yesterday_codes = set()


            result = RadicalBuyBlockManager.is_radical_buy(code, yesterday_codes)


            print(code, result)


            if result[0]:


                can_buy_result = RadicalBuyDataManager.is_code_can_buy(code)


                if can_buy_result[0]:


                    print("可以买", code, result)


                else:


                    print("不可以买", code, can_buy_result)




        # l2.l2_data_manager_new.L2TradeDataProcessor.can_buy_first(code, None)




@@ -295,6 +316,13 @@


        for d in fdatas:


            l2_transaction_data_processor.HuaXinTransactionDatasProcessor().process_huaxin_transaction_datas(code, d)




    def test_cancel(self):


        code = "603300"


        l2.l2_data_util.load_l2_data(code)


        TradeBuyQueue.get_traded_index = mock.Mock(return_value=(3742, False))


        l2.cancel_buy_strategy.RDCancelBigNumComputer._RDCancelBigNumComputer__watch_indexes_cache ={ code: {3686, 3691, 3693, 3694, 3699, 3700}}


        l2.cancel_buy_strategy.RDCancelBigNumComputer().need_cancel(code, 4370, 4372)






class TestTradedProgress(unittest.TestCase):


    @unittest.skip("跳过此单元测试")