bug修复

Administrator

2023-10-30 fb47d36048e94b9a506d5c153e3dd19a01e37df1

 code_attribute/code_nature_analyse.py

@@ -5,12 +5,16 @@
# 是否有涨停
import copy
import json
import random
import time

from code_attribute import gpcode_manager

# 代码股性记录管理
from db import redis_manager
from utils import tool
from db.redis_manager import RedisManager, RedisUtils
from db.redis_manager_delegate import RedisManager, RedisUtils
from utils.tool import CodeDataCacheUtil


class CodeNatureRecordManager:
@@ -25,11 +29,11 @@
    # 保存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))
        RedisUtils.setex(cls.__get_redis(), f"k_format-{code}", tool.get_expire(), json.dumps(k_format))

    @classmethod
    def get_k_format(cls, code):
        val = cls.__get_redis().get(f"k_format-{code}")
        val = RedisUtils.get(cls.__get_redis(), f"k_format-{code}")
        if val:
            return json.loads(val)
        return None
@@ -49,11 +53,11 @@
    # 保存股性
    @classmethod
    def save_nature(cls, code, natures):
        RedisUtils.setex(cls.__get_redis(),f"code_nature-{code}", tool.get_expire(), json.dumps(natures))
        RedisUtils.setex(cls.__get_redis(), f"code_nature-{code}", tool.get_expire(), json.dumps(natures))

    @classmethod
    def get_nature(cls, code):
        val = cls.__get_redis().get(f"code_nature-{code}")
        val = RedisUtils.get(cls.__get_redis(), f"code_nature-{code}")
        if val:
            return json.loads(val)
        return None
@@ -66,6 +70,53 @@
        if val:
            cls.__nature_cache[code] = val
        return val


class LatestMaxVolumeManager:
    __db = 0
    __instance = None
    __redis_manager = redis_manager.RedisManager(0)
    __max_volume_cache = {}

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

    @classmethod
    def __load_datas(cls):
        __redis = cls.__get_redis()
        try:
            keys = RedisUtils.keys(__redis, "is_latest_max_volume-*")
            for k in keys:
                code = k.split("-")[-1]
                val = RedisUtils.get(__redis, k)
                CodeDataCacheUtil.set_cache(cls.__max_volume_cache, code, val)
        finally:
            RedisUtils.realse(__redis)

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

    def __save_has_latest_max_volume(self, code):
        RedisUtils.setex_async(self.__db, f"is_latest_max_volume-{code}", tool.get_expire(), "1")

    # 设置最近有最大量
    def set_has_latest_max_volume(self, code):
        CodeDataCacheUtil.set_cache(self.__max_volume_cache, code, 1)
        self.__save_has_latest_max_volume(code)

    # 最近是否有最大量
    def is_latest_max_volume(self, code):
        return code in self.__max_volume_cache

    def clear(self):
        self.__max_volume_cache.clear()
        keys = RedisUtils.keys(self.__get_redis(), "is_latest_max_volume-*")
        for k in keys:
            RedisUtils.delete_async(self.__db, k)


# 设置历史K线
@@ -132,6 +183,85 @@
    return 0, ''


# 是否涨得太高
def is_up_too_high_in_10d(record_datas):
    datas = copy.deepcopy(record_datas)
    datas.sort(key=lambda x: x["bob"])
    datas = datas[-10:]
    limit_ups = []
    limit_up_count = 0
    max_price = datas[0]["high"]
    for data in datas:
        limit_up_price = float(gpcode_manager.get_limit_up_price_by_preprice(data["pre_close"]))
        date = data['bob'].strftime("%Y-%m-%d")
        if data["high"] > max_price:
            max_price = data["high"]
        if abs(limit_up_price - data["high"]) < 0.01:
            limit_ups.append((date, True))
            limit_up_count += 1
        else:
            limit_ups.append((date, False))
    # 下降幅度
    limit_down_rate = round((max_price - datas[-1]["close"]) / max_price, 3)

    if limit_up_count < 3:
        return False
    # 连续5天有3天涨停
    for i in range(len(limit_ups)):
        if i + 5 > len(limit_ups):
            break
        temp_datas = limit_ups[i:i + 5]
        t_count = 0
        for t in temp_datas:
            if t[1]:
                t_count += 1
        if t_count >= 3 and limit_down_rate < 0.2:
            # 降幅小于20%
            return True

    return False


# 120 天内是否长得太高
def is_up_too_high_in_120d(record_datas):
    datas = copy.deepcopy(record_datas)
    datas.sort(key=lambda x: x["bob"])
    datas = datas[-120:]
    today_limit_up_price = round(float(gpcode_manager.get_limit_up_price_by_preprice(datas[-1]["close"])), 2)
    max_price = 0
    for data in datas:
        if data["high"] > max_price:
            max_price = data["high"]
    if today_limit_up_price <= max_price:
        return False

    # 计算120天的均价
    total_amount = 0
    total_volume = 0
    for data in datas:
        total_amount += data["amount"]
        total_volume += data["volume"]
    average_price = round(total_amount / total_volume, 2)
    if (today_limit_up_price - average_price) / average_price > 0.3:
        return True
    else:
        return False


# 最近几天是否有最大量
def is_have_latest_max_volume(record_datas, day_count):
    datas = copy.deepcopy(record_datas)
    datas.sort(key=lambda x: x["bob"])
    datas = datas[-120:]
    max_volume = (0, datas[0]["volume"])
    for i in range(0, len(datas)):
        if max_volume[1] < datas[i]["volume"]:
            max_volume = (i, datas[i]["volume"])
    if len(datas) - max_volume[0] <= day_count:
        return True
    return False


# 是否有涨停
def get_first_limit_up_count(datas):
    datas = copy.deepcopy(datas)