异常保护

Administrator

4 天以前 48fb7a00951f91bdc707e5dd2d196e5bccb752c3

 trade/trade_result_manager.py

@@ -1,84 +1,171 @@
# 虚拟买成功
import logging

import dask

from l2 import l2_data_manager
from l2.cancel_buy_strategy import HourCancelBigNumComputer, SecondCancelBigNumComputer, L2LimitUpSellStatisticUtil
from l2.l2_data_util import local_today_datas, local_today_num_operate_map
from l2.safe_count_manager import BuyL2SafeCountManager
from log import logger_l2_error
from trade import trade_data_manager
from cancel_strategy.s_l_h_cancel_strategy import HourCancelBigNumComputer
from cancel_strategy.s_l_h_cancel_strategy import LCancelBigNumComputer
from cancel_strategy.s_l_h_cancel_strategy import SCancelBigNumComputer
from code_attribute.gpcode_manager import MustBuyCodesManager, GreenListCodeManager, WantBuyCodesManager, \
    WhiteListCodeManager
from l2 import l2_data_manager, place_order_single_data_manager
from l2.cancel_buy_strategy import FCancelBigNumComputer, \
    NewGCancelBigNumComputer, JCancelBigNumComputer, NBCancelBigNumComputer
from l2.l2_data_manager import OrderBeginPosInfo
from l2.l2_data_util import local_today_datas, L2DataUtil
from l2.l2_sell_manager import L2MarketSellManager
from log_module.log import logger_l2_error
from trade import trade_record_log_util
from trade.buy_radical.radical_buy_data_manager import RadicalBuyDataManager
from trade.trade_data_manager import PlaceOrderCountManager
from trade.trade_queue_manager import THSBuy1VolumnManager
from utils import buy_condition_util

__thsBuy1VolumnManager = THSBuy1VolumnManager()
__buyL2SafeCountManager = BuyL2SafeCountManager()


def virtual_buy_success(code):
    # 已经不需要了，暂时注释掉
    # 增加下单计算
    trade_data_manager.placeordercountmanager.place_order(code)
    # trade_data_manager.PlaceOrderCountManager().place_order(code)
    # 删除之前的板上卖信息
    L2LimitUpSellStatisticUtil.delete(code)
    # L2LimitUpSellStatisticUtil().delete(code)
    pass


# 虚拟撤成功
def virtual_cancel_success(code, buy_single_index, buy_exec_index, total_datas):
    f1 = dask.delayed(l2_data_manager.TradePointManager.delete_buy_point)(code)
    f2 = dask.delayed(l2_data_manager.TradePointManager.delete_buy_cancel_point)(code)
    f3 = dask.delayed(l2_data_manager.TradePointManager.delete_compute_info_for_cancel_buy)(code)
    f4 = dask.delayed(l2_data_manager.TradePointManager.delete_count_info_for_cancel_buy)(code)
    # 安全笔数计算
    f5 = dask.delayed(__buyL2SafeCountManager.save_place_order_info)(code, buy_single_index, buy_exec_index,
                                                                     total_datas[-1]["index"])
    f6 = dask.delayed(SecondCancelBigNumComputer.cancel_success)(code)
    dask.compute(f1, f2, f3, f4, f5, f6)
    l2_data_manager.TradePointManager().delete_buy_point(code)
    SCancelBigNumComputer().cancel_success(code)
    LCancelBigNumComputer().cancel_success(code)
    NewGCancelBigNumComputer().cancel_success(code)
    JCancelBigNumComputer().cancel_success(code)
    NBCancelBigNumComputer().cancel_success(code)
    # dask.compute(f1, f2, f5, f6, f7, f8)


# 真实买成功
def real_buy_success(code):
    @dask.delayed
