注释修改/删除多余的代码

Administrator

2024-09-10 f3d95299f8a84b0104003bea577ef9105ac9ba36

注释修改/删除多余的代码

 cancel_strategy/s_l_h_cancel_strategy.py

@@ -467,7 +467,7 @@
                    # 15分钟内真实成交位距离真实下单位，金额≤800万 ,大单阈值变为200w
                    threash_money_w = threash_money_danger_w
        except Exception as e:
            l2_log.s_cancel_debug(code, f"S撤激进下单计算大单卖阈值出错：{str(e)}")
            l2_log.s_cancel_debug(code, f"S撤积极下单计算大单卖阈值出错：{str(e)}")
        total_fast_money = int(total_fast_num * 100 * float(limit_up_price))
        if total_fast_money == 0:
            # 防止分母为0

 code_attribute/first_target_code_data_processor.py

@@ -251,9 +251,6 @@
        # 纠正数据
        if is_limit_up and limit_up_time is None:
            limit_up_time = tool.get_now_time_str()
        if is_limit_up:
            # 加入首板涨停
            gpcode_manager.FirstCodeManager().add_limited_up_record([code])
        pricePre = gpcode_manager.CodePrePriceManager.get_price_pre_cache(code)
        if pricePre is None:
            history_k_data_manager.re_set_price_pres([code])

 code_attribute/gpcode_manager.py

@@ -69,8 +69,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):
@@ -95,27 +93,6 @@

    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


# 想要买的代码

 constant.py

@@ -3,7 +3,7 @@

from huaxin_client import constant

# 所有的票激进买
# 所有的票积极买
ALL_ACTIVE_BUY = False

TEST = False

 inited_data.py

@@ -90,8 +90,6 @@
        gpcode_manager.WhiteListCodeManager().clear()
        # 清空想要买
        gpcode_manager.WantBuyCodesManager().clear()
        # 清空分数禁止代码
        trade_manager.ForbiddenBuyCodeByScoreManager().clear()
        # 清空暂停交易代码
        gpcode_manager.PauseBuyCodesManager().clear()
        # 清除L撤数据

 servers/huaxin_trade_server.py

