买入策略修改

Administrator

2023-01-06 59fba698b03a51a8da5b56a919ebbf94d4784f74

买入策略修改

 data_export_util.py

@@ -13,13 +13,13 @@
import l2_data_manager


def export_l2_excel(code,date=None):
def export_l2_excel(code, date=None):
    # 获取L2的数据
    local_today_datas=log.load_l2_from_log(date)
    local_today_datas = log.load_l2_from_log(date)
    datas = local_today_datas[code]
    # 获取L2处理位置信息
    process_indexs = log.get_l2_process_position(code,date)
    trade_indexs = log.get_l2_trade_position(code,date)
    process_indexs = log.get_l2_process_position(code, date)
    trade_indexs = log.get_l2_trade_position(code, date)
    export_l2_data(code, datas, process_indexs, trade_indexs)


@@ -193,6 +193,6 @@


if __name__ == "__main__":
    codes = ["000610"]
    codes = ["002441"]
    for code in codes:
        export_l2_excel(code,"2022-12-27")
        export_l2_excel(code)

 l2_code_operate.py

@@ -80,12 +80,16 @@
                for item in codes_info:
                    gpcode_manager.set_listen_code_by_pos(client_id, item[0], item[1])
                    L2CodeOperate.set_operate_code_state(client_id, item[0], 1)
                return True
            else:
                return False

        except Exception as e:
            logging.exception(e)
            logger_code_operate.error("setGPCode出错：{}", str(e))
        finally:
            gpcode_manager.rm_operates(codes)
        return False

    @classmethod
    def run(cls):
@@ -301,7 +305,7 @@
# 批量设置代码
def betch_set_client_codes(client_id,codes_info):
    # 获取涨幅前16位代码
    L2CodeOperate.betchSetGPCode(client_id, codes_info)
    return L2CodeOperate.betchSetGPCode(client_id, codes_info)


if __name__ == "__main__":

 l2_data_manager_new.py

@@ -464,12 +464,12 @@
                        buy_nums += int(_val["num"]) * int(total_datas[i]["re"])
                    elif L2DataUtil.is_limit_up_price_buy_cancel(_val):
                        buy_nums -= int(_val["num"]) * int(total_datas[i]["re"])
                if buy_nums < sell1_volumn:
                    return False, "纯买量({})小于卖1量{} 卖1时间：{}".format(buy_nums, sell1_volumn, sell1_time)
                if buy_nums < sell1_volumn * 0.49:
                    return False, "纯买量({})小于卖1量的49%{} 卖1时间：{}".format(buy_nums, sell1_volumn, sell1_time)
        except Exception as e:
            logging.exception(e)

        # 量比超过1.1的不能买
        # 量比超过1.3的不能买
        volumn_rate = l2_trade_factor.L2TradeFactorUtil.get_volumn_rate_by_code(code)
        if volumn_rate >= 1.3:
            return False, "最大量比超过1.3不能买"
@@ -512,12 +512,12 @@
            for key in codes_index:
                if codes_index.get(key) == 0:
                    first_codes.append(key)

            for key in first_codes:
                state = trade_manager.get_trade_state(key)
                if state == trade_manager.TRADE_STATE_BUY_SUCCESS:
                    # 老大已经买成功了
                    return False, "老大{}已经买成功，老二无需购买".format(key)
            # 暂时注释掉
            # for key in first_codes:
            #     state = trade_manager.get_trade_state(key)
            #     if state == trade_manager.TRADE_STATE_BUY_SUCCESS:
            #         # 老大已经买成功了
            #         return False, "老大{}已经买成功，老二无需购买".format(key)
            #
            # # 有9点半涨停的老大才能买老二，不然不能买
            # # 获取老大的涨停时间
@@ -607,9 +607,14 @@

        # 是否为新获取到的位置
        if buy_single_index is None:
            place_order_count = trade_data_manager.placeordercountmanager.get_place_order_count(code)
            continue_count = 3
            # 前2次的信号连续笔数为3，后面为2
            if place_order_count > 2:
                continue_count = 2
            # 有买入信号
            has_single, _index = cls.__compute_order_begin_pos(code, max(
                compute_start_index - 2 if new_add else compute_start_index, 0), 3, compute_end_index)
                compute_start_index - 2 if new_add else compute_start_index, 0), continue_count, compute_end_index)
            buy_single_index = _index
            if has_single:
                num = 0
@@ -679,7 +684,7 @@
                cls.debug(code, "数据处理完毕，下单, 数据截图时间-{}", capture_time)
                # 数据已经处理完毕，如果还没撤单就实际下单
                if need_cancel:
                    if cls.cancel_buy(code, "分钟级大单撤销"):
                    if cls.cancel_buy(code, "S级大单撤销"):
                        # 执行撤单成功
                        pass
                else:
@@ -829,17 +834,13 @@

        buy_single_time_seconds = L2DataUtil.get_time_as_second(total_datas[buy_single_index]["val"]["time"])

        # 可以触发买
        # 可以触发买，当有涨停买信号时才会触发买
        trigger_buy = True
        place_order_count = trade_data_manager.placeordercountmanager.get_place_order_count(code)
        max_space_time = 2
        if place_order_count <= 0:
            max_space_time = 2
        elif place_order_count <= 1:
            max_space_time = 6 - 1
        else:
            max_space_time = 9 - 1

        if place_order_count>3:
            place_order_count = 3
        # 间隔最大时间依次为：3,9,27,81
        max_space_time = pow(3,place_order_count + 1) - 1
        for i in range(compute_start_index, compute_end_index + 1):
            data = total_datas[i]
            _val = total_datas[i]["val"]
@@ -1572,7 +1573,7 @@
                    num += int(val["num"])

        average_num = num // count
        average_num = round(5900/ gpcode_manager.get_limit_up_price(code))
        average_num = round(5900 / gpcode_manager.get_limit_up_price(code))
        average_up_count = 0
        for i in range(start_index, end_index + 1):
            data = total_data[i]
@@ -1590,6 +1591,7 @@
    @classmethod
    def need_cancel(cls, code, buy_single_index, buy_exec_index, start_index, end_index, need_cancel=True):
        average_num, average_up_count, a_start_index, a_end_index = cls.__get_average_data(code)
        L2TradeDataProcessor.cancel_debug(code,"s级是否需要撤单，数据范围：{}-{}  平均大单信息-({},{},{},{})",start_index,end_index,average_num, average_up_count, a_start_index, a_end_index)
        if average_num is None:
            return False, None
        total_data = local_today_datas[code]
@@ -1626,16 +1628,16 @@
        if need_cancel:
            # 计算买撤大单暂比
            cancel_datas = cls.__get_cancel_datas(code)

            if cancel_datas is not None and len(cancel_datas) > 0:
                L2TradeDataProcessor.cancel_debug(code, "s级大单 取消数量:{}", len(cancel_datas))
                cancel_rate_threshold = 0.49
                place_order_count = trade_data_manager.placeordercountmanager.get_place_order_count(code)
                if place_order_count <= 1:
                    cancel_rate_threshold = 0.49
                elif place_order_count <= 2:
                    ancel_rate_threshold = 0.549
                    cancel_rate_threshold = 0.549
                else:
                    ancel_rate_threshold = 0.59
                    cancel_rate_threshold = 0.59
                cancel_indexs = []
                for index in cancel_datas:
                    cancel_indexs.append(int(index))
@@ -1703,15 +1705,19 @@
        cls.place_order_success(code, buy_single_index, buy_exec_index)
        # 执行是否需要计算average
        cls.compute_average_big_num(code, buy_single_index, buy_single_index, datas[3])
        for i in range(buy_single_index, datas[4]):
            cancel, cancel_data = cls.need_cancel(code, i, i)

        cancel, cancel_data = cls.need_cancel(code, buy_single_index, buy_exec_index, buy_single_index, buy_exec_index,
                                              False)

        for i in range(buy_exec_index + 1, datas[4]):
            cancel, cancel_data = cls.need_cancel(code, buy_single_index, buy_exec_index, i, i)
            if cancel:
                print("需要撤单", cancel, cancel_data["index"])
                break

    @classmethod
    def test(cls):
        cls.__test(("000716", 410, 420, 461, 536))
        cls.__test(("000909", 607, 646, 646, 694))
        # 代码 买入信号起始点  买入信息执行位置  计算末位 最远计算位置
        # cls.__test(("002793", 292, 308, 314, 410))

@@ -1803,7 +1809,7 @@
                    num += int(val["num"])

        average_num = num // count
        #average_num = 0
        # average_num = 0
        average_num = round(5900 / gpcode_manager.get_limit_up_price(code))
        average_up_count = 0
        for i in range(start_index, end_index + 1):
@@ -1860,12 +1866,12 @@
            if cancel_datas is not None and len(cancel_datas) > 0:
                cancel_rate_threshold = 0.49
                place_order_count = trade_data_manager.placeordercountmanager.get_place_order_count(code)
                if place_order_count <=1:
                    cancel_rate_threshold=0.49
                elif place_order_count <=2:
                    ancel_rate_threshold = 0.549
                if place_order_count <= 1:
                    cancel_rate_threshold = 0.49
                elif place_order_count <= 2:
                    cancel_rate_threshold = 0.549
                else:
                    ancel_rate_threshold = 0.59
                    cancel_rate_threshold = 0.59
                cancel_indexs = []
                for index in cancel_datas:
                    cancel_indexs.append(int(index))
@@ -2091,9 +2097,10 @@
    # AverageBigNumComputer.test()
    # LongAverageBigNumComputer.test()
    # L2TradeDataProcessor.test()
    load_l2_data("600213")

    buy_index, buy_data = l2_data_util.get_buy_data_with_cancel_data(local_today_datas["600213"][84],
                                                                     local_today_num_operate_map.get(
                                                                         "600213"))
    print(buy_index, buy_data)
    SecondAverageBigNumComputer.test()
    # load_l2_data("600213")
    #
    # buy_index, buy_data = l2_data_util.get_buy_data_with_cancel_data(local_today_datas["600213"][84],
    #                                                                  local_today_num_operate_map.get(
    #                                                                      "600213"))
    # print(buy_index, buy_data)

 l2_trade_test.py

@@ -38,9 +38,9 @@

        redis_info.delete(k)

#

# class VirtualTrade(unittest.TestCase):
#     code = "002419"
#     code = "002093"
#     clear_trade_data(code)
#     l2_data_manager.load_l2_data(code)
#     total_datas = l2_data_manager.local_today_datas[code]
@@ -59,7 +59,7 @@
#     if pos_list[-1][1] < total_datas[-1]["index"]:
#         pos_list.append((pos_list[-1][1] + 1, total_datas[-1]["index"]))
#     l2_data_manager_new.local_today_datas = {code: []}
#     l2_trade_factor.L2TradeFactorUtil.get_safe_buy_count = mock.Mock(return_value=30)
#     l2_trade_factor.L2TradeFactorUtil.get_safe_buy_count = mock.Mock(return_value=10)
#     for indexs in pos_list:
#         L2TradeDataProcessor.random_key[code] = mock.Mock(return_value=random.randint(0, 100000))
#         # 设置封单额，获取买1量
@@ -74,7 +74,7 @@
#
#         print("----------------处理位置", indexs)
#         L2TradeDataProcessor.process_add_datas(code, total_datas[indexs[0]:indexs[1] + 1], 0, 0)

#

# class TestTrade(unittest.TestCase):
#     processor = L2TradeDataProcessor()

 log.py

@@ -195,25 +195,28 @@
    today_data = {}
    if  date is None:
        date = datetime.datetime.now().strftime("%Y-%m-%d")
    with open("D:/logs/gp/l2/l2_data.{}.log".format(date), mode='r') as f:
        while True:
            data = f.readline()
            if not data:
                break
            index = data.find('save_l2_data:')
            index = data.find('-', index)
            data = data[index + 1:].strip()
            code = data[0:6]
            data = data[7:]
            dict_ = eval(data)
            if code not in today_data:
                today_data[code] = dict_
            else:
                today_data[code].extend(dict_)
    for key in today_data:
        news = sorted(today_data[key], key=lambda x: x["index"])
        today_data[key] = news
        print(key, len(today_data[key]) - 1, today_data[key][-1]["index"])
    try:
        with open("D:/logs/gp/l2/l2_data.{}.log".format(date), mode='r') as f:
            while True:
                data = f.readline()
                if not data:
                    break
                index = data.find('save_l2_data:')
                index = data.find('-', index)
                data = data[index + 1:].strip()
                code = data[0:6]
                data = data[7:]
                dict_ = eval(data)
                if code not in today_data:
                    today_data[code] = dict_
                else:
                    today_data[code].extend(dict_)
        for key in today_data:
            news = sorted(today_data[key], key=lambda x: x["index"])
            today_data[key] = news
            print(key, len(today_data[key]) - 1, today_data[key][-1]["index"])
    except:
        pass
    return today_data


@@ -287,7 +290,7 @@

if __name__ == '__main__':
    # logger_l2_process_time.info("test123")
    codes = ["603255", "600853", "000620", "002044", "001256"]
    codes = ["000909"]
    for code in codes:
        export_logs(code)


 server.py

@@ -375,7 +375,15 @@
                            if i >= len(codes):
                                break
                            codes_datas.append((i, codes[i]))
                        l2_code_operate.betch_set_client_codes(client_id, codes_datas)
                        # 如果设置失败需要重试2次
                        for i in range(0, 3):
                            set_success = l2_code_operate.betch_set_client_codes(client_id, codes_datas)
                            if set_success:
                                break
                            else:
                                time.sleep(3)


                    else:
                        return_json = {"code": 0, "msg": "开启在线状态"}
                        return_str = json.dumps(return_json)

 trade_manager.py

@@ -47,6 +47,7 @@

# 设置交易状态
def set_trade_state(code, state):
    logger_trade.info("set_trade_state {}-{}".format(code, state))
    redis = __redis_manager.getRedis()
    redis.setex("trade-state-{}".format(code), tool.get_expire(), state)

@@ -96,7 +97,7 @@
            dict_[trade_num]["money"] = round(float(dict_[trade_num]["money"]) + float(data["money"]), 3)

    for key in dict_:
        data= dict_[key]
        data = dict_[key]
        _time = data["time"]
        # 过滤错误数据
        if _time == "00:00:00":