hikyuu 2.1.0__cp38-none-win_amd64.whl → 2.1.2__cp38-none-win_amd64.whl

hikyuu/include/hikyuu/strategy/RunSystemInStrategy.h

@@ -0,0 +1,37 @@
+/*
+ *  Copyright (c) 2024 hikyuu.org
+ *
+ *  Created on: 2024-08-24
+ *      Author: fasiondog
+ */
+
+#pragma once
+#include "hikyuu/trade_sys/system/System.h"
+#include "Strategy.h"
+
+namespace hku {
+
+class HKU_API RunSystemInStrategy {
+public:
+    RunSystemInStrategy() = default;
+    RunSystemInStrategy(const SYSPtr& sys, const OrderBrokerPtr& broker, const KQuery& query,
+                        const TradeCostPtr& costfunc);
+    virtual ~RunSystemInStrategy() = default;
+
+    void run(const Stock& stock);
+
+private:
+    SYSPtr m_sys;
+    OrderBrokerPtr m_broker;
+    KQuery m_query;
+
+    TradeRequest m_buyRequest;
+    TradeRequest m_sellRequest;
+};
+
+StrategyPtr HKU_API crtSysStrategy(const SYSPtr& sys, const string& stk_market_code,
+                                   const KQuery& query, const OrderBrokerPtr& broker,
+                                   const TradeCostPtr& costfunc, const string& name = "SYSStrategy",
+                                   const string& config_file = "");
+
+}  // namespace hku

hikyuu/include/hikyuu/strategy/Strategy.h

