redis上级缓存添加

Administrator

2023-08-03 783f6b0c18272b7f9ee988664c4194ecc80e23a7

redis上级缓存添加

 l2/code_price_manager.py

@@ -45,6 +45,9 @@

    @classmethod
    def __save_buy1_price(cls, code, buy_1_price):
        # 不保存重复的数据
        if code in cls.__current_buy_1_price and cls.__current_buy_1_price[code] == buy_1_price:
            return
        cls.__current_buy_1_price[code] = buy_1_price
        RedisUtils.setex(cls.__get_redis(), f"buy1_price-{code}", tool.get_expire(), buy_1_price)


 output/code_info_output.py

@@ -80,7 +80,7 @@
    day = tool.get_now_date_str()
    is_target_code = gpcode_manager.FirstCodeManager().is_in_first_record_cache(code)
    code_extra_infos = []
    if l2_trade_util.BlackListCodeManager.is_in_cache(code):
    if l2_trade_util.BlackListCodeManager().is_in_cache(code):
        code_extra_infos.append("黑名单")
    if l2_trade_util.WhiteListCodeManager.is_in(code):
        code_extra_infos.append("白名单")

 server.py

@@ -707,7 +707,7 @@
                    return_str = json.dumps({"code": 0})
                elif type == 301:
                    # 黑名单列表
                    codes = l2_trade_util.BlackListCodeManager.list_codes()
                    codes = l2_trade_util.BlackListCodeManager().list_codes()
                    datas = []
                    for code in codes:
                        name = gpcode_manager.get_code_name(code)

 third_data/code_plate_key_manager.py

@@ -408,7 +408,7 @@

        # 涨停列表中匹配关键词，返回（板块:代码集合），代码集合中已经排除自身
        if not keys:
            return cls.BLOCK_TYPE_NONE, None, "尚未找到涨停原因"
            return None, "尚未找到涨停原因"
        code_limit_up_reason_dict = {}
        load_code_block()
        msg_list = []
@@ -469,7 +469,7 @@
                            f"板块-{block}: 不是top4涨停板块，满足精选/行业流入要求,不为主板龙1（实时身位-{current_shsz_rank},历史身位-{record_shsz_rank}）")
                        continue
        if len(can_buy_blocks) == len(keys):
            blocks = "/".join([x[0] for x in can_buy_blocks])
            blocks = [x[0] for x in can_buy_blocks]
            blocks_msg = "\n".join([x[1] for x in can_buy_blocks])
            return blocks, blocks_msg

@@ -483,10 +483,10 @@
        if constant.TEST:
            return True, "", cls.BLOCK_TYPE_NONE

        block, block_msg = cls.get_can_buy_block(code, current_limit_up_datas,
                                                 limit_up_record_datas, yesterday_current_limit_up_codes,
                                                 before_blocks_dict)
        if block is None:
        blocks, block_msg = cls.get_can_buy_block(code, current_limit_up_datas,
                                                  limit_up_record_datas, yesterday_current_limit_up_codes,
                                                  before_blocks_dict)
        if not blocks:
            return False, block_msg

        # ---------------------------------判断目标代码的板块-------------------start------------
@@ -567,11 +567,11 @@
        # ---------------------------------加载已经下单/成交的代码信息------------end-------------

        msg_list = []
        for key in [block]:
        for key in blocks:
            # 板块中已经有成交的就不下单了
            if key in trade_success_blocks_count:
                success_codes_count = len(trade_success_blocks_count[key])
                if success_codes_count >= 2:
                if success_codes_count >= 1:
                    msg_list.append(f"【{key}】中已经有{success_codes_count}个成交代码")
                    log.logger_kpl_debug.debug(f"{code}：板块（{key}）已经有成交【{trade_success_blocks_count[key]}】")
                    continue

 third_data/data_server.py

