hikyuu 2.6.3__py3-none-win_amd64.whl → 2.6.6__py3-none-win_amd64.whl

hikyuu/include/hikyuu/plugin/interface/plugins.h

@@ -12,6 +12,8 @@
 #include "DataServerPluginInterface.h"
 #include "ImportKDataToHdf5PluginInterface.h"
 #include "ExtendIndicatorsPluginInterface.h"
+#include "TMReportPluginInterface.h"
+#include "DataDriverPluginInterface.h"
 
 namespace hku {
 
@@ -20,5 +22,7 @@ namespace hku {
 #define HKU_PLUGIN_DATASERVER "dataserver"
 #define HKU_PLUGIN_IMPORTKDATATOHDF5 "import2hdf5"
 #define HKU_PLUGIN_EXTEND_INDICATOR "extind"
+#define HKU_PLUGIN_TMREPORT "tmreport"
+#define HKU_PLUGIN_CLICKHOUSE_DRIVER "clickhousedriver"
 
 }

hikyuu/include/hikyuu/strategy/Strategy.h

@@ -267,14 +267,5 @@ void HKU_API runInStrategy(const PFPtr& pf, const KQuery& query, const OrderBrok
                            const TradeCostPtr& costfunc,
                            const std::vector<OrderBrokerPtr>& other_brokers = {});
 
-/**
- * 从 hikyuu 数据缓存服务器拉取更新最新的缓存数据
- * @param addr 缓存服务地址，如: tcp://192.168.1.1:9201
- * @param stklist 待更新的股票列表
- * @param ktype 指定更新的K线类型
- */
-void HKU_API getDataFromBufferServer(const std::string& addr, const StockList& stklist,
-                                     const KQuery::KType& ktype);
-
 /** @} */
 }  // namespace hku

hikyuu/include/hikyuu/trade_manage/Performance.h

@@ -10,7 +10,7 @@
 #define PERFORMANCE_H_
 
 #include <boost/function.hpp>
-#include "TradeManager.h"
+#include "TradeManagerBase.h"
 
 namespace hku {
 
@@ -23,14 +23,15 @@ public:
     Performance();
     virtual ~Performance();
 
-    Performance(const Performance& other) : m_result(other.m_result) {}
-    Performance(Performance&& other) : m_result(std::move(other.m_result)) {}
+    Performance(const Performance& other) = default;
+    Performance(Performance&& other)
+    : m_result(std::move(other.m_result)), m_keys(std::move(other.m_keys)) {}
 
     Performance& operator=(const Performance& other);
     Performance& operator=(Performance&& other);
 
     /** 是否为合法的统计项 */
-    static bool exist(const string& key);
+    bool exist(const string& key);
 
     /** 复位，清除已计算的结果 */
     void reset();
@@ -44,12 +45,12 @@ public:
     }
 
     /**
-     * 简单的文本统计报告，用于直接输出打印
-     * @param tm
+     * 简单的文本统计报告，用于直接输出打印。
+     * @note 只有运行 statistics 后或 Performance 本身为从 TM 获取的结果时才生效
      * @param datetime 指定的截止时刻
      * @return
      */
-    string report(const TradeManagerPtr& tm, const Datetime& datetime = Datetime::now());
+    string report();
 
     /**
      * 根据交易记录，统计截至某一时刻的系统绩效, datetime必须大于等于lastDatetime，
@@ -61,7 +62,7 @@ public:
 
     /** 获取所有统计项名称，顺序与 values 相同 */
     const StringList& names() const {
-        return ms_keys;
+        return m_keys;
     }
 
     /** 获取所有统计项值，顺序与 names 相同*/
@@ -71,9 +72,16 @@ public:
     typedef map_type::iterator iterator;
     typedef map_type::const_iterator const_iterator;
 
+    const map_type& getAll() const {
+        return m_result;
+    }
+
+    void addKey(const string& key);
+    void setValue(const string& key, double value);
+
 private:
     map_type m_result;
-    static StringList ms_keys;  // 保存统计项顺序, map/unordered_map都不能保持按插入顺序遍历
+    StringList m_keys;  // 保存统计项顺序, map/unordered_map都不能保持按插入顺序遍历
 };
 
 } /* namespace hku */

