强势时间段调整

Administrator

2023-12-06 52c4cb753226d69e9ca04ff73ffa6e8ba79dd917

强势时间段调整

 code_attribute/first_target_code_data_processor.py

@@ -130,7 +130,7 @@

                if code_nature_analyse.is_up_too_high_in_120d(volumes_data):
                    # 判断是否太高
                    l2_trade_util.forbidden_trade(code, "120天内股价长得太高")
                    # l2_trade_util.forbidden_trade(code, "120天内股价长得太高")
                    HighIncreaseCodeManager().add_code(code)

                if code_nature_analyse.is_price_too_high_in_days(volumes_data, limit_up_price):

 code_attribute/gpcode_manager.py

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

import constant
@@ -295,6 +294,109 @@
        return self.__pause_buy_codes_cache


class WhiteListCodeManager:
    __instance = None
    __redis_manager = redis_manager.RedisManager(2)

    def __new__(cls, *args, **kwargs):
        if not cls.__instance:
            cls.__instance = super(WhiteListCodeManager, cls).__new__(cls, *args, **kwargs)
            # 初始化设置
            # 获取交易窗口的锁
            cls.__instance.__white_codes_cache = RedisUtils.smembers(cls.__get_redis(), "white_list_codes")

        return cls.__instance

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

    def sync(self):
        data = RedisUtils.smembers(self.__get_redis(), "white_list_codes")
        self.__white_codes_cache.clear()
        if data:
            self.__white_codes_cache |= data

    def add_code(self, code):
        self.__white_codes_cache.add(code)
        RedisUtils.sadd(self.__get_redis(), "white_list_codes", code)
        RedisUtils.expire(self.__get_redis(), "white_list_codes", tool.get_expire())

    def remove_code(self, code):
        self.__white_codes_cache.discard(code)
        RedisUtils.srem(self.__get_redis(), "white_list_codes", code)

    def is_in(self, code):
        return RedisUtils.sismember(self.__get_redis(), "white_list_codes", code)

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

    def list_codes(self):
        return RedisUtils.smembers(self.__get_redis(), "white_list_codes")

    def list_codes_cache(self):
        return self.__white_codes_cache

    def clear(self):
        self.__white_codes_cache.clear()
        RedisUtils.delete(self.__get_redis(), "white_list_codes")


class BlackListCodeManager:
    __instance = None
    __db = 2
    __redis_manager = redis_manager.RedisManager(2)

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

        return cls.__instance

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

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

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

    def remove_code(self, code):
        self.__forbidden_trade_codes_cache.discard(code)
        RedisUtils.srem(self.__get_redis(), "forbidden-trade-codes", code)

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

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

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

    def list_codes_cache(self):
        return self.__forbidden_trade_codes_cache

    def clear(self):
        self.__forbidden_trade_codes_cache.clear()
        RedisUtils.delete(self.__get_redis(), "forbidden-trade-codes")


def __parse_codes_data(code_datas):
    codes = []
    name_codes = {}

 constant.py

@@ -155,5 +155,5 @@
    TRADE_ENABLE = True

# 最大的代码价格
MAX_CODE_PRICE = 40
MAX_SUBSCRIPT_CODE_PRICE = 40
MAX_CODE_PRICE = 50
MAX_SUBSCRIPT_CODE_PRICE = 50

 inited_data.py

@@ -87,7 +87,7 @@
        # 删除禁止代码
        l2_trade_util.init_forbidden_trade_codes()
        # 清空白名单
        l2_trade_util.WhiteListCodeManager().clear()
        gpcode_manager.WhiteListCodeManager().clear()
        # 清空想要买
        gpcode_manager.WantBuyCodesManager().clear()
        # 清空分数禁止代码

 l2/l2_data_manager_new.py