@@ -208,7 +208,7 @@
            limit_up_dict, limit_up_codes, open_limit_up_codes = limit_up_data_filter.get_limit_up_info(codes_set)
            score_dict = limit_up_data_filter.get_codes_scores_dict(codes_set)
            want_codes = gpcode_manager.WantBuyCodesManager().list_code_cache()
            black_codes = BlackListCodeManager.list_codes()
            black_codes = BlackListCodeManager().list_codes()
            total_datas = KPLLimitUpDataRecordManager.total_datas
            code_info_dict = {}
            for val in total_datas:

 trade/l2_trade_util.py

@@ -36,58 +36,61 @@


class BlackListCodeManager:
    __redis_manager = redis_manager.RedisManager(2)
    __forbidden_trade_codes_cache = set()
    __instance = None

    @classmethod
    def __get_redis(cls):
        return cls.__redis_manager.getRedis()
    def __new__(cls, *args, **kwargs):
        if not cls.__instance:
            cls.__instance = super(BlackListCodeManager, cls).__new__(cls, *args, **kwargs)
            # 初始化设置
            # 获取交易窗口的锁
            cls.__instance.__redis_manager = redis_manager.RedisManager(2)
            cls.__instance.__forbidden_trade_codes_cache = RedisUtils.smembers(cls.__instance.__get_redis(),
                                                                               "forbidden-trade-codes")

    @classmethod
    def add_code(cls, code):
        cls.__forbidden_trade_codes_cache.add(code)
        RedisUtils.sadd(cls.__get_redis(), "forbidden-trade-codes", code)
        RedisUtils.expire(cls.__get_redis(), "forbidden-trade-codes", tool.get_expire())
        return cls.__instance

    @classmethod
    def remove_code(cls, code):
        cls.__forbidden_trade_codes_cache.discard(code)
        RedisUtils.srem(cls.__get_redis(), "forbidden-trade-codes", code)
    def __get_redis(self):
        return self.__redis_manager.getRedis()

    @classmethod
    def is_in(cls, code):
        return RedisUtils.sismember(cls.__get_redis(), "forbidden-trade-codes", code)
    def add_code(self, code):
        self.__forbidden_trade_codes_cache.add(code)
        RedisUtils.sadd(self.__get_redis(), "forbidden-trade-codes", code)
        RedisUtils.expire(self.__get_redis(), "forbidden-trade-codes", tool.get_expire())

    @classmethod
    def is_in_cache(cls, code):
        return code in cls.__forbidden_trade_codes_cache
    def remove_code(self, code):
        self.__forbidden_trade_codes_cache.discard(code)
        RedisUtils.srem(self.__get_redis(), "forbidden-trade-codes", code)

    @classmethod
    def list_codes(cls):
        codes = RedisUtils.smembers(cls.__get_redis(), "forbidden-trade-codes")
        cls.__forbidden_trade_codes_cache = codes
    def is_in(self, code):
        return RedisUtils.sismember(self.__get_redis(), "forbidden-trade-codes", code)

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

    def list_codes(self):
        codes = RedisUtils.smembers(self.__get_redis(), "forbidden-trade-codes")
        self.__forbidden_trade_codes_cache = codes
        return codes

    @classmethod
    def clear(cls):
        cls.__forbidden_trade_codes_cache.clear()
        RedisUtils.delete(cls.__get_redis(), "forbidden-trade-codes")
    def clear(self):
        self.__forbidden_trade_codes_cache.clear()
        RedisUtils.delete(self.__get_redis(), "forbidden-trade-codes")


#  初始化禁止交易代码库
def init_forbidden_trade_codes():
    BlackListCodeManager.clear()
    BlackListCodeManager.add_code("000000")
    BlackListCodeManager().clear()
    BlackListCodeManager().add_code("000000")


# 移除禁止交易代码
def remove_from_forbidden_trade_codes(code):
    BlackListCodeManager.remove_code(code)
    BlackListCodeManager().remove_code(code)


# 添加代码到禁止交易
def add_to_forbidden_trade_codes(code):
    BlackListCodeManager.add_code(code)
    BlackListCodeManager().add_code(code)


