blame | 历史 | 补丁 | 提交 | 提交对比 | ignore whitespace
Administrator
2023-09-01 2f7fea8cbc410351ff1b2fce571e1fe92e682a71 
 code_attribute/gpcode_manager.py


@@ -5,8 +5,8 @@


import time




import constant


from db import redis_manager


from db.redis_manager import RedisUtils


from db import redis_manager_delegate as redis_manager


from db.redis_manager_delegate import RedisUtils


from utils import tool


import decimal




@@ -16,6 +16,7 @@






class CodesNameManager:


    __db = 0


    redisManager = redis_manager.RedisManager(0)


    __gp_list_names_first_cache = []




@@ -83,7 +84,7 @@


    # 设置首板代码名称


    @classmethod


    def set_first_code_names(cls, datas):


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


        RedisUtils.set_async(cls.__db, "gp_list_names_first", json.dumps(datas))




    # 删除首板代码名称


    @classmethod


@@ -130,6 +131,7 @@


# 首板代码管理


class FirstCodeManager:


    __instance = None


    __db = 0




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


        if not cls.__instance:


@@ -151,11 +153,11 @@


        hasChanged = False


        for code in codes:


            if code not in self.__first_code_record_cache:


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


                RedisUtils.sadd_async(self.__db, "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())


            RedisUtils.expire_async(self.__db, "first_code_record", tool.get_expire())




    def is_in_first_record(self, code):


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


@@ -171,11 +173,11 @@


        hasChanged = False


        for code in codes:


            if code not in self.__first_code_limited_up_record_cache:


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


                RedisUtils.sadd_async(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())


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




    # 是否涨停过


    def is_limited_up(self, code):


@@ -191,22 +193,23 @@


# 想要买的代码


class WantBuyCodesManager:


    __instance = None


    redisManager = redis_manager.RedisManager(0)


    __redis_key = "want_buy_codes"




    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)


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


                                                                        cls.__redis_key)


        return cls.__instance




    __want_buy_codes_cache = set()




    def __get_redis(self):


        return self.redisManager.getRedis()


    @classmethod


    def __get_redis(cls):


        return cls.redisManager.getRedis()




    def clear(self):


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


@@ -221,10 +224,10 @@


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




    def sync(self):


        codes = self.list_code()


        self.__want_buy_codes_cache.clear()


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


        if codes:


            self.__want_buy_codes_cache += set(codes)


            self.__want_buy_codes_cache |= set(codes)




    def is_in(self, code):


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


@@ -242,33 +245,52 @@


# 暂停下单代码管理


# 与黑名单的区别是暂停交易代码只是不交易，不能移除L2监控位


class PauseBuyCodesManager:


    __instance = None


    redisManager = redis_manager.RedisManager(0)


    __redis_key = "pause_buy_codes"




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


        if not cls.__instance:


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


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


                                                                         cls.__redis_key)


        return cls.__instance




    @classmethod


    def __get_redis(cls):


        return cls.redisManager.getRedis()




    @classmethod


    def clear(cls):


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


    def clear(self):


        self.__pause_buy_codes_cache.clear()


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




    @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 sync(self):


        data = RedisUtils.smembers(self.__get_redis(),


                                   self.__redis_key)


        self.__pause_buy_codes_cache.clear()


        if data:


            self.__pause_buy_codes_cache |= data




    @classmethod


    def remove_code(cls, code):


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


    def add_code(self, code):


        self.__pause_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 is_in(cls, code):


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


    def remove_code(self, code):


        self.__pause_buy_codes_cache.discard(code)


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




    @classmethod


    def list_code(cls):


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


    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.__pause_buy_codes_cache




    def list_code(self):


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




    def list_code_cache(self):


        return self.__pause_buy_codes_cache






def __parse_codes_data(code_datas):


@@ -299,7 +321,7 @@


            RedisUtils.sadd(redis_instance, "gp_list", d, auto_free=False)


        CodesNameManager.set_second_code_names(name_codes)


    finally:


        redis_instance.connection_pool.disconnect()


        RedisUtils.realse(redis_instance)






# 新增代码


@@ -319,67 +341,107 @@


                old_name_codes[key] = name_codes[key]


        CodesNameManager.set_second_code_names(old_name_codes)


    finally:


        redis_instance.connection_pool.disconnect()






__gp_list_first_codes_cache = set()


        RedisUtils.realse(redis_instance)






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


# 添加首板代码


# code_datas 掘金返回的数据


