redis上级缓存添加

Administrator

2023-08-03 35cf19418535fb67cd51919a744177249d052ba1

redis上级缓存添加

 code_attribute/first_target_code_data_processor.py

@@ -34,7 +34,7 @@
            codes.append(code)

    # ---查询想买单，如果没有在列表中就需要强行加入列表
    want_codes = gpcode_manager.WantBuyCodesManager.list_code()
    want_codes = gpcode_manager.WantBuyCodesManager().list_code_cache()
    if want_codes:
        # 没有在现价采集中的想买代码
        diff_codes = set(want_codes) - set(codes)

 code_attribute/gpcode_manager.py

@@ -170,7 +170,7 @@
    def add_limited_up_record(self, codes):
        hasChanged = False
        for code in codes:
            if code not in  self.__first_code_limited_up_record_cache:
            if code not in self.__first_code_limited_up_record_cache:
                RedisUtils.sadd(self.__get_redis(), "first_code_limited_up_record", code)
                hasChanged = True
            self.__first_code_limited_up_record_cache.add(code)
@@ -190,47 +190,53 @@

# 想要买的代码
class WantBuyCodesManager:
    redisManager = redis_manager.RedisManager(0)
    __redis_key = "want_buy_codes"
    __instance = None

    def __new__(cls, *args, **kwargs):
        if not cls.__instance:
            cls.__instance = super(WantBuyCodesManager, cls).__new__(cls, *args, **kwargs)
            # 初始化设置
            # 获取交易窗口的锁
            cls.__instance.redisManager = redis_manager.RedisManager(0)
            cls.__instance.__redis_key = "want_buy_codes"
            cls.__instance.__want_buy_codes_cache = RedisUtils.smembers(cls.__instance.__get_redis(),
                                                                        cls.__instance.__redis_key)
        return cls.__instance

    __want_buy_codes_cache = set()

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

    @classmethod
    def clear(cls):
        RedisUtils.delete(cls.__get_redis(), cls.__redis_key)
    def clear(self):
        RedisUtils.delete(self.__get_redis(), self.__redis_key)

    @classmethod
    def add_code(cls, code):
        cls.__want_buy_codes_cache.add(code)
        RedisUtils.sadd(cls.__get_redis(), cls.__redis_key, code)
        RedisUtils.expire(cls.__get_redis(), cls.__redis_key, tool.get_expire())
    def add_code(self, code):
        self.__want_buy_codes_cache.add(code)
        RedisUtils.sadd(self.__get_redis(), self.__redis_key, code)
        RedisUtils.expire(self.__get_redis(), self.__redis_key, tool.get_expire())

    @classmethod
    def remove_code(cls, code):
        cls.__want_buy_codes_cache.discard(code)
        RedisUtils.srem(cls.__get_redis(), cls.__redis_key, code)
    def remove_code(self, code):
        self.__want_buy_codes_cache.discard(code)
        RedisUtils.srem(self.__get_redis(), self.__redis_key, code)

    @classmethod
    def sync(cls):
        cls.__want_buy_codes_cache.clear()
        codes = RedisUtils.smembers(cls.__get_redis(), cls.__redis_key)
    def sync(self):
        self.__want_buy_codes_cache.clear()
        codes = RedisUtils.smembers(self.__get_redis(), self.__redis_key)
        if codes:
            cls.__want_buy_codes_cache += set(codes)
            self.__want_buy_codes_cache += set(codes)

    @classmethod
    def is_in(cls, code):
        return RedisUtils.sismember(cls.__get_redis(), cls.__redis_key, code)
    def is_in(self, code):
        return RedisUtils.sismember(self.__get_redis(), self.__redis_key, code)

    @classmethod
    def is_in_cache(cls, code):
        return code in cls.__want_buy_codes_cache
    def is_in_cache(self, code):
        return code in self.__want_buy_codes_cache

    @classmethod
    def list_code(cls):
        return RedisUtils.smembers(cls.__get_redis(), cls.__redis_key)
    def list_code(self):
        return RedisUtils.smembers(self.__get_redis(), self.__redis_key)

    def list_code_cache(self):
        return self.__want_buy_codes_cache


