blame | 历史 | 补丁 | 提交 | 提交对比 | ignore whitespace
Administrator
2023-08-03 90886c62a62ecbd64c9b229b48e4ef2cf600ae43 
 code_attribute/gpcode_manager.py


@@ -17,6 +17,7 @@




class CodesNameManager:


    redisManager = redis_manager.RedisManager(0)


    __gp_list_names_first_cache = []




    @classmethod


    def __get_redis(cls):


@@ -44,8 +45,8 @@


        return None




    @classmethod


    def list_second_code_name_dict(cls):


        val = RedisUtils.get(cls.__get_redis(), "gp_list_names")


    def list_first_code_name_dict_cache(cls):


        val = RedisUtils.get(cls.__get_redis(), "gp_list_names_first")


        if val is not None:


            val = json.loads(val)


            return val


@@ -61,16 +62,6 @@


            if val[k] == code:


                return k


        return None




    @classmethod


    def get_second_code_name(cls, code):


        val = RedisUtils.get(cls.__get_redis(), "gp_list_names")


        if not val:


            return None


        val = json.loads(val)


        for k in val:


            if val[k] == code:


                return k




    @classmethod


    def get_first_name_code(cls, name):


@@ -89,6 +80,34 @@


        val[name] = code


        cls.set_first_code_names(val)




    # 设置首板代码名称


    @classmethod


    def set_first_code_names(cls, datas):


        RedisUtils.set(cls.__get_redis(), "gp_list_names_first", json.dumps(datas))




    # 删除首板代码名称


    @classmethod


    def clear_first_code_names(cls):


        RedisUtils.delete(cls.__get_redis(), "gp_list_names_first")




    @classmethod


    def list_second_code_name_dict(cls):


        val = RedisUtils.get(cls.__get_redis(), "gp_list_names")


        if val is not None:


            val = json.loads(val)


            return val


        return None




    @classmethod


    def get_second_code_name(cls, code):


        val = RedisUtils.get(cls.__get_redis(), "gp_list_names")


        if not val:


            return None


        val = json.loads(val)


        for k in val:


            if val[k] == code:


                return k




    @classmethod


    def get_second_name_code(cls, name):


        val = RedisUtils.get(cls.__get_redis(), "gp_list_names")


@@ -97,20 +116,10 @@


        val = json.loads(val)


        return val.get(name)




    # 设置首板代码名称


    @classmethod


    def set_first_code_names(cls, datas):


        RedisUtils.set(cls.__get_redis(), "gp_list_names_first", json.dumps(datas))




    # 设置二板代码名称


    @classmethod


    def set_second_code_names(cls, datas):


        RedisUtils.set(cls.__get_redis(), "gp_list_names", json.dumps(datas))




    # 删除首板代码名称


    @classmethod


    def clear_first_code_names(cls):


        RedisUtils.delete(cls.__get_redis(), "gp_list_names_first")




    # 设置二板代码名称


    @classmethod


@@ -120,71 +129,114 @@




# 首板代码管理


class FirstCodeManager:


    redisManager = redis_manager.RedisManager(0)


    __instance = None




    @classmethod


    def __get_redis(cls):


        return cls.redisManager.getRedis()


    def __new__(cls, *args, **kwargs):


        if not cls.__instance:


            cls.__instance = super(FirstCodeManager, cls).__new__(cls, *args, **kwargs)


            # 初始化设置


            # 获取交易窗口的锁


            cls.__instance.redisManager = redis_manager.RedisManager(0)


            cls.__instance.__first_code_record_cache = RedisUtils.smembers(cls.__instance.__get_redis(),


                                                                           "first_code_record")


            cls.__instance.__first_code_limited_up_record_cache = RedisUtils.smembers(cls.__instance.__get_redis(),


                                                                                      "first_code_limited_up_record")


        return cls.__instance




    def __get_redis(self):


        return self.redisManager.getRedis()




    # 加入首板历史记录


    @classmethod


    def add_record(cls, codes):


    def add_record(self, codes):


        hasChanged = False


        for code in codes:


            RedisUtils.sadd(cls.__get_redis(), "first_code_record", code)


        RedisUtils.expire(cls.__get_redis(), "first_code_record", tool.get_expire())


            if code not in self.__first_code_record_cache:


                RedisUtils.sadd(self.__get_redis(), "first_code_record", code)


                hasChanged = True


            self.__first_code_record_cache.add(code)


        if hasChanged:


            RedisUtils.expire(self.__get_redis(), "first_code_record", tool.get_expire())




    @classmethod


    def is_in_first_record(cls, code):


        if RedisUtils.sismember(cls.__get_redis(), "first_code_record", code):


    def is_in_first_record(self, code):


        if RedisUtils.sismember(self.__get_redis(), "first_code_record", code):


            return True


        else:


            return False




    def is_in_first_record_cache(self, code):


        return code in self.__first_code_record_cache




    # 加入首板涨停过代码集合


    @classmethod


    def add_limited_up_record(cls, codes):


    def add_limited_up_record(self, codes):


        hasChanged = False


        for code in codes:


            RedisUtils.sadd(cls.__get_redis(), "first_code_limited_up_record", code)


        RedisUtils.expire(cls.__get_redis(), "first_code_limited_up_record", tool.get_expire())


            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)


        if hasChanged:


            RedisUtils.expire(self.__get_redis(), "first_code_limited_up_record", tool.get_expire())




    # 是否涨停过


    @classmethod


    def is_limited_up(cls, code):


        if RedisUtils.sismember(cls.__get_redis(), "first_code_limited_up_record", code):


    def is_limited_up(self, code):


        if RedisUtils.sismember(self.__get_redis(), "first_code_limited_up_record", code):


            return True


        else:


            return False




    def is_limited_up_cache(self, code):


        return code in self.__first_code_limited_up_record_cache






# 想要买的代码


class WantBuyCodesManager:


    redisManager = redis_manager.RedisManager(0)


    __redis_key = "want_buy_codes"


    __instance = None




    @classmethod


    def __get_redis(cls):


        return cls.redisManager.getRedis()


    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




    @classmethod


    def clear(cls):


        RedisUtils.delete(cls.__get_redis(), cls.__redis_key)


    __want_buy_codes_cache = set()




    @classmethod


    def add_code(cls, code):


        RedisUtils.sadd(cls.__get_redis(), cls.__redis_key, code)


        RedisUtils.expire(cls.__get_redis(), cls.__redis_key, tool.get_expire())


    def __get_redis(self):


        return self.redisManager.getRedis()




    @classmethod


    def remove_code(cls, code):


        RedisUtils.srem(cls.__get_redis(), cls.__redis_key, code)


    def clear(self):


        RedisUtils.delete(self.__get_redis(), self.__redis_key)




    @classmethod


    def is_in(cls, code):


        return RedisUtils.sismember(cls.__get_redis(), cls.__redis_key, code)


    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 list_code(cls):


        return RedisUtils.smembers(cls.__get_redis(), cls.__redis_key)


    def remove_code(self, code):


        self.__want_buy_codes_cache.discard(code)


        RedisUtils.srem(self.__get_redis(), self.__redis_key, code)




    def sync(self):


        self.__want_buy_codes_cache.clear()


        codes = RedisUtils.smembers(self.__get_redis(), self.__redis_key)


        if codes:


            self.__want_buy_codes_cache += set(codes)




    def is_in(self, code):


        return RedisUtils.sismember(self.__get_redis(), self.__redis_key, code)




    def is_in_cache(self, code):


        return code in self.__want_buy_codes_cache




    def list_code(self):


        return RedisUtils.smembers(self.__get_redis(), self.__redis_key)




    def list_code_cache(self):


        return self.__want_buy_codes_cache






# 暂停下单代码管理


@@ -264,6 +316,9 @@


    CodesNameManager.set_second_code_names(old_name_codes)






__gp_list_first_codes_cache = set()






# -------------------------------首板代码管理-------------------------------


# 添加首板代码


# code_datas 掘金返回的数据


@@ -273,7 +328,7 @@


    codes_set = set()


    for code in codes:


        codes_set.add(code)


    old_codes_set = RedisUtils.smembers(redis_instance, "gp_list_first")


    old_codes_set = __gp_list_first_codes_cache


    if old_codes_set is None:


        old_codes_set = set()


    del_set = old_codes_set - codes_set


@@ -282,7 +337,12 @@


        RedisUtils.sadd(redis_instance, "gp_list_first", code)


    for code in del_set:


        RedisUtils.srem(redis_instance, "gp_list_first", code)


    RedisUtils.expire(redis_instance, "gp_list_first", tool.get_expire())


    if add_codes or del_set:


        RedisUtils.expire(redis_instance, "gp_list_first", tool.get_expire())


    # 更新缓存


    __gp_list_first_codes_cache.clear()


    for code in codes_set:


        __gp_list_first_codes_cache.add(code)




    old_name_codes = CodesNameManager.list_first_code_name_dict()


    if old_name_codes is None:


@@ -401,35 +461,38 @@


    return list






# 获取收盘价


def get_price_pre(code):


    redis_instance = __redisManager.getRedis()


    result = RedisUtils.get(redis_instance, "price-pre-{}".format(code))


    if result is not None:


        return float(result)


    return None


class CodePrePriceManager:


    __price_pre_cache = {}


    __redisManager = redis_manager.RedisManager(0)




    # 获取收盘价


    @classmethod


    def get_price_pre(cls, code):


        redis_instance = cls.__redisManager.getRedis()


        result = RedisUtils.get(redis_instance, "price-pre-{}".format(code))


        if result is not None:


            return float(result)


        return None




__price_pre_cache = {}


    # 获取缓存


    @classmethod


    def get_price_pre_cache(cls, code):


        if code in cls.__price_pre_cache:


            return float(cls.__price_pre_cache[code])


        val = cls.get_price_pre(code)


        if val:


            cls.__price_pre_cache[code] = val


        return val






# 获取缓存


def get_price_pre_cache(code):


    if code in __price_pre_cache:


        return __price_pre_cache[code]


    val = get_price_pre(code)


    if val:


        __price_pre_cache[code] = val


    return val






# 设置收盘价


def set_price_pre(code, price, force=False):


    codes = get_gp_list()


    if code not in codes and not FirstCodeManager.is_in_first_record(code) and not force:


        return


    redis_instance = __redisManager.getRedis()


    RedisUtils.setex(redis_instance, "price-pre-{}".format(code), tool.get_expire(), str(price))


    # 设置收盘价


    @classmethod


    def set_price_pre(cls, code, price, force=False):


        codes = get_gp_list()


        if code not in codes and not FirstCodeManager().is_in_first_record_cache(code) and not force:


            return


        redis_instance = cls.__redisManager.getRedis()


        RedisUtils.setex(redis_instance, "price-pre-{}".format(code), tool.get_expire(), str(price))


        cls.__price_pre_cache[code] = float(price)






__limit_up_price_dict = {}


@@ -440,7 +503,7 @@


    # 读取内存中的值


    if code in __limit_up_price_dict:


        return __limit_up_price_dict[code]


    price = get_price_pre(code)


    price = CodePrePriceManager.get_price_pre_cache(code)


    if price is None:


        return None


    limit_up_price = tool.to_price(decimal.Decimal(str(price)) * decimal.Decimal("1.1"))


@@ -456,7 +519,7 @@




# 获取跌停价


def get_limit_down_price(code):


    price = get_price_pre(code)


    price = CodePrePriceManager.get_price_pre_cache(code)


    if price is None:


        return None


    return tool.to_price(decimal.Decimal(str(price)) * decimal.Decimal("0.9"))


@@ -471,8 +534,14 @@


    return None






__current_price_cache = {}






# 设置现价


def set_price(code, price):


    if code in __current_price_cache and __current_price_cache[code] == price:


        return


    __current_price_cache[code] = price


    redis_instance = __redisManager.getRedis()


    RedisUtils.setex(redis_instance, "price-{}".format(code), tool.get_expire(), price)