blame | 历史 | 补丁 | 提交 | 提交对比 | ignore whitespace
Administrator
4 天以前 48fb7a00951f91bdc707e5dd2d196e5bccb752c3 
 output/code_info_output.py


@@ -6,21 +6,26 @@


# 下单参数信息


# 选股宝


# 市场热度


import logging


import sys


import time


import code_attribute


from code_attribute import code_volumn_manager, limit_up_time_manager, global_data_loader, gpcode_manager


import constant


from code_attribute import code_volumn_manager, limit_up_time_manager, global_data_loader, gpcode_manager, \


    code_nature_analyse


from l2.l2_data_manager import OrderBeginPosInfo


from l2.l2_data_util import L2DataUtil


from third_data.code_plate_key_manager import KPLCodeJXBlockManager


from third_data.kpl_data_constant import LimitUpCodesBlockRecordManager


from trade.buy_radical.block_special_codes_manager import BlockSpecialCodesManager


from utils import global_util, tool


from log_module import log, log_export


from l2 import l2_data_manager, l2_data_util, transaction_progress, l2_data_manager_new, code_price_manager


from l2.cancel_buy_strategy import HourCancelBigNumComputer


from cancel_strategy.s_l_h_cancel_strategy import HourCancelBigNumComputer


import l2.l2_data_manager_new


from third_data import kpl_data_manager, kpl_api


from third_data.kpl_data_manager import KPLLimitUpDataRecordManager


from trade import first_code_score_manager, l2_trade_factor, trade_manager, l2_trade_util


from trade import l2_trade_factor, trade_manager, l2_trade_util, trade_record_log_util, trade_constant


from trade.l2_trade_factor import L2TradeFactorUtil


import trade.deal_big_money_manager




base_output_content = {}


kpl_block_info_dict = {}


@@ -29,7 +34,6 @@






def __get_base_html_content():


    print("路径", sys.path[0])


    if base_output_content.get('css') is None:


        __base_html_content = ""


        with open("./output/css/style.css", mode='r') as f:


@@ -39,7 +43,6 @@


        base_output_content['css'] = __base_html_content




    return f"<head><style>{base_output_content['css']}</style></head>"








def money_desc(money):


@@ -67,9 +70,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):


@@ -78,191 +81,55 @@


        code_extra_infos.append("暂不买")


    params["code"] = code


    params["code_name"] = f"{gpcode_manager.get_code_name(code)} {code}  （{','.join(code_extra_infos)}）"




    score_info = None


    buy_params_info = None


    xgb_infos = None


    total_datas = l2_data_util.local_today_datas.get(code)


    if total_datas is None:


        l2_data_util.load_l2_data(code)


        total_datas = l2_data_util.local_today_datas.get(code)


        total_datas = []


        # l2_data_util.load_l2_data(code)


        # total_datas = l2_data_util.local_today_datas.get(code)


    if is_target_code:


        params["score_data"] = {}


        limit_up_price = gpcode_manager.get_limit_up_price(code)


        limit_up_time = limit_up_time_manager.LimitUpTimeManager().get_limit_up_time_cache(code)


        volume_rate, volume_info = code_volumn_manager.get_volume_rate(code, True)


        (score, score_list), score_source_list = first_code_score_manager.get_score(code, volume_rate, limit_up_time,


                                                                                    True)


        volume_rate, volume_info = code_volumn_manager.CodeVolumeManager().get_volume_rate(code, with_info=True)




        ################################买前评分################################


        # ["换手量能", "竞价强度", "资金力度", "K线形态", "历史股性", "板块热度", "上板时间", "市值大小","股价大小"]




        # 换手量能


        # 获取当前量信息


        max_60, yest = code_volumn_manager.get_histry_volumn(code)


        today = code_volumn_manager.get_today_volumn(code)


        params["score_data"]["volume"] = {"score": score_list[6], "now": f"{round(int(today) / 1000000, 2)}",


                                          "high": {"num": round(max_60[0] / 1000000, 2), "date": max_60[1]},


                                          "rate": round(score_source_list[6] * 100, 2)}




        # 竞价强度


        params["score_data"]["bidding"] = {"score": score_list[2],


                                           "money": (score_source_list[2] if score_source_list[2] else 0)}




        # 资金力度


        deal_indexes = set()


        deal_info = ""


        params["score_data"]["deal_big_money"] = {"score": score_list[8], "money": score_source_list[8][0] // 10000,


                                                  "base_money": score_source_list[8][1] // 10000,


                                                  "rate": round(score_source_list[8][0] / score_source_list[8][1], 2)}


        if deal_indexes:


            temps = []


            for index in deal_indexes:


                temps.append(int(index))


            temps.sort()


            start_index = temps[0]


            end_index = temps[-1]


            try:


                deal_info = f"【{total_datas[start_index]['val']['time']}&{total_datas[start_index]['val']['num']}手-{total_datas[end_index]['val']['time']}&{total_datas[end_index]['val']['num']}手】,"


            except:


                pass


            params["score_data"]["deal_big_money"]["start"] = {"time": total_datas[start_index]['val']['time'],


                                                               "num": total_datas[start_index]['val']['num']}


            params["score_data"]["deal_big_money"]["end"] = {"time": total_datas[end_index]['val']['time'],


                                                             "num": total_datas[end_index]['val']['num']}




        # K线形态


        k_score = 0


        k_source = []


        for k in score_list[3]:


            k_score += k




        # (15个交易日是否涨幅24.9%,是否破前高，是否超跌，是否接近前高，是否N,是否V)


        for k in range(0, len(score_source_list[3])):


            if k == 0:


                if score_source_list[3][k][0]:


                    k_source.append(("涨幅过高", score_list[3][k]))


            elif k == 1:


                if score_source_list[3][k][0]:


                    k_source.append(("突破前高", score_list[3][k]))


            elif k == 2:


                if score_source_list[3][k][0]:


                    k_source.append(("超跌补涨", score_list[3][k]))


            elif k == 3:


                if score_source_list[3][k][0]:


                    k_source.append((f"逼近前高-{score_source_list[3][k][1]}】", score_list[3][k]))


            elif k == 4:


                if score_source_list[3][k][0]:


                    k_source.append(("N字型", score_list[3][k]))


            elif k == 5:


                if score_source_list[3][k][0]:


                    k_source.append(("V字型", score_list[3][k]))


            elif k == 6:


                if not score_source_list[3][k][0]:


                    k_source.append(("不满足任何形态", score_list[3][k]))


            elif k == 7:


                if score_source_list[3][k][0]:


                    k_source.append(("天量大阳", score_list[3][k]))




        params["score_data"]["k_form"] = {"score": k_score, "datas": k_source}




        log.logger_debug.info(f"K线形态耗时：{time.time() - __start_time}")


        __start_time = time.time()




        # 历史股性


        nature_score = 0


        nature_source = []


        for k in score_list[4]:


            nature_score += k




        code_nature_datas = {"score": nature_score, "limit_up_count": score_source_list[4][0]}




        for n in range(0, len(score_source_list[4])):


            if n == 0:


                nature_source.append(f"涨停次数【{score_source_list[4][n]}】")


            elif n == 1:


                if score_source_list[4][n]:


                    nature_source.append(f"首板溢价率【{round(score_source_list[4][n], 2)}】")


                    code_nature_datas["first_limit_up_yijia"] = round(score_source_list[4][1], 2)


                else:


                    nature_source.append(f"无首板")


                    code_nature_datas["first_limit_up_yijia"] = "无首板"


            elif n == 2:


                if score_source_list[4][n]:


                    nature_source.append(f"首板炸板溢价率【{round(score_source_list[4][n], 2)}】")


                    code_nature_datas["first_open_limit_up_yijia"] = round(score_source_list[4][2], 2)


                else:


                    nature_source.append(f"无首板炸板")


                    code_nature_datas["first_open_limit_up_yijia"] = "无首板炸板"




        params["score_data"]["code_nature"] = code_nature_datas




        log.logger_debug.info(f"历史股性耗时：{time.time() - __start_time}")


        __start_time = time.time()




        # 板块热度


        hot_block_score = 0


        for k in score_list[5]:


            hot_block_score += k


        hot_block_source_data = score_source_list[5]


        for k in hot_block_source_data:


            hot_block = {


                # 目标板块信息（板块名称,板块涨幅,历史板块出现次数）


                "target_block_info": ("无板块", 0, 0),


                # 涨停顺序


                "limit_up_index": 0,


                # 涨停代码数量


                "limit_up_codes_count": 0,


                # 板块代码涨幅信息


                "block_codes_rates_info": (0, 0),


                # 炸板代码数量


                "break_size": 0,


                # 炸板回封数量


                "re_limit_up_size": 0,


                # 高位版信息


                "high_block_infos": [],


            }


        params["score_data"]["hot_block"] = {"score": hot_block_score,


                                             "limit_up_index": hot_block_source_data['limit_up_index'] + 1,


                                             "block_name": hot_block_source_data['target_block_info'][0],


                                             "limit_up_count": hot_block_source_data['limit_up_codes_count'],


                                             "block_history_count": hot_block_source_data['target_block_info'][2],


                                             "open_limit_up_count": hot_block_source_data['break_size']}




        # 上板时间


        params["score_data"]["limit_up_time"] = {"score": score_list[7], "time": score_source_list[7]}


        # 市值大小


        params["score_data"]["zyltgb"] = {"score": score_list[0], "value": round(score_source_list[0] / 100000000, 2)}


        # 股价大小


        params["score_data"]["limit_up_price"] = {"score": score_list[1], "price": score_source_list[1]}




        params["score_data"]["total_score"] = score




        # zyltgb, limit_price, bidding, k_form, code_nature, hot_block, volume_rate, limit_up_time,


        # deal_big_money


        log.logger_debug.info(f"板块热度耗时：{time.time() - __start_time}")


        # log.logger_debug.info(f"板块热度耗时：{time.time() - __start_time}")


        __start_time = time.time()




        ###############################下单信息###############################


        params["trade_data"] = {}




        # 获取买入意愿


        volume_rate = score_source_list[6]


        __L2PlaceOrderParamsManager = l2_trade_factor.L2PlaceOrderParamsManager(code, True, volume_rate,


                                                                                code_volumn_manager.get_volume_rate_index(


                                                                                code_volumn_manager.CodeVolumeManager().get_volume_rate_index(


                                                                                    volume_rate),


                                                                                (


                                                                                    (score, score_list),


                                                                                    score_source_list))


                                                                                None)


        # 是否可以买入的信息


        can_buy_info = l2.l2_data_manager_new.L2TradeDataProcessor.can_buy_first(code, limit_up_price)


        params["trade_data"]["can_buy_info"] = can_buy_info


        try:


            can_buy_info = l2.l2_data_manager_new.L2TradeDataProcessor.can_buy_first_new(code, limit_up_price)


            params["trade_data"]["can_buy_info"] = can_buy_info


        except:


            pass




        # 获取量参考日期


        try:


            volume_refer_date, volume_refer_date_distance = code_volumn_manager.CodeVolumeManager().get_volume_refer_date(


                code)


            params["trade_data"]["volume_refer_date"] = volume_refer_date


        except:


            pass




        # 获取是否


        k_format = code_nature_analyse.CodeNatureRecordManager().get_k_format_cache(code)


        if k_format:


            params["trade_data"]["special_info"] = k_format[8]




        __base_L2PlaceOrderParamsManager = l2_trade_factor.L2PlaceOrderParamsManager(code, False, volume_rate,


                                                                                     code_volumn_manager.get_volume_rate_index(


                                                                                     code_volumn_manager.CodeVolumeManager().get_volume_rate_index(


                                                                                         volume_rate),


                                                                                     ((score, score_list),


                                                                                      score_source_list))


                                                                                     None)


        if -1 < __L2PlaceOrderParamsManager.score_index < 3:


            params["trade_data"]["star"] = {"desc": "主动买入"}


            if __L2PlaceOrderParamsManager.score_index == 0:


@@ -298,54 +165,69 @@


            # buy_params_info.append("未识别")


            pass


        else:


            if trade_progress<len(total_datas):


            if trade_progress < len(total_datas):




                trade_progress_datas = []


                for min_money in [30000, 20000, 10000]:


                    for i in range(trade_progress - 1, -1, -1):


                        # 是否为涨停买


                        data = total_datas[i]


                        if L2DataUtil.is_limit_up_price_buy(total_datas[i]['val']):


                            if data['val']['num'] * float(data['val']['price']) > min_money:


                                trade_progress_datas.append({"time": data['val']['time'],


                                                             "num": data['val']['num'], "money": money_desc(round(


                                        data['val']['num'] * float(data['val']['price']) * 100))})


                                break


                    if trade_progress_datas:


                        break


                data = total_datas[trade_progress]


                params["trade_data"]["trade_progress"] = {"time": data['val']['time'],


                                                          "num": data['val']['num'], "money": round(


                        data['val']['num'] * float(data['val']['price']) * 100 / 10000, 1)}


                trade_progress_datas.append({"time": data['val']['time'],


                                             "num": data['val']['num'], "money": money_desc(round(


                        data['val']['num'] * float(data['val']['price']) * 100))})


                params["trade_data"]["trade_progress"] = trade_progress_datas




        # 买入信号


        buy_single_index, buy_exec_index, compute_index, num, count, max_num_set, volume_rate = l2_data_manager.TradePointManager().get_buy_compute_start_data_cache(


        order_begin_pos = l2_data_manager.TradePointManager().get_buy_compute_start_data_cache(


            code)




        if buy_single_index is None:


        if order_begin_pos.buy_single_index is None:


            # buy_params_info.append("无信号")


            pass


        else:


            data = total_datas[buy_single_index]


            data = total_datas[order_begin_pos.buy_single_index]


            params["trade_data"]["buy_single"] = {"time": data['val']['time'], "num": data['val']['num'],


                                                  "money": round(data['val']['num'] * float(


                                                      data['val']['price']) * 100 / 10000, 1)}




        if buy_exec_index is None or buy_exec_index < 0:


        if order_begin_pos.buy_exec_index is None or order_begin_pos.buy_exec_index < 0:


            # buy_params_info.append("未下单")


            pass


        else:


            data = total_datas[buy_exec_index]


            data = total_datas[order_begin_pos.buy_exec_index]


            params["trade_data"]["buy_exec"] = {"time": data['val']['time'], "num": data['val']['num'],


                                                "money": round(data['val']['num'] * float(


                                                    data['val']['price']) * 100 / 10000, 1)}


        params["trade_data"]["trade_state"] = {}


        trade_state = trade_manager.CodesTradeStateManager().get_trade_state_cache(code)


        if trade_state == trade_manager.TRADE_STATE_BUY_PLACE_ORDER or trade_state == trade_manager.TRADE_STATE_BUY_DELEGATED:


        if trade_state == trade_constant.TRADE_STATE_BUY_PLACE_ORDER or trade_state == trade_constant.TRADE_STATE_BUY_DELEGATED:


            params["trade_data"]["trade_state"]["order"] = True


            params["trade_data"]["trade_state"]["desc"] = "已下单"


        else:


            params["trade_data"]["trade_state"]["order"] = False


            if trade_state == trade_manager.TRADE_STATE_NOT_TRADE:


            if trade_state == trade_constant.TRADE_STATE_NOT_TRADE:


                params["trade_data"]["trade_state"]["desc"] = "未交易"


            elif trade_state == trade_manager.TRADE_STATE_BUY_CANCEL_ING:


            elif trade_state == trade_constant.TRADE_STATE_BUY_CANCEL_ING:


                params["trade_data"]["trade_state"]["desc"] = "撤单中"


            elif trade_state == trade_manager.TRADE_STATE_BUY_CANCEL_SUCCESS:


            elif trade_state == trade_constant.TRADE_STATE_BUY_CANCEL_SUCCESS:


                params["trade_data"]["trade_state"]["desc"] = "撤单成功"


            elif trade_state == trade_manager.TRADE_STATE_BUY_SUCCESS:


            elif trade_state == trade_constant.TRADE_STATE_BUY_SUCCESS:


                params["trade_data"]["trade_state"]["desc"] = "已成交"




        log.logger_debug.info(f"下单信息耗时：{time.time() - __start_time}")


        # log.logger_debug.info(f"下单信息耗时：{time.time() - __start_time}")


        __start_time = time.time()




        # H撤监听范围


        if trade_state == trade_manager.TRADE_STATE_BUY_PLACE_ORDER or trade_state == trade_manager.TRADE_STATE_BUY_DELEGATED or trade_state == trade_manager.TRADE_STATE_BUY_SUCCESS:


        if trade_state == trade_constant.TRADE_STATE_BUY_PLACE_ORDER or trade_state == trade_constant.TRADE_STATE_BUY_DELEGATED or trade_state == trade_constant.TRADE_STATE_BUY_SUCCESS:


            hcancel_datas_dict, cancel_indexes_set = HourCancelBigNumComputer().get_watch_index_dict(code)


            # 根据日志读取实时的计算数据


            h_cancel_latest_compute_info = log_export.get_h_cancel_compute_info(code)


@@ -363,30 +245,30 @@


                    params["trade_data"]["h_cancel"]["datas"].append(


                        (val["time"], val["num"], money_desc(val["num"] * float(val["price"]) * 100),


                         (1 if canceled else 0)))


        log.logger_debug.info(f"H撤监听范围耗时：{time.time() - __start_time}")


        # log.logger_debug.info(f"H撤监听范围耗时：{time.time() - __start_time}")


        __start_time = time.time()




    ##############################主动买，被动买##################################


    # 返回主动买,被动买,不买的列表(代码, 名称, 得分, 是否涨停)


    codes_score = __load_codes_scores()


    # codes_score = __load_codes_scores()


    params["initiative_buy_codes"] = []


    for d in codes_score[0]:


        params["initiative_buy_codes"].append(


            {"name": d[1], "code": d[0], "score": d[2], "limit_up": d[3], "open_limit_up": d[4]})


    # for d in codes_score[0]:


    #     params["initiative_buy_codes"].append(


    #         {"name": d[1], "code": d[0], "score": d[2], "limit_up": d[3], "open_limit_up": d[4]})




    params["passive_buy_codes"] = []


    for d in codes_score[1]:


        params["passive_buy_codes"].append(


            {"name": d[1], "code": d[0], "score": d[2], "limit_up": d[3], "open_limit_up": d[4]})


    # for d in codes_score[1]:


    #     params["passive_buy_codes"].append(


    #         {"name": d[1], "code": d[0], "score": d[2], "limit_up": d[3], "open_limit_up": d[4]})




    params["passive_buy_codes"] = params["passive_buy_codes"]


    log.logger_debug.info(f"主动买，被动买耗时：{time.time() - __start_time}")


    # log.logger_debug.info(f"主动买，被动买耗时：{time.time() - __start_time}")


    __start_time = time.time()




    trade_info = __load_trade_record(code, total_datas)


    trade_info = load_trade_record(code, total_datas)


    params["trade_record"] = {"open_limit_up": trade_info[0], "records": trade_info[2]}




    log.logger_debug.info(f"读取交易记录耗时：{time.time() - __start_time}")


    # log.logger_debug.info(f"读取交易记录耗时：{time.time() - __start_time}")


    __start_time = time.time()




    ##############################开盘啦相关信息##################################


@@ -395,17 +277,24 @@


        "industry": format_plate_output(industry)}


    # 获取开盘啦板块


    plate_info = None


    if code not in kpl_block_info_dict:


        plate_info = kpl_api.getStockIDPlate(code)


    else:


        plate_info = kpl_block_info_dict.get(code)


    jingxuan_block_info = KPLCodeJXBlockManager().get_jx_blocks_cache(code)


    if not jingxuan_block_info:


        jingxuan_block_info = KPLCodeJXBlockManager().get_jx_blocks_cache(code, by=True)


    if jingxuan_block_info:


        jingxuan_blocks = jingxuan_block_info[0]


        plate_info = [(0, x, 0) for x in jingxuan_blocks]  # set([x[1] for x in jingxuan_blocks])


    if not plate_info:


        if code not in kpl_block_info_dict:


            plate_info = kpl_api.getStockIDPlate(code)


        else:


            plate_info = kpl_block_info_dict.get(code)


    if plate_info:


        kpl_block_info_dict[code] = plate_info


        plate_info.sort(key=lambda x: x[2])


        plate_info.reverse()


        params["kpl_code_info"]["plate"] = [(k[0], k[1], k[2], format_plate_output(k[1])[1]) for k in plate_info]




    log.logger_debug.info(f"开盘啦板块耗时：{time.time() - __start_time}")


    # log.logger_debug.info(f"开盘啦板块耗时：{time.time() - __start_time}")


    __start_time = time.time()




    # 获取代码的历史涨停数据,(涨停原因,日期,板块)


