想买单策略修改

Administrator

2024-07-10 d475991a9d0abc94edfb3a5d9761df8bed8b4fc4

想买单策略修改

 code_attribute/gpcode_manager.py

@@ -106,4 +106,6 @@
    price = CodePrePriceManager.get_price_pre_cache(code)
    if price is None:
        return None
    return tool.to_price(decimal.Decimal(str(price)) * decimal.Decimal(f"{tool.get_limit_down_rate(code)}"))
    return tool.to_price(decimal.Decimal(str(price)) * decimal.Decimal(f"{tool.get_limit_down_rate(code)}"))



 main.py

@@ -9,6 +9,7 @@
import time

from code_attribute import target_codes_manager, gpcode_manager, code_market_manager, history_k_data_util
from code_attribute.gpcode_manager import CodesNameManager
from db.redis_manager_delegate import RedisUtils
from huaxin_client import l2_client_for_cb
from huaxin_client.client_network import SendResponseSkManager
@@ -16,9 +17,10 @@
from records import huaxin_trade_record_manager
from third_data import kpl_data_manager, kpl_util
from third_data.kpl_data_manager import PullTask, KPLCodeJXBlockManager, KPLLimitUpDataRecordManager
from trade import huaxin_trade_api, huaxin_trade_data_update, huaxin_sell_util, backtest_trade
from trade import huaxin_trade_api, huaxin_trade_data_update, huaxin_sell_util, backtest_trade, buy_strategy
from trade.buy_strategy import BuyStrategyDataManager
from trade.trade_manager import CodeTradeStateManager
from trade.trade_settings import WantBuyCodesManager, TradeStateManager
from utils import middle_api_protocol, outside_api_command_manager, constant, tool, huaxin_util, socket_util, sell_util, \
    output_util, l2_huaxin_util, output_data_util

@@ -215,7 +217,7 @@
                        volume = sum([x["volume"] for x in temp_dict[k]])
                        x = temp_dict[k][0]
                        r["buy_list"].append({"price": str(x["price"]), "tradeTime": x["tradeTime"], "volume": volume})
                    r["createTime"] = int(buys[-1]["tradeTime"].replace(":", ""))
                    r["createTime"] = int(buys[0]["tradeTime"].replace(":", ""))

                if "sell_list" not in r:
                    sells = huaxin_trade_record_manager.DealRecordManager().list_sell_by_code_cache(cb_code)
@@ -270,6 +272,41 @@
                send_response({"code": 0, "data": {}}, client_id, request_id)
            except Exception as e:
                send_response({"code": 0, "data": {}, "msg": str(e)}, client_id, request_id)
        elif ctype == "want_buy_codes":
            try:
                operate = data["operate"]
                if operate == outside_api_command_manager.OPERRATE_ADD:
                    code = data["code"]
                    WantBuyCodesManager().add_code(code, buy_strategy.STRATEGY_TYPE_LIMIT_UP)
                    WantBuyCodesManager().add_code(code, buy_strategy.STRATEGY_TYPE_RISE_HIGH_WITH_BLOCKS)
                    send_response({"code": 0, "data": {}}, client_id, request_id)
                elif operate == outside_api_command_manager.OPERRATE_GET:
                    code_infos = WantBuyCodesManager().list_code()
                    codes = set([x.split("-")[0] for x in code_infos])
                    code_infos = [(x, CodesNameManager.get_code_name(x)) for x in codes]
                    send_response({"code": 0, "data": code_infos}, client_id, request_id)
                elif operate == outside_api_command_manager.OPERRATE_DELETE:
                    code = data["code"]
                    WantBuyCodesManager().remove_code(code, buy_strategy.STRATEGY_TYPE_LIMIT_UP)
                    WantBuyCodesManager().remove_code(code, buy_strategy.STRATEGY_TYPE_RISE_HIGH_WITH_BLOCKS)
                    send_response({"code": 0, "data": {}}, client_id, request_id)
            except Exception as e:
                send_response({"code": 1, "msg": str(e)}, client_id, request_id)
        elif ctype == "trade_state":
            try:
                operate = data["operate"]
                if operate == outside_api_command_manager.OPERRATE_SET:
                    state = data["state"]
                    if state > 0:
                        TradeStateManager().open_buy()
                    else:
                        TradeStateManager().close_buy()
                    send_response({"code": 0, "data": {}}, client_id, request_id)
                elif operate == outside_api_command_manager.OPERRATE_GET:
                    state = 1 if TradeStateManager().is_can_buy() else 0
                    send_response({"code": 0, "data": {"state": state}}, client_id, request_id)
            except Exception as e:
                send_response({"code": 1, "msg": str(e)}, client_id, request_id)


def test():
@@ -302,12 +339,15 @@
                buy_infos = result[3]
                for buy_info in buy_infos:
                    if buy_info[0]:
                        if not TradeStateManager().is_can_buy():
                            continue
                        # 策略类型
                        strategy_type = buy_info[1]
                        # 获取股票代码的可转债代码
                        cb_code = target_codes_manager.get_cb_code(code)
                        if CodeTradeStateManager().get_trade_state(cb_code,
                                                                   strategy_type) == CodeTradeStateManager.TRADE_STATE_ALREADY_BUY:
                                                                   strategy_type) == CodeTradeStateManager.TRADE_STATE_ALREADY_BUY and not WantBuyCodesManager().is_in_cache(cb_code, strategy_type):
                            # 已经买了且没在想买单
                            continue
                        # 获取可转债的涨停价
                        market_info = code_market_manager.get_market_info(cb_code)
