添加新F撤

Administrator

2024-01-12 2dd2e7a717491cb1d7cd06a1065be996f9bbe232

 l2/cancel_buy_strategy.py

@@ -1569,6 +1569,7 @@
            return watch_indexes
        return set()

    #
    def __compute_watch_indexes(self, code, begin_pos_info: OrderBeginPosInfo, total_datas):
        MAX_COUNT = constant.F_CANCEL_WATCH_COUNT
        watch_indexes = self.__get_watch_indexes(code)
@@ -1677,6 +1678,79 @@
        self.clear(code)


# 新F撤，根据成交数据来撤
class FCancelBigNumComputer:
    __db = 0
    __redis_manager = redis_manager.RedisManager(0)
    __cancel_real_order_index_cache = {}

    __instance = None

    def __new__(cls, *args, **kwargs):
        if not cls.__instance:
            cls.__instance = super(FCancelBigNumComputer, cls).__new__(cls, *args, **kwargs)

            cls.__load_datas()
        return cls.__instance

    @classmethod
    def __load_datas(cls):
        __redis = cls.__get_redis()
        try:
            keys = RedisUtils.keys(__redis, "f_cancel_real_order_index-*")
            for k in keys:
                code = k.split("-")[-1]
                val = RedisUtils.get(__redis, k)
                CodeDataCacheUtil.set_cache(cls.__cancel_real_order_index_cache, code, int(val))
        finally:
            RedisUtils.realse(__redis)

    @classmethod
    def __get_redis(cls):
        return cls.__redis_manager.getRedis()

    def __set_real_order_index(self, code, index):
        CodeDataCacheUtil.set_cache(self.__cancel_real_order_index_cache, code, index)
        RedisUtils.setex_async(self.__db, f"f_cancel_real_order_index-{code}", tool.get_expire(), f"{index}")

    def __del_real_order_index(self, code):
        CodeDataCacheUtil.clear_cache(self.__cancel_real_order_index_cache, code)
        RedisUtils.delete_async(self.__db, f"f_cancel_real_order_index-{code}")

    def __get_real_order_index(self, code):
        val = RedisUtils.get(self.__db, f"f_cancel_real_order_index-{code}")
        if val:
            return int(val)
        return None

    def __get_real_order_index_cache(self, code):
        cache_result = CodeDataCacheUtil.get_cache(self.__cancel_real_order_index_cache, code)
        if cache_result[0]:
            return cache_result[1]
        return None

    def clear(self, code=None):
        if code:
            self.__del_real_order_index(code)
        else:
            keys = RedisUtils.keys(self.__get_redis(), "f_cancel_real_order_index-*")
            if keys:
                for k in keys:
                    code = k.split("-")[1]
                    self.__del_real_order_index(code)

    # 设置真实的下单位置,返回是否需要撤单
    def set_real_order_index(self, code, index):
        self.__set_real_order_index(code, index)

    def place_order_success(self, code):
        self.clear(code)

    def cancel_success(self, code):
        self.clear(code)



# ---------------------------------G撤-------------------------------
class GCancelBigNumComputer:
    __real_place_order_index_dict = {}