@@ -228,8 +228,8 @@
    __AccountAvailableMoneyManager = AccountAvailableMoneyManager()
    __TradeBuyDataManager = trade_data_manager.TradeBuyDataManager()
    __LimitUpTimeManager = limit_up_time_manager.LimitUpTimeManager()
    __BlackListCodeManager = l2_trade_util.BlackListCodeManager()
    __WhiteListCodeManager = l2_trade_util.WhiteListCodeManager()
    __BlackListCodeManager = gpcode_manager.BlackListCodeManager()
    __WhiteListCodeManager = gpcode_manager.WhiteListCodeManager()
    __WantBuyCodesManager = gpcode_manager.WantBuyCodesManager()
    __TradeTargetCodeModeManager = TradeTargetCodeModeManager()
    __TradeOrderIdManager = trade_huaxin.TradeOrderIdManager()
@@ -844,39 +844,15 @@
            HighIncreaseCodeManager().add_code(code)
            return False, True, f"股价大于{constant.MAX_CODE_PRICE}块"

        place_order_count = cls.__PlaceOrderCountManager.get_place_order_count(code)
        if place_order_count and place_order_count >= 10:
            l2_trade_util.forbidden_trade(code, msg="当日下单次数已达10次")
            return False, True, f"当日下单次数已达10次"
        # place_order_count = cls.__PlaceOrderCountManager.get_place_order_count(code)
        # if place_order_count and place_order_count >= 10:
        #     l2_trade_util.forbidden_trade(code, msg="当日下单次数已达10次")
        #     return False, True, f"当日下单次数已达10次"

        # ---------均价约束-------------
        average_rate = cls.__Buy1PriceManager.get_average_rate(code)
        if average_rate and average_rate <= 0.01:
            return False, True, f"均价涨幅({average_rate})小于1%"

        # -------量的约束--------
        if float(limit_up_price) < 3.0 and cls.volume_rate_info[code][0] < 0.6:
            return False, True, f"涨停价小于3块，当日量比({cls.volume_rate_info[code][0]})小于0.6"

        if HighIncreaseCodeManager().is_in(code) and cls.volume_rate_info[code][0] < 0.6:
            return False, True, f"股价涨得过高，当日量比({cls.volume_rate_info[code][0]})小于0.6"

        if int(tool.get_now_time_str().replace(":", "")) <= int("100000"):
            if cls.volume_rate_info[code][0] < 0.1:
                return False, True, f"当日量比({cls.volume_rate_info[code][0]})小于0.1"
        else:
            if cls.volume_rate_info[code][0] < 0.2:
                return False, True, f"当日量比({cls.volume_rate_info[code][0]})小于0.2"
        k_format = code_nature_analyse.CodeNatureRecordManager().get_k_format_cache(code)
        if k_format and (k_format[1][0] or k_format[3][0]):
            # 股价创新高或者逼近前高
            if cls.volume_rate_info[code][0] < 0.3:
                return False, True, f"股价创新高或者逼近前高,当日量比({cls.volume_rate_info[code][0]})小于0.3"
        if code_nature_analyse.LatestMaxVolumeManager().is_latest_max_volume(code):
            # 最近几天有最大量，判断量比是否大于60%
            if cls.volume_rate_info[code][0] < 0.6:
                # HighIncreaseCodeManager().add_code(code)
                return False, True, f"近日出现最大量，当日量比({cls.volume_rate_info[code][0]})小于0.6"

        total_data = local_today_datas.get(code)
        if constant.L2_SOURCE_TYPE == constant.L2_SOURCE_TYPE_HUAXIN:
@@ -960,56 +936,17 @@
                        codes.discard(code)
                    if not codes:
                        return False, True, f"13:15以后炸板之后下单，（{limit_up_reason}） 为独苗"
        # 暂时注释想买单功能
        # if not cls.__WantBuyCodesManager.is_in_cache(code):
        # if cls.__TradeTargetCodeModeManager.get_mode_cache() == TradeTargetCodeModeManager.MODE_ONLY_BUY_WANT_CODES:
        #     return False, True, f"只买想买单中的代码"
        return cls.can_buy_first(code, limit_up_price)
        # else:
        #     return True, False, "在想买名单中"

        # limit_up_info = cls.__Buy1PriceManager.get_limit_up_info(code)
        # if limit_up_info[0] is None and False:
        #     total_data = local_today_datas.get(code)
        #     buy_single_index, buy_exec_index, buy_compute_index, num, count, max_num_set, buy_volume_rate = cls.__get_order_begin_pos(
        #         code)
        #     # 之前没有涨停过
        #     # 统计买入信号位到当前位置没有撤的大单金额
        #     min_money_w = l2_data_util.get_big_money_val(float(total_data[buy_single_index]["val"]["price"])) // 10000
        #     left_big_num = cls.__SecondCancelBigNumComputer.compute_left_big_num(code,
        #                                                                          buy_single_index,
        #                                                                          buy_exec_index,
        #                                                                          total_data[-1][
        #                                                                              "index"],
        #                                                                          total_data,
        #                                                                          0, min_money_w)
        #     if left_big_num > 0:
        #         # 重新获取分数与分数索引
        #         limit_up_time = cls.__LimitUpTimeManager.get_limit_up_time_cache(code)
        #         if limit_up_time is None:
        #             limit_up_time = tool.get_now_time_str()

        # logger_place_order_score.info("code={},data='score_index':{},'score_info':{}", code,
        #                               cls.__l2PlaceOrderParamsManagerDict[code].score_index,
        #                               cls.__l2PlaceOrderParamsManagerDict[code].score_info)

        if not cls.__WantBuyCodesManager.is_in_cache(code):
            if cls.__TradeTargetCodeModeManager.get_mode_cache() == TradeTargetCodeModeManager.MODE_ONLY_BUY_WANT_CODES:
                return False, True, f"只买想买单中的代码"
            score_index = None  # cls.__l2PlaceOrderParamsManagerDict[code].score_index
            score = None  # cls.__l2PlaceOrderParamsManagerDict[code].score
            score_info = None  # cls.__l2PlaceOrderParamsManagerDict[code].score_info

            # lp = LineProfiler()
            # lp.enable()
            # lp_wrap = lp(cls.can_buy_first)
            # results = lp_wrap(code, limit_up_price, score_index, score, score_info, cls.volume_rate_info[code])
            # output = io.StringIO()
            # lp.print_stats(stream=output)
            # lp.disable()
            # with open(f"{constant.get_path_prefix()}/logs/profile/{code}_can_buy_first.txt", 'w') as f:
            #     f.write(output.getvalue())
            # return results
            return cls.can_buy_first(code, limit_up_price)
        else:
            return True, False, "在想买名单中"

    # 获取可以买的板块
    @classmethod
    def can_buy_first(cls, code, limit_up_price):
        # 判断板块
    def __get_can_buy_block(cls, code):
        can_buy_result = CodePlateKeyBuyManager.can_buy(code)
        if can_buy_result is None:
            async_log_util.warning(logger_debug, "没有获取到板块缓存，将获取板块")
@@ -1021,36 +958,73 @@
                                                         block_info.get_before_blocks_dict(),
                                                         kpl_data_manager.KPLLimitUpDataRecordManager.get_current_reason_codes_dict())
            can_buy_result = CodePlateKeyBuyManager.can_buy(code)
        return can_buy_result

    @classmethod
    def can_buy_first(cls, code, limit_up_price):
        # 判断板块
        can_buy_result = cls.__get_can_buy_block(code)
        if can_buy_result is None:
            return False, True, "尚未获取到板块信息"

        if can_buy_result[1]:
            # ------自由流通市值约束------
            zyltgb = global_util.zyltgb_map.get(code)
            if zyltgb:
                if zyltgb < 10 * 100000000:
                    return False, True, f"独苗，自由流通小于10亿（{zyltgb}）"
            if code in cls.volume_rate_info and cls.volume_rate_info[code][0] < 0.6:
                return False, True, f"独苗：量比（{cls.volume_rate_info[code][0]}）未达到60%"

        # 获取K线形态，判断是否近2天是否为10天内最大量
        # -------量的约束--------
        k_format = code_nature_analyse.CodeNatureRecordManager().get_k_format_cache(code)
        if k_format and len(k_format) >= 10 and k_format[9]:
            # 是独苗
            if code in cls.volume_rate_info and cls.volume_rate_info[code][0] < 0.3:
                return False, True, f"近2天有10日内最高量，量比（{cls.volume_rate_info[code][0]}）未达到30%"
        # 是独苗
        if can_buy_result[1]:
            now_time_int = int(tool.get_now_time_str().replace(":", ""))
            if now_time_int < int("100000") or int("130000") <= now_time_int < int("133000"):
                # 独苗必须9:30-10:00和13:00-13:30时间段内买
                return True, False, f"独苗：{can_buy_result[2]}"
            else:
                return False, True, f"独苗：当前时间不能买"
        if k_format and (k_format[1][0] or k_format[3][0]):
            # 股价创新高或者逼近前高
            if cls.volume_rate_info[code][0] < 0.3:
                return False, True, f"股价创新高或者逼近前高,当日量比({cls.volume_rate_info[code][0]})小于0.3"

        # 如果是早上的强势后排就不需要判断量
        now_timestamp = int(tool.get_now_time_str().replace(":", ""))
        if can_buy_result[0] and not can_buy_result[1] and now_timestamp <= int("094000"):
            return True, False, f"9:40:00之前非独苗：{can_buy_result[0]}"
        else:
            if can_buy_result[0]:
                return True, False, can_buy_result[2]
            if code in cls.volume_rate_info:
                if float(limit_up_price) < 3.0 and cls.volume_rate_info[code][0] < 0.6:
                    return False, True, f"涨停价小于3块，当日量比({cls.volume_rate_info[code][0]})小于0.6"

                if HighIncreaseCodeManager().is_in(code) and cls.volume_rate_info[code][0] < 0.6:
                    return False, True, f"股价涨得过高，当日量比({cls.volume_rate_info[code][0]})小于0.6"

                if now_timestamp <= int("100000"):
                    if cls.volume_rate_info[code][0] < 0.1:
                        return False, True, f"当日量比({cls.volume_rate_info[code][0]})小于0.1"
                else:
                    if cls.volume_rate_info[code][0] < 0.2:
                        return False, True, f"当日量比({cls.volume_rate_info[code][0]})小于0.2"

                if code_nature_analyse.LatestMaxVolumeManager().is_latest_max_volume(code):
                    # 最近几天有最大量，判断量比是否大于60%
                    if cls.volume_rate_info[code][0] < 0.6:
                        # HighIncreaseCodeManager().add_code(code)
                        return False, True, f"近日出现最大量，当日量比({cls.volume_rate_info[code][0]})小于0.6"

            if can_buy_result[1]:
                # 独苗
                # ------自由流通市值约束------
                zyltgb = global_util.zyltgb_map.get(code)
                if zyltgb:
                    if zyltgb < 10 * 100000000:
                        return False, True, f"独苗，自由流通小于10亿（{zyltgb}）"
                if code in cls.volume_rate_info and cls.volume_rate_info[code][0] < 0.6:
                    return False, True, f"独苗：量比（{cls.volume_rate_info[code][0]}）未达到60%"

                # 判断是否近2天是否为10天内最大量
                if k_format and len(k_format) >= 10 and k_format[9]:
                    # 是独苗
                    if code in cls.volume_rate_info and cls.volume_rate_info[code][0] < 0.3:
                        return False, True, f"近2天有10日内最高量，量比（{cls.volume_rate_info[code][0]}）未达到30%"

                # 是独苗
                if can_buy_result[1]:
                    if now_timestamp < int("100000") or int("130000") <= now_timestamp < int("133000"):
                        # 独苗必须9:30-10:00和13:00-13:30时间段内买
                        return True, False, f"独苗：{can_buy_result[2]}"
                    else:
                        return False, True, f"独苗：当前时间不能买"
                else:
                    if can_buy_result[0]:
                        return True, False, can_buy_result[2]
        return False, True, can_buy_result[2]

    @classmethod

 output/code_info_output.py