@@ -325,6 +365,8 @@
                            result = huaxin_trade_api.order(1, cb_code, volume, buy_price, blocking=True)
                            CodeTradeStateManager().set_trade_state(cb_code, strategy_type,
                                                                    CodeTradeStateManager.TRADE_STATE_ALREADY_BUY)
                            # 移除想买单
                            WantBuyCodesManager().remove_code(cb_code, strategy_type)
                            async_log_util.info(logger_trade, f"可转债下单结果：{result}")
                            huaxin_trade_data_update.add_position_list()
                            huaxin_trade_data_update.add_money_list()

 test/test_trade_settings.py

New file
@@ -0,0 +1,28 @@
from db.redis_manager_delegate import RedisUtils
from trade.trade_settings import TradeStateManager, WantBuyCodesManager


def test_trade_state():
    print(TradeStateManager().is_can_buy(), TradeStateManager().is_can_buy_cache())
    TradeStateManager().open_buy()
    print(TradeStateManager().is_can_buy(), TradeStateManager().is_can_buy_cache())
    TradeStateManager().close_buy()
    print(TradeStateManager().is_can_buy_cache(), TradeStateManager().is_can_buy_cache())


def test_want_buy():
    code, buy_type = "000333", 1
    print(WantBuyCodesManager().add_code(code, buy_type))
    print(WantBuyCodesManager().list_code())
    print(WantBuyCodesManager().list_code_cache())
    print(WantBuyCodesManager().is_in(code, buy_type))
    print(WantBuyCodesManager().is_in_cache(code, buy_type))

    print(WantBuyCodesManager().remove_code(code, buy_type))
    print(WantBuyCodesManager().list_code())
    print(WantBuyCodesManager().list_code_cache())


if __name__ == "__main__":
    test_want_buy()
    RedisUtils.run_loop()

 trade/trade_settings.py

New file
@@ -0,0 +1,123 @@
"""
交易设置
"""
# 想要买的代码
from db.redis_manager_delegate import RedisUtils, RedisManager
from utils import tool, constant


class WantBuyCodesManager:
    """
    想买单
    """
    __instance = None
    __redis_key = "want_buy_code_infos"
    __redisManager = RedisManager(constant.REDIS_DB)

    def __new__(cls, *args, **kwargs):
        if not cls.__instance:
            cls.__instance = super(WantBuyCodesManager, cls).__new__(cls, *args, **kwargs)
            # 初始化设置
            # 获取交易窗口的锁
            cls.__want_buy_code_infos_cache = RedisUtils.smembers(cls.__get_redis(),
                                                                  cls.__redis_key)
        return cls.__instance

    # 格式：{"代码-买入类型"}
    __want_buy_code_infos_cache = set()

    @classmethod
    def __get_redis(cls):
        return cls.__redisManager.getRedis()

    def clear(self):
        RedisUtils.delete(self.__get_redis(), self.__redis_key)

    @classmethod
    def __get_key(cls, code, buy_type):
        return f"{code}-{buy_type}"

    @classmethod
    def __parse_key(cls, k):
        ks = k.split("-")
        return ks[0], int(ks[1])

    def add_code(self, code, buy_type: int):
        self.__want_buy_code_infos_cache.add(self.__get_key(code,buy_type))
        RedisUtils.sadd(self.__get_redis(), self.__redis_key, self.__get_key(code,buy_type))
        RedisUtils.expire(self.__get_redis(), self.__redis_key, tool.get_expire())

    def remove_code(self, code, buy_type):
        k = self.__get_key(code, buy_type)
        if k not in self.__want_buy_code_infos_cache:
            return
        self.__want_buy_code_infos_cache.discard(k)
        RedisUtils.srem(self.__get_redis(), self.__redis_key, k)

    def sync(self):
        codes_info = self.list_code()
        self.__want_buy_code_infos_cache.clear()
        if codes_info:
            self.__want_buy_code_infos_cache |= set(codes_info)

    def is_in(self, code, buy_type):
        return RedisUtils.sismember(self.__get_redis(), self.__redis_key, self.__get_key(code, buy_type))

    def is_in_cache(self, code, buy_type):
        return self.__get_key(code, buy_type) in self.__want_buy_code_infos_cache

    def list_code(self):
        return RedisUtils.smembers(self.__get_redis(), self.__redis_key)

    def list_code_cache(self):
        return self.__want_buy_code_infos_cache


class TradeStateManager:
    """
    交易状态管理
    """
    __instance = None
    __db = constant.REDIS_DB
    redisManager = RedisManager(constant.REDIS_DB)

    def __new__(cls, *args, **kwargs):
        if not cls.__instance:
            cls.__instance = super(TradeStateManager, cls).__new__(cls, *args, **kwargs)
            cls.__instance.__trade_buy_state_cache = cls.is_can_buy()
        return cls.__instance

    @classmethod
    def __get_redis(cls):
        return cls.redisManager.getRedis()

    def sync(self):
        self.__trade_buy_state_cache = self.is_can_buy()

    # 开启购买入口
    def open_buy(self):
        self.__trade_buy_state_cache = True
        RedisUtils.setex_async(self.__db, "trade_buy_state", tool.get_expire(), 1)

    # 关闭购买入口
    def close_buy(self):
        self.__trade_buy_state_cache = False
        RedisUtils.setex_async(self.__db, "trade_buy_state", tool.get_expire(), 0)

    # 是否可以下单
    @classmethod
    def is_can_buy(cls):
        # 默认设置为可交易
        val = RedisUtils.get(cls.__get_redis(), "trade_buy_state")
        if val is None:
            return True
        if int(val) == 1:
            return True
        else:
            return False

        # 是否可以下单

    def is_can_buy_cache(self):
        # 默认设置为可交易
        return self.__trade_buy_state_cache