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


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




import constant


from db import redis_manager


from db.redis_manager import RedisUtils


from utils import tool


import decimal




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




class CodesNameManager:


    redisManager = redis_manager.RedisManager(0)


    __gp_list_names_first_cache = []




    @classmethod


    def __get_redis(cls):


@@ -36,15 +38,15 @@




    @classmethod


    def list_first_code_name_dict(cls):


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


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


        if val is not None:


            val = json.loads(val)


            return val


        return None




    @classmethod


    def list_second_code_name_dict(cls):


        val = cls.__get_redis().get("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


@@ -52,7 +54,7 @@




    @classmethod


    def get_first_code_name(cls, code):


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


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


        if not val:


            return None


        val = json.loads(val)


@@ -62,8 +64,43 @@


        return None




    @classmethod


    def get_first_name_code(cls, name):


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


        if not val:


            return None


        val = json.loads(val)


        return val.get(name)




    @classmethod


    def add_first_code_name(cls, code, name):


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


        if not val:


            return None


        val = json.loads(val)


        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 = cls.__get_redis().get("gp_list_names")


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


        if not val:


            return None


        val = json.loads(val)


@@ -72,49 +109,22 @@


                return k




    @classmethod


    def get_first_name_code(cls, name):


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


        if not val:


            return None


        val = json.loads(val)


        return val.get(name)




    @classmethod


    def add_first_code_name(cls, code, name):


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


        if not val:


            return None


        val = json.loads(val)


        val[name] = code


        cls.set_first_code_names(val)




    @classmethod


    def get_second_name_code(cls, name):


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


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


        if not val:


            return None


        val = json.loads(val)


        return val.get(name)




    # 设置首板代码名称


    @classmethod


    def set_first_code_names(cls, datas):


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




    # 设置二板代码名称


    @classmethod


    def set_second_code_names(cls, datas):


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




    # 删除首板代码名称


    @classmethod


    def clear_first_code_names(cls):


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


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




    # 设置二板代码名称


    @classmethod


    def clear_second_code_names(cls):


        cls.__get_redis().delete("gp_list_names")


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






# 首板代码管理


@@ -129,12 +139,12 @@


    @classmethod


    def add_record(cls, codes):


        for code in codes:


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


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


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


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




    @classmethod


    def is_in_first_record(cls, code):


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


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


            return True


        else:


            return False


@@ -143,13 +153,13 @@


    @classmethod


    def add_limited_up_record(cls, codes):


        for code in codes:


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


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


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


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




    # 是否涨停过


    @classmethod


    def is_limited_up(cls, code):


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


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


            return True


        else:


            return False


@@ -159,6 +169,7 @@


class WantBuyCodesManager:


    redisManager = redis_manager.RedisManager(0)


    __redis_key = "want_buy_codes"


    __want_buy_codes_cache = set()




    @classmethod


    def __get_redis(cls):


@@ -166,24 +177,37 @@




    @classmethod


    def clear(cls):


        cls.__get_redis().delete(cls.__redis_key)


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




    @classmethod


    def add_code(cls, code):


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


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


        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())




    @classmethod


    def remove_code(cls, code):


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


        cls.__want_buy_codes_cache.discard(code)


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




    @classmethod


    def sync(cls):


        cls.__want_buy_codes_cache.clear()


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


        if codes:


            cls.__want_buy_codes_cache += set(codes)




    @classmethod


    def is_in(cls, code):


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


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




    @classmethod


    def is_in_cache(cls, code):


        return code in cls.__want_buy_codes_cache




    @classmethod


    def list_code(cls):


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


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






# 暂停下单代码管理


@@ -198,24 +222,24 @@




    @classmethod


    def clear(cls):


        cls.__get_redis().delete(cls.__redis_key)


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




    @classmethod


    def add_code(cls, code):


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


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


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


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




    @classmethod


    def remove_code(cls, code):


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


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




    @classmethod


    def is_in(cls, code):


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


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




    @classmethod


    def list_code(cls):


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


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






def __parse_codes_data(code_datas):


@@ -239,10 +263,10 @@


    codes, name_codes = __parse_codes_data(code_datas)


    redis_instance = __redisManager.getRedis()


    # 删除之前的


    redis_instance.delete("gp_list")


    RedisUtils.delete(redis_instance, "gp_list")


    CodesNameManager.clear_second_code_names()


    for d in codes:


        redis_instance.sadd("gp_list", d)


        RedisUtils.sadd(redis_instance, "gp_list", d)


    CodesNameManager.set_second_code_names(name_codes)






@@ -253,7 +277,7 @@


    redis_instance = __redisManager.getRedis()


    codes, name_codes = __parse_codes_data(code_datas)


    for d in codes:


        redis_instance.sadd("gp_list", d)


        RedisUtils.sadd(redis_instance, "gp_list", d)


    old_name_codes = CodesNameManager.list_second_code_name_dict()


    if old_name_codes is None:


        old_name_codes = name_codes


@@ -261,6 +285,9 @@


        for key in name_codes:


            old_name_codes[key] = name_codes[key]


    CodesNameManager.set_second_code_names(old_name_codes)






__gp_list_first_codes_cache = set()






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


@@ -272,16 +299,21 @@


    codes_set = set()


    for code in codes:


        codes_set.add(code)


    old_codes_set = redis_instance.smembers("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


    add_codes = codes_set - old_codes_set


    for code in add_codes:


        redis_instance.sadd("gp_list_first", code)


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


    for code in del_set:


        redis_instance.srem("gp_list_first", code)


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


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


    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:


@@ -296,19 +328,19 @@


def remove_first_gp_code(codes):


    redis_instance = __redisManager.getRedis()


    for code in codes:


        redis_instance.srem("gp_list_first", code)


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






# 获取首板代码


def get_first_gp_codes():


    redis_instance = __redisManager.getRedis()


    return redis_instance.smembers("gp_list_first")


    return RedisUtils.smembers(redis_instance, "gp_list_first")






# 是否在首板里面


def is_in_first_gp_codes(code):


    redis_instance = __redisManager.getRedis()


    return redis_instance.sismember("gp_list_first", code)


    return RedisUtils.sismember(redis_instance, "gp_list_first", code)






# 获取名称对应的代码


@@ -349,33 +381,34 @@


    # 获取基本信息


    redis_instance = __redisManager.getRedis()


    # 删除之前的


    redis_instance.delete("gp_limit_up_list")


    RedisUtils.delete(redis_instance, "gp_limit_up_list")


    for d in gpset:


        redis_instance.sadd("gp_limit_up_list", json.dumps(d))


    redis_instance.expire("gp_limit_up_list", tool.get_expire())


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


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


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


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






# 获取涨停列表


def get_limit_up_list():


    redis_instance = __redisManager.getRedis()


    return redis_instance.get("gp_limit_up_list_update_time"), redis_instance.smembers("gp_limit_up_list")


    return RedisUtils.get(redis_instance, "gp_limit_up_list_update_time"), RedisUtils.smembers(redis_instance,


                                                                                               "gp_limit_up_list")






def rm_gp(code):


    redis_instance = __redisManager.getRedis()


    redis_instance.srem("gp_list", code)


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


    remove_first_gp_code([code])






def is_in_gp_pool(code):


    redis_instance = __redisManager.getRedis()


    return redis_instance.sismember("gp_list", code) or is_in_first_gp_codes(code)


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






def get_gp_list():


    redis_instance = __redisManager.getRedis()


    codes = redis_instance.smembers("gp_list")


    codes = RedisUtils.smembers(redis_instance, "gp_list")


    first_codes = get_first_gp_codes()


    return set.union(codes, first_codes)




@@ -383,7 +416,7 @@


# 获取二板代码


def get_second_gp_list():


    redis_instance = __redisManager.getRedis()


    codes = redis_instance.smembers("gp_list")


    codes = RedisUtils.smembers(redis_instance, "gp_list")


    return codes






@@ -402,10 +435,23 @@


# 获取收盘价


def get_price_pre(code):


    redis_instance = __redisManager.getRedis()


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


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


    if result is not None:


        return float(result)


    return None






__price_pre_cache = {}






# 获取缓存


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






# 设置收盘价


@@ -414,7 +460,7 @@


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


        return


    redis_instance = __redisManager.getRedis()


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


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






__limit_up_price_dict = {}


@@ -425,7 +471,7 @@


    # 读取内存中的值


    if code in __limit_up_price_dict:


        return __limit_up_price_dict[code]


    price = get_price_pre(code)


    price = 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"))


@@ -441,7 +487,7 @@




# 获取跌停价


def get_limit_down_price(code):


    price = get_price_pre(code)


    price = get_price_pre_cache(code)


    if price is None:


        return None


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


@@ -450,25 +496,31 @@


# 获取现价


def get_price(code):


    redis_instance = __redisManager.getRedis()


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


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


    if result is not None:


        return float(result)


    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()


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


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






# 获取正在监听的代码


def get_listen_codes():


    redis_instance = __redisManager.getRedis()


    keys = redis_instance.keys("listen_code-*-*")


    keys = RedisUtils.keys(redis_instance, "listen_code-*-*")


    codes = set()


    for k in keys:


        code = redis_instance.get(k)


        code = RedisUtils.get(redis_instance, k)


        if code is not None and len(code) > 0:


            codes.add(code)


    return codes


@@ -478,7 +530,7 @@


def get_listen_code_by_pos(client_id, pos):


    redis_instance = __redisManager.getRedis()


    key = "listen_code-{}-{}".format(client_id, pos)


    value = redis_instance.get(key)


    value = RedisUtils.get(redis_instance, key)


    # print("redis:", key,value)


    return value




@@ -486,7 +538,7 @@


# 设置位置的监听代码


def set_listen_code_by_pos(client_id, pos, code):


    redis_instance = __redisManager.getRedis()


    redis_instance.setex("listen_code-{}-{}".format(client_id, pos), tool.get_expire(), code)


    RedisUtils.setex(redis_instance, "listen_code-{}-{}".format(client_id, pos), tool.get_expire(), code)


    # 同步监听的代码集合


    __sync_listen_codes_pos()




@@ -495,55 +547,55 @@


def __sync_listen_codes_pos():


    redis_instance = __redisManager.getRedis()


    # 获取已经正在监听的代码


    keys = redis_instance.keys("code_listen_pos-*")


    keys = RedisUtils.keys(redis_instance, "code_listen_pos-*")


    codes_set = set()


    for key in keys:


        codes_set.add(key.replace("code_listen_pos-", ""))




    keys = redis_instance.keys("listen_code-*-*")


    keys = RedisUtils.keys(redis_instance, "listen_code-*-*")




    for key in keys:


        result = redis_instance.get(key)


        result = RedisUtils.get(redis_instance, key)


        if result:


            # 移除需要添加的代码


            codes_set.discard(result)


            client_id_, pos_, code_ = int(key.split("-")[1]), int(key.split("-")[2]), result


            key_ = "code_listen_pos-{}".format(code_)


            val = redis_instance.get(key_)


            val = RedisUtils.get(redis_instance, key_)


            if val is None:


                redis_instance.setex(key_, tool.get_expire(), json.dumps((client_id_, pos_)))


                RedisUtils.setex(redis_instance, key_, tool.get_expire(), json.dumps((client_id_, pos_)))


            else:


                val = json.loads(val)


                if val[0] != client_id_ or val[1] != pos_:


                    redis_instance.setex(key_, tool.get_expire(), json.dumps((client_id_, pos_)))


                    RedisUtils.setex(redis_instance, key_, tool.get_expire(), json.dumps((client_id_, pos_)))




    # 移除没有监听的代码


    for code_ in codes_set:


        redis_instance.delete(code_)


        RedisUtils.delete(redis_instance, code_)






# 初始化位置


def init_listen_code_by_pos(client_id, pos):


    redis_instance = __redisManager.getRedis()


    key = "listen_code-{}-{}".format(client_id, pos)


    redis_instance.setnx(key, "")


    redis_instance.expire(key, tool.get_expire())


    RedisUtils.setnx(redis_instance, key, "")


    RedisUtils.expire(redis_instance, key, tool.get_expire())






# 清除所有监听代码


def clear_listen_codes():


    redis_instance = __redisManager.getRedis()


    keys = redis_instance.keys("listen_code-*-*")


    keys = RedisUtils.keys(redis_instance, "listen_code-*-*")


    for key in keys:


        redis_instance.setex(key, tool.get_expire(), "")


        RedisUtils.setex(redis_instance, key, tool.get_expire(), "")






def clear_first_codes():


    redis_instance = __redisManager.getRedis()


    redis_instance.delete("gp_list_first")


    redis_instance.delete("gp_list_names_first")


    redis_instance.delete("first_code_record")


    redis_instance.delete("first_code_limited_up_record")


    RedisUtils.delete(redis_instance, "gp_list_first")


    RedisUtils.delete(redis_instance, "gp_list_names_first")


    RedisUtils.delete(redis_instance, "first_code_record")


    RedisUtils.delete(redis_instance, "first_code_limited_up_record")






# 获取可以操作的位置


@@ -558,14 +610,14 @@


    for client_id in client_ids:


        redis_instance = __redisManager.getRedis()


        k = "listen_code-{}-*".format(client_id)


        keys = redis_instance.keys(k)


        keys = RedisUtils.keys(redis_instance, k)


        # random.shuffle(keys)


        codes = []


        for key in keys:


            index = key.split("-")[-1]


            if int(index) + 1 > constant.L2_CODE_COUNT_PER_DEVICE:


                continue


            result = redis_instance.get(key)


            result = RedisUtils.get(redis_instance, key)


            if result is None or len(result) == 0:


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


            else:


@@ -583,7 +635,9 @@


        # 获取健康状态


        available_positions_health_states = l2_listen_pos_health_manager.list_health_state(available_positions)


        # 尽量不分配第一个位置


        available_positions_new = sorted(available_positions, key=lambda x: (available_positions_health_states[x], 0 if x[1] ==0 else 1), reverse=True)


        available_positions_new = sorted(available_positions,


                                         key=lambda x: (available_positions_health_states[x], 0 if x[1] == 0 else 1),


                                         reverse=True)


        # available_positions.sort(key=lambda x: available_positions_health_states[x], reverse=True)


        # 取第1个数据


        return available_positions_new[0][0], available_positions_new[0][1]


@@ -598,9 +652,9 @@


    for client_id in client_ids:


        redis_instance = __redisManager.getRedis()


        k = "listen_code-{}-*".format(client_id)


        keys = redis_instance.keys(k)


        keys = RedisUtils.keys(redis_instance, k)


        for key in keys:


            code = redis_instance.get(key)


            code = RedisUtils.get(redis_instance, key)


            if not code:


                free_count += 1


    return free_count


@@ -609,7 +663,7 @@


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


def get_listen_code_pos(code):


    redis_instance = __redisManager.getRedis()


    val = redis_instance.get("code_listen_pos-{}".format(code))


    val = RedisUtils.get(redis_instance, "code_listen_pos-{}".format(code))


    if val is None:


        return None, None


    val = json.loads(val)


@@ -625,7 +679,7 @@


# 是否正在监听


def is_listen(code):


    redis_instance = __redisManager.getRedis()


    val = redis_instance.get("code_listen_pos-{}".format(code))


    val = RedisUtils.get(redis_instance, "code_listen_pos-{}".format(code))


    if val is None:


        return False


    else:


@@ -649,33 +703,35 @@


# 是否正在操作


def is_operate(code):


    redis_instance = __redisManager.getRedis()


    return redis_instance.get("gp_operate-{}".format(code)) is not None


    return RedisUtils.get(redis_instance, "gp_operate-{}".format(code)) is not None






# 设置正在操作的代码


def set_operate(code):


    redis_instance = __redisManager.getRedis()


    redis_instance.setex("gp_operate-{}".format(code), 30, "1")


    RedisUtils.setex(


        redis_instance, "gp_operate-{}".format(code), 30, "1")






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


def set_operates(codes):


    redis_instance = __redisManager.getRedis()


    for code in codes:


        redis_instance.setex("gp_operate-{}".format(code), 30, "1")


        RedisUtils.setex(


            redis_instance, "gp_operate-{}".format(code), 30, "1")






# 移除正在操作的代码


def rm_operate(code):


    redis_instance = __redisManager.getRedis()


    redis_instance.delete("gp_operate-{}".format(code))


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






# 批量移除正在操作的代码


def rm_operates(codes):


    redis_instance = __redisManager.getRedis()


    for code in codes:


        redis_instance.delete("gp_operate-{}".format(code))


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






if __name__ == '__main__':