@@ -67,9 +67,9 @@
    day = tool.get_now_date_str()
    is_target_code = gpcode_manager.FirstCodeManager().is_in_first_record_cache(code)
    code_extra_infos = []
    if l2_trade_util.BlackListCodeManager().is_in_cache(code):
    if gpcode_manager.BlackListCodeManager().is_in_cache(code):
        code_extra_infos.append("黑名单")
    if l2_trade_util.WhiteListCodeManager().is_in_cache(code):
    if gpcode_manager.WhiteListCodeManager().is_in_cache(code):
        code_extra_infos.append("白名单")
    # 获取白名单,黑名单
    if code_attribute.gpcode_manager.WantBuyCodesManager().is_in_cache(code):

 server.py

@@ -659,7 +659,7 @@
                            # if zyltgb > 50 * 100000000:
                            #     raise Exception("自由流通股本大于50亿")

                            l2_trade_util.WhiteListCodeManager().add_code(code)
                            gpcode_manager.WhiteListCodeManager().add_code(code)
                            name = gpcode_manager.get_code_name(code)
                            if not name:
                                results = HistoryKDatasUtils.get_gp_codes_names([code])
@@ -683,12 +683,12 @@
                    data = json.loads(_str)
                    codes = data["data"]["codes"]
                    for code in codes:
                        l2_trade_util.WhiteListCodeManager().remove_code(code)
                        gpcode_manager.WhiteListCodeManager().remove_code(code)
                    return_str = json.dumps({"code": 0})
                    self.__notify_trade("white_list")
                elif type == 301:
                    # 黑名单列表
                    codes = l2_trade_util.BlackListCodeManager().list_codes()
                    codes = gpcode_manager.BlackListCodeManager().list_codes()
                    datas = []
                    for code in codes:
                        name = gpcode_manager.get_code_name(code)
@@ -696,7 +696,7 @@
                    return_str = json.dumps({"code": 0, "data": datas})
                elif type == 302:
                    # 黑名单列表
                    codes = l2_trade_util.WhiteListCodeManager().list_codes()
                    codes = gpcode_manager.WhiteListCodeManager().list_codes()
                    datas = []
                    for code in codes:
                        name = gpcode_manager.get_code_name(code)
@@ -797,7 +797,7 @@
                    # 查询是否想买单/白名单/黑名单/暂不买
                    code_name = gpcode_manager.get_code_name(code)
                    want = gpcode_manager.WantBuyCodesManager().is_in_cache(code)
                    white = l2_trade_util.WhiteListCodeManager().is_in_cache(code)
                    white = gpcode_manager.WhiteListCodeManager().is_in_cache(code)
                    black = l2_trade_util.is_in_forbidden_trade_codes(code)
                    pause_buy = gpcode_manager.PauseBuyCodesManager().is_in_cache(code)


 third_data/data_server.py

@@ -7,6 +7,7 @@
from http.server import BaseHTTPRequestHandler
import dask

from code_attribute.gpcode_manager import BlackListCodeManager
from log_module.log import logger_system, logger_debug
from utils import global_util, tool, data_export_util
from code_attribute import gpcode_manager
@@ -25,7 +26,6 @@
from output import code_info_output, limit_up_data_filter, output_util, kp_client_msg_manager

from trade import bidding_money_manager, trade_manager, l2_trade_util, trade_record_log_util
from trade.l2_trade_util import BlackListCodeManager
import concurrent.futures

# 禁用http.server的日志输出

 trade/huaxin/huaxin_trade_api_server.py

