红名单逻辑添加

Administrator

2023-12-13 1f778b63698d89edeae8625f1c8bf3dd6fdbfe58

红名单逻辑添加

 code_attribute/gpcode_manager.py

@@ -294,6 +294,67 @@
        return self.__pause_buy_codes_cache


# 必买单
class MustBuyCodesManager:
    __instance = None
    __db = 0
    redisManager = redis_manager.RedisManager(0)
    __redis_key = "must_buy_rate-"
    __must_buy_code_cancel_rate_cache = {}

    def __new__(cls, *args, **kwargs):
        if not cls.__instance:
            cls.__instance = super(MustBuyCodesManager, cls).__new__(cls, *args, **kwargs)
            keys = RedisUtils.keys(cls.__get_redis(), cls.__redis_key + "*")
            for k in keys:
                code = k.split("-")[-1]
                val = RedisUtils.get(cls.__get_redis(), k)
                cls.__must_buy_code_cancel_rate_cache[code] = round(float(val), 2)
        return cls.__instance

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

    def clear(self):
        self.__must_buy_code_cancel_rate_cache.clear()
        keys = RedisUtils.keys(self.__get_redis(), self.__redis_key + "*")
        for k in keys:
            RedisUtils.delete(self.__get_redis(), k)

    def add_code(self, code, rate=0.9):
        self.__must_buy_code_cancel_rate_cache[code] = round(rate, 2)
        RedisUtils.setex_async(self.__db, self.__redis_key + str(code), tool.get_expire(), str(round(rate, 2)))

    def remove_code(self, code):
        if code in self.__must_buy_code_cancel_rate_cache:
            self.__must_buy_code_cancel_rate_cache.pop(code)
        RedisUtils.delete_async(self.__db, self.__redis_key + str(code))

    def is_in(self, code):
        return RedisUtils.get(self.__get_redis(), self.__redis_key + str(code))

    def is_in_cache(self, code):
        return code in self.__must_buy_code_cancel_rate_cache

    def list_code(self):
        codes = set()
        keys = RedisUtils.keys(self.__get_redis(), self.__redis_key + "*")
        if keys:
            for k in keys:
                code = k.split("-")[-1]
                codes.add(code)
        return codes

    def list_code_cache(self):
        return self.__must_buy_code_cancel_rate_cache.keys()

    def get_cancel_rate_cache(self, code):
        if code not in self.__must_buy_code_cancel_rate_cache:
            return None
        return self.__must_buy_code_cancel_rate_cache[code]


class WhiteListCodeManager:
    __instance = None
    __redis_manager = redis_manager.RedisManager(2)

 l2/cancel_buy_strategy.py

@@ -686,7 +686,14 @@
                                                                                                             code))
                cancel_num += val['num'] * (data['re'] - left_count)
            rate = round(cancel_num / total_num, 4)
            if rate >= constant.H_CANCEL_RATE:
            must_buy_cancel_rate =  constant.H_CANCEL_RATE
            try:
                temp_rate = gpcode_manager.MustBuyCodesManager().get_cancel_rate_cache(code)
                if temp_rate:
                    must_buy_cancel_rate = temp_rate
            except Exception as e:
                async_log_util.error(logger_l2_h_cancel, str(e))
            if rate >= must_buy_cancel_rate:
                l2_log.h_cancel_debug(code, f"撤单比例：{rate}")
                return True, total_data[-1]
        return False, None
@@ -817,10 +824,18 @@
class LCancelRateManager:
    __block_limit_up_count_dict = {}
    __big_num_deal_rate_dict = {}
    __MustBuyCodesManager = gpcode_manager.MustBuyCodesManager()

    # 获取撤单比例
    @classmethod
    def get_cancel_rate(cls, code, is_up=False):
        try:
            must_buy_cancel_rate = cls.__MustBuyCodesManager.get_cancel_rate_cache(code)
            if must_buy_cancel_rate is not None:
                return must_buy_cancel_rate
        except Exception as e:
            async_log_util.error(logger_l2_l_cancel,str(e))

        base_rate = constant.L_CANCEL_RATE
        if is_up:
            base_rate = constant.L_CANCEL_RATE_UP
@@ -899,6 +914,8 @@

    __SecondCancelBigNumComputer = SecondCancelBigNumComputer()



    __last_l_up_compute_info = {}

    __instance = None

 outside_api_command_manager.py

@@ -41,6 +41,7 @@
CODE_LIST_BLACK = "black"
CODE_LIST_WANT = "want"
CODE_LIST_PAUSE_BUY = "pause_buy"
CODE_LIST_MUST_BUY = "must_buy"

# 类型
API_TYPE_TRADE = "trade"  # 交易

 trade/huaxin/huaxin_trade_server.py

@@ -747,6 +747,24 @@
                        name = gpcode_manager.get_code_name(code)
                        datas.append(f"{name}:{code}")
                    fresult = {"code": 0, "data": datas}
            elif code_list_type == outside_api_command_manager.CODE_LIST_MUST_BUY:
                if operate == outside_api_command_manager.OPERRATE_SET:
                    gpcode_manager.MustBuyCodesManager().add_code(code)
                    name = gpcode_manager.get_code_name(code)
                    if not name:
                        results = HistoryKDatasUtils.get_gp_codes_names([code])
                        if results:
                            gpcode_manager.CodesNameManager.add_first_code_name(code, results[code])
                elif operate == outside_api_command_manager.OPERRATE_DELETE:
                    gpcode_manager.MustBuyCodesManager().remove_code(code)
                elif operate == outside_api_command_manager.OPERRATE_GET:
                    codes = gpcode_manager.MustBuyCodesManager().list_code_cache()
                    datas = []
                    for code in codes:
                        name = gpcode_manager.get_code_name(code)
                        datas.append(f"{name}:{code}")
                    fresult = {"code": 0, "data": datas}

            self.send_response(fresult, client_id, request_id)
        except Exception as e:
            self.send_response({"code": 1, "msg": str(e)}, client_id, request_id)