G撤华鑫本地日志添加

Administrator

2023-08-24 73c75c86b60513e0c8f5d19ccfed78064af5f47c

G撤华鑫本地日志添加

 huaxin_client/l2_data_manager.py

@@ -11,7 +11,8 @@

# 活动时间
from log_module import log_export
from log_module.log import logger_local_huaxin_l2_error, logger_local_huaxin_l2_upload, logger_local_huaxin_l2_buy_no
from log_module.log import logger_local_huaxin_l2_error, logger_local_huaxin_l2_upload, logger_local_huaxin_l2_buy_no, \
    logger_local_huaxin_g_cancel

order_detail_upload_active_time_dict = {}
transaction_upload_active_time_dict = {}
@@ -223,7 +224,10 @@
    while True:
        try:
            temp = trading_canceled_queue.get()
            upload_data(temp[0], "trading_order_canceled", temp[1])
            if temp:
                logger_local_huaxin_g_cancel.info(f"准备上报：{temp}")
                upload_data(temp[0], "trading_order_canceled", temp[1])
                logger_local_huaxin_g_cancel.info(f"上报成功：{temp}")
        except Exception as e:
            logger_local_huaxin_l2_error.exception(e)
            logger_local_huaxin_l2_error.error(f"上传普通数据出错：{str(e)}")

 l2/cancel_buy_strategy.py

@@ -105,6 +105,12 @@
            return cache_result[1]
        return None

    def get_real_place_order_index_cache(self, code):
        cache_result = CodeDataCacheUtil.get_cache(self.__s_cancel_real_place_order_index_cache, code)
        if cache_result[0]:
            return cache_result[1]
        return None

    def __clear_data(self, code):
        CodeDataCacheUtil.clear_cache(self.__s_big_num_cancel_compute_data_cache, code)
        CodeDataCacheUtil.clear_cache(self.__s_cancel_real_place_order_index_cache, code)
@@ -1081,6 +1087,37 @@
        self.clear(code)


# ---------------------------------G撤-------------------------------
class GCancelBigNumComputer:
    __SecondCancelBigNumComputer = SecondCancelBigNumComputer()

    # 开始撤单
    def start_cancel(self, code, buy_no, total_datas, buy_order_no_map, local_operate_map, m_val_num):
        place_order_index = self.__SecondCancelBigNumComputer.get_real_place_order_index_cache(code)
        if place_order_index is None:
            raise Exception("未获取到下单真实位置")
        buy_data = buy_order_no_map.get(buy_no)
        if not buy_data:
            raise Exception("尚未获取到撤买单详情数据")
        # 从成交位置到下单位置计算m值
        transaction_index = buy_data["index"]
        need_cancel = True
        buy_nums = 0
        for index in range(transaction_index + 1, place_order_index):
            data = total_datas[index]
            if L2DataUtil.is_limit_up_price_buy(data["val"]):
                # 获取是否在买入执行信号周围2s
                left_count = l2_data_source_util.L2DataSourceUtils.get_limit_up_buy_no_canceled_count(code, index, data,
                                                                                                      local_operate_map)
                if left_count > 0:
                    buy_nums += left_count * data["val"]["num"]
                    if buy_nums > m_val_num:
                        break
        if buy_nums > m_val_num:
            need_cancel = False
        return need_cancel, f"成交进度位({transaction_index})-真实下单位({place_order_index})  纯买手数:{buy_nums}/m值手数:{m_val_num}"


# --------------------------------封单额变化撤------------------------
# 涨停封单额统计
class L2LimitUpMoneyStatisticUtil:

 log_module/log.py

@@ -217,6 +217,11 @@
        logger.add(self.get_local_huaxin_path("l2", "upload"),
                   filter=lambda record: record["extra"].get("name") == "local_huaxin_upload",
                   rotation="00:00", compression="zip", enqueue=True)

        logger.add(self.get_local_huaxin_path("l2", "error"),
                   filter=lambda record: record["extra"].get("name") == "local_huaxin_error",
                   rotation="00:00", compression="zip", enqueue=True)

        logger.add(self.get_local_huaxin_path("l2", "subscript"),
                   filter=lambda record: record["extra"].get("name") == "local_huaxin_subscript",
                   rotation="00:00", compression="zip", enqueue=True)

 trade/huaxin/trade_server.py

@@ -18,13 +18,14 @@
import constant
import inited_data
import outside_api_command_manager
from code_attribute import gpcode_manager
from code_attribute import gpcode_manager, code_volumn_manager
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
from huaxin_client.client_network import SendResponseSkManager
from l2 import l2_data_manager_new, l2_log, code_price_manager, l2_data_util, l2_data_manager, transaction_progress
from l2.cancel_buy_strategy import HourCancelBigNumComputer, LCancelBigNumComputer, DCancelBigNumComputer
from l2.cancel_buy_strategy import HourCancelBigNumComputer, LCancelBigNumComputer, DCancelBigNumComputer, \
    GCancelBigNumComputer
from l2.huaxin import huaxin_target_codes_manager
from l2.huaxin.huaxin_target_codes_manager import HuaXinL1TargetCodesManager
from l2.l2_data_manager_new import L2TradeDataProcessor
@@ -40,6 +41,7 @@
from trade import deal_big_money_manager, current_price_process_manager, trade_huaxin, trade_manager, l2_trade_util

from trade.huaxin import huaxin_trade_api as trade_api, huaxin_trade_api, huaxin_trade_data_update
from trade.l2_trade_factor import L2PlaceOrderParamsManager
from trade.trade_manager import TradeTargetCodeModeManager
from utils import socket_util, data_export_util, middle_api_protocol, tool

@@ -59,6 +61,7 @@
    __inited = False
    __TradeBuyQueue = transaction_progress.TradeBuyQueue()
    __KPLCodeJXBlockManager = KPLCodeJXBlockManager()
    __GCancelBigNumComputer = GCancelBigNumComputer()

    def setup(self):
        self.__init()
@@ -344,11 +347,36 @@
                        finally:
                            sk.sendall(socket_util.load_header(json.dumps({"code": 0}).encode(encoding='utf-8')))
                    elif data_json["type"] == "trading_order_canceled":
                        logger_l2_g_cancel.info(f"正在成交的订单撤单，data:{data_json}")
                        data = data_json["data"]
                        code = data["code"]
                        order_no = data["data"]
                        logger_l2_g_cancel.info(f"{code}-正在成交的订单撤单，order_no:{order_no}")
                        l2_data_manager_new.L2TradeDataProcessor.cancel_buy(code, "G撤撤单", "G撤")
                        volume_rate = code_volumn_manager.get_volume_rate(code)
                        volume_rate_index = code_volumn_manager.get_volume_rate_index(volume_rate)
                        m_val = L2PlaceOrderParamsManager(code, True, volume_rate, volume_rate_index, None).get_m_val()[
                            0]
                        limit_up_price = gpcode_manager.get_limit_up_price(code)
                        m_val_num = int(m_val / (float(limit_up_price) * 100))

                        try:
                            need_cancel, msg = self.__GCancelBigNumComputer.start_cancel(code, order_no,
                                                                                         l2_data_util.local_today_datas.get(
                                                                                             code),
                                                                                         l2_data_util.local_today_buyno_map.get(
                                                                                             code),
                                                                                         l2_data_util.local_today_num_operate_map.get(
                                                                                             code), m_val_num)
                            if need_cancel:
                                # 需要撤单
                                l2_data_manager_new.L2TradeDataProcessor.cancel_buy(code, "G撤撤单", "G撤")
                            else:
                                logger_l2_g_cancel.info(f"{code}-不需要撤单：{str(e)}")


                        except Exception as e:
                            logger_l2_g_cancel.error(f"{code}-撤单异常：{str(e)}")


                else:
                    # 断开连接
                    break