@@ -503,13 +503,13 @@
                        gpcode_manager.WantBuyCodesManager().sync()
                        print("want_list after", gpcode_manager.WantBuyCodesManager().list_code_cache())
                    elif type_ == "white_list":
                        print("white_list before", l2_trade_util.WhiteListCodeManager().list_codes_cache())
                        l2_trade_util.WhiteListCodeManager().sync()
                        print("white_list after", l2_trade_util.WhiteListCodeManager().list_codes_cache())
                        print("white_list before", gpcode_manager.WhiteListCodeManager().list_codes_cache())
                        gpcode_manager.WhiteListCodeManager().sync()
                        print("white_list after", gpcode_manager.WhiteListCodeManager().list_codes_cache())
                    elif type_ == "black_list":
                        print("black_list before", l2_trade_util.BlackListCodeManager().list_codes_cache())
                        l2_trade_util.BlackListCodeManager().sync()
                        print("black_list after", l2_trade_util.BlackListCodeManager().list_codes_cache())
                        print("black_list before", gpcode_manager.BlackListCodeManager().list_codes_cache())
                        gpcode_manager.BlackListCodeManager().sync()
                        print("black_list after", gpcode_manager.BlackListCodeManager().list_codes_cache())
                    elif type_ == "pause_buy_list":
                        print("pause_buy_list before", gpcode_manager.PauseBuyCodesManager().list_code_cache())
                        gpcode_manager.PauseBuyCodesManager().sync()

 trade/huaxin/huaxin_trade_server.py

@@ -22,7 +22,7 @@
import inited_data
import outside_api_command_manager
from code_attribute import gpcode_manager, code_volumn_manager, global_data_loader
from code_attribute.gpcode_manager import CodePrePriceManager, CodesNameManager
from code_attribute.gpcode_manager import CodePrePriceManager, CodesNameManager, WantBuyCodesManager
from db import mysql_data_delegate as mysql_data, redis_manager_delegate as redis_manager
from db.redis_manager_delegate import RedisUtils
from huaxin_client import l1_subscript_codes_manager, l2_data_transform_protocol
@@ -31,8 +31,7 @@
from l2 import l2_data_manager_new, l2_log, code_price_manager, l2_data_util, l2_data_manager, transaction_progress, \
    l2_data_source_util
from l2.cancel_buy_strategy import LCancelBigNumComputer, GCancelBigNumComputer, SecondCancelBigNumComputer, \
    LCancelRateManager, \
    UCancelBigNumComputer
    LCancelRateManager
from l2.huaxin import huaxin_target_codes_manager
from l2.huaxin.huaxin_target_codes_manager import HuaXinL1TargetCodesManager
from l2.l2_data_listen_manager import L2DataListenManager
@@ -697,6 +696,7 @@
            elif code_list_type == outside_api_command_manager.CODE_LIST_BLACK:
                if operate == outside_api_command_manager.OPERRATE_SET:
                    l2_trade_util.forbidden_trade(code, msg="手动加入 trade_server")
                    WantBuyCodesManager().remove_code(code)
                    name = gpcode_manager.get_code_name(code)
                    if not name:
                        results = HistoryKDatasUtils.get_gp_codes_names([code])
@@ -704,8 +704,9 @@
                            gpcode_manager.CodesNameManager.add_first_code_name(code, results[code])
                elif operate == outside_api_command_manager.OPERRATE_DELETE:
                    l2_trade_util.remove_from_forbidden_trade_codes(code)
                    WantBuyCodesManager().add_code(code)
                elif operate == outside_api_command_manager.OPERRATE_GET:
                    codes = l2_trade_util.BlackListCodeManager().list_codes_cache()
                    codes = gpcode_manager.BlackListCodeManager().list_codes_cache()
                    datas = []
                    for code in codes:
                        name = gpcode_manager.get_code_name(code)
@@ -713,16 +714,16 @@
                    fresult = {"code": 0, "data": datas}
            elif code_list_type == outside_api_command_manager.CODE_LIST_WHITE:
                if operate == outside_api_command_manager.OPERRATE_SET:
                    l2_trade_util.WhiteListCodeManager().add_code(code)
                    gpcode_manager.WhiteListCodeManager().add_code(code)
                    name = gpcode_manager.get_code_name(code)
                    if not name:
                        results = HistoryKDatasUtils.get_gp_codes_names([code])
                        if results:
                            gpcode_manager.CodesNameManager.add_first_code_name(code, results[code])
                elif operate == outside_api_command_manager.OPERRATE_DELETE:
                    l2_trade_util.WhiteListCodeManager().remove_code(code)
                    gpcode_manager.WhiteListCodeManager().remove_code(code)
                elif operate == outside_api_command_manager.OPERRATE_GET:
                    codes = l2_trade_util.WhiteListCodeManager().list_codes_cache()
                    codes = gpcode_manager.WhiteListCodeManager().list_codes_cache()
                    datas = []
                    for code in codes:
                        name = gpcode_manager.get_code_name(code)
@@ -788,7 +789,7 @@
            # 查询是否想买单/白名单/黑名单/暂不买
            code_name = gpcode_manager.get_code_name(code)
            want = gpcode_manager.WantBuyCodesManager().is_in_cache(code)
            white = l2_trade_util.WhiteListCodeManager().is_in_cache(code)
            white = gpcode_manager.WhiteListCodeManager().is_in_cache(code)
            black = l2_trade_util.is_in_forbidden_trade_codes(code)
            pause_buy = gpcode_manager.PauseBuyCodesManager().is_in_cache(code)

@@ -1024,7 +1025,7 @@
            # 查询是否想买单/白名单/黑名单/暂不买
            code_name = gpcode_manager.get_code_name(code)
            want = gpcode_manager.WantBuyCodesManager().is_in_cache(code)
            white = l2_trade_util.WhiteListCodeManager().is_in_cache(code)
            white = gpcode_manager.WhiteListCodeManager().is_in_cache(code)
            black = l2_trade_util.is_in_forbidden_trade_codes(code)
            pause_buy = gpcode_manager.PauseBuyCodesManager().is_in_cache(code)

@@ -1134,7 +1135,7 @@
            huaxin_trade_record_manager.DelegateRecordManager.add([data])
            if huaxin_util.is_deal(order_status):
                if int(str(data["direction"])) == huaxin_util.TORA_TSTP_D_Buy:
                    l2_trade_util.forbidden_trade(data["securityID"], msg="已成交")
                    l2_trade_util.forbidden_trade(data["securityID"], msg="已成交", force = True)
                # 成交，更新成交列表与资金列表
                huaxin_trade_data_update.add_deal_list()
                huaxin_trade_data_update.add_money_list()

 trade/l2_trade_util.py

@@ -1,147 +1,50 @@
# 是否在禁止交易代码中
from code_attribute import gpcode_manager
from db import redis_manager_delegate as redis_manager
from db.redis_manager_delegate import RedisUtils
from log_module import async_log_util
from log_module.log import logger_trade
from trade import trade_record_log_util
from utils import tool

__redis_manager = redis_manager.RedisManager(2)


class WhiteListCodeManager:
    __instance = None
    __redis_manager = redis_manager.RedisManager(2)

    def __new__(cls, *args, **kwargs):
        if not cls.__instance:
            cls.__instance = super(WhiteListCodeManager, cls).__new__(cls, *args, **kwargs)
            # 初始化设置
            # 获取交易窗口的锁
            cls.__instance.__white_codes_cache = RedisUtils.smembers(cls.__get_redis(), "white_list_codes")

        return cls.__instance

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

    def sync(self):
        data = RedisUtils.smembers(self.__get_redis(), "white_list_codes")
        self.__white_codes_cache.clear()
        if data:
            self.__white_codes_cache |= data

    def add_code(self, code):
        self.__white_codes_cache.add(code)
        RedisUtils.sadd(self.__get_redis(), "white_list_codes", code)
        RedisUtils.expire(self.__get_redis(), "white_list_codes", tool.get_expire())

    def remove_code(self, code):
        self.__white_codes_cache.discard(code)
        RedisUtils.srem(self.__get_redis(), "white_list_codes", code)

    def is_in(self, code):
        return RedisUtils.sismember(self.__get_redis(), "white_list_codes", code)

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

    def list_codes(self):
        return RedisUtils.smembers(self.__get_redis(), "white_list_codes")

    def list_codes_cache(self):
        return self.__white_codes_cache

    def clear(self):
        self.__white_codes_cache.clear()
        RedisUtils.delete(self.__get_redis(), "white_list_codes")