hikyuu/include/hikyuu/trade_manage/PositionExtInfo.h

@@ -0,0 +1,92 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-05-30
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "PositionRecord.h"
+
+namespace hku {
+// 持仓扩展信息（只适合一买一卖的情况，一买多卖的情况，部分统计不准确仅供参考)
+struct HKU_API PositionExtInfo final {
+    PositionRecord position;
+    price_t maxHighPrice{0.};       // 期间最高价最大值
+    price_t minLowPrice{0.0};       // 期间最低价最小值
+    price_t maxClosePrice{0.};      // 期间收盘价最高值
+    price_t minClosePrice{0.0};     // 期间收盘价最低值
+    price_t currentClosePrice{0.};  // 当前收盘价
+    price_t maxPullBack1{0.};       // 最大回撤百分比1(仅使用最大收盘价和最低收盘价计算)(负数)
+    price_t maxPullBack2{0.};   // 最大回撤百分比2(使用期间最高价最大值和最低价最小值计算)（负数）
+    price_t currentProfit{0.};  // 当前浮动盈亏(不含预计卖出成本)
+
+    /** 当前回撤百分比1(仅使用最大收盘价和当前收盘价计算) */
+    price_t currentPullBack1() const {
+        price_t ret = (maxClosePrice - currentClosePrice) / maxClosePrice;
+        return ret > 0. ? 0. : ret;
+    }
+
+    /** 当前回撤百分比2(使用期间最高价最大值和当前收盘价计算) */
+    price_t currentPullBack2() const {
+        price_t ret = (maxHighPrice - currentClosePrice) / maxHighPrice;
+        return ret > 0. ? 0. : ret;
+    }
+
+    /** 期间最大浮盈1 (正数, 仅使用收盘价计算, 不含预计卖出成本, 多次买卖时统计不准) */
+    price_t maxFloatingProfit1() const {
+        price_t ret = maxClosePrice * position.number + position.sellMoney - position.buyMoney;
+        return ret < 0. ? 0. : ret;
+    }
+
+    /** 期间最大浮盈2 (正数, 使用最高值最大值进行计算,不含预计卖出成本，多次买卖时统计不准) */
+    price_t maxFloatingProfit2() const {
+        price_t ret = maxHighPrice * position.number + position.sellMoney - position.buyMoney;
+        return ret < 0. ? 0. : ret;
+    }
+
+    /** 期间最大浮亏1（负数，仅使用收盘价计算, 不含预计卖出成本，多次买卖时统计不准) */
+    price_t minLossProfit1() const {
+        price_t ret = minClosePrice * position.number + position.sellMoney - position.buyMoney;
+        return ret > 0. ? 0. : ret;
+    }
+
+    /** 期间最大浮亏2（负数，仅期间最低价计算, 不含预计卖出成本，多次买卖时统计不准) */
+    price_t minLossProfit2() const {
+        price_t ret = minLowPrice * position.number + position.sellMoney - position.buyMoney;
+        return ret > 0. ? 0. : ret;
+    }
+
+    PositionExtInfo() = default;
+    PositionExtInfo(const PositionExtInfo&) = default;
+    PositionExtInfo& operator=(const PositionExtInfo&) = default;
+
+    PositionExtInfo(PositionExtInfo&& rhs)
+    : position(std::move(rhs.position)),
+      maxHighPrice(rhs.maxHighPrice),
+      minLowPrice(rhs.minLowPrice),
+      maxClosePrice(rhs.maxClosePrice),
+      minClosePrice(rhs.minClosePrice),
+      currentClosePrice(rhs.currentClosePrice),
+      maxPullBack1(rhs.maxPullBack1),
+      maxPullBack2(rhs.maxPullBack2),
+      currentProfit(rhs.currentProfit) {}
+
+    PositionExtInfo& operator=(PositionExtInfo&& rhs) {
+        if (this != &rhs) {
+            position = std::move(rhs.position);
+            maxHighPrice = rhs.maxHighPrice;
+            minLowPrice = rhs.minLowPrice;
+            maxClosePrice = rhs.maxClosePrice;
+            minClosePrice = rhs.minClosePrice;
+            currentClosePrice = rhs.currentClosePrice;
+            maxPullBack1 = rhs.maxPullBack1;
+            maxPullBack2 = rhs.maxPullBack2;
+            currentProfit = rhs.currentProfit;
+        }
+        return *this;
+    }
+};
+
+}  // namespace hku