@@ -413,6 +302,13 @@


    if code_records:


        code_records = [(format_plate_output(k[0]), k[1], [format_plate_output(k1) for k1 in k[2].split("、")]) for k in


                        code_records]


    # 修改历史


    # code_records = LimitUpCodesBlockRecordManager().get_radical_buy_blocks_origin_data(code)


    # if code_records:


    #     code_records = [(f"{x[0]}x{x[1]}", x[2], '') for x in code_records]


    # else:


    #     code_records = []




    params["kpl_code_info"]["code_records"] = code_records




    if not KPLLimitUpDataRecordManager.total_datas:


@@ -425,64 +321,72 @@


            params["kpl_code_info"]["today"] = (format_plate_output(d[2]), d[1], plates)


            break




    log.logger_debug.info(f"获取代码的历史涨停数据耗时：{time.time() - __start_time}")


    # log.logger_debug.info(f"获取代码的历史涨停数据耗时：{time.time() - __start_time}")


    __start_time = time.time()


    return params






def __load_codes_scores():


    # 获取所有监听中的代码


    codes = gpcode_manager.FirstGPCodesManager().get_first_gp_codes()


    scores = {}  # l2_data_manager_new.L2TradeDataProcessor.get_code_scores()


    for code in codes:


        if code not in scores:


            # 获取分数


            try:


                limit_up_time = limit_up_time_manager.LimitUpTimeManager().get_limit_up_time_cache(code)


                volume_rate, volume_info = code_volumn_manager.get_volume_rate(code, True)


                (score, score_list), score_source_list = first_code_score_manager.get_score(code, volume_rate,


                                                                                            limit_up_time,


                                                                                            True)


                scores[code] = score


            except:


                pass


    # 筛选180分以上的代码


    scores_list = []


    for code in scores:


        code_name = gpcode_manager.get_code_name(code)


        # 获取现价，判断是否涨停


        current_price_info = global_util.cuurent_prices.get(code)


        limit_up_info = code_price_manager.Buy1PriceManager().get_limit_up_info(code)


        is_limit_up = True


        open_limit_up = limit_up_info[0] and limit_up_info[1]


        if current_price_info is not None and not current_price_info[1]:


            is_limit_up = False


# 获取开盘啦板块信息


def get_kpl_block_info(code):


    def format_plate_output(_plat):


        return _plat, ''




    ##############################开盘啦相关信息##################################


    industry = global_util.code_industry_map.get(code)


    kpl_code_info = {


        "industry": format_plate_output(industry)}


    # 获取开盘啦板块


    plate_info = None


    jingxuan_block_info = KPLCodeJXBlockManager().get_jx_blocks_cache(code)


    if not jingxuan_block_info:


        jingxuan_block_info = KPLCodeJXBlockManager().get_jx_blocks_cache(code, by=True)


    if jingxuan_block_info:


        jingxuan_blocks = jingxuan_block_info[0]


        plate_info = [(0, x, 0) for x in jingxuan_blocks]  # set([x[1] for x in jingxuan_blocks])


    if not plate_info:


        if code not in kpl_block_info_dict:


            plate_info = kpl_api.getStockIDPlate(code)


        else:


            is_limit_up = True


        scores_list.append((code, code_name, scores[code], is_limit_up, open_limit_up))


    scores_list.sort(key=lambda x: x[2], reverse=True)


    fscores_list = [[], [], []]


    for score in scores_list:


        if score[2] >= constant.BUY_SCORE_RANK_1:


            fscores_list[0].append(score)


        elif score[2] >= constant.BUY_SCORE_RANK_0:


            fscores_list[1].append(score)


        else:


            fscores_list[2].append(score)


            plate_info = kpl_block_info_dict.get(code)


    if plate_info:


        kpl_block_info_dict[code] = plate_info


        plate_info.sort(key=lambda x: x[2])


        plate_info.reverse()


        kpl_code_info["plate"] = [(k[0], k[1], k[2], format_plate_output(k[1])[1]) for k in plate_info]




    return fscores_list


    code_records = KPLLimitUpDataRecordManager.get_latest_infos(code, 4, False)[:2]


    if code_records:


        code_records = [(format_plate_output(k[0]), k[1], [format_plate_output(k1) for k1 in k[2].split("、")]) for k in


                        code_records]


    kpl_code_info["code_records"] = code_records




    if not KPLLimitUpDataRecordManager.total_datas:


        KPLLimitUpDataRecordManager.load_total_datas()


    for d in KPLLimitUpDataRecordManager.total_datas:


        if d[3] == code:


            # 获取今日


            plates = d[6].split("、")


            plates = [format_plate_output(p) for p in plates]


            kpl_code_info["today"] = (format_plate_output(d[2]), d[1], plates)


            break


    return kpl_code_info






def __load_trade_record(code, total_datas):


def load_trade_record(code, total_datas, date=tool.get_now_date_str()):


    def format_l2_data(item):


        return f"{item['val']['time']}#{item['val']['num']}手#{round(item['val']['num'] * float(item['val']['price']) * 100 / 10000, 1)}万"




    def load_cancel_watch_index(latest_cancel_watch_index_dict_):


        for k in latest_cancel_watch_index_dict_:


            records_new_data.append(latest_cancel_watch_index_dict_[k])


        latest_cancel_watch_index_dict_.clear()




    # 获取炸板信息


    limit_up_info = code_price_manager.Buy1PriceManager().get_limit_up_info(code)


    break_time = limit_up_info[1]


    records = []


    try:


        records = log_export.load_buy_score_recod(code)


        records = log_export.load_trade_recod(code, date=date)


    except:


        pass


    records_new = []


@@ -490,96 +394,143 @@


    index = 0


    if records:


        try:


            latest_cancel_watch_index_dict = {}


            for record in records:


                time_ = record[0]


                type = record[1]


                data = record[2]


                if type == '下单':


                    index += 1


                    temp = f"第{index}次下单：【{time_}】&【{data['score']}分】,{data.get('desc')}"


                    records_new.append(temp)


                    records_new_data.append({"type": 1, "index": index, "time": time_, "score": data['score']})


                elif type == 'S撤':


                    # index':378 , 'rate':0.51 , 'target_rate':0.49


                    pass


                elif type == 'S撤范围':


                    start = format_l2_data(total_datas[data['start_index']])


                    end = format_l2_data(total_datas[data['end_index']])


                    range_seconds = data['range_seconds']


                    temp = f"第{index}次撤单：S撤囊括范围：【起始位:{start}】至【截止位:{end}】囊括时间【{range_seconds}】秒"


                elif type == 'H撤范围':


                    start = format_l2_data(total_datas[data['start_index']])


                    end = format_l2_data(total_datas[data['end_index']])


                    count = data['count']


                    temp = f"H撤囊括范围：【起始位:{start}】至【截止位:{end}】物理笔数共【{count}】笔"


                elif type == 'H撤':


                    # 'start_index':339,'end_index':464, 'count':17


                    pass


                elif type == '撤单':


                    temp = f"第{index}次撤单：【{time_}】{data['msg']}"


                    records_new.append(temp)


                    records_new_data.append({"type": 0, "time": time_, "desc": data['msg']})


                if type == trade_record_log_util.TYPE_PLACE_ORDER:


                    # if data['kpl_blocks'] and (type(data['kpl_blocks'][0]) == list or type(data['kpl_blocks'][0]) == tuple):


                    #     records_new_data.append((time_, "开盘啦推荐原因",


                    #                              f"{'、'.join([k[1] for k in data['kpl_blocks']])}",


                    #                              None))


                    # else:


                    records_new_data.append((time_, "开盘啦推荐原因",


                                             f"{'、'.join(data['kpl_blocks'])}",


                                             None))


                    if "kpl_match_blocks" in data:


                        if data["kpl_match_blocks"]:


                            records_new_data.append((time_, "匹配原因",


                                                     f"{'、'.join(data['kpl_match_blocks'])}",


                                                     None))


                        else:


                            records_new_data.append((time_, "匹配原因",


                                                     f"独苗",


                                                     None))


                    extra_datas = []


                    if data.get('big_num_indexes'):


                        big_num_desc = []


                        for i in data['big_num_indexes']:


                            big_num_desc.append(format_l2_data(total_datas[i]))


                        extra_datas.append(f"包含大单：{' & '.join(big_num_desc)}")


                    if data.get('m_val'):


                        extra_datas.append(f"M值：{money_desc(data['m_val'])}")


                    if data.get('safe_count'):


                        extra_datas.append(f"安全笔数：{data['safe_count']}")


                    extra_datas.append(f"总卖额：{data.get('sell_info')}")




        except:


            pass


                    records_new_data.append((time_, "", "-------------------------", []))


                    mode = data.get('mode')


                    mode_desc = data.get('mode_desc')


                    if mode == OrderBeginPosInfo.MODE_ACTIVE:


                        records_new_data.append((time_, "积极下单",


                                                 mode_desc,


                                                 extra_datas))


                    elif mode == OrderBeginPosInfo.MODE_FAST:


                        records_new_data.append((time_, "闪电下单",


                                                 mode_desc,


                                                 extra_datas))


                    elif mode == OrderBeginPosInfo.MODE_RADICAL:


                        records_new_data.append((time_, "扫入下单",


                                                 mode_desc,


                                                 extra_datas))


                    else:


                        records_new_data.append((time_, "常规下单",


                                                 mode_desc,


                                                 extra_datas))


                elif type == trade_record_log_util.TYPE_REAL_PLACE_ORDER_POSITION:


                    _datas = []


                    MIN_MONEYS = [30000, 20000, 10000]


                    for min_money in MIN_MONEYS:


                        for i in range(data['index'] - 2, 0, -1):


                            if L2DataUtil.is_limit_up_price_buy(total_datas[i]['val']) and total_datas[i]['val'][


                                'num'] * float(total_datas[i]['val']['price']) >= min_money:


                                _datas.append(f"【{format_l2_data(total_datas[i])}】")


                                if len(_datas) >= 1:


                                    break


                        if len(_datas) >= 1:


                            break


                    for i in range(data['index'], 0, -1):


                        if L2DataUtil.is_limit_up_price_buy(total_datas[i]['val']) and total_datas[i]['val'][


                            'num'] * float(total_datas[i]['val']['price']) >= 3000:


                            _datas.append(f"【{format_l2_data(total_datas[i])}】")


                            break


                    records_new_data.append(


                        (time_, "实际挂单位", "".join(_datas), []))




                elif type == trade_record_log_util.TYPE_CANCEL_WATCH_INDEXES:


                    indexes = data['watch_indexes']


                    if indexes:


                        cancel_type = data['cancel_type']


                        indexes.sort()


                        indexes_data = []


                        for index in indexes:


                            indexes_data.append(format_l2_data(total_datas[index]))


                        desc = f"【{format_l2_data(total_datas[indexes[0]])}】-【{format_l2_data(total_datas[indexes[-1]])}】"


                        if cancel_type == trade_record_log_util.CancelWatchIndexesInfo.CANCEL_TYPE_L_DOWN:


                            latest_cancel_watch_index_dict[cancel_type] = (time_, "L撤后囊括", desc, indexes_data)


                        elif cancel_type == trade_record_log_util.CancelWatchIndexesInfo.CANCEL_TYPE_L_UP:


                            latest_cancel_watch_index_dict[cancel_type] = (time_, "L撤前囊括", desc, indexes_data)


                        elif cancel_type == trade_record_log_util.CancelWatchIndexesInfo.CANCEL_TYPE_H:


                            latest_cancel_watch_index_dict[cancel_type] = (time_, "H撤囊括", desc, indexes_data)


                        elif cancel_type == trade_record_log_util.CancelWatchIndexesInfo.CANCEL_TYPE_D:


                            latest_cancel_watch_index_dict[cancel_type] = (time_, "D撤囊括", desc, indexes_data)


                        elif cancel_type == trade_record_log_util.CancelWatchIndexesInfo.CANCEL_TYPE_S:


                            latest_cancel_watch_index_dict[cancel_type] = (time_, "S撤囊括", desc, indexes_data)


                elif type == trade_record_log_util.TYPE_FORBIDDEN_BUY:


                    records_new_data.append((time_, "加入黑名单", f"原因：{data['msg']}", []))


                elif type == trade_record_log_util.TYPE_CANT_PLACE_ORDER:


                    records_new_data.append((time_, "不能下单", f"原因：{data['msg']}", []))


                elif type == trade_record_log_util.TYPE_CANCEL:


                    load_cancel_watch_index(latest_cancel_watch_index_dict)


                    records_new_data.append((time_, "撤单", f"原因：{data['msg']}", []))


                elif type == trade_record_log_util.TYPE_ACTION:


                    records_new_data.append((time_, data['type'], f"{data['msg']}", []))


            load_cancel_watch_index(latest_cancel_watch_index_dict)


            records_new_data.sort(key=lambda x: x[0])


            if records_new_data:


                for d in records_new_data:


                    records_new.append(f"【{d[0]}】" + "{:<10}".format(f'【{d[1]}】') + d[2])


        except Exception as e:


            logging.exception(e)


    records_new.reverse()


    records_new_data.reverse()


    return break_time, records_new, records_new_data






# 返回内容[（类型,buy_single_index,indexes）]


def load_trade_record_cancel_watch_indexes(code, cancel_type=None, date=tool.get_now_date_str()):


    fresults = []


    records = []


    try:


        records = log_export.load_trade_recod(code, date=date)


    except:


        pass


    if records:


        for record in records:


            time_ = record[0]


            type = record[1]


            data = record[2]


            if type == trade_record_log_util.TYPE_CANCEL_WATCH_INDEXES:


                indexes = data['watch_indexes']


                if indexes:


                    if cancel_type and cancel_type != data.get("cancel_type"):


                        continue


                    fresults.append((data.get("cancel_type"), data.get('buy_single_index'), indexes))


    return fresults






if __name__ == '__main__':


    plate_info = kpl_api.getStockIDPlate("600748")


    print(plate_info)




if __name__ == '__main__1':


    datas = {


        "base_url": "http://192.168.3.122/kp/",


        "code_name": "天域生态 002255",


        "score_data": {"volume": {"score": 20, "now": "12", "high": {"num": "56", "date": "2023-04-13"}},


                       "bidding": {"score": 10, "money": "4563"},


                       "deal_big_money": {"score": 10, "money": 0, "base_money": 456.5,


                                          "start": {"time": "09:00:00", "num": 1456},


                                          "end": {"time": "09:00:00", "num": 1456}},


                       "k_form": {"score": 10, "datas": ["破前高", "超跌补涨", "涨幅过高"]},


                       "code_nature": {"score": 10, "data_desc": "涨停次数2次"},


                       "hot_block": {"score": 10, "block_name": "影视", "limit_up_count": 10, "open_limit_up_count": 2},


                       "limit_up_time": {"score": 10, "time": "09:56:00"},


                       "zyltgb": {"score": 10, "value": "12.5"},


                       "limit_up_price": {"score": 10, "price": "6.35"},


                       "total_score": "210"


                       },


        "trade_data": {"star": {"desc": "被动买入", "count": 0},


                       "safe_count": {"base": 12, "now": 2},


                       "m": {"base": 1200, "now": 1000},


                       "big_num": {"base": 10, "now": 2},


                       "trade_progress": {"time": "09:12:12", "num": 1111, "money": "12.56"},


                       "buy_single": {"time": "09:12:12", "num": 1111, "money": "12.56"},


                       "buy_exec": {"time": "09:12:12", "num": 1111, "money": "12.56"},




                       },


        "xgb_code_infos": [{"date": "今天", "blocks": [


            {"name": "影视", "limit_up_count": 2, "index": 1, "price": "12.00", "rate": "+10.00%"},


            {"name": "文旅", "limit_up_count": 3, "index": 2, "price": "12.00", "rate": "+10.00%"},


        ]}],


        "initiative_buy_codes": [


            {"name": "测试1", "code": "000123", "score": 125, "limit_up": True, "open_limit_up": True},


            {"name": "测试2", "code": "000123", "score": 125, "limit_up": False, "open_limit_up": True},


            {"name": "测试2", "code": "000123", "score": 125, "limit_up": False, "open_limit_up": True},


            {"name": "测试2", "code": "000123", "score": 125, "limit_up": False, "open_limit_up": False}


        ],


        "passive_buy_codes": [{"name": "测试1", "code": "000123", "score": 125},


                              {"name": "测试2", "code": "000123", "score": 125},


                              {"name": "测试2", "code": "000123", "score": 125},


                              {"name": "测试2", "code": "000123", "score": 125}


                              ],


        "trade_record": {"open_limit_up": "10:00:03", "records": [


            {"type": 1, "index": 1, "time": "11:00:00", "score": 12},


            {"type": 0, "time": "11:26:00", "desc": "H撤撤单"}


        ]},


        "xgb_infos": [{"block": {"name": "测试1", "rate": "+12.00%", "limit_up_count": 10},


                       "codes": [


                           {"limit_up": True, "name": "测试代码", "code": "000654"},


                           {"limit_up": True, "name": "测试代码", "code": "000654"},


                           {"limit_up": True, "name": "测试代码", "code": "000654"},


                           {"limit_up": False, "name": "测试代码", "code": "000654"},


                       ]}]


    }


    print(render(datas))


    code = '603616'


    records = load_trade_record_cancel_watch_indexes(code,


                                                     trade_record_log_util.CancelWatchIndexesInfo.CANCEL_TYPE_H)