卖出规则制定

Administrator

2023-11-23 4f068c719670f55d27327f593974b4edb893bfbf

卖出规则制定

 huaxin_client/l1_client.py

@@ -117,7 +117,8 @@
        # print(pMarketDataField.SecurityID, pMarketDataField.SecurityName, rate, pMarketDataField.Volume)

        level1_data_dict[pMarketDataField.SecurityID] = (
            pMarketDataField.SecurityID, pMarketDataField.LastPrice, rate, pMarketDataField.Volume, time.time())
            pMarketDataField.SecurityID, pMarketDataField.LastPrice, rate, pMarketDataField.Volume, time.time(),
            pMarketDataField.BidPrice1, pMarketDataField.BidVolume1)
        # print(
        #     "SecurityID[%s] SecurityName[%s] LastPrice[%.2f] Volume[%d] Turnover[%.2f] BidPrice1[%.2f] BidVolume1[%d] AskPrice1[%.2f] AskVolume1[%d] UpperLimitPrice[%.2f] LowerLimitPrice[%.2f]"
        #     % (pMarketDataField.SecurityID, pMarketDataField.SecurityName, pMarketDataField.LastPrice,

 l2/huaxin/huaxin_target_codes_manager.py

@@ -76,7 +76,7 @@

        for d in datas:
            code = d[0]
            # 格式 (代码,现价,涨幅,量,更新时间)
            # 格式 (代码,现价,涨幅,量,更新时间,买1价格,买1量)
            # 剔除昨日涨停的票
            if code in yesterday_codes:
                continue

 l2/l2_data_manager_new.py

@@ -842,7 +842,7 @@
            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.00001:
            if False and float(limit_up_price) - float(trade_price) > 0.00001:
                # 计算信号起始位置到当前的手数
                order_begin_pos = cls.__get_order_begin_pos(
                    code)

 trade/huaxin/huaxin_trade_server.py

@@ -58,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.l2_trade_factor import L2PlaceOrderParamsManager
from trade.sell_rule_manager import SellRuleManager
from trade.trade_manager import TradeTargetCodeModeManager
from utils import socket_util, data_export_util, middle_api_protocol, tool, huaxin_util, output_util

@@ -283,6 +284,23 @@
    __TradeBuyQueue = transaction_progress.TradeBuyQueue()
    __KPLCodeJXBlockManager = KPLCodeJXBlockManager()
    __GCancelBigNumComputer = GCancelBigNumComputer()
    __sell_thread_pool = concurrent.futures.ThreadPoolExecutor(max_workers=10)

    @classmethod
    def __sell(cls, datas):
        rules = SellRuleManager().list_can_excut_rules_cache()
        if rules:
            for d in datas:
                code = d[0]
                # 格式 (代码,现价,涨幅,量,更新时间,买1价格,买1量)
                buy1_volume = d[6]
                buy1_price = d[5]
                if buy1_volume:
                    for r in rules:
                        if r.code == code and r.buy1_volume >= buy1_volume:
                            # 提交卖
                            huaxin_trade_api.order(2, code, r.sell_volume, tool.get_buy_min_price(buy1_price))
                            SellRuleManager().excute_sell(r.id_)

    # 设置目标代码
    @classmethod
@@ -290,6 +308,7 @@
        data = data_json["data"]
        request_id = data_json["request_id"]
        datas = data["data"]
        cls.__sell_thread_pool.submit(lambda : cls.__sell(datas))
        HuaXinL1TargetCodesManager.set_level_1_codes_datas(datas, request_id=request_id)

    @classmethod

 trade/sell_rule_manager.py

New file
@@ -0,0 +1,106 @@
"""
卖出规则管理
"""
import json
from db import mysql_data_delegate as mysql_data
from utils import tool


class SellRule:
    def __init__(self, id_=None, code=None, buy1_volume=None, sell_volume=None, day=None, create_time=None, excuted=0):
        self.day = day
        self.create_time = create_time
        self.sell_volume = sell_volume
        self.buy1_volume = buy1_volume
        self.code = code
        self.id_ = id_
        self.excuted = 0

    def to_json_str(self):
        return json.dumps(vars(self))

    def to_dict(self):
        return vars(self)

    @classmethod
    def to_object(cls, json_str: str):
        d = json.loads(json_str)
        return SellRule(**d)

    @property
    def id(self):
        return self.id_


