bug修复

Administrator

2023-07-24 0e68e24f54db11d340785b17570fff2bc5fc7ac6

 l2/l2_data_manager_new.py

@@ -4,16 +4,18 @@
from code_attribute import big_money_num_manager, code_volumn_manager, code_data_util, industry_codes_sort, \
    limit_up_time_manager, global_data_loader, gpcode_manager
import constant
from l2.huaxin import l2_huaxin_util
from l2.huaxin import l2_huaxin_util, huaxin_delegate_postion_manager
from third_data import kpl_data_manager, block_info
from utils import global_util, ths_industry_util, tool
import l2_data_util
from db import redis_manager
from third_data.code_plate_key_manager import CodePlateKeyBuyManager
from trade import trade_manager, trade_queue_manager, l2_trade_factor, l2_trade_util, \
    trade_result_manager, first_code_score_manager
from l2 import safe_count_manager, l2_data_manager, l2_data_log, l2_log, l2_data_source_util, code_price_manager
    trade_result_manager, first_code_score_manager, current_price_process_manager
from l2 import safe_count_manager, l2_data_manager, l2_data_log, l2_log, l2_data_source_util, code_price_manager, \
    transaction_progress
from l2.cancel_buy_strategy import SecondCancelBigNumComputer, HourCancelBigNumComputer, L2LimitUpMoneyStatisticUtil, \
    L2LimitUpSellStatisticUtil
    L2LimitUpSellStatisticUtil, DCancelBigNumComputer, LCancelBigNumComputer
from l2.l2_data_manager import L2DataException, TradePointManager
from l2.l2_data_util import local_today_datas, L2DataUtil, local_today_num_operate_map, local_today_buyno_map, \
    local_latest_datas
@@ -160,6 +162,7 @@
    __buyL2SafeCountManager = safe_count_manager.BuyL2SafeCountManager()
    __l2PlaceOrderParamsManagerDict = {}
    __last_buy_single_dict = {}
    __TradeBuyQueue = transaction_progress.TradeBuyQueue()

    # 获取代码评分
    @classmethod
@@ -231,10 +234,14 @@
                _start_index = local_today_datas[code][-1]["index"] + 1
            datas = l2_huaxin_util.get_format_l2_datas(code, datas,
                                                       gpcode_manager.get_limit_up_price(code), _start_index)
            # 获取下单位置
            place_order_index = huaxin_delegate_postion_manager.get_l2_place_order_position(code, datas)
            if place_order_index:
                logger_l2_process.info("code:{} 获取到下单真实位置：{}", code, place_order_index)
                DCancelBigNumComputer.set_real_order_index(code, place_order_index)

            __start_time = round(t.time() * 1000)
            print("格式化L2数据成功", code)
            cls.process_add_datas(code, datas, 0, __start_time)
            print("huaxin L2数据处理成功", code)
        except Exception as e:
            print("huaxin L2数据处理异常", code, str(e))
            logging.exception(e)
@@ -289,6 +296,9 @@
            cls.volume_rate_info[code] = (volume_rate, volume_rate_index)

            latest_time = add_datas[len(add_datas) - 1]["val"]["time"]

            __start_time = l2_data_log.l2_time(code, round(t.time() * 1000) - __start_time,
                                               "l2数据准备时间")
            # 时间差不能太大才能处理
            if not l2_trade_util.is_in_forbidden_trade_codes(code):
                # 判断是否已经挂单
@@ -411,6 +421,24 @@
                l2_data_log.l2_time(code, round(t.time() * 1000) - _start_time, "已下单-H撤大单计算")
            return None, ""

        # L撤
        @dask.delayed
        def l_cancel():
            _start_time = round(t.time() * 1000)
            try:
                b_need_cancel, b_cancel_data = LCancelBigNumComputer.need_cancel(code,
                                                                                 buy_exec_index, start_index,
                                                                                 end_index, total_data,
                                                                                 local_today_num_operate_map.get(
                                                                                     code), is_first_code)
                if b_need_cancel and b_cancel_data:
                    return b_cancel_data, "L撤销比例触发阈值"
            except Exception as e:
                logging.exception(e)
            finally:
                l2_data_log.l2_time(code, round(t.time() * 1000) - _start_time, "已下单-L撤大单计算")
            return None, ""

        # 板上卖撤
        @dask.delayed
        def sell_cancel():