def set_first_gp_codes_with_data(code_datas):


    redis_instance = __redisManager.getRedis()


    try:


        codes, name_codes = __parse_codes_data(code_datas)


        codes_set = set()


        for code in codes:


            codes_set.add(code)


        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


        add_codes = codes_set - old_codes_set


        for code in add_codes:


            RedisUtils.sadd(redis_instance, "gp_list_first", code, auto_free=False)


        for code in del_set:


            RedisUtils.srem(redis_instance, "gp_list_first", code, auto_free=False)


        if add_codes or del_set:


            RedisUtils.expire(redis_instance, "gp_list_first", tool.get_expire(), auto_free=False)


        # 更新缓存


        __gp_list_first_codes_cache.clear()


        for code in codes_set:


            __gp_list_first_codes_cache.add(code)


class FirstGPCodesManager:


    __db = 0


    __redisManager = redis_manager.RedisManager(0)


    __gp_list_first_codes_cache = set()


    __instance = None




        old_name_codes = CodesNameManager.list_first_code_name_dict()


        if old_name_codes is None:


            old_name_codes = name_codes


        else:


            for key in name_codes:


                old_name_codes[key] = name_codes[key]


        CodesNameManager.set_first_code_names(old_name_codes)


    finally:


        redis_instance.connection_pool.disconnect()


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


        if not cls.__instance:


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


            cls.__load_datas()


        return cls.__instance




    @classmethod


    def __get_redis(cls):


        return cls.__redisManager.getRedis()




# 移除首板代码


def remove_first_gp_code(codes):


    redis_instance = __redisManager.getRedis()


    try:


        for code in codes:


            RedisUtils.srem(redis_instance, "gp_list_first", code, auto_free=False)


    finally:


        redis_instance.connection_pool.disconnect()


    @classmethod


    def __load_datas(cls):


        __redis = cls.__get_redis()


        try:


            cls.__gp_list_first_codes_cache = RedisUtils.smembers(__redis, "gp_list_first")


        finally:


            RedisUtils.realse(__redis)




    @classmethod


    def __parse_codes_data(cls, code_datas):


        codes = []


        name_codes = {}


        for _data in code_datas:


            # 正常的股票


            if _data["sec_type"] == 1 and _data["sec_level"] == 1:


                code = _data["symbol"].split(".")[1]


                if code.find("30") != 0 and code.find("68") != 0:


                    name = _data["sec_name"]


                    codes.append(code)


                    # 保存代码对应的名称


                    name_codes[name] = code


        return codes, name_codes




# 获取首板代码


def get_first_gp_codes():


    return RedisUtils.smembers(__redisManager.getRedis(), "gp_list_first")


    # 添加首板代码


    # code_datas 掘金返回的数据


    def set_first_gp_codes_with_data(self, code_datas):


        redis_instance = self.__get_redis()


        try:


            codes, name_codes = self.__parse_codes_data(code_datas)


            codes_set = set()


            for code in codes:


                codes_set.add(code)


            old_codes_set = self.__gp_list_first_codes_cache


            if old_codes_set is None:


                old_codes_set = set()


            del_set = old_codes_set - codes_set


            add_codes = codes_set - old_codes_set


            for code in add_codes:


                RedisUtils.sadd_async(self.__db, "gp_list_first", code, auto_free=False)


            for code in del_set:


                RedisUtils.srem_async(self.__db, "gp_list_first", code, auto_free=False)


            if add_codes or del_set:


                RedisUtils.expire_async(self.__db, "gp_list_first", tool.get_expire(), auto_free=False)


            # 更新缓存


            self.__gp_list_first_codes_cache.clear()


            self.__gp_list_first_codes_cache |= codes_set




            old_name_codes = CodesNameManager.list_first_code_name_dict()


            if old_name_codes is None:


                old_name_codes = name_codes


            else:


                for key in name_codes:


                    old_name_codes[key] = name_codes[key]


            CodesNameManager.set_first_code_names(old_name_codes)


        finally:


            RedisUtils.realse(redis_instance)




# 是否在首板里面


def is_in_first_gp_codes(code):


    return RedisUtils.sismember(__redisManager.getRedis(), "gp_list_first", code)


    # 移除首板代码


    def remove_first_gp_code(self, codes):


        redis_instance = self.__get_redis()


        try:


            for code in codes:


                self.__gp_list_first_codes_cache.discard(code)


                RedisUtils.srem(redis_instance, "gp_list_first", code, auto_free=False)


        finally:


            RedisUtils.realse(redis_instance)




    # 获取首板代码


    def get_first_gp_codes(self):


        return RedisUtils.smembers(self.__get_redis(), "gp_list_first")




    def get_first_gp_codes_cache(self):


        return self.__gp_list_first_codes_cache




    # 是否在首板里面


    def is_in_first_gp_codes(self, code):


        return RedisUtils.sismember(self.__get_redis(), "gp_list_first", code)




    # 是否在首板里面


    def is_in_first_gp_codes_cache(self, code):


        return code in self.__gp_list_first_codes_cache






# 获取名称对应的代码