@@ -32,7 +32,7 @@
from l2.l2_data_manager_new import L2TradeDataProcessor
from l2.l2_data_util import L2DataUtil
from l2.l2_sell_manager import L2MarketSellManager
from l2.l2_transaction_data_manager import HuaXinSellOrderStatisticManager, BigOrderDealManager
from l2.l2_transaction_data_manager import HuaXinSellOrderStatisticManager
from l2.l2_transaction_data_processor import HuaXinTransactionDatasProcessor
from l2.place_order_single_data_manager import L2TradeSingleCallback, L2TradeSingleDataManager
from log_module import async_log_util, log_export
@@ -720,13 +720,13 @@
                                                        sell_info=sell_info,
                                                        threshold_money=0)
                    l2_data_manager_new.L2TradeDataProcessor.save_order_begin_data(code, order_begin_pos)
                    l2_log.debug(code, "激进下单，获取到买入执行位置：{} 成交数据触发模式：{} 大单数量：{}",
                    l2_log.debug(code, "积极下单，获取到买入执行位置：{} 成交数据触发模式：{} 大单数量：{}",
                                 order_begin_pos.buy_exec_index,
                                 _type, big_buy_order_count)
                    l2_data_manager_new.L2TradeDataProcessor.start_buy(code, total_datas[-1], total_datas[-1]["index"],
                                                                       True)
                else:
                    l2_log.debug(code, "激进下单，不满足激进下单条件，无法激进")
                    l2_log.debug(code, "积极下单，不满足激进下单条件，无法激进")
            else:
                if not tool.is_sz_code(code):
                    return

 third_data/code_plate_key_manager.py

@@ -588,12 +588,12 @@
        l2_trade_util.forbidden_trade(code, msg=msg)
        logger_kpl_block_can_buy.info(msg)

    # 是否需要激进买
    # 是否需要积极买
    @classmethod
    def __is_need_active_buy(cls, code, block, current_rank, open_limit_up_count):
        """
        板块是否需要激进买入
        规则：根据身位判断是否需要激进买，根据时间划分
        板块是否需要积极买入
        规则：根据身位判断是否需要积极买，根据时间划分
        @param code: 代码
        @param block: 板块名称
        @param current_rank: 目前在板块中的身位，从0开始
@@ -615,7 +615,7 @@
                break
        return False

    # 返回内容(是否可买, 是否为独苗, 描述信息, 是否为强势主线, 是否需要激进买)
    # 返回内容(是否可买, 是否为独苗, 描述信息, 是否为强势主线, 是否需要积极买)
    @classmethod
    def __is_block_can_buy(cls, code, block, current_limit_up_datas, code_limit_up_reasons_dict,
                           yesterday_current_limit_up_codes, limit_up_record_datas, current_limit_up_block_codes_dict,
@@ -698,7 +698,7 @@
                                                                                                    current_open_limit_up_codes),
                                                                                                shsz=True,
                                                                                                limit_up_time=first_limit_up_time)
        # 计算是否需要激进买入
        # 计算是否需要积极买入
        is_active_buy = cls.__is_need_active_buy(code, block, current_shsz_rank, len(current_open_limit_up_codes))

        # record_shsz_rank, record_shsz_rank_codes = kpl_block_util.get_code_record_rank(code, block,
@@ -831,7 +831,7 @@
                                                                                                shsz=True,
                                                                                                limit_up_time=first_limit_up_time)

        # 计算是否需要激进买入
        # 计算是否需要积极买入
        is_active_buy = cls.__is_need_active_buy(code, block, current_shsz_rank, len(current_open_limit_up_codes))

        if current_shsz_rank < len(current_open_limit_up_codes) + max_rank:
@@ -903,7 +903,7 @@

    # 是否可以下单
    # 返回：可以买的板块,是否独苗,消息
    #  可买的板块, 是否独苗, 消息, 可买的强势板块, 关键词, 激进买的板块
    #  可买的板块, 是否独苗, 消息, 可买的强势板块, 关键词, 积极买的板块
    @classmethod
    def can_buy(cls, code):
        if constant.TEST:
@@ -913,7 +913,7 @@
        #     return True, "不判断板块身位"
        return cls.__can_buy_compute_result_dict.get(code)

    # 返回:(可以买的板块列表, 是否是独苗, 消息简介,可买的强势主线, 激进买入板块列表)
    # 返回:(可以买的板块列表, 是否是独苗, 消息简介,可买的强势主线, 积极买入板块列表)
    @classmethod
    def __compute_can_buy_blocks(cls, code, current_limit_up_datas, limit_up_record_datas,
                                 yesterday_current_limit_up_codes, before_blocks_dict,
@@ -976,7 +976,7 @@
        msg_list = []
        active_buy_blocks = []
        for r in blocks_compute_results:
            # r的数据结构(板块,是否可以买,是否独苗,消息,是否是强势板块, 激进买入信息)
            # r的数据结构(板块,是否可以买,是否独苗,消息,是否是强势板块, 积极买入信息)
            if r[2]:
                # 独苗
                unique_count += 1
@@ -1001,7 +1001,7 @@
                    msg_list.append(r[3])
                if r[5]:
                    active_buy_blocks.append(r[0])
                    msg_list.append(f"【{r[0]}】激进买入({r[5]})")
                    msg_list.append(f"【{r[0]}】积极买入({r[5]})")
            else:
                if r[3]:
                    msg_list.append(r[3])

 trade/current_price_process_manager.py

@@ -47,7 +47,7 @@
                if tool.is_ge_code(code):
                    # 创业板的涨幅需要打折
                    rate = rate / 2
                if rate >= 0 and not trade_manager.ForbiddenBuyCodeByScoreManager().is_in_cache(code):
                if rate >= 0:
                    # 暂存涨幅为正的代码
                    _code_list.append((rate, code, 1 if is_want_buy else 0))
                elif is_want_buy:

 trade/trade_manager.py

@@ -175,42 +175,6 @@
    def get_mode_cache(self):
        return self.__auto_cancel_sell_mode


# 根据分数禁止买的票管理
class ForbiddenBuyCodeByScoreManager:
    __instance = None

    def __new__(cls, *args, **kwargs):
        if not cls.__instance:
            cls.__instance = super(ForbiddenBuyCodeByScoreManager, cls).__new__(cls, *args, **kwargs)
            cls.__instance.__redisManager = redis_manager.RedisManager(2)
            cls.__instance.__key = "forbidden_codes_by_score"
            cls.__instance.__forbidden_codes_by_score_cache = RedisUtils.smembers(cls.__instance.__get_redis(),
                                                                                  cls.__instance.__key)
        return cls.__instance

    def __get_redis(self):
        return self.__redisManager.getRedis()

    def add_code(self, code):
        self.__forbidden_codes_by_score_cache.add(code)
        RedisUtils.sadd(self.__get_redis(), self.__key, code)

    def remove_code(self, code):
        self.__forbidden_codes_by_score_cache.discard(code)
        RedisUtils.srem(self.__get_redis(), self.__key, code)

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

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

    def clear(self):
        self.__forbidden_codes_by_score_cache.clear()
        RedisUtils.delete(self.__get_redis(), self.__key)


# 代码的交易状态管理
class CodesTradeStateManager:
    __trade_state_cache = {}