代码异常保护

Administrator

2024-11-04 65afea1ba534b51f947cbe7989d7f4d650bbc9e6

 code_attribute/gpcode_manager.py

@@ -1,6 +1,7 @@
"""
股票代码管理器
"""
import copy
import json
import time

@@ -19,9 +20,61 @@
__db = 0


class BuyOpenLimitUpCodeManager:
    """
    排1代码管理
    """
    __db = 2
    __redisManager = redis_manager.RedisManager(2)
    __instance = None
    __codes_cache = set()

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

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

    @classmethod
    def __load_data(cls):
        val = RedisUtils.get(cls.__get_redis(), "buy_open_limit_up_codes")
        if val:
            val = json.loads(val)
            cls.__codes_cache = set(val)

    def set_codes(self, codes):
        self.__codes_cache = copy.deepcopy(codes)
        RedisUtils.set_async(self.__db, "buy_open_limit_up_codes", json.dumps(list(codes)))

    def get_codes(self):
        return self.__codes_cache

    def is_in_cache(self, code):
        if not self.__codes_cache:
            return False
        if code in self.__codes_cache:
            return True
        return False


class CodesNameManager:
    __mysqldb = Mysqldb()
    __code_name_dict = {}
    __instance = None

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

    @classmethod
    def __load_data(cls):
        cls.__code_name_dict = cls.list_code_name_dict()

    @classmethod
    def list_code_name_dict(cls):
@@ -36,7 +89,7 @@
    def get_code_name(cls, code):
        if code in cls.__code_name_dict:
            return cls.__code_name_dict[code]
        fresults = cls.__mysqldb.select_one(f"select code_name from code_name where code = {code}")
        fresults = cls.__mysqldb.select_one(f"select code_name from code_name where code = '{code}'")
        if fresults:
            cls.__code_name_dict[code] = fresults[0]
            return fresults[0]
@@ -45,11 +98,23 @@
    @classmethod
    def add_code_name(cls, code, name):
        cls.__code_name_dict[code] = name
        fresults = cls.__mysqldb.select_one(f"select code_name from code_name where code = {code}")
        fresults = cls.__mysqldb.select_one(f"select code_name from code_name where code = '{code}'")
        if fresults:
            cls.__mysqldb.execute(f"update code_name set code_name ='{name}', update_time = now() where code= {code}")
            cls.__mysqldb.execute(f"update code_name set code_name ='{name}', update_time = now() where code= '{code}'")
        else:
            cls.__mysqldb.execute(f"insert into code_name(code,code_name,update_time ) values({code},'{name}',now())")
            cls.__mysqldb.execute(f"insert into code_name(code,code_name,update_time ) values('{code}','{name}',now())")

    @classmethod
    def add_code_names(cls, code_name_dict):
        """
        批量添加代码名称
        @param code_name_dict:
        @return:
        """
        for code in code_name_dict:
            if code in cls.__code_name_dict and cls.__code_name_dict[code] == code_name_dict[code]:
                continue
            cls.add_code_name(code, code_name_dict[code])

    @classmethod
    def add_first_code_name(cls, code, name):
@@ -69,8 +134,6 @@
            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):
@@ -96,31 +159,11 @@
    def is_in_first_record_cache(self, code):
        return code in self.__first_code_record_cache

    # 加入首板涨停过代码集合
    def add_limited_up_record(self, codes):
        hasChanged = False
        for code in codes:
            if code not in self.__first_code_limited_up_record_cache:
                RedisUtils.sadd_async(self.__db, "first_code_limited_up_record", code)
                hasChanged = True
            self.__first_code_limited_up_record_cache.add(code)
        if hasChanged:
            RedisUtils.expire_async(self.__db, "first_code_limited_up_record", tool.get_expire())

    # 是否涨停过
    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:
    __instance = None
    __db = 0
    redisManager = redis_manager.RedisManager(0)
    __redis_key = "want_buy_codes"

@@ -149,7 +192,7 @@

    def remove_code(self, code):
        self.__want_buy_codes_cache.discard(code)
        RedisUtils.srem(self.__get_redis(), self.__redis_key, code)
        RedisUtils.srem_async(self.__db, self.__redis_key, code)

    def sync(self):
        codes = self.list_code()
@@ -385,6 +428,62 @@
        RedisUtils.delete(self.__get_redis(), "forbidden-trade-codes")


class GreenListCodeManager:
    """
    绿名单：买入即加红，撤单不移红
    """
    __instance = None
    __db = 2
    __redis_manager = redis_manager.RedisManager(2)
    __codes_set = set()

    def __new__(cls, *args, **kwargs):
        if not cls.__instance:
            cls.__instance = super(GreenListCodeManager, cls).__new__(cls, *args, **kwargs)
            # 初始化设置
            # 获取交易窗口的锁
            cls.__codes_set = RedisUtils.smembers(cls.__get_redis(), "green-trade-codes")
        return cls.__instance

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

    def add_code(self, code):
        self.__codes_set.add(code)
        RedisUtils.sadd_async(self.__db, "green-trade-codes", code)
        RedisUtils.expire_async(self.__db, "green-trade-codes", tool.get_expire())

    def sync(self):
        data = RedisUtils.smembers(self.__get_redis(),
                                   "green-trade-codes")
        self.__codes_set.clear()
        if data:
            self.__codes_set |= data

    def remove_code(self, code):
        self.__codes_set.discard(code)
        RedisUtils.srem_async(self.__db, "green-trade-codes", code)

    def is_in(self, code):
        return RedisUtils.sismember(self.__get_redis(), "green-trade-codes", code)

    def is_in_cache(self, code):
        return code in self.__codes_set

    def list_codes(self):
        codes = RedisUtils.smembers(self.__get_redis(), "green-trade-codes")
        self.__codes_set = codes
        return codes

    def list_codes_cache(self):
        return self.__codes_set

    def clear(self):
        self.__codes_set.clear()
        RedisUtils.delete(self.__get_redis(), "green-trade-codes")


def __parse_codes_data(code_datas):
    codes = []
    name_codes = {}
@@ -499,7 +598,7 @@

# 获取代码的名称
def get_code_name(code):
    return CodesNameManager.get_code_name(code)
    return CodesNameManager().get_code_name(code)


def get_name_codes():
@@ -595,8 +694,7 @@
    # 设置收盘价
    @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:
        if code in cls.__price_pre_cache and not force:
            return
        price = round(float(price), 2)
        logger_pre_close_price.info(f"{code}-{price}")
@@ -619,6 +717,13 @@
    return limit_up_price


def get_limit_up_price_as_num(code):
    limit_up_price = get_limit_up_price(code)
    if limit_up_price:
        return round(float(limit_up_price), 2)
    return None


def get_limit_up_price_cache(code):
    if code in __limit_up_price_dict:
        return __limit_up_price_dict[code]