hikyuu/include/hikyuu/trade_manage/PositionRecord.h

@@ -25,11 +25,17 @@ public:
                    double number, price_t stoploss, price_t goalPrice, double totalNumber,
                    price_t buyMoney, price_t totalCost, price_t totalRisk, price_t sellMoney);
 
+    PositionRecord(const PositionRecord& ths) = default;
+    PositionRecord& operator=(const PositionRecord& ths) = default;
+
+    PositionRecord(PositionRecord&& rhs);
+    PositionRecord& operator=(PositionRecord&& rhs);
+
     /** 仅用于python的__str__ */
     string str() const;
 
     /**
-     * @brief 盈亏 = 买入资金 - 累计交易总成本 - 卖出资金
+     * @brief 盈亏 = 卖出资金 - 累计交易总成本 - 买入资金
      * @note 只对已清仓的记录有效，未清仓将返回0.0
      */
     price_t totalProfit() const;

hikyuu/include/hikyuu/trade_manage/TradeManagerBase.h

@@ -10,6 +10,7 @@
 #include "../utilities/Parameter.h"
 #include "TradeRecord.h"
 #include "PositionRecord.h"
+#include "PositionExtInfo.h"
 #include "BorrowRecord.h"
 #include "FundsRecord.h"
 #include "LoanRecord.h"