# 禁止代码交易
@@ -98,7 +101,7 @@


def is_in_forbidden_trade_codes(code):
    return BlackListCodeManager.is_in_cache(code)
    return BlackListCodeManager().is_in_cache(code)


if __name__ == "__main__":

 trade/trade_data_manager.py

@@ -161,7 +161,18 @@

# 代码实时价格管理器
class CodeActualPriceProcessor:
    __redisManager = redis_manager.RedisManager(0)
    __instance = None

    def __new__(cls, *args, **kwargs):
        if not cls.__instance:
            cls.__instance = super(CodeActualPriceProcessor, cls).__new__(cls, *args, **kwargs)
            # 初始化设置
            # 获取交易窗口的锁
            cls.__instance.__redisManager = redis_manager.RedisManager(0)
            cls.__instance.__under_water_last_time_cache = {}
            cls.__instance.__code_current_rate_cache = {}

        return cls.__instance

    def __get_redis(self):
        return self.__redisManager.getRedis()
@@ -169,15 +180,25 @@
    # 保存跌价的时间
    def __save_down_price_time(self, code, time_str):
        key = "under_water_last_time-{}".format(code)
        tool.CodeDataCacheUtil.set_cache(self.__under_water_last_time_cache, code, time_str)
        RedisUtils.setex(self.__get_redis(), key, tool.get_expire(), time_str)

    def __remove_down_price_time(self, code):
        key = "under_water_last_time-{}".format(code)
        tool.CodeDataCacheUtil.clear_cache(self.__under_water_last_time_cache, code)
        RedisUtils.delete(self.__get_redis(), key)

    def __get_last_down_price_time(self, code):
        key = "under_water_last_time-{}".format(code)
        return RedisUtils.get(self.__get_redis(), key)

    def __get_last_down_price_time_cache(self, code):
        cache_result = tool.CodeDataCacheUtil.get_cache(self.__under_water_last_time_cache, code)
        if cache_result[0]:
            return cache_result[1]
        val = self.__get_last_down_price_time(code)
        tool.CodeDataCacheUtil.set_cache(self.__under_water_last_time_cache, code, val)
        return val

    def __increment_down_price_time(self, code, seconds):
        key = "under_water_seconds-{}".format(code)
@@ -212,6 +233,7 @@

    # 保存当前涨幅
    def __save_current_rate(self, code, rate):
        tool.CodeDataCacheUtil.set_cache(self.__code_current_rate_cache, code, rate)
        key = "code_current_rate-{}".format(code)
        RedisUtils.setex(self.__get_redis(), key, tool.get_expire(), rate)

@@ -224,7 +246,12 @@
        return None

    def get_current_rate(self, code):
        return self.__get_current_rate(code)
        cache_result = tool.CodeDataCacheUtil.get_cache(self.__code_current_rate_cache, code)
        if cache_result[0]:
            return cache_result[1]
        val = self.__get_current_rate(code)
        tool.CodeDataCacheUtil.set_cache(self.__code_current_rate_cache, code, val)
        return val

    def process_rate(self, code, rate, time_str):
        # 保存目前的代码涨幅
@@ -234,7 +261,7 @@
            return
        # now_str = tool.get_now_time_str()
        if rate >= 0:
            down_start_time = self.__get_last_down_price_time(code)
            down_start_time = self.__get_last_down_price_time_cache(code)
            if down_start_time is None:
                return
            else:
@@ -245,7 +272,7 @@
                self.__remove_down_price_time(code)
        else:
            # 记录开始值
            if self.__get_last_down_price_time(code) is None:
            if self.__get_last_down_price_time_cache(code) is None:
                self.__save_down_price_time(code, time_str)

    # 保存现价
@@ -292,7 +319,7 @@
        infos = []
        for k in keys:
            code = k.split("-")[1]
            rate = self.__get_current_rate(code)
            rate = self.get_current_rate(code)
            infos.append((code, rate))
        # 排序信息
        sorted_infos = sorted(infos, key=lambda tup: tup[1], reverse=True)