hikyuu 2.1.1__cp39-none-win_amd64.whl → 2.1.2__cp39-none-win_amd64.whl

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;  // 成本算法

hikyuu/include/hikyuu/utilities/TimerManager.h

@@ -35,7 +35,23 @@ public:
      * @param work_num 定时任务执行线程池线程数量
      */
     explicit TimerManager(size_t work_num = 1)
-    : m_stop(true), m_current_timer_id(-1), m_work_num(work_num) {
+    : m_stop(true),
+      m_current_timer_id(-1),
+      m_work_num(work_num),
+      m_tg(nullptr),
+      m_use_extend_tg(false) {
+        HKU_ASSERT(work_num >= 1);
+        start();
+    }
+
+    /**
+     * 指定线程池方式构造，以便共享其他线程池
+     * @note 请自行保证 tg 的生命周期在 TimerManager 存活期间始终有效
+     * @param tg 指定任务组线程池
+     */
+    explicit TimerManager(ThreadPool* tg)
+    : m_stop(true), m_current_timer_id(-1), m_work_num(1), m_tg(tg), m_use_extend_tg(true) {
+        HKU_ASSERT(m_tg);
         start();
     }
 
@@ -60,11 +76,7 @@ public:
         std::priority_queue<IntervalS> new_queue;
         m_queue.swap(new_queue);
         if (!m_tg) {
-#if CPP_STANDARD >= CPP_STANDARD_14
-            m_tg = std::make_unique<ThreadPool>(m_work_num);
-#else
-            m_tg = std::unique_ptr<ThreadPool>(new ThreadPool(m_work_num));
-#endif
+            m_tg = new ThreadPool(m_work_num);
         }
 
         /*
@@ -152,9 +164,10 @@ public:
             m_detect_thread.join();
         }
 
-        if (m_tg) {
+        if (!m_use_extend_tg && m_tg) {
             m_tg->stop();
-            m_tg.reset();
+            delete m_tg;
+            m_tg = nullptr;
         }
     }
 
@@ -532,7 +545,8 @@ private:
     std::unordered_map<int, Timer*> m_timers;
     int m_current_timer_id;
     size_t m_work_num;  // 任务执行线程池线程数量
-    std::unique_ptr<ThreadPool> m_tg;
+    ThreadPool* m_tg{nullptr};
+    bool m_use_extend_tg{false};
 };
 
 }  // namespace hku

hikyuu/include/hikyuu/utilities/arithmetic.h

@@ -88,11 +88,11 @@ ValueT roundEx(ValueT number, int ndigits = 0) {
     ValueT pow1, pow2, y, z;
     ValueT x = number;
     if (ndigits >= 0) {
-        pow1 = std::pow<ValueT>(10.0, (ValueT)ndigits);
+        pow1 = pow(ValueT(10.0), ValueT(ndigits));
         pow2 = 1.0;
         y = (x * pow1) * pow2;
     } else {
-        pow1 = std::pow<ValueT>(10.0, (ValueT)-ndigits);
+        pow1 = pow(ValueT(10.0), ValueT(-ndigits));
         pow2 = 1.0;
         y = x / pow1;
     }

hikyuu/include/hikyuu/utilities/datetime/Datetime.h

@@ -106,6 +106,7 @@ public:
      *     2、"20010101"
      *     3、"2001-01-01 18:00:00.12345"
      *     4、"20010101T181159"
+     *     5、"20240822 11:30:06.230"
      * </pre>
      */
     explicit Datetime(const std::string &);

hikyuu/include/hikyuu/utilities/exception.h

@@ -14,40 +14,38 @@
 #include <string>
 #include <exception>
 
+#ifndef HKU_UTILS_API
+#define HKU_UTILS_API
+#endif
+
 namespace hku {
 
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable : 4275)
+#endif
+
 /**
  * @ingroup Utilities
  * @addtogroup Exception Exception 异常处理
  * @{
  */
 
-#if !defined(__clang__) && !defined(__GNUC__)
-class exception : public std::exception {
-public:
-    exception() : std::exception("Unknown exception!") {}
-    exception(const std::string& msg)  // cppcheck-suppress noExplicitConstructor
-    : std::exception(msg.c_str()) {}
-    exception(const char* msg) : std::exception(msg) {}  // cppcheck-suppress noExplicitConstructor
-    virtual ~exception() noexcept {};
-};
-
-#else
-// llvm 中的 std::exception 不接受参数
-class exception : public std::exception {
+class HKU_UTILS_API exception : public std::exception {
 public:
     exception() : m_msg("Unknown exception!") {}
     exception(const char *msg) : m_msg(msg) {}         // cppcheck-suppress noExplicitConstructor
     exception(const std::string &msg) : m_msg(msg) {}  // cppcheck-suppress noExplicitConstructor
     virtual ~exception() noexcept {}
-    virtual const char *what() const noexcept {
-        return m_msg.c_str();
-    }
+    virtual const char *what() const noexcept;
 
 protected:
     std::string m_msg;
 };
-#endif /* #ifdef __clang__ */
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
 
 } /* namespace hku */
 

hikyuu/include/hikyuu/utilities/http_client/HttpClient.h

@@ -132,7 +132,7 @@ public:
     }
 
     void setUrl(const std::string& url) noexcept {
-        m_url = std::move(nng::url(url));
+        m_url = nng::url(url);
         reset();
     }
 

hikyuu/include/hikyuu/utilities/mo/moFileReader.h

@@ -588,7 +588,7 @@ public:
 
         // Beautify Output
         std::string fname;
-        unsigned int pos = infile.find_last_of(MO_PATHSEP);
+        size_t pos = infile.find_last_of(MO_PATHSEP);
         if (pos != std::string::npos) {
             fname = infile.substr(pos + 1, infile.length());
         } else {

hikyuu/include/hikyuu/version.h

@@ -12,13 +12,13 @@
 #define HKU_VERSION_H
 
 // clang-format off
-#define HKU_VERSION "2.1.1"
+#define HKU_VERSION "2.1.2"
 #define HKU_VERSION_MAJOR 2
 #define HKU_VERSION_MINOR 1
-#define HKU_VERSION_ALTER 1
-#define HKU_VERSION_BUILD 202408091418
+#define HKU_VERSION_ALTER 2
+#define HKU_VERSION_BUILD 202408260144
 #define HKU_VERSION_MODE "RELEASE"
-#define HKU_VERSION_GIT "2.1.1 release.664f60e9 (RELEASE)"
+#define HKU_VERSION_GIT "2.1.2 release.619f2a88 (RELEASE)"
 // clang-format on
 
 #endif /* HKU_VERSION_H */