# 暂停下单代码管理

 inited_data.py

@@ -76,9 +76,9 @@
        # 清空白名单
        l2_trade_util.WhiteListCodeManager.clear()
        # 清空想要买
        gpcode_manager.WantBuyCodesManager.clear()
        gpcode_manager.WantBuyCodesManager().clear()
        # 清空分数禁止代码
        trade_manager.ForbiddenBuyCodeByScoreManager.clear()
        trade_manager.ForbiddenBuyCodeByScoreManager().clear()
        # 清空暂停交易代码
        gpcode_manager.PauseBuyCodesManager.clear()
        # 清除L撤数据

 l2/l2_data_manager_new.py

@@ -863,7 +863,7 @@
                                      cls.__l2PlaceOrderParamsManagerDict[code].score_index,
                                      cls.__l2PlaceOrderParamsManagerDict[code].score_info)

        if not gpcode_manager.WantBuyCodesManager.is_in_cache(code):
        if not gpcode_manager.WantBuyCodesManager().is_in_cache(code):
            if TradeTargetCodeModeManager.get_mode() == TradeTargetCodeModeManager.MODE_ONLY_BUY_WANT_CODES:
                return False, True, f"只买想买单中的代码"
            score_index = cls.__l2PlaceOrderParamsManagerDict[code].score_index

 output/code_info_output.py

@@ -85,7 +85,7 @@
    if l2_trade_util.WhiteListCodeManager.is_in(code):
        code_extra_infos.append("白名单")
    # 获取白名单,黑名单
    if code_attribute.gpcode_manager.WantBuyCodesManager.is_in_cache(code):
    if code_attribute.gpcode_manager.WantBuyCodesManager().is_in_cache(code):
        code_extra_infos.append("想买单")
    if code_attribute.gpcode_manager.PauseBuyCodesManager.is_in(code):
        code_extra_infos.append("暂不买")

 server.py

@@ -726,7 +726,7 @@
                    data = json.loads(_str)
                    codes = data["data"]["codes"]
                    for code in codes:
                        gpcode_manager.WantBuyCodesManager.add_code(code)
                        gpcode_manager.WantBuyCodesManager().add_code(code)
                        name = gpcode_manager.get_code_name(code)
                        if not name:
                            results = HistoryKDatasUtils.get_gp_codes_names([code])
@@ -741,7 +741,7 @@
                    data = json.loads(_str)
                    codes = data["data"]["codes"]
                    for code in codes:
                        gpcode_manager.WantBuyCodesManager.remove_code(code)
                        gpcode_manager.WantBuyCodesManager().remove_code(code)
                    return_str = json.dumps({"code": 0})
                elif type == 403:
                    plate = None
@@ -755,7 +755,7 @@
                                if code_map[k] == plate:
                                    include_codes.add(k)

                    codes = gpcode_manager.WantBuyCodesManager.list_code()
                    codes = gpcode_manager.WantBuyCodesManager().list_code_cache()
                    datas = []
                    for code in codes:
                        if plate and plate != '其他' and code not in include_codes:
@@ -810,7 +810,7 @@
                    code = data["data"]["code"]
                    # 查询是否想买单/白名单/黑名单/暂不买
                    code_name = gpcode_manager.get_code_name(code)
                    want = gpcode_manager.WantBuyCodesManager.is_in_cache(code)
                    want = gpcode_manager.WantBuyCodesManager().is_in_cache(code)
                    white = l2_trade_util.WhiteListCodeManager.is_in(code)
                    black = l2_trade_util.is_in_forbidden_trade_codes(code)
                    pause_buy = gpcode_manager.PauseBuyCodesManager.is_in(code)

 third_data/code_plate_key_manager.py

@@ -398,7 +398,8 @@
            for k in k2:
                if k not in constant.KPL_INVALID_BLOCKS:
                    keys.add(k)
        if not keys:
        # 始终获取精选板块
        if True:
            # 获取
            jx_blocks = cls.__KPLCodeJXBlockManager.get_jx_blocks(code)
            if jx_blocks:
@@ -437,7 +438,7 @@
                            pen_limit_up_codes) + 1:
                        # 属于龙1,龙2
                        can_buy_blocks.append((block,
                                               f"{block}：top4涨停板块，主板开1({pen_limit_up_codes}),属于主板前龙{len(pen_limit_up_codes) + 1}(实时身位-{current_shsz_rank})"))
                                               f"{block}：top10涨停板块，主板开1({pen_limit_up_codes}),属于主板前龙{len(pen_limit_up_codes) + 1}(实时身位-{current_shsz_rank})"))
                        continue
                    else:
                        msg_list.append(

 third_data/data_server.py

@@ -59,7 +59,7 @@
        for k in limit_up_reason_dict:
            limit_up_reason_dict[k].sort(key=lambda x: int(x[5]))
        # 统计想买单数量
        want_codes = gpcode_manager.WantBuyCodesManager.list_code()
        want_codes = gpcode_manager.WantBuyCodesManager().list_code_cache()
        limit_up_reason_want_count_dict = {}
        for d in total_datas:
            if d[2] not in limit_up_reason_want_count_dict:
@@ -207,7 +207,7 @@
            codes_set = set([d[0] for d in temps])
            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()
            want_codes = gpcode_manager.WantBuyCodesManager().list_code_cache()
            black_codes = BlackListCodeManager.list_codes()
            total_datas = KPLLimitUpDataRecordManager.total_datas
            code_info_dict = {}
@@ -374,7 +374,7 @@
                    [d[3], d[4], tool.to_time_str(int(d[5])), d[3] not in now_limit_up_codes, False, False])
            codes_info.sort(key=lambda x: x[2])
            # 查询是否为想买单
            want_codes = gpcode_manager.WantBuyCodesManager.list_code()
            want_codes = gpcode_manager.WantBuyCodesManager().list_code_cache()
            for code_info in codes_info:
                code_info[4] = 1 if code_info[0] in want_codes else 0
                # 获取代码状态

 trade/current_price_process_manager.py

@@ -35,7 +35,7 @@
    now_str = tool.get_now_time_str()
    now_strs = now_str.split(":")
    # 获取想买单
    want_codes = gpcode_manager.WantBuyCodesManager.list_code()
    want_codes = gpcode_manager.WantBuyCodesManager().list_code_cache()
    if True:
        _code_list = []
        _delete_list = []
@@ -48,7 +48,7 @@
                rate = round((price - pricePre) * 100 / pricePre, 2)
                if first_codes and code in first_codes:
                    rate = rate / 2
                if rate >= 0 and not trade_manager.ForbiddenBuyCodeByScoreManager.is_in(code):
                if rate >= 0 and not trade_manager.ForbiddenBuyCodeByScoreManager().is_in_cache(code):
                    # 暂存涨幅为正的代码
                    _code_list.append((rate, code, 1 if code in want_codes else 0))
                else:

 trade/l2_trade_factor.py

@@ -99,7 +99,7 @@
                break
        self.score_index = score_index
        # 只要加入想买单的，全部执行主动买入二星方案
        if gpcode_manager.WantBuyCodesManager.is_in_cache(code):
        if gpcode_manager.WantBuyCodesManager().is_in_cache(code):
            self.score_index = 1
            self.is_want_buy = True
        else:

 trade/trade_manager.py

@@ -55,7 +55,7 @@
    # 开启购买入口
    @classmethod
    def open_buy(cls):
        RedisUtils.setex(cls.__get_redis(),"trade_buy_state", tool.get_expire(), 1)
        RedisUtils.setex(cls.__get_redis(), "trade_buy_state", tool.get_expire(), 1)

    # 关闭购买入口
    @classmethod
@@ -107,34 +107,43 @@

# 根据分数禁止买的票管理
class ForbiddenBuyCodeByScoreManager:
    __redisManager = redis_manager.RedisManager(2)
    __key = "forbidden_codes_by_score"
    __instance = None

    @classmethod
    def __get_redis(cls):
        return cls.__redisManager.getRedis()
    def __new__(cls, *args, **kwargs):
        if not cls.__instance:
            cls.__instance = super(ForbiddenBuyCodeByScoreManager, cls).__new__(cls, *args, **kwargs)
            cls.__instance.__redisManager = redis_manager.RedisManager(2)
            cls.__instance.__key = "forbidden_codes_by_score"
            cls.__instance.__forbidden_codes_by_score_cache = RedisUtils.smembers(cls.__instance.__get_redis(),
                                                                                  cls.__instance.__key)
        return cls.__instance

    @classmethod
    def add_code(cls, code):
        RedisUtils.sadd( cls.__get_redis(), cls.__key, code)
    def __get_redis(self):
        return self.__redisManager.getRedis()

    @classmethod
    def remove_code(cls, code):
        RedisUtils.srem(cls.__get_redis(), cls.__key, code)
    def add_code(self, code):
        self.__forbidden_codes_by_score_cache.add(code)
        RedisUtils.sadd(self.__get_redis(), self.__key, code)

    @classmethod
    def is_in(cls, code):
        return RedisUtils.sismember( cls.__get_redis(), cls.__key, code)
    def remove_code(self, code):
        self.__forbidden_codes_by_score_cache.discard(code)
        RedisUtils.srem(self.__get_redis(), self.__key, code)

    @classmethod
    def clear(cls):
        RedisUtils.delete( cls.__get_redis(), cls.__key)
    def is_in(self, code):
        return RedisUtils.sismember(self.__get_redis(), self.__key, code)

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

    def clear(self):
        self.__forbidden_codes_by_score_cache.clear()
        RedisUtils.delete(self.__get_redis(), self.__key)


# 获取交易状态
def get_trade_state(code):
    redis = __redis_manager.getRedis()
    state =RedisUtils.get(redis, "trade-state-{}".format(code))
    state = RedisUtils.get(redis, "trade-state-{}".format(code))
    if state is None:
        return TRADE_STATE_NOT_TRADE
    return int(state)
@@ -172,7 +181,7 @@
# 设置交易账户的可用金额
def set_available_money(client_id, money):
    redis = __redis_manager.getRedis()
    RedisUtils.set(redis,"trade-account-canuse-money", money)
    RedisUtils.set(redis, "trade-account-canuse-money", money)


# 获取交易账户的可用金额
@@ -243,8 +252,8 @@

    # 保存最新的委托数据
    redis = __redis_manager.getRedis()
    RedisUtils.setex(redis,"trade-delegate-latest", tool.get_expire(), json.dumps(datas))
    RedisUtils.setex(redis,"trade-delegate-latest-time", tool.get_expire(), time_str)
    RedisUtils.setex(redis, "trade-delegate-latest", tool.get_expire(), json.dumps(datas))
    RedisUtils.setex(redis, "trade-delegate-latest-time", tool.get_expire(), time_str)


# 获取交易成功数据
@@ -259,14 +268,14 @@
                "time": result[5], "trade_num": result[6], "type": result[7], "day": result[8],
                "create_time": result[9]}
        datas.append(data)
    return datas, RedisUtils.get(redis,"trade-success-latest-time")
    return datas, RedisUtils.get(redis, "trade-success-latest-time")


# 获取交易委托数据
def get_trade_delegate_data():
    redis = __redis_manager.getRedis()
    result = RedisUtils.get(redis, "trade-delegate-latest")
    time_str =RedisUtils.get(redis, "trade-delegate-latest-time")
    time_str = RedisUtils.get(redis, "trade-delegate-latest-time")
    if result is None:
        return [], time_str
    else:
@@ -360,7 +369,7 @@
            if constant.TRADE_WAY == constant.TRADE_WAY_JUEJIN:
                trade_juejin.order_volume(code, price, count)
            elif constant.TRADE_WAY == constant.TRADE_WAY_HUAXIN:
                trade_huaxin.order_volume(code, price, count,last_data_index)
                trade_huaxin.order_volume(code, price, count, last_data_index)
        else:
            guiTrade.buy(code, price)
        __place_order_success(code, capture_timestamp, last_data, last_data_index)
@@ -542,7 +551,7 @@
    redis_l2 = redis_manager.RedisManager(1).getRedis()
    keys = RedisUtils.keys(redis_l2, "big_data-*")
    for k in keys:
        RedisUtils.delete( redis_l2, k)
        RedisUtils.delete(redis_l2, k)


if __name__ == "__main__":