@@ -0,0 +1,174 @@
+/*
+ *  Copyright(C) 2021 hikyuu.org
+ *
+ *  Create on: 2021-02-16
+ *     Author: fasiondog
+ */
+
+#pragma once
+
+#include <future>
+#include "hikyuu/DataType.h"
+#include "hikyuu/StrategyContext.h"
+#include "hikyuu/global/SpotRecord.h"
+#include "hikyuu/utilities/thread/FuncWrapper.h"
+#include "hikyuu/utilities/thread/ThreadSafeQueue.h"
+#include "hikyuu/trade_sys/portfolio/Portfolio.h"
+#include "BrokerTradeManager.h"
+
+namespace hku {
+
+/**
+ * @ingroup Stratgy
+ * @{
+ */
+
+/**
+ * @brief 策略运行时
+ */
+class HKU_API Strategy {
+    CLASS_LOGGER_IMP(Strategy)
+
+public:
+    Strategy();
+    explicit Strategy(const string& name, const string& config_file = "");
+    Strategy(const vector<string>& codeList, const vector<KQuery::KType>& ktypeList,
+             const string& name = "Strategy", const string& config_file = "");
+    explicit Strategy(const StrategyContext& context, const string& name = "Strategy",
+                      const string& config_file = "");
+
+    virtual ~Strategy();
+
+    const string& name() const {
+        return m_name;
+    }
+
+    void name(const string& name) {
+        m_name = name;
+    }
+
+    const StrategyContext& context() const {
+        return m_context;
+    }
+
+    /**
+     * 每日开盘时间内，以 delta 为周期循环定时执行指定任务
+     * @param func 待执行的任务
+     * @param delta 间隔时间
+     * @param market 指定的市场
+     * @param ignoreMarket 是否忽略市场时间限制，如为 true，则为定时循环不受开闭市时间限制
+     */
+    void runDaily(std::function<void()>&& func, const TimeDelta& delta,
+                  const std::string& market = "SH", bool ignoreMarket = false);
+
+    /**
+     * 每日在指定时刻执行任务
+     * @param func 待执行的任务
+     * @param delta 指定时刻
+     * @param ignoreHoliday 忽略节假日，即节假日不执行
+     */
+    void runDailyAt(std::function<void()>&& func, const TimeDelta& delta,
+                    bool ignoreHoliday = true);
+
+    /**
+     * 正确数据发生变化调用，即接收到相应行情数据变更
+     * @note 通常用于调试。且只要收到行情采集消息就会触发，不受开、闭市时间限制
+     * @param stk 数据发生变化的 stock
+     * @param spot 接收到的具体数据
+     */
+    void onChange(std::function<void(const Stock&, const SpotRecord& spot)>&& changeFunc);
+
+    /**
+     * 一批行情数据接受完毕后通知
+     * @note 通常仅用于调试打印，该批行情数据中不一定含有上下文中包含的 stock
+     *       且只要收到行情采集消息就会触发，不受开、闭市时间限制。
+     */
+    void onReceivedSpot(std::function<void(const Datetime&)>&& recievedFucn);
+
+    /**
+     * 启动策略执行，必须在已注册相关处理函数后执行
+     */
+    void start();
+
+private:
+    string m_name;
+    string m_config_file;
+    StrategyContext m_context;
+    std::function<void(const Datetime&)> m_on_recieved_spot;
+    std::function<void(const Stock&, const SpotRecord& spot)> m_on_change;
+
+    std::function<void()> m_run_daily_func;
+    TimeDelta m_run_daily_delta;
+    string m_run_daily_market;
+    bool m_ignoreMarket{false};
+
+    std::function<void()> m_run_daily_at_func;
+    TimeDelta m_run_daily_at_delta;
+
+private:
+    void _init();
+    void _receivedSpot(const SpotRecord& spot);
+    void _runDaily();
+    void _runDailyAt();
+
+private:
+    static std::atomic_bool ms_keep_running;
+    static void sig_handler(int sig);
+
+    typedef FuncWrapper event_type;
+    ThreadSafeQueue<event_type> m_event_queue;  // 消息队列
+
+    /** 先消息队列提交任务后返回的对应 future 的类型 */
+    template <typename ResultType>
+    using event_handle = std::future<ResultType>;
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4996)
+#endif
+
+    /** 向线程池提交任务 */
+    template <typename FunctionType>
+    event_handle<typename std::result_of<FunctionType()>::type> event(FunctionType f) {
+        typedef typename std::result_of<FunctionType()>::type result_type;
+        std::packaged_task<result_type()> task(f);
+        event_handle<result_type> res(task.get_future());
+        m_event_queue.push(std::move(task));
+        return res;
+    }
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+    void _startEventLoop();
+};
+
+typedef shared_ptr<Strategy> StrategyPtr;
+
+/**
+ * @brief 在策略运行时中执行系统交易 SYS
+ * @note 目前仅支持 buy_delay| sell_delay 均为 false 的系统，即 close 时执行交易
+ * @param sys 交易系统
+ * @param stk 交易对象
+ * @param query 查询条件
+ * @param broker 订单代理
+ * @param costfunc 成本函数
+ */
+void HKU_API runInStrategy(const SYSPtr& sys, const Stock& stk, const KQuery& query,
+                           const OrderBrokerPtr& broker, const TradeCostPtr& costfunc);
+
+/**
+ * @brief 在策略运行时中执行组合策略 PF
+ * @note 目前仅支持 buy_delay| sell_delay 均为 false 的系统，即 close 时执行交易
+ * @param pf 资产组合
+ * @param query 查询条件
+ * @param adjust_cycle 调仓周期
+ * @param broker 订单代理
+ * @param costfunc 成本函数
+ */
+void HKU_API runInStrategy(const PFPtr& pf, const KQuery& query, int adjust_cycle,
+                           const OrderBrokerPtr& broker, const TradeCostPtr& costfunc);
+
+/** @} */
+}  // namespace hku

hikyuu/include/hikyuu/trade_manage/FundsRecord.h