def real_buy_success(code, tradePointManager):
    def clear_max_buy1_volume(code):
        # 下单成功，需要删除最大买1
        __thsBuy1VolumnManager.clear_max_buy1_volume(code)

    @dask.delayed
    def safe_count(code, buy_single_index, buy_exec_index):
        try:
            __buyL2SafeCountManager.save_place_order_info(code, buy_single_index, buy_exec_index, None)
        except Exception as e:
            logging.exception(e)
            logger_l2_error.exception(e)

    @dask.delayed
    def h_cancel(code, buy_single_index, buy_exec_index):
        try:
            HourCancelBigNumComputer.place_order_success(code, buy_single_index, buy_exec_index,
                                                         local_today_datas.get(code),
                                                         local_today_num_operate_map.get(code))
            HourCancelBigNumComputer().place_order_success(code, buy_single_index, buy_exec_index,
                                                           local_today_datas.get(code))
        except Exception as e:
            logging.exception(e)
            logger_l2_error.exception(e)

    buy_single_index, buy_exec_index, buy_compute_index, num, count, max_num_set = l2_data_manager.TradePointManager.get_buy_compute_start_data(
    def l_cancel(code):
        try:
            LCancelBigNumComputer().place_order_success(code)
        except Exception as e:
            logging.exception(e)
            logger_l2_error.exception(e)

    def s_cancel(code):
        try:
            SCancelBigNumComputer().place_order_success(code)
        except Exception as e:
            logging.exception(e)
            logger_l2_error.exception(e)

    def f_cancel(code):
        try:
            FCancelBigNumComputer().place_order_success(code)
        except Exception as e:
            logging.exception(e)
            logger_l2_error.exception(e)

    def g_cancel(code):
        try:
            NewGCancelBigNumComputer().place_order_success(code)
        except Exception as e:
            logging.exception(e)
            logger_l2_error.exception(e)

    order_begin_pos = tradePointManager.get_buy_compute_start_data_cache(
        code)

    f1 = clear_max_buy1_volume(code)
    f2 = safe_count(code, buy_single_index, buy_exec_index)
    f3 = h_cancel(code, buy_single_index, buy_exec_index)
    dask.compute(f1, f2, f3)
    l2_data_manager.TradePointManager.delete_buy_cancel_point(code)
    clear_max_buy1_volume(code)
    s_cancel(code)
    # H撤暂时不生效
    h_cancel(code, order_begin_pos.buy_single_index, order_begin_pos.buy_exec_index)
    l_cancel(code)
    g_cancel(code)
    JCancelBigNumComputer().place_order_success(code)
    NBCancelBigNumComputer().place_order_success(code)
    if order_begin_pos.mode == OrderBeginPosInfo.MODE_FAST:
        f_cancel(code)
        # 记录卖盘统计时间被用
        L2MarketSellManager().set_sell_time_used(code, order_begin_pos.sell_info[0])
    # 下单成功
    PlaceOrderCountManager().place_order(code)
    # 下单成功之后移除红名单
    if not GreenListCodeManager().is_in_cache(code):
        MustBuyCodesManager().remove_code(code)

    # 如果是绿名单，下单之后就加红
    # if GreenListCodeManager().is_in_cache(code):
    #     MustBuyCodesManager().add_code(code)
    #     trade_record_log_util.add_must_buy(code, "如果是绿名单，下单之后就加红")

    # 如果是扫入下单，下单之后就加红
    if order_begin_pos.mode == OrderBeginPosInfo.MODE_RADICAL:
        # 移除人为移白
        WhiteListCodeManager().clear_huamn_info(code)
        RadicalBuyDataManager.place_order_success(code)

    # 清除下单信号
    place_order_single_data_manager.L2TradeSingleDataManager.clear_data(code)


__latest_cancel_l2_data_dict = {}


# 真实撤成功
def real_cancel_success(code, buy_single_index, buy_exec_index, total_datas):
    # 安全笔数计算
    f1 = dask.delayed(__buyL2SafeCountManager.save_place_order_info)(code, buy_single_index, buy_exec_index,
                                                                     total_datas[-1]["index"])
def real_cancel_success(code, buy_single_index, buy_exec_index, total_datas, from_real_cancel=False):
    """
    撤单
    @param code:
    @param buy_single_index:
    @param buy_exec_index:
    @param total_datas:
    @param from_real_cancel: 是否是真实撤单
    @return:
    """
    # 取消买入标识
    f2 = dask.delayed(l2_data_manager.TradePointManager.delete_buy_point)(code)
    f3 = dask.delayed(l2_data_manager.TradePointManager.delete_buy_cancel_point)(code)
    f4 = dask.delayed(l2_data_manager.TradePointManager.delete_compute_info_for_cancel_buy)(code)
    f5 = dask.delayed(l2_data_manager.TradePointManager.delete_count_info_for_cancel_buy)(code)
    f6 = dask.delayed(SecondCancelBigNumComputer.cancel_success)(code)
    dask.compute(f1, f2, f3, f4, f5, f6)
    l2_data_manager.TradePointManager().delete_buy_point(code)
    SCancelBigNumComputer().cancel_success(code)
    LCancelBigNumComputer().cancel_success(code)
    FCancelBigNumComputer().cancel_success(code)
    NewGCancelBigNumComputer().cancel_success(code)
    JCancelBigNumComputer().cancel_success(code)
    NBCancelBigNumComputer().cancel_success(code)
    # 记录最近的撤单时间
    if from_real_cancel:
        __latest_cancel_l2_data_dict[code] = total_datas[-1]

    if from_real_cancel:
        # 撤单成功需要移除红名单
        if GreenListCodeManager().is_in_cache(code):
            GreenListCodeManager().remove_code(code)
            if WantBuyCodesManager().is_in_cache(code):
                WantBuyCodesManager().remove_code(code)
        if MustBuyCodesManager().is_in_cache(code):
            MustBuyCodesManager().remove_code(code)


# 根据撤单时间判断是否可以下单
def can_place_order_for_cancel_time(code, buy_exec_data):
    if code not in __latest_cancel_l2_data_dict:
        return True
    threshold_time_space = buy_condition_util.get_cancel_and_buy_space_time(code)
    if L2DataUtil.time_sub_as_ms(buy_exec_data["val"],
                                 __latest_cancel_l2_data_dict[code]["val"]) >= threshold_time_space:
        return True
    return False


if __name__ == "__main__":
    pass