@@ -458,9 +486,10 @@
        f4 = h_cancel()
        f5 = buy_1_cancel()
        f6 = sell_cancel()
        dask_result = is_need_cancel(f1, f2, f3, f4, f5, f6)
        f7 = l_cancel()
        dask_result = is_need_cancel(f1, f2, f3, f4, f5, f6, f7)
        if is_first_code:
            dask_result = is_need_cancel(f3, f4)
            dask_result = is_need_cancel(f3, f4, f7)

        cancel_data, cancel_msg = dask_result.compute()

@@ -531,6 +560,7 @@
                                    buy_single_index, buy_exec_index, cls.volume_rate_info[code][0],
                                    cls.__l2PlaceOrderParamsManagerDict[code].score, params_desc)
            except Exception as e:
                logger_l2_error.exception(e)
                l2_log.debug(code, "执行买入异常:{}", str(e))
                pass
            finally:
@@ -708,36 +738,58 @@
        if gpcode_manager.PauseBuyCodesManager.is_in(code):
            return False, True, f"该代码被暂停交易"

        # 判断买1价格档位
        zyltgb = global_util.zyltgb_map.get(code)
        if zyltgb is None:
            global_data_loader.load_zyltgb()
            zyltgb = global_util.zyltgb_map.get(code)
        buy1_price = code_price_manager.Buy1PriceManager.get_buy1_price(code)
        if buy1_price is None:
            return False, True, f"尚未获取到买1价"
        limit_up_price = gpcode_manager.get_limit_up_price(code)

        dif = float(limit_up_price) - float(buy1_price)
        if zyltgb >= 200 * 100000000:
            # 大于10档
            if dif > 0.10001:
                return False, True, f"自由流通200亿以上，买1剩余档数大于10档，买一（{buy1_price}）涨停（{limit_up_price}）"
        # elif zyltgb >= 80 * 100000000:
        #     # 大于2档
        #     if dif > 0.02001:
        #         return False, True, f"买1剩余档数大于2档，买一（{buy1_price}）涨停（{limit_up_price}）"
        # elif zyltgb >= 60 * 100000000:
        #     # 大于2档
        #     if dif > 0.03001:
        #         return False, True, f"买1剩余档数大于3档，买一（{buy1_price}）涨停（{limit_up_price}）"
        # elif zyltgb >= 40 * 100000000:
        #     # 大于2档
        #     if dif > 0.04001:
        #         return False, True, f"买1剩余档数大于4档，买一（{buy1_price}）涨停（{limit_up_price}）"
        # else:
        #     if dif > 0.05001:
        #         return False, True, f"买1剩余档数大于5档，买一（{buy1_price}）涨停（{limit_up_price}）"
        if float(limit_up_price) >= 40:
            return False, True, "股价大于40块"

        if constant.L2_SOURCE_TYPE == constant.L2_SOURCE_TYPE_HUAXIN:
            trade_price = current_price_process_manager.get_trade_price(code)
            if trade_price is None:
                return False, True, f"尚未获取到当前成交价"
            if float(limit_up_price) - float(trade_price) > 0.02001:
                return False, False, f"当前成交价（{trade_price}）尚未在2档及以内"

            # 判断成交进度是否距离我们的位置很近
            total_data = local_today_datas.get(code)
            trade_index, is_default = cls.__TradeBuyQueue.get_traded_index(code)
            if not is_default and trade_index:
                buy_index_set = set()
                num_operate_map = local_today_num_operate_map.get(code)
                for i in range(trade_index + 1, total_data[-1]["index"] + 1):
                    if L2DataUtil.is_limit_up_price_buy(total_data[i]["val"]):
                        left_count = l2_data_source_util.L2DataSourceUtils.get_limit_up_buy_no_canceled_count(code,
                                                                                                              total_data[
                                                                                                                  i][
                                                                                                                  "index"],
                                                                                                              total_data,
                                                                                                              num_operate_map)
                        if left_count > 0:
                            buy_index_set.add(total_data[i]["index"])

                if len(buy_index_set) < 5:
                    return False, False, f"成交位置距离当前位置小于5笔"
        else:
            # 判断买1价格档位
            zyltgb = global_util.zyltgb_map.get(code)
            if zyltgb is None:
                global_data_loader.load_zyltgb()
                zyltgb = global_util.zyltgb_map.get(code)

            if zyltgb >= 200 * 100000000:
                buy1_price = code_price_manager.Buy1PriceManager.get_buy1_price(code)
                if buy1_price is None:
                    return False, True, f"尚未获取到买1价"
                dif = float(limit_up_price) - float(buy1_price)
                # 大于10档
                if dif > 0.10001:
                    return False, True, f"自由流通200亿以上，买1剩余档数大于10档，买一（{buy1_price}）涨停（{limit_up_price}）"

        open_limit_up_lowest_price = code_price_manager.Buy1PriceManager.get_open_limit_up_lowest_price(code)
        price_pre_close = gpcode_manager.get_price_pre(code)
        if open_limit_up_lowest_price and (
                float(open_limit_up_lowest_price) - price_pre_close) / price_pre_close < 0.05:
            return False, True, f"炸板后最低价跌至5%以下"

        limit_up_info = code_price_manager.Buy1PriceManager.get_limit_up_info(code)
        if limit_up_info[0] is None and False:
@@ -779,18 +831,39 @@

    @classmethod
    def can_buy_first(cls, code, limit_up_price, score_index, score, score_info, volume_rate_info):
        def is_has_k_format(score_info):
            # (15个交易日涨幅是否大于24.9%,是否破前高，是否超跌，是否接近前高，是否N,是否V,是否有形态,天量大阳信息,是否具有辨识度)

            if score_info[1][3][6][0] and not score_info[1][3][3][0]:
                return True
            if score_info[1][3][7][0]:
                return True
            return False

        if float(limit_up_price) >= 40:
            return False, True, "股价大于40块"

        # 9:35之前买大市值(>=80亿)票
        if int(tool.get_now_date_str("%Y%m%d")) < int("093500"):
            zyltgb = global_util.zyltgb_map.get(code)
            if zyltgb is None:
                global_data_loader.load_zyltgb()
                zyltgb = global_util.zyltgb_map.get(code)
            if zyltgb >= 80 * 100000000:
                return True, False, "{9:30:00-9:35:00}自由市值≥80亿"
        # 判断板块
        plate_can_buy, msg = CodePlateKeyBuyManager.can_buy(code)
        plate_can_buy, msg = CodePlateKeyBuyManager.can_buy(code,
                                                            kpl_data_manager.KPLLimitUpDataRecordManager.latest_origin_datas,
                                                            kpl_data_manager.KPLLimitUpDataRecordManager.total_datas,block_info.get_before_blocks_dict())
        if not plate_can_buy:
            return False, True, msg
        return True, False, msg

        # if volume_rate_info[0] < 0.4:
        #     return False, True, f"量大于40%才下单,量比：{volume_rate_info[0]}"

        # 是否有K线形态(有K线形态或者天量大阳),10点后才需要判断是否有K线形态与分值
        if int(tool.get_now_time_str().replace(":","")) > int("100000"):
        if int(tool.get_now_time_str().replace(":", "")) > int("100000"):
            has_k_format = score_info[1][3][6][0] or score_info[1][3][7][0]
            if not has_k_format:
                return False, True, f"无K线形态"