9:25之前的开1订阅

Administrator

2024-06-04 dc36d72459ea92e4c78e2a2eefb5655e82a3d459

 code_attribute/gpcode_manager.py

@@ -294,6 +294,170 @@
        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)

    def __new__(cls, *args, **kwargs):
        if not cls.__instance:
            cls.__instance = super(WhiteListCodeManager, cls).__new__(cls, *args, **kwargs)
            # 初始化设置
            # 获取交易窗口的锁
            cls.__instance.__white_codes_cache = RedisUtils.smembers(cls.__get_redis(), "white_list_codes")

        return cls.__instance

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

    def sync(self):
        data = RedisUtils.smembers(self.__get_redis(), "white_list_codes")
        self.__white_codes_cache.clear()
        if data:
            self.__white_codes_cache |= data

    def add_code(self, code):
        self.__white_codes_cache.add(code)
        RedisUtils.sadd(self.__get_redis(), "white_list_codes", code)
        RedisUtils.expire(self.__get_redis(), "white_list_codes", tool.get_expire())

    def remove_code(self, code):
        self.__white_codes_cache.discard(code)
        RedisUtils.srem(self.__get_redis(), "white_list_codes", code)

    def is_in(self, code):
        return RedisUtils.sismember(self.__get_redis(), "white_list_codes", code)

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

    def list_codes(self):
        return RedisUtils.smembers(self.__get_redis(), "white_list_codes")

    def list_codes_cache(self):
        return self.__white_codes_cache

    def clear(self):
        self.__white_codes_cache.clear()
        RedisUtils.delete(self.__get_redis(), "white_list_codes")


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

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

        return cls.__instance

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

    def add_code(self, code):
        self.__forbidden_trade_codes_cache.add(code)
        RedisUtils.sadd_async(self.__db, "forbidden-trade-codes", code)
        RedisUtils.expire_async(self.__db, "forbidden-trade-codes", tool.get_expire())

    def sync(self):
        data = RedisUtils.smembers(self.__get_redis(),
                                   "forbidden-trade-codes")
        self.__forbidden_trade_codes_cache.clear()
        if data:
            self.__forbidden_trade_codes_cache |= data

    def remove_code(self, code):
        self.__forbidden_trade_codes_cache.discard(code)
        RedisUtils.srem(self.__get_redis(), "forbidden-trade-codes", code)

    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

    def list_codes_cache(self):
        return self.__forbidden_trade_codes_cache

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


def __parse_codes_data(code_datas):
    codes = []
    name_codes = {}
@@ -590,8 +754,6 @@
def get_limit_up_price_cache(code):
    if code in __limit_up_price_dict:
        return __limit_up_price_dict[code]


    return None


@@ -601,6 +763,12 @@
    return tool.to_price(decimal.Decimal(str(price)) * decimal.Decimal("1.1"))


def get_limit_down_price_by_preprice(price):
    if price is None:
        return None
    return tool.to_price(decimal.Decimal(str(price)) * decimal.Decimal("0.9"))


# 获取跌停价
def get_limit_down_price(code):
    price = CodePrePriceManager.get_price_pre_cache(code)