@@ -19,6 +20,8 @@
 
 namespace hku {
 
+class HKU_API Performance;
+
 /**
  * 账户交易管理基类，管理帐户的交易记录及资金使用情况
  * @details
@@ -28,7 +31,7 @@ namespace hku {
  * </pre>
  * @ingroup TradeManagerClass
  */
-class HKU_API TradeManagerBase {
+class HKU_API TradeManagerBase : public enable_shared_from_this<TradeManagerBase> {
     PARAMETER_SUPPORT_WITH_CHECK
 
 public:
@@ -706,6 +709,62 @@ public:
         HKU_WARN("The subclass does not implement this method");
     }
 
+    //-------------------------------------------------------------
+    // 以下为可能需要授权的功能
+    //-------------------------------------------------------------
+    /**
+     * 统计截至某一时刻的系统绩效, datetime必须大于等于lastDatetime，
+     * 以便用于计算当前市值
+     * @param datetime 统计截止时刻
+     */
+    Performance getPerformance(const Datetime& datetime = Datetime::now(),
+                               const KQuery::KType& ktype = KQuery::DAY);
+
+    /**
+     * @brief 获取指定时刻时账户的最大回撤百分比（负数）（仅根据收盘价计算）
+     * @param tm 指定账户
+     * @param date 指定日期（包含该时刻）
+     * @param ktype k线类型
+     * @return price_t
+     */
+    price_t getMaxPullBack(const Datetime& date, const KQuery::KType& ktype = KQuery::DAY);
+
+    /**
+     * @brief 获取账户历史持仓扩展详情
+     * @param ktype k线类型
+     * @param trade_mode 交易模式，影响部分统计项: 0-收盘时交易, 1-下一开盘时交易
+     * @return std::vector<PositionExtInfo>
+     */
+    std::vector<PositionExtInfo> getHistoryPositionExtInfoList(
+      const KQuery::KType& ktype = KQuery::DAY, int trade_mode = 0);
+
+    /**
+     * @brief 获取账户最后交易时刻后持仓详情
+     * @param current_time 当前时刻（需大于等于最后交易时刻）
+     * @param ktype k线类型
+     * @param trade_mode 交易模式，影响部分统计项: 0-收盘时交易, 1-下一开盘时交易
+     * @return std::vector<PositionExtInfo>
+     */
+    std::vector<PositionExtInfo> getPositionExtInfoList(
+      const Datetime& current_time = Datetime::now(), const KQuery::KType& ktype = KQuery::DAY,
+      int trade_mode = 0);
+
+    /**
+     * @brief 获取指定截止时间前各月的收益百分比
+     * @param datetime
+     * @return std::vector<std::pair<Datetime, double>>
+     */
+    std::vector<std::pair<Datetime, double>> getProfitPercentMonthly(
+      const Datetime& datetime = Datetime::now());
+
+    /**
+     * @brief 获取指定截止时间前各年的收益百分比
+     * @param datetime
+     * @return std::vector<std::pair<Datetime, double>>
+     */
+    std::vector<std::pair<Datetime, double>> getProfitPercentYearly(
+      const Datetime& datetime = Datetime::now());
+
 protected:
     string m_name;            // 账户名称
     TradeCostPtr m_costfunc;  // 成本算法

hikyuu/include/hikyuu/trade_sys/selector/crt/SE_Optimal.h

@@ -23,4 +23,12 @@ SEPtr HKU_API SE_MaxFundsOptimal();
  */
 SEPtr HKU_API SE_PerformanceOptimal(const string& key = "帐户平均年收益率%", int mode = 0);
 
+/**
+ * 使用自定义评估函数进行寻优的选择器
+ * @param evaluate
+ * @return SEPtr
+ */
+SEPtr HKU_API
+SE_EvaluateOptimal(std::function<double(const SystemPtr&, const Datetime&)>&& evaluate);
+
 }  // namespace hku

hikyuu/include/hikyuu/trade_sys/selector/imp/optimal/OptimalEvaluateSelector.h

@@ -0,0 +1,28 @@
+/*
+ *  Copyright (c) 2024 hikyuu.org
+ *
+ *  Created on: 2024-09-22
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "OptimalSelectorBase.h"
+
+namespace hku {
+
+class OptimalEvaluateSelector : public OptimalSelectorBase {
+    OPTIMAL_SELECTOR_IMP(OptimalEvaluateSelector)
+    OPTIMAL_SELECTOR_NO_PRIVATE_MEMBER_SERIALIZATION
+
+public:
+    OptimalEvaluateSelector();
+    OptimalEvaluateSelector(std::function<double(const SystemPtr&, const Datetime&)>&& evaluate);
+
+    virtual ~OptimalEvaluateSelector();
+
+private:
+    std::function<double(const SystemPtr&, const Datetime&)> m_evaluate;
+};
+
+}  // namespace hku

hikyuu/include/hikyuu/trade_sys/selector/imp/optimal/OptimalSelectorBase.h

@@ -43,6 +43,7 @@ public:
     // 以便继承子类只需要实现 _clone 和 该接口即可
     // 该接口实现系统绩效评估，getSelected 时将取评估结果最大的系统
     // 使用 std::function 的话，在 C++ 中无法序列化，所以使用继承
+    // 返回 Null<double> 时，将不被评估选中
     virtual double evaluate(const SYSPtr& sys, const Datetime& endDate) noexcept {
         return Null<double>();
     }

hikyuu/include/hikyuu/utilities/DllLoader.h

@@ -0,0 +1,226 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-03-18
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef HKU_UTILS_DLL_LOADER_H_
+#define HKU_UTILS_DLL_LOADER_H_
+
+#include <string>
+#include <vector>
+#include <cstdlib>
+#include "hikyuu/utilities/config.h"
+#include "hikyuu/utilities/osdef.h"
+#include "hikyuu/utilities/os.h"
+#include "hikyuu/utilities/Log.h"
+#include "hikyuu/utilities/arithmetic.h"
+
+#if HKU_OS_WINDOWS
+#include <windows.h>
+#else
+#include <dlfcn.h>
+#endif
+
+namespace hku {
+
+class DllLoader {
+public:
+    DllLoader() {
+        initDefaultSearchPath();
+    }
+
+    explicit DllLoader(const std::vector<std::string>& path) {
+        if (!path.empty()) {
+            m_search_paths.resize(path.size());
+            std::copy(path.begin(), path.end(), m_search_paths.begin());
+        } else {
+            HKU_WARN("DllLoader: empty search path! Use default search path!");
+            initDefaultSearchPath();
+        }
+    }
+
+    DllLoader(const DllLoader&) = delete;
+    DllLoader& operator=(const DllLoader&) = delete;
+
+    DllLoader(DllLoader&& rhs)
+    : m_handle(rhs.m_handle), m_search_paths(std::move(rhs.m_search_paths)) {
+        rhs.m_handle = nullptr;
+    }
+
+    DllLoader& operator=(DllLoader&& rhs) {
+        if (this == &rhs) {
+            m_handle = rhs.m_handle;
+            m_search_paths = std::move(rhs.m_search_paths);
+            rhs.m_handle = nullptr;
+        }
+        return *this;
+    }
+
+    virtual ~DllLoader() {
+        unload();
+    }
+
+    bool load(const std::string& dllname) noexcept {
+        std::string filename = search(dllname);
+        HKU_WARN_IF_RETURN(filename.empty(), false, "Not found dll: {}!", dllname);
+
+#if HKU_OS_WINDOWS
+        m_handle = LoadLibrary(HKU_PATH(filename).c_str());
+#else
+        m_handle = dlopen(filename.c_str(), RTLD_LAZY);
+#endif
+        HKU_WARN_IF_RETURN(!m_handle, false, "load dll({}) failed!", filename);
+        return true;
+    }
+
+    void unload() noexcept {
+        if (m_handle) {
+#if HKU_OS_WINDOWS
+            FreeLibrary(m_handle);
+#else
+            dlclose(m_handle);
+#endif
+        }
+    }
+
+    std::string search(const std::string& dllname) const noexcept {
+#if HKU_OS_WINDOWS
+        std::string dll = fmt::format("{}.dll", dllname);
+#elif HKU_OS_OSX
+        std::string dll = fmt::format("lib{}.dylib", dllname);
+#else
+        std::string dll = fmt::format("lib{}.so", dllname);
+#endif
+        for (const auto& path : m_search_paths) {
+            auto filename = fmt::format("{}/{}", path, dll);
+            if (existFile(filename)) {
+                return filename;
+            }
+        }
+
+        return std::string();
+    }
+
+    void* getSymbol(const char* symbol) noexcept {
+#if HKU_OS_WINDOWS
+        void* func = GetProcAddress(m_handle, symbol);
+#else
+        void* func = dlsym(m_handle, symbol);
+#endif
+        return func;
+    }
+
+private:
+    void initDefaultSearchPath() noexcept {
+        m_search_paths.emplace_back(".");
+
+        std::string userdir = getUserDir();
+        if (!userdir.empty()) {
+            m_search_paths.emplace_back(userdir + "/lib");
+        }
+
+#if HKU_OS_WINDOWS
+        m_search_paths.emplace_back("C:/Windows/System32");
+        m_search_paths.emplace_back("C:/Windows/SysWOW64");
+        m_search_paths.emplace_back("C:/Windows");
+        const char* path = getenv("PATH");
+        if (path) {
+            std::string pathstr(path);
+            auto items = split(pathstr, ";");
+            for (auto& item : items) {
+                std::string nitem(item);
+                trim(nitem);
+                if (!item.empty()) {
+                    m_search_paths.emplace_back(nitem);
+                }
+            }
+        }
+
+#elif HKU_OS_OSX
+        const char* path = getenv("DYLD_IMAGE_SUFFIX");
+        if (path) {
+            std::string pathstr(path);
+            auto items = split(pathstr, ";");
+            for (auto& item : items) {
+                std::string nitem(item);
+                trim(nitem);
+                if (!item.empty()) {
+                    m_search_paths.emplace_back(nitem);
+                }
+            }
+        }
+        path = getenv("DYLD_FRAMEWORK_PATH");
+        if (path) {
+            std::string pathstr(path);
+            auto items = split(pathstr, ";");
+            for (auto& item : items) {
+                std::string nitem(item);
+                trim(nitem);
+                if (!item.empty()) {
+                    m_search_paths.emplace_back(nitem);
+                }
+            }
+        }
+        path = getenv("DYLD_LIBRARY_PATH");
+        if (path) {
+            std::string pathstr(path);
+            auto items = split(pathstr, ";");
+            for (auto& item : items) {
+                std::string nitem(item);
+                trim(nitem);
+                if (!item.empty()) {
+                    m_search_paths.emplace_back(nitem);
+                }
+            }
+        }
+        m_search_paths.emplace_back("/Library/Frameworks");
+        m_search_paths.emplace_back("/Network/Library/Frameworks");
+        m_search_paths.emplace_back("/System/Library/Frameworks");
+        m_search_paths.emplace_back("/usr/local/lib");
+        m_search_paths.emplace_back("/usr/lib");
+        m_search_paths.emplace_back("/lib");
+
+#else
+        const char* path = getenv("LD_LIBRARY_PATH");
+        if (path) {
+            std::string pathstr(path);
+            auto items = split(pathstr, ";");
+            for (auto& item : items) {
+                std::string nitem(item);
+                trim(nitem);
+                if (!item.empty()) {
+                    m_search_paths.emplace_back(nitem);
+                }
+            }
+        }
+        m_search_paths.emplace_back("/usr/local/lib");
+        m_search_paths.emplace_back("/usr/lib");
+        m_search_paths.emplace_back("/lib");
+        if (HKU_ARCH_X64) {
+            m_search_paths.emplace_back("/usr/lib/x86_64-linux-gnu");
+        } else if (HKU_ARCH_ARM64) {
+            m_search_paths.emplace_back("/usr/lib/aarch64-linux-gnu");
+        } else if (HKU_ARCH_X86) {
+            m_search_paths.emplace_back("/usr/lib/i386-linux-gnu");
+        } else if (HKU_ARCH_ARM) {
+            m_search_paths.emplace_back("/usr/lib/arm-linux-gnueabihf");
+        }
+#endif
+    }
+
+private:
+#if HKU_OS_WINDOWS
+    HMODULE m_handle{nullptr};
+#else
+    void* m_handle{nullptr};
+#endif
+
+    std::vector<std::string> m_search_paths;
+};
+
+}  // namespace hku
+
+#endif /* HKU_UTILS_DLL_LOADER_H_ */

hikyuu/include/hikyuu/utilities/config.h

@@ -28,7 +28,7 @@
 #define HKU_USE_SPDLOG_ASYNC_LOGGER 0
 #define HKU_LOG_ACTIVE_LEVEL 2
 
-#define HKU_ENABLE_MO 0
+#define HKU_ENABLE_MO 1
 
 #define HKU_ENABLE_HTTP_CLIENT 1
 #define HKU_ENABLE_HTTP_CLIENT_SSL 0

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

@@ -62,6 +62,20 @@ public:
      */
     static Datetime fromHex(uint64_t time);
 
+    /**
+     * @brief 从时间戳（微秒）创建Datetime对象
+     * @param timestamp 微妙级别的时间戳(从1970年1月1日0时0分0秒开始)
+     * @return Datetime
+     */
+    static Datetime fromTimestamp(int64_t timestamp);
+
+    /**
+     * @brief 从时间戳（微秒）创建Datetime对象，并加上本地UTC时间偏差
+     * @param timestamp 微妙级别的时间戳(从1970年1月1日0时0分0秒开始)
+     * @return Datetime
+     */
+    static Datetime fromTimestampUTC(int64_t timestamp);
+
 public:
     /** 默认构造函数，Null<Datetime> */
     Datetime();
@@ -178,6 +192,12 @@ public:
     /** 距离最小日期过去的微秒数 */
     uint64_t ticks() const noexcept;
 
+    /** 时间戳，距离1970-01-01 00:00:00的微秒数 */
+    int64_t timestamp() const noexcept;
+
+    /** 时间戳，距离1970-01-01 00:00:00的微秒数, 并扣除本地 UTC 偏差时间 */
+    int64_t timestampUTC() const noexcept;
+
     /**
      * 转化为字符串，供打印阅读，格式：
      * <pre>

hikyuu/include/hikyuu/utilities/datetime/TimeDelta.h

@@ -316,6 +316,12 @@ inline TimeDelta Microseconds(int64_t microsecs) {
     return TimeDelta::fromTicks(microsecs);
 }
 
+/**
+ * 获取当前 UTC 时间偏移
+ * @return TimeDelta
+ */
+TimeDelta HKU_UTILS_API UTCOffset();
+
 } /* namespace hku */
 
 namespace std {