class SellRuleManager:
    __instance = None
    __sell_rules_dict_cache = {}

    def __new__(cls, *args, **kwargs):
        if not cls.__instance:
            cls.__instance = super(SellRuleManager, cls).__new__(cls, *args, **kwargs)
            cls.__instance.__load_datas()
        return cls.__instance

    def __load_datas(self):
        rules = self.__list_rules()
        self.__sell_rules_dict_cache.clear()
        for rule in rules:
            self.__sell_rules_dict_cache[rule.id_] = rule

    def __list_rules(self):
        results = mysql_data.Mysqldb().select_all(f"select * from sell_rules r where r.day='{tool.get_now_date_str()}'")
        fresults = []
        if results:
            for r in results:
                rule = SellRule()
                rule.id_ = r[0]
                rule.code = r[1]
                rule.buy1_volume = r[2]
                rule.sell_volume = r[3]
                rule.day = r[4]
                rule.create_time = r[5]
                rule.excuted = r[6]
                fresults.append(rule)
        return fresults

    # 添加规则
    def add_rule(self, rule: SellRule):
        _id = tool.get_now_date_str('%Y%m%d') + tool.get_now_time_str().replace(":", "") + "_" + rule.code
        if not rule.id:
            rule.id_ = _id
        if not rule.day:
            rule.day = tool.get_now_date_str()
        mysql_data.Mysqldb().execute(
            "insert into sell_rules(_id,code,buy1_volume,sell_volume,day,create_time,excuted) values ('%s','%s','%s','%s','%s',now() ,'%s') " % (
                rule.id_, rule.code, rule.buy1_volume, rule.sell_volume, rule.day, rule.excuted))
        self.__sell_rules_dict_cache[_id] = rule

    # 删除规则
    def del_rule(self, _id):
        mysql_data.Mysqldb().execute(f"delete from sell_rules where _id='{_id}'")
        if _id in self.__sell_rules_dict_cache:
            self.__sell_rules_dict_cache.pop(_id)

    def list_rules_cache(self):
        return [self.__sell_rules_dict_cache[k] for k in self.__sell_rules_dict_cache]

    # 获取可以执行的规则
    def list_can_excut_rules_cache(self):
        rules = []
        for k in self.__sell_rules_dict_cache:
            rule = self.__sell_rules_dict_cache[k]
            if rule.excuted == 0 and rule.day == tool.get_now_date_str():
                rules.append(rule)
        return rules

    # 执行卖
    def excute_sell(self, _id):
        if _id in self.__sell_rules_dict_cache:
            self.__sell_rules_dict_cache[_id].excuted = 1
        mysql_data.Mysqldb().execute(f"update sell_rules r set r.excuted=1 where r._id='{_id}'")


if __name__ == "__main__":
    SellRuleManager().del_rule("20231123142639_000333")
    SellRuleManager().excute_sell("20231123142919_000333")

 utils/data_export_util.py

@@ -37,7 +37,7 @@
    trade_indexs = log_export.get_l2_trade_position(code, date)
    real_position_indexes = log_export.get_real_place_order_positions(code, date)
    deal_list = log_export.load_huaxin_deal_record(code)
    deal_list_dict={}
    deal_list_dict = {}
    for d in deal_list:
        deal_list_dict[d[0]] = d

@@ -159,8 +159,8 @@
                except Exception as e:
                    logging.exception(e)
            else:
                if data["val"].get("orderNo") in deal_list_dict:
                    cancel_info = deal_list_dict[ data["val"].get("orderNo")][3]
                if int(data["val"].get("orderNo")) in deal_list_dict:
                    cancel_info = deal_list_dict[int(data["val"].get("orderNo"))][3]
        format_data.append(cancel_info)
        cancel_order_info = None
        if trade_info: