卖的相关接口支持

Administrator

2023-11-24 8723789759c6e1c4b97ef6ed9a50de05eba9eed4

卖的相关接口支持

 code_attribute/gpcode_manager.py

@@ -591,8 +591,6 @@
def get_limit_up_price_cache(code):
    if code in __limit_up_price_dict:
        return __limit_up_price_dict[code]


    return None



 l2/huaxin/huaxin_target_codes_manager.py

@@ -62,6 +62,8 @@
# 根据华鑫L2选出目标代码
class HuaXinL1TargetCodesManager:

    __current_price_dict = {}

    @classmethod
    def set_level_1_codes_datas(cls, datas, request_id=None):
        async_log_util.info(logger_l2_codes_subscript, f"({request_id})接受到L1的数据，开始预处理")

 outside_api_command_manager.py

@@ -59,7 +59,7 @@
API_TYPE_CODE_TRADE_INFO = "code_trade_info"  # 代码交易信息
API_TYPE_CODE_L2_LISTEN_ACTIVE_COUNT = "l2_listen_active_count"  # L2有效监听数量
API_TYPE_SAVE_RUNNING_DATA = "save_running_data"  # 保存运行时数据

API_TYPE_GET_CODE_POSITION_INFO = "get_code_position_info"  # 获取代码持仓信息

class ActionCallback(object):
    # 交易
@@ -114,6 +114,9 @@
        pass

    def OnSaveRunningData(self, client_id, request_id):
        pass

    def OnGetCodePositionInfo(self, client_id, request_id, data):
        pass


@@ -223,6 +226,8 @@
                            cls.action_callback.OnGetActiveListenCount(client_id, request_id)
                        elif content_type == API_TYPE_SAVE_RUNNING_DATA:
                            cls.action_callback.OnSaveRunningData(client_id, request_id)
                        elif content_type == API_TYPE_GET_CODE_POSITION_INFO:
                            cls.action_callback.OnGetCodePositionInfo(client_id, request_id, data)

                    except Exception as e:
                        logging.exception(e)

 trade/huaxin/huaxin_trade_data_update.py

@@ -17,7 +17,8 @@
import concurrent.futures

trade_data_request_queue = queue.Queue()
__process_thread_pool = concurrent.futures.ThreadPoolExecutor(max_workers=5)
__process_thread_pool = concurrent.futures.ThreadPoolExecutor(max_workers=10)


# 主动更新数据
def __read_update_task_queue():
@@ -103,8 +104,12 @@
                    elif type_ == "position_list":
                        dataJSON = huaxin_trade_api.get_position_list()
                        if dataJSON["code"] == 0:
                            data = dataJSON["data"]
                            huaxin_trade_record_manager.PositionManager.add(data)
                            datas = dataJSON["data"]
                            huaxin_trade_record_manager.PositionManager.cache(datas)
                            # 获取持仓股的涨停价
                            for d in datas:
                                gpcode_manager.get_limit_up_price(d["securityID"])
                            __process_thread_pool.submit(huaxin_trade_record_manager.PositionManager.add, datas)
                    async_log_util.info(hx_logger_trade_debug, f"获取交易数据成功：{type_}")
                except Exception as e1:
                    # if str(e1).find("超时") >= 0:

 trade/huaxin/huaxin_trade_record_manager.py

@@ -3,6 +3,7 @@
"""

# 委托记录
import copy
import datetime
import json

@@ -113,6 +114,8 @@
# 持仓记录
class PositionManager:
    __redisManager = redis_manager.RedisManager(2)
    latest_positions=[]


    @classmethod
    def __get_redis(cls):
@@ -131,6 +134,10 @@
        return int(val)

    @classmethod
    def cache(cls, datas):
        cls.latest_positions = copy.deepcopy(datas)

    @classmethod
    def add(cls, datas):
        mysqldb = mysql_data.Mysqldb()
        try:

 trade/huaxin/huaxin_trade_server.py

@@ -27,6 +27,7 @@
import inited_data
import outside_api_command_manager
from code_attribute import gpcode_manager, code_volumn_manager, global_data_loader
from code_attribute.gpcode_manager import CodePrePriceManager
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, l2_data_transform_protocol
@@ -57,6 +58,7 @@

from trade.huaxin import huaxin_trade_api as trade_api, huaxin_trade_api, huaxin_trade_data_update, \
    huaxin_trade_record_manager
from trade.huaxin.huaxin_trade_record_manager import PositionManager
from trade.l2_trade_factor import L2PlaceOrderParamsManager
from trade.sell_rule_manager import SellRuleManager, SellRule
from trade.trade_manager import TradeTargetCodeModeManager
@@ -285,6 +287,8 @@
    __KPLCodeJXBlockManager = KPLCodeJXBlockManager()
    __GCancelBigNumComputer = GCancelBigNumComputer()
    __sell_thread_pool = concurrent.futures.ThreadPoolExecutor(max_workers=10)
    __process_l1_data_thread_pool = concurrent.futures.ThreadPoolExecutor(max_workers=10)
    __current_price_dict = {}

    @classmethod
    def __sell(cls, datas):
@@ -302,14 +306,30 @@
                            huaxin_trade_api.order(2, code, r.sell_volume, tool.get_buy_min_price(buy1_price))
                            SellRuleManager().excute_sell(r.id_)

    # 保存现价
    @classmethod
    def __save_l1_current_price(cls, datas):
        for d in datas:
            code = d[0]
            # 格式 (代码,现价,涨幅,量,更新时间,买1价格,买1量)
            price = d[1]
            cls.__current_price_dict[code] = price

    # 获取L1现价
    @classmethod
    def get_l1_current_price(cls, code):
        return cls.__current_price_dict.get(code)

    # 设置目标代码
    @classmethod
    def set_target_codes(cls, data_json):
        data = data_json["data"]
        request_id = data_json["request_id"]
        datas = data["data"]
        cls.__save_l1_current_price(datas)
        cls.__sell_thread_pool.submit(lambda: cls.__sell(datas))
        HuaXinL1TargetCodesManager.set_level_1_codes_datas(datas, request_id=request_id)
        cls.__process_l1_data_thread_pool.submit(
            lambda: HuaXinL1TargetCodesManager.set_level_1_codes_datas(datas, request_id=request_id))

    @classmethod
    def l2_order(cls, code, _datas, timestamp):
@@ -384,7 +404,8 @@

        async_log_util.info(hx_logger_l2_market_data, f"{code}#{data}")
        L2MarketSellManager().set_current_total_sell_data(code, time_str,
                                                          data["totalAskVolume"] * data["avgAskPrice"], data["totalAskVolume"])
                                                          data["totalAskVolume"] * data["avgAskPrice"],
                                                          data["totalAskVolume"])

    @classmethod
    def trading_order_canceled(cls, code, order_no):
@@ -484,9 +505,37 @@
                price_type = data["price_type"]
                price = data["price"]
                sinfo = data["sinfo"]
                result = huaxin_trade_api.order(direction, code, volume, price, price_type=price_type, sinfo=sinfo,
                                                blocking=True, request_id=request_id)
                self.send_response({"code": 0, "data": result}, client_id, request_id)
                if direction == huaxin_util.TORA_TSTP_D_Sell:
                    pass
                    # price_type: 0-价格笼子 1-跌停价  2-涨停价 3-现价
                    # 获取现价
                    if price_type == 0:
                        current_price = TradeServerProcessor.get_l1_current_price(code)
                        if not current_price:
                            raise Exception("没有获取到L1现价")
                        price = tool.get_buy_min_price(current_price)
                    elif price_type == 1:
                        price_ = gpcode_manager.get_limit_down_price(code)
                        if not price_:
                            raise Exception("没有获取到跌停价")
                        price = round(float(price_), 2)
                    elif price_type == 2:
                        price_ = gpcode_manager.get_limit_up_price(code)
                        if not price_:
                            raise Exception("没有获取到涨停价")
                        price = round(float(price_), 2)
                    elif price_type == 3:
                        current_price = TradeServerProcessor.get_l1_current_price(code)
                        if not current_price:
                            raise Exception("没有获取到L1现价")
                        price = current_price
                    result = huaxin_trade_api.order(direction, code, volume, price, sinfo=sinfo,
                                                    blocking=True, request_id=request_id)
                    self.send_response({"code": 0, "data": result}, client_id, request_id)
                else:
                    result = huaxin_trade_api.order(direction, code, volume, price, price_type=price_type, sinfo=sinfo,
                                                    blocking=True, request_id=request_id)
                    self.send_response({"code": 0, "data": result}, client_id, request_id)
            elif trade_type == outside_api_command_manager.TRADE_TYPE_CANCEL_ORDER:
                print("手动撤单：", data)
                code = data["code"]
@@ -907,6 +956,28 @@
            logging.exception(e)
            self.send_response(json.dumps({"code": 1, "msg": f"数据处理出错：{e}"}), client_id, request_id)

    def OnGetCodePositionInfo(self, client_id, request_id, data):
        try:
            code = data["code"]
            # 获取持仓
            positions = PositionManager.latest_positions
            sell_rules_count = len(SellRuleManager().list_can_excut_rules_cache())
            fdata = {"code": code, "total": 0, "available": 0, "sell_rules_count": sell_rules_count}
            if positions:
                for d in positions:
                    if d["prePosition"] <= 0:
                        continue
                    if d["securityID"] != code:
                        continue
                    fdata["total"] = d["prePosition"]
                    fdata["available"] = d["availablePosition"]
                    break
            result = {"code": 0, "data": fdata}
            self.send_response(result, client_id, request_id)
        except Exception as e:
            logging.exception(e)
            self.send_response(json.dumps({"code": 1, "msg": f"数据处理出错：{e}"}), client_id, request_id)


class MyL2DataCallback(l2_data_transform_protocol.L2DataCallBack):
    def OnL2Order(self, code, datas, timestamp):

 trade/sell_rule_manager.py

@@ -89,10 +89,12 @@
        return [self.__sell_rules_dict_cache[k] for k in self.__sell_rules_dict_cache]

    # 获取可以执行的规则
    def list_can_excut_rules_cache(self):
    def list_can_excut_rules_cache(self, code=None):
        rules = []
        for k in self.__sell_rules_dict_cache:
            rule = self.__sell_rules_dict_cache[k]
            if code and code != rule.code:
                continue
            if rule.excuted == 0 and rule.day == tool.get_now_date_str() and tool.trade_time_sub(rule.end_time,
                                                                                                 tool.get_now_time_str()) > 0:
                rules.append(rule)