class BlackListCodeManager:
    __instance = None
    __db = 2
    __redis_manager = redis_manager.RedisManager(2)

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

        return cls.__instance

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

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

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

    def remove_code(self, code):
        self.__forbidden_trade_codes_cache.discard(code)
        RedisUtils.srem(self.__get_redis(), "forbidden-trade-codes", code)

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

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

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

    def list_codes_cache(self):
        return self.__forbidden_trade_codes_cache

    def clear(self):
        self.__forbidden_trade_codes_cache.clear()
        RedisUtils.delete(self.__get_redis(), "forbidden-trade-codes")


#  初始化禁止交易代码库
def init_forbidden_trade_codes():
    BlackListCodeManager().clear()
    BlackListCodeManager().add_code("000000")
    gpcode_manager.BlackListCodeManager().clear()
    gpcode_manager.BlackListCodeManager().add_code("000000")


# 移除禁止交易代码
def remove_from_forbidden_trade_codes(code):
    BlackListCodeManager().remove_code(code)
    gpcode_manager.BlackListCodeManager().remove_code(code)


# 添加代码到禁止交易
def add_to_forbidden_trade_codes(code):
    BlackListCodeManager().add_code(code)
    gpcode_manager.BlackListCodeManager().add_code(code)


# 禁止代码交易
def forbidden_trade(code, msg=None):
    if not is_in_forbidden_trade_codes(code):
        trade_record_log_util.add_forbidden_buy_log(code, msg)
    add_to_forbidden_trade_codes(code)
    async_log_util.warning(logger_trade, f"{code}加入黑名单原因：{msg}")
# force 是否强制加入黑名单
def forbidden_trade(code, msg=None, force=False):
    need_add = False
    if force:
        need_add = True
    else:
        # 检查是否在想买单中
        if gpcode_manager.WantBuyCodesManager().is_in_cache(code):
            need_add = False
        else:
            need_add = True
    if need_add:
        if not is_in_forbidden_trade_codes(code):
            trade_record_log_util.add_forbidden_buy_log(code, msg)
        add_to_forbidden_trade_codes(code)
        async_log_util.warning(logger_trade, f"{code}加入黑名单原因：{msg}")
    # l2_data_manager.remove_from_l2_fixed_codes(code)
    # l2_code_operate.L2CodeOperate.get_instance().remove_l2_listen(code, "禁止代码交易")


def is_in_forbidden_trade_codes(code):
    return BlackListCodeManager().is_in_cache(code)
    return gpcode_manager.BlackListCodeManager().is_in_cache(code)


if __name__ == "__main__":
    # add_to_forbidden_trade_codes("000977")
    WhiteListCodeManager().add_code("002977")

 trade/trade_manager.py

@@ -584,7 +584,7 @@
            continue
        # 买入成功
        if code is not None and int(data["type"]) == 0:
            l2_trade_util.forbidden_trade(code, msg="交易成功")
            l2_trade_util.forbidden_trade(code, msg="交易成功",force = True)
            state = CodesTradeStateManager().get_trade_state_cache(code)
            if state != TRADE_STATE_BUY_SUCCESS:
                CodesTradeStateManager().set_trade_state(code, TRADE_STATE_BUY_SUCCESS)
@@ -671,7 +671,7 @@
def buy_success(code):
    # 加入黑名单
    if not l2_trade_util.is_in_forbidden_trade_codes(code):
        l2_trade_util.forbidden_trade(code, "buy success")
        l2_trade_util.forbidden_trade(code, "buy success",force=True)
    # 取s消所有的挂单
    if constant.API_TRADE_ENABLE:
        if constant.TRADE_WAY == constant.TRADE_WAY_JUEJIN: