bug修复

Administrator

2023-12-15 b2582f385fa24b86d08d1a3d5b2630c7194a8087

 code_attribute/code_nature_analyse.py

@@ -18,58 +18,83 @@


class CodeNatureRecordManager:
    __redisManager = RedisManager(0)
    __k_format_cache = {}
    __nature_cache = {}

    __db = 0
    __instance = None
    __redis_manager = redis_manager.RedisManager(0)

    def __new__(cls, *args, **kwargs):
        if not cls.__instance:
            cls.__instance = super(CodeNatureRecordManager, cls).__new__(cls, *args, **kwargs)
            cls.__load_datas()
        return cls.__instance

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

    @classmethod
    def __load_datas(cls):
        __redis = cls.__get_redis()
        try:
            keys = RedisUtils.keys(__redis, "k_format-*")
            for k in keys:
                code = k.split("-")[1]
                val = RedisUtils.get(__redis, k)
                val = json.loads(val)
                cls.__k_format_cache[code] = val
            keys = RedisUtils.keys(__redis, "code_nature-*")
            for k in keys:
                code = k.split("-")[1]
                val = RedisUtils.get(__redis, k)
                val = json.loads(val)
                cls.__nature_cache[code] = val
        except:
            pass
        finally:
            RedisUtils.realse(__redis)

    # 保存K线形态
    @classmethod
    def save_k_format(cls, code, k_format):
        RedisUtils.setex(cls.__get_redis(), f"k_format-{code}", tool.get_expire(), json.dumps(k_format))
    def save_k_format(self, code, k_format):
        self.__k_format_cache[code] = k_format
        RedisUtils.setex_async(self.__db, f"k_format-{code}", tool.get_expire(), json.dumps(k_format))

    @classmethod
    def get_k_format(cls, code):
        val = RedisUtils.get(cls.__get_redis(), f"k_format-{code}")
    def get_k_format(self, code):
        val = RedisUtils.get(self.__get_redis(), f"k_format-{code}")
        if val:
            return json.loads(val)
        return None

    @classmethod
    def get_k_format_cache(cls, code):
        val = None
        if code in cls.__k_format_cache:
            val = cls.__k_format_cache[code]
        if not val:
            val = cls.get_k_format(code)
            if val:
                cls.__k_format_cache[code] = val
    def get_k_format_cache(self, code):
        val = self.__k_format_cache.get(code)
        # 复制
        return copy.deepcopy(val) if val else None

    # 保存股性
    @classmethod
    def save_nature(cls, code, natures):
        RedisUtils.setex(cls.__get_redis(), f"code_nature-{code}", tool.get_expire(), json.dumps(natures))
    def clear(self):
        self.__k_format_cache.clear()
        self.__nature_cache.clear()
        keys = RedisUtils.keys(self.__get_redis(), "k_format-*")
        for k in keys:
            RedisUtils.delete(self.__get_redis(), k)
        keys = RedisUtils.keys(self.__get_redis(), "code_nature-*")
        for k in keys:
            RedisUtils.delete(self.__get_redis(), k)

    @classmethod
    def get_nature(cls, code):
        val = RedisUtils.get(cls.__get_redis(), f"code_nature-{code}")
    # 保存股性

    def save_nature(self, code, natures):
        RedisUtils.setex_async(self.__db, f"code_nature-{code}", tool.get_expire(), json.dumps(natures))

    def get_nature(self, code):
        val = RedisUtils.get(self.__get_redis(), f"code_nature-{code}")
        if val:
            return json.loads(val)
        return None

    @classmethod
    def get_nature_cache(cls, code):
        if code in cls.__nature_cache:
            return cls.__nature_cache[code]
        val = cls.get_nature(code)
        if val:
            cls.__nature_cache[code] = val
        return val
    def get_nature_cache(self, code):
        return self.__nature_cache.get(code)


class LatestMaxVolumeManager:
@@ -167,13 +192,13 @@
# 设置历史K线
def set_record_datas(code, limit_up_price, record_datas):
    k_format = get_k_format(float(limit_up_price), record_datas)
    CodeNatureRecordManager.save_k_format(code, k_format)
    CodeNatureRecordManager().save_k_format(code, k_format)
    natures = get_nature(record_datas)
    CodeNatureRecordManager.save_nature(code, natures)
    CodeNatureRecordManager().save_nature(code, natures)


# 获取K线形态
# 返回 (15个交易日涨幅是否大于24.9%,是否破前高，是否超跌，是否接近前高，是否N,是否V,是否有形态,天量大阳信息,是否具有辨识度)
# 返回 (15个交易日涨幅是否大于24.9%,是否破前高，是否超跌，是否接近前高，是否N,是否V,是否有形态,天量大阳信息,是否具有辨识度,近2天有10天内最大量,上个交易日是否炸板)
def get_k_format(limit_up_price, record_datas):
    p1_data = get_lowest_price_rate(record_datas)
    p1 = p1_data[0] >= 0.249, p1_data[1]
@@ -192,13 +217,15 @@

    # 是否具有辨识度
    p9 = is_special(record_datas)
    p10 = is_latest_10d_max_volume_at_latest_2d(record_datas)
    p11 = __is_yesterday_open_limit_up(record_datas)

    return p1, p2, p3, p4, p5, p6, p7, p8, p9
    return p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11


# 是否具有K线形态
def is_has_k_format(limit_up_price, record_datas):
    is_too_high, is_new_top, is_lowest, is_near_new_top, is_n, is_v, has_format, volume_info, is_special = get_k_format(
    is_too_high, is_new_top, is_lowest, is_near_new_top, is_n, is_v, has_format, volume_info, is_special, has_max_volume, open_limit_up = get_k_format(
        float(limit_up_price), record_datas)
    if not has_format:
        return False, "不满足K线形态"
@@ -229,7 +256,7 @@


# 是否涨得太高
def is_up_too_high_in_10d(record_datas):
def is_up_too_high_in_10d_with_limit_up(record_datas):
    datas = copy.deepcopy(record_datas)
    datas.sort(key=lambda x: x["bob"])
    datas = datas[-10:]
@@ -265,6 +292,21 @@
            return True

    return False


# 10天内的最高量是否集中在最近两天
def is_latest_10d_max_volume_at_latest_2d(record_datas):
    datas = copy.deepcopy(record_datas)
    datas.sort(key=lambda x: x["bob"])
    datas = datas[-10:]
    max_volume_info = None
    for i in range(0, len(datas)):
        if not max_volume_info:
            max_volume_info = (i, datas[i]["volume"])
        else:
            if max_volume_info[1] < datas[i]["volume"]:
                max_volume_info = (i, datas[i]["volume"])
    return len(datas) - max_volume_info[0] <= 2


# 120 天内是否长得太高
@@ -307,6 +349,31 @@
    return False


# 在最近几天内股价是否长得太高
def is_price_too_high_in_days(record_datas, limit_up_price, day_count=6):
    datas = copy.deepcopy(record_datas)
    datas.sort(key=lambda x: x["bob"])
    datas = datas[0 - day_count:]
    min_price = None
    max_price = None
    for d in datas:
        if min_price is None:
            min_price = d["low"]
        if max_price is None:
            max_price = d["high"]
        if min_price > d["low"]:
            min_price = d["low"]
        if max_price < d["high"]:
            max_price = d["high"]
    if max_price > float(limit_up_price):
        return False
    rate = (float(limit_up_price) - min_price) / min_price
    # print(rate)
    if rate >= 0.28:
        return True
    return False


# 是否有涨停
def get_first_limit_up_count(datas):
    datas = copy.deepcopy(datas)
@@ -344,33 +411,17 @@
    datas = copy.deepcopy(datas)
    datas.sort(key=lambda x: x["bob"])
    datas = datas[-80:]
    max_volume = 0
    max_volume_index = 0

    max_price = 0
    max_price_index = 0
    for index in range(0, len(datas)):
        data = datas[index]
        if max_volume < data["volume"]:
            max_volume = data["volume"]
            max_volume_index = index

    price = 0
    price_index = 0
    for index in range(max_volume_index, len(datas)):
        data = datas[index]
        if data["high"] > price:
            price = data["high"]
            price_index = index

    index = price_index
    # 最大量当日最高价比当日之后的最高价涨幅在15%以内
    if (price - datas[max_volume_index]["high"]) / datas[max_volume_index]["high"] < 0.15:
        price = datas[max_volume_index]["high"]
        index = max_volume_index

    print(max_volume)
    rate = (price - limit_up_price) / limit_up_price
    if 0 < rate < 0.03:
        return True, datas[index]['bob'].strftime("%Y-%m-%d")
        if data["high"] > max_price:
            max_price = data["high"]
            max_price_index = index
    rate = (max_price - float(limit_up_price)) / max_price
    if 0 < rate < 0.02:
        return True, datas[max_price_index]['bob'].strftime("%Y-%m-%d")
    return False, ''


@@ -417,6 +468,18 @@
        if max_price > min_price:
            return True, ''
    return False, ''


# 昨天是否炸板
def __is_yesterday_open_limit_up(datas):
    datas = copy.deepcopy(datas)
    datas.sort(key=lambda x: x["bob"])
    item = datas[-1]
    limit_up_price = float(gpcode_manager.get_limit_up_price_by_preprice(item["pre_close"]))
    if abs(limit_up_price - item["high"]) < 0.001 and abs(limit_up_price - item["close"]) > 0.001:
        # 炸板
        return True
    return False


# V字形
@@ -541,4 +604,3 @@
    HighIncreaseCodeManager().add_code("000333")
    print(HighIncreaseCodeManager().is_in("000333"))
    print(HighIncreaseCodeManager().is_in("000222"))