@@ -20,17 +20,17 @@ namespace hku {
  */
 class HKU_API FundsRecord {
 public:
-    FundsRecord();
+    FundsRecord() = default;
     FundsRecord(price_t cash, price_t market_value, price_t short_market_value, price_t base_cash,
                 price_t base_asset, price_t borrow_cash, price_t borrow_asset);
 
-    price_t cash;               /**< 当前现金 */
-    price_t market_value;       /**< 当前多头市值 */
-    price_t short_market_value; /**< 当前空头仓位市值 */
-    price_t base_cash;          /**< 当前投入本金principal */
-    price_t base_asset;         /**< 当前投入的资产价值 */
-    price_t borrow_cash;        /**< 当前借入的资金，即负债 */
-    price_t borrow_asset;       /**< 当前借入证券资产价值 */
+    price_t cash{0.0};               /**< 当前现金 */
+    price_t market_value{0.0};       /**< 当前多头市值 */
+    price_t short_market_value{0.0}; /**< 当前空头仓位市值 */
+    price_t base_cash{0.0};          /**< 当前投入本金principal */
+    price_t base_asset{0.0};         /**< 当前投入的资产价值 */
+    price_t borrow_cash{0.0};        /**< 当前借入的资金，即负债 */
+    price_t borrow_asset{0.0};       /**< 当前借入证券资产价值 */
 
     // 当前总资产 = 现金 + 多头市值 + 空头数量×（借入价格 - 当前价格)
     //          = cash + market_value + borrow_asset - short_market_value

hikyuu/include/hikyuu/trade_manage/OrderBrokerBase.h

@@ -11,9 +11,28 @@
 
 #include "../DataType.h"
 #include "../utilities/Parameter.h"
+#include "../trade_sys/system/SystemPart.h"
 
 namespace hku {
 
+struct HKU_API BrokerPositionRecord {
+    Stock stock;
+    price_t number{0.0};  // 数量
+    price_t money{0.0};   // 买入花费总资金
+
+    BrokerPositionRecord() = default;
+    BrokerPositionRecord(const Stock& stock, price_t number, price_t money);
+    BrokerPositionRecord(const BrokerPositionRecord&) = default;
+    BrokerPositionRecord(BrokerPositionRecord&& rv);
+
+    BrokerPositionRecord& operator=(const BrokerPositionRecord&) = default;
+    BrokerPositionRecord& operator=(BrokerPositionRecord&& rv);
+
+    string str() const;
+};
+
+HKU_API std::ostream& operator<<(std::ostream& os, const BrokerPositionRecord&);
+
 /**
  * 订单代理基类，实现实际的订单操作及程序化的订单。
  * @details 可通过向 TradeManager.regBroker 向 TradeManager 注册多个订单代理实例。
@@ -49,10 +68,12 @@ public:
      * @param code 证券代码
      * @param price 买入价格
      * @param num 买入数量
-     * @return 操作执行的时刻。实盘时，应返回委托单时间或服务器交易时间。
+     * @param stoploss 预期的止损价
+     * @param goalPrice 预期的目标价位
+     * @param from 系统部件来源
      */
-    Datetime buy(Datetime datetime, const string& market, const string& code, price_t price,
-                 double num);
+    void buy(Datetime datetime, const string& market, const string& code, price_t price, double num,
+             price_t stoploss, price_t goalPrice, SystemPart from) noexcept;
 
     /**
      * 执行卖出操作
@@ -61,34 +82,65 @@ public:
      * @param code 证券代码
      * @param price 卖出价格
      * @param num 卖出数量
-     * @return 操作执行的时刻。实盘时，应返回委托单时间或服务器交易时间。
+     * @param stoploss 新的预期止损价
+     * @param goalPrice 新的预期目标价位
+     * @param from 系统部件来源
      */
-    Datetime sell(Datetime datetime, const string& market, const string& code, price_t price,
-                  double num);
+    void sell(Datetime datetime, const string& market, const string& code, price_t price,
+              double num, price_t stoploss, price_t goalPrice, SystemPart from) noexcept;
 
     /**
-     * 执行实际买入操作
+     * 获取当前资产信息
+     * @return string json字符串
+     * <pre>
+     * 接口规范：
+     * {
+     *   "datetime": "2001-01-01 18:00:00.12345",
+     *   "cash": 0.0,
+     *   "positions": [
+     *       {"market": "SZ", "code": "000001", "number": 100.0, "stoploss": 0.0, "goal_price": 0.0,
+     *        "cost_price": 0.0},
+     *       {"market": "SH", "code": "600001", "number": 100.0, "stoploss": 0.0, "goal_price": 0.0,
+     *        "cost_price": 0.0},
+     *    ]
+     * }
+     *
+     * 说明：
+     * cash: 当前可用资金
+     * number 应该为：现有持仓 + 正在买入 - 正在卖出
+     * cost_price: 每股买入成本价
+     * </pre>
+     */
+    string getAssetInfo() noexcept;
+
+    /**
+     * 子类实现接口，执行实际买入操作
      * @param datetime 策略指示时间
      * @param market 市场标识
      * @param code 证券代码
      * @param price 买入价格
      * @param num 买入数量
-     * @return 操作执行的时刻。实盘时，应返回委托单时间或服务器交易时间。
+     * @param stoploss 预期的止损价
+     * @param goalPrice 预期的目标价位
+     * @param from 系统部件来源
      */
-    virtual Datetime _buy(Datetime datetime, const string& market, const string& code,
-                          price_t price, double num) = 0;
+    virtual void _buy(Datetime datetime, const string& market, const string& code, price_t price,
+                      double num, price_t stoploss, price_t goalPrice, SystemPart from) = 0;
 
     /**
-     * 执行实际卖出操作
+     * 子类实现接口，执行实际卖出操作
      * @param datetime 策略指示时间
      * @param market 市场标识
      * @param code 证券代码
      * @param price 卖出价格
      * @param num 卖出数量
-     * @return 操作执行的时刻。实盘时，应返回委托单时间或服务器交易时间。
      */
-    virtual Datetime _sell(Datetime datetime, const string& market, const string& code,
-                           price_t price, double num) = 0;
+    virtual void _sell(Datetime datetime, const string& market, const string& code, price_t price,
+                       double num, price_t stoploss, price_t goalPrice, SystemPart from) = 0;
+
+    virtual string _getAssetInfo() {
+        return string();
+    }
 
 protected:
     string m_name;

hikyuu/include/hikyuu/trade_manage/PositionRecord.h

@@ -26,19 +26,19 @@ public:
                    price_t buyMoney, price_t totalCost, price_t totalRisk, price_t sellMoney);
 
     /** 仅用于python的__str__ */
-    string toString() const;
+    string str() const;
 
-    Stock stock;             ///< 交易对象
-    Datetime takeDatetime;   ///< 初次建仓日期
-    Datetime cleanDatetime;  ///< 平仓日期，当前持仓记录中为Null<Datetime>()
-    double number;           ///< 当前持仓数量
-    price_t stoploss;        ///< 当前止损价
-    price_t goalPrice;       ///< 当前的目标价格
-    double totalNumber;      ///< 累计持仓数量
-    price_t buyMoney;        ///< 累计买入资金
-    price_t totalCost;       ///< 累计交易总成本
-    price_t totalRisk;  ///< 累计交易风险 = 各次 （买入价格-止损)*买入数量, 不包含交易成本
-    price_t sellMoney;  ///< 累计卖出资金
+    Stock stock;              ///< 交易对象
+    Datetime takeDatetime;    ///< 初次建仓日期
+    Datetime cleanDatetime;   ///< 平仓日期，当前持仓记录中为Null<Datetime>()
+    double number{0.0};       ///< 当前持仓数量
+    price_t stoploss{0.0};    ///< 当前止损价
+    price_t goalPrice{0.0};   ///< 当前的目标价格
+    double totalNumber{0.0};  ///< 累计持仓数量
+    price_t buyMoney{0.0};    ///< 累计买入资金
+    price_t totalCost{0.0};   ///< 累计交易总成本
+    price_t totalRisk{0.0};  ///< 累计交易风险 = 各次 （买入价格-止损)*买入数量, 不包含交易成本
+    price_t sellMoney{0.0};  ///< 累计卖出资金
 
 //===================
 // 序列化支持

hikyuu/include/hikyuu/trade_manage/TradeManager.h

@@ -344,6 +344,15 @@ public:
      */
     virtual bool addTradeRecord(const TradeRecord& tr) override;
 
+    /**
+     * 直接加入持仓记录
+     * @note 特殊用途构建初始持仓，可能引起混乱
+     * @param pr 持仓记录
+     * @return true 成功
+     * @return false 失败
+     */
+    virtual bool addPosition(const PositionRecord& pr) override;
+
     /** 字符串输出 */
     virtual string str() const override;
 

hikyuu/include/hikyuu/trade_manage/TradeManagerBase.h

@@ -668,6 +668,17 @@ public:
         return false;
     }
 
+    /**
+     * 直接加入持仓记录
+     * @param pr 持仓记录
+     * @return true 成功
+     * @return false 失败
+     */
+    virtual bool addPosition(const PositionRecord& pr) {
+        HKU_WARN("The subclass does not implement this method");
+        return false;
+    }
+
     /** 字符串输出 */
     virtual string str() const {
         HKU_WARN("The subclass does not implement this method");
@@ -682,6 +693,14 @@ public:
         HKU_WARN("The subclass does not implement this method");
     }
 
+    /**
+     * 从订单代理实例同步当前账户资产信息（包含资金、持仓等）
+     * @param broker 订单代理实例
+     */
+    virtual void fetchAssetInfoFromBroker(const OrderBrokerPtr& broker) {
+        HKU_WARN("The subclass does not implement this method");
+    }
+
 protected:
     string m_name;            // 账户名称
     TradeCostPtr m_costfunc;  // 成本算法