@@ -425,9 +487,11 @@


        for d in gpset:


            RedisUtils.sadd(redis_instance, "gp_limit_up_list", json.dumps(d), auto_free=False)


        RedisUtils.expire(redis_instance, "gp_limit_up_list", tool.get_expire(), auto_free=False)


        RedisUtils.setex(redis_instance, "gp_limit_up_list_update_time", tool.get_expire(), round(time.time() * 1000), auto_free=False)


        RedisUtils.setex(redis_instance, "gp_limit_up_list_update_time", tool.get_expire(), round(time.time() * 1000),


                         auto_free=False)


    finally:


        redis_instance.connection_pool.disconnect()


        RedisUtils.realse(redis_instance)






# 获取涨停列表


def get_limit_up_list():


@@ -437,21 +501,21 @@


                              auto_free=False), RedisUtils.smembers(redis_instance,


                                                                    "gp_limit_up_list", auto_free=False)


    finally:


        redis_instance.connection_pool.disconnect()


        RedisUtils.realse(redis_instance)






def rm_gp(code):


    RedisUtils.srem(__redisManager.getRedis(), "gp_list", code)


    remove_first_gp_code([code])


    FirstGPCodesManager().remove_first_gp_code([code])






def is_in_gp_pool(code):


    return RedisUtils.sismember(__redisManager.getRedis(), "gp_list", code) or is_in_first_gp_codes(code)


    return RedisUtils.sismember(__redisManager.getRedis(), "gp_list", code) or FirstGPCodesManager().is_in_first_gp_codes_cache(code)






def get_gp_list():


    codes = RedisUtils.smembers( __redisManager.getRedis(), "gp_list")


    first_codes = get_first_gp_codes()


    codes = RedisUtils.smembers(__redisManager.getRedis(), "gp_list")


    first_codes = FirstGPCodesManager().get_first_gp_codes_cache()


    return set.union(codes, first_codes)






@@ -501,7 +565,7 @@


        codes = get_gp_list()


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


            return


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


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


        cls.__price_pre_cache[code] = float(price)






@@ -554,6 +618,18 @@


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






# datas:[(code,price)]


def set_prices(datas):


    pipe = __redisManager.getRedis().pipeline()


    for d in datas:


        code, price = d[0], d[1]


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


            continue


        __current_price_cache[code] = price


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


    pipe.execute()






# 获取正在监听的代码


def get_listen_codes():


    redis_instance = __redisManager.getRedis()


@@ -566,7 +642,7 @@


                codes.add(code)


        return codes


    finally:


        redis_instance.connection_pool.disconnect()


        RedisUtils.realse(redis_instance)






# 根据位置获取正在监听的代码


@@ -617,7 +693,7 @@


        for code_ in codes_set:


            RedisUtils.delete(redis_instance, code_, auto_free=False)


    finally:


        redis_instance.connection_pool.disconnect()


        RedisUtils.realse(redis_instance)






# 初始化位置


@@ -635,7 +711,7 @@


        for key in keys:


            RedisUtils.setex(redis_instance, key, tool.get_expire(), "", auto_free=False)


    finally:


        redis_instance.connection_pool.disconnect()


        RedisUtils.realse(redis_instance)






def clear_first_codes():


@@ -646,7 +722,7 @@


        RedisUtils.delete(redis_instance, "first_code_record", auto_free=False)


        RedisUtils.delete(redis_instance, "first_code_limited_up_record", auto_free=False)


    finally:


        redis_instance.connection_pool.disconnect()


        RedisUtils.realse(redis_instance)






# 获取可以操作的位置


@@ -673,7 +749,7 @@


                available_positions.append((client_id, int(key.replace("listen_code-{}-".format(client_id), ""))))


            else:


                codes.append((key, result))


        redis_instance.connection_pool.disconnect()


        RedisUtils.realse(redis_instance)


        # 查询是否有重复的代码


        codes_set = set()


        count = 0


@@ -711,7 +787,7 @@


                if not code:


                    free_count += 1


        finally:


            redis_instance.connection_pool.disconnect()


            RedisUtils.realse(redis_instance)


    return free_count






@@ -760,7 +836,7 @@




# 设置正在操作的代码


def set_operate(code):


    RedisUtils.setex( __redisManager.getRedis(), "gp_operate-{}".format(code), 30, "1")


    RedisUtils.setex(__redisManager.getRedis(), "gp_operate-{}".format(code), 30, "1")






# 批量设置正在操作的代码


@@ -781,7 +857,7 @@


        for code in codes:


            RedisUtils.delete(redis_instance, "gp_operate-{}".format(code), auto_free=False)


    finally:


        redis_instance.connection_pool.disconnect()


        RedisUtils.realse(redis_instance)






if __name__ == '__main__':