hikyuu 2.5.6__py3-none-win_amd64.whl → 2.6.0__py3-none-win_amd64.whl

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

@@ -0,0 +1,20 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-04-10
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "BackTestPluginInterface.h"
+#include "DevicePluginInterface.h"
+#include "DataServerPluginInterface.h"
+
+namespace hku {
+
+#define HKU_PLUGIN_BACKTEST "backtest"
+#define HKU_PLUGIN_DEVICE "device"
+#define HKU_PLUGIN_DATASERVER "dataserver"
+
+}

hikyuu/include/hikyuu/python/pybind_utils.h

@@ -98,6 +98,14 @@ public:                                                                      \
         return std::shared_ptr<classname>(keep_python_state_alive, ptr);     \
     }
 
+// 用于检查已 py::object 方式传递的函数参数个数是否符合预期
+inline bool check_pyfunction_arg_num(py::object& func, size_t arg_num) {
+    py::module_ inspect = py::module_::import("inspect");
+    py::object sig = inspect.attr("signature")(func);
+    py::object params = sig.attr("parameters");
+    return len(params) == arg_num;
+}
+
 }  // namespace hku
 
 #endif  // HIKYUU_PYTHON_BIND_UTILS_H

hikyuu/include/hikyuu/strategy/BrokerTradeManager.h

@@ -23,7 +23,8 @@ public:
 
     virtual shared_ptr<TradeManagerBase> _clone() override;
 
-    virtual void fetchAssetInfoFromBroker(const OrderBrokerPtr& broker) override;
+    virtual void fetchAssetInfoFromBroker(const OrderBrokerPtr& broker,
+                                          const Datetime& datetime = Null<Datetime>()) override;
 
     /**
      * 根据权息信息更新当前持仓与交易情况

hikyuu/include/hikyuu/strategy/RunPortfolioInStrategy.h

@@ -25,6 +25,7 @@ private:
     PFPtr m_pf;
     OrderBrokerPtr m_broker;
     KQuery m_query;
+    std::unordered_set<Stock> m_stocks;
 };
 
 StrategyPtr HKU_API crtPFStrategy(const PFPtr& pf, const KQuery& query,

hikyuu/include/hikyuu/strategy/Strategy.h

@@ -8,6 +8,7 @@
 #pragma once
 
 #include <future>
+#include <forward_list>
 #include "hikyuu/DataType.h"
 #include "hikyuu/StrategyContext.h"
 #include "hikyuu/global/SpotRecord.h"
@@ -34,7 +35,8 @@ 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 = "");
+             const unordered_map<string, int>& preloadNum = {}, const string& name = "Strategy",
+             const string& config_file = "");
     explicit Strategy(const StrategyContext& context, const string& name = "Strategy",
                       const string& config_file = "");
 
@@ -55,14 +57,16 @@ public:
         return m_context;
     }
 
+    bool running() const;
+
     /**
      * 每日开盘时间内，以 delta 为周期循环定时执行指定任务
      * @param func 待执行的任务
      * @param delta 间隔时间
-     * @param market 指定的市场
+     * @param market 指定的市场, 用于获取开/收盘时间
      * @param ignoreMarket 是否忽略市场时间限制，如为 true，则为定时循环不受开闭市时间限制
      */
-    void runDaily(std::function<void()>&& func, const TimeDelta& delta,
+    void runDaily(const std::function<void(Strategy*)>& func, const TimeDelta& delta,
                   const std::string& market = "SH", bool ignoreMarket = false);
 
     /**
@@ -71,7 +75,7 @@ public:
      * @param delta 指定时刻
      * @param ignoreHoliday 忽略节假日，即节假日不执行
      */
-    void runDailyAt(std::function<void()>&& func, const TimeDelta& delta,
+    void runDailyAt(const std::function<void(Strategy*)>& func, const TimeDelta& delta,
                     bool ignoreHoliday = true);
 
     /**
@@ -79,7 +83,8 @@ public:
      * @note 通常用于调试。且只要收到行情采集消息就会触发，不受开、闭市时间限制
      * @param changeFunc 回调函数
      */
-    void onChange(std::function<void(const Stock&, const SpotRecord& spot)>&& changeFunc);
+    void onChange(
+      const std::function<void(Strategy*, const Stock&, const SpotRecord& spot)>& changeFunc);
 
     /**
      * 一批行情数据接受完毕后通知
@@ -87,36 +92,111 @@ public:
      *       且只要收到行情采集消息就会触发，不受开、闭市时间限制。
      * @param recievedFucn 回调函数
      */
-    void onReceivedSpot(std::function<void(const Datetime&)>&& recievedFucn);
+    void onReceivedSpot(const std::function<void(Strategy*, const Datetime&)>& recievedFucn);
 
     /**
      * 启动策略执行，必须在已注册相关处理函数后执行
      */
     void start(bool autoRecieveSpot = true);
 
-private:
+    //==========================================================================
+    // 以下为策略运行时对外接口，建议使用这些接口代替同名其他功能函数，已保证回测和实盘一致
+    //==========================================================================
+
+    TradeManagerPtr getTM() const noexcept {
+        return m_tm;
+    }
+
+    void setTM(const TradeManagerPtr& tm) noexcept {
+        m_tm = tm;
+    }
+
+    /** 仅在回测状态下使用 */
+    SlippagePtr getSP() const noexcept {
+        return m_sp;
+    }
+
+    void setSP(const SlippagePtr& slippage) noexcept {
+        m_sp = slippage;
+    }
+
+    KData getKData(const Stock& stk, const Datetime& start_date, const Datetime& end_date,
+                   const KQuery::KType& ktype,
+                   KQuery::RecoverType recover_type = KQuery::NO_RECOVER) const {
+        return stk.getKData(KQueryByDate(start_date, end_date, ktype, recover_type));
+    }
+
+    KData getLastKData(const Stock& stk, const Datetime& start_date, const KQuery::KType& ktype,
+                       KQuery::RecoverType recover_type = KQuery::NO_RECOVER) const {
+        return getKData(stk, start_date, Null<Datetime>(), ktype, recover_type);
+    }
+
+    KData getLastKData(const Stock& stk, size_t lastnum, const KQuery::KType& ktype,
+                       KQuery::RecoverType recover_type = KQuery::NO_RECOVER) const;
+
+    virtual Datetime today() const {
+        return Datetime::today();
+    }
+
+    virtual Datetime now() const {
+        return Datetime::now();
+    }
+
+    virtual Datetime nextDatetime() const {
+        return Null<Datetime>();
+    }
+
+    virtual TradeRecord buy(const Stock& stk, price_t price, double num, double stoploss = 0.0,
+                            double goal_price = 0.0,
+                            SystemPart part_from = SystemPart::PART_SIGNAL) {
+        HKU_ASSERT(m_tm);
+        return m_tm->buy(Datetime::now(), stk, price, num, stoploss, goal_price, price, part_from);
+    }
+
+    virtual TradeRecord sell(const Stock& stk, price_t price, double num, price_t stoploss = 0.0,
+                             price_t goal_price = 0.0,
+                             SystemPart part_from = SystemPart::PART_SIGNAL) {
+        HKU_ASSERT(m_tm);
+        return m_tm->sell(Datetime::now(), stk, price, num, stoploss, goal_price, price, part_from);
+    }
+
+    virtual bool isBacktesting() const {
+        return false;
+    }
+
+protected:
     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;
+    TradeManagerPtr m_tm;
+    SlippagePtr m_sp;
+
+    std::function<void(Strategy*, const Datetime&)> m_on_recieved_spot;
+    std::function<void(Strategy*, const Stock&, const SpotRecord& spot)> m_on_change;
+
+    struct RunDailyAt {
+        std::function<void()> func;
+        TimeDelta delta;
+        string market;
+        bool ignoreMarket{false};
+    };
+    std::forward_list<RunDailyAt> m_run_daily_at_list;
+
+    std::unordered_map<TimeDelta, std::function<void()>> m_run_daily_at_funcs;
 
-    std::function<void()> m_run_daily_func;
-    TimeDelta m_run_daily_delta;
-    string m_run_daily_market;
-    bool m_ignoreMarket{false};
+protected:
+    static std::atomic_bool ms_keep_running;
 
-    std::map<TimeDelta, std::function<void()>> m_run_daily_at_funcs;
+protected:
+    void _init();
 
 private:
     void _initParam();
-    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;

hikyuu/include/hikyuu/trade_manage/TradeManagerBase.h

@@ -697,8 +697,10 @@ public:
     /**
      * 从订单代理实例同步当前账户资产信息（包含资金、持仓等）
      * @param broker 订单代理实例
+     * @param datetime 同步时，通常为当前时间（Null)，也可以强制为指定的时间点
      */
-    virtual void fetchAssetInfoFromBroker(const OrderBrokerPtr& broker) {
+    virtual void fetchAssetInfoFromBroker(const OrderBrokerPtr& broker,
+                                          const Datetime& datetime = Null<Datetime>()) {
         HKU_WARN("The subclass does not implement this method");
     }
 
@@ -706,7 +708,7 @@ protected:
     string m_name;            // 账户名称
     TradeCostPtr m_costfunc;  // 成本算法
 
-    Datetime m_broker_last_datetime;  // 订单代理最近一次执行操作的时刻,当前启动运行时间
+    Datetime m_broker_last_datetime;     // 订单代理最近一次执行操作的时刻,当前启动运行时间
     list<OrderBrokerPtr> m_broker_list;  // 订单代理列表
 
 //============================================

hikyuu/include/hikyuu/trade_sys/system/imp/WalkForwardTradeManager.h

@@ -437,8 +437,9 @@ public:
      * 从订单代理实例同步当前账户资产信息（包含资金、持仓等）
      * @param broker 订单代理实例
      */
-    virtual void fetchAssetInfoFromBroker(const OrderBrokerPtr& broker) override {
-        m_tm->fetchAssetInfoFromBroker(broker);
+    virtual void fetchAssetInfoFromBroker(const OrderBrokerPtr& broker,
+                                          const Datetime& datetime = Null<Datetime>()) override {
+        m_tm->fetchAssetInfoFromBroker(broker, datetime);
     }
 
 private:

hikyuu/include/hikyuu/utilities/plugin/PluginClient.h

@@ -17,7 +17,7 @@ public:
     PluginClient() = delete;
     PluginClient(const std::string &path, const std::string &filename) {
         m_loader = std::make_unique<PluginLoader>(path);
-        m_loader->load(filename);
+        HKU_CHECK(m_loader->load(filename), "load plugin failed! {}/{}", path, filename);
         m_impl = m_loader->instance<InterfaceT>();
     }
     virtual ~PluginClient() = default;
@@ -46,7 +46,7 @@ public:
     }
 
 protected:
-    InterfaceT *m_impl;
+    InterfaceT *m_impl{nullptr};
 
 protected:
     std::unique_ptr<PluginLoader> m_loader;

hikyuu/include/hikyuu/utilities/plugin/PluginLoader.h

@@ -14,29 +14,29 @@
 #include <memory>
 #include "hikyuu/utilities/config.h"
 #include "hikyuu/utilities/osdef.h"
+#include "hikyuu/utilities/os.h"
 #include "hikyuu/utilities/Log.h"
 #include "PluginBase.h"
 
 #if HKU_OS_WINDOWS
 #include <windows.h>
-#endif
-
-#ifndef HKU_UTILS_API
-#define HKU_UTILS_API
+#else
+#include <dlfcn.h>
 #endif
 
 namespace hku {
 
-class HKU_UTILS_API PluginLoader final {
+class PluginLoader final {
 public:
-    PluginLoader();
-    explicit PluginLoader(const std::string& path);
+    PluginLoader() : PluginLoader(".") {}
+    explicit PluginLoader(const std::string& path) : m_path(path) {}
+
     PluginLoader(const PluginLoader&) = delete;
     PluginLoader(PluginLoader&&) = delete;
 
-    ~PluginLoader();
-
-    bool load(const std::string& pluginname) noexcept;
+    ~PluginLoader() {
+        unload();
+    }
 
     template <typename T>
     T* instance() const noexcept {
@@ -44,10 +44,63 @@ public:
         return dynamic_cast<T*>(m_plugin.get());
     }
 
+    bool load(const std::string& pluginname) noexcept {
+        std::string filename = getFileName(pluginname);
+        HKU_WARN_IF_RETURN(!existFile(filename), false, "file({}) not exist!", filename);
+
+#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 plugin({}) failed!", filename);
+
+        typedef PluginBase* (*CreateFunction)();
+        CreateFunction createFunction =
+          reinterpret_cast<CreateFunction>(getFunciton("createPlugin"));
+        HKU_WARN_IF_RETURN(!createFunction, false, "Failed to get plugin({}) handle!", filename);
+
+        m_plugin.reset(createFunction());
+        if (!m_plugin) {
+            HKU_ERROR("Failed to create plugin ({})!", filename);
+            unload();
+            m_plugin.reset();
+            return false;
+        }
+
+        return true;
+    }
+
 private:
-    void unload() noexcept;
-    void* getFunciton(const char* symbol) noexcept;
-    std::string getFileName(const std::string& pluginname) const noexcept;
+    void unload() noexcept {
+        m_plugin.reset();
+        if (m_handle) {
+#if HKU_OS_WINDOWS
+            FreeLibrary(m_handle);
+#else
+            dlclose(m_handle);
+#endif
+        }
+    }
+
+    void* getFunciton(const char* symbol) noexcept {
+#if HKU_OS_WINDOWS
+        void* func = GetProcAddress(m_handle, symbol);
+#else
+        void* func = dlsym(m_handle, symbol);
+#endif
+        return func;
+    }
+
+    std::string getFileName(const std::string& pluginname) const noexcept {
+#if HKU_OS_WINDOWS
+        return fmt::format("{}/{}.dll", m_path, pluginname);
+#elif HKU_OS_LINUX
+        return fmt::format("{}/lib{}.so", m_path, pluginname);
+#elif HKU_OS_OSX
+        return fmt::format("{}/lib{}.dylib", m_path, pluginname);
+#endif
+    }
 
 private:
 #if HKU_OS_WINDOWS

hikyuu/include/hikyuu/utilities/plugin/PluginManager.h

@@ -0,0 +1,72 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-04-10
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include <string>
+#include <memory>
+#include <unordered_map>
+#include <mutex>
+#include "hikyuu/utilities/Log.h"
+#include "hikyuu/utilities/plugin/PluginLoader.h"
+
+namespace hku {
+
+class PluginManager final {
+public:
+    PluginManager() : m_plugin_path(".") {};
+    explicit PluginManager(const std::string& plugin_path) : m_plugin_path(plugin_path) {}
+
+    ~PluginManager() = default;
+    PluginManager(const PluginManager&) = delete;
+    PluginManager(PluginManager&&) = delete;
+    PluginManager& operator=(const PluginManager&) = delete;
+    PluginManager& operator=(PluginManager&&) = delete;
+
+    const std::string& pluginPath() const noexcept {
+        return m_plugin_path;
+    }
+
+    void pluginPath(const std::string& plugin_path) noexcept {
+        HKU_TRACE_IF_RETURN(!m_plugins.empty(), void(),
+                            "Existing loaded plugins, Ignore set plugin path: {}, ", plugin_path);
+        m_plugin_path = plugin_path;
+    }
+
+    template <typename PluginInterfaceT>
+    PluginInterfaceT* getPlugin(const std::string& pluginname) noexcept;
+
+private:
+    std::unordered_map<std::string, std::unique_ptr<PluginLoader>>::iterator load(
+      const std::string& pluginname) noexcept {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        std::unique_ptr<PluginLoader> loader = std::make_unique<PluginLoader>(m_plugin_path);
+        if (loader->load(pluginname)) {
+            auto [it, success] = m_plugins.insert(std::make_pair(pluginname, std::move(loader)));
+            if (success) {
+                return it;
+            }
+        }
+        return m_plugins.end();
+    }
+
+private:
+    std::string m_plugin_path;
+    std::unordered_map<std::string, std::unique_ptr<PluginLoader>> m_plugins;
+    std::mutex m_mutex;
+};
+
+template <typename PluginInterfaceT>
+PluginInterfaceT* PluginManager::getPlugin(const std::string& pluginname) noexcept {
+    auto it = m_plugins.find(pluginname);
+    if (it == m_plugins.end()) {
+        it = load(pluginname);
+    }
+    return it != m_plugins.end() ? it->second->instance<PluginInterfaceT>() : nullptr;
+}
+
+}  // namespace hku

hikyuu/include/hikyuu/version.h

@@ -12,13 +12,13 @@
 #define HKU_VERSION_H
 
 // clang-format off
-#define HKU_VERSION "2.5.6"
+#define HKU_VERSION "2.6.0"
 #define HKU_VERSION_MAJOR 2
-#define HKU_VERSION_MINOR 5
-#define HKU_VERSION_ALTER 6
-#define HKU_VERSION_BUILD 202504131513
+#define HKU_VERSION_MINOR 6
+#define HKU_VERSION_ALTER 0
+#define HKU_VERSION_BUILD 202504301710
 #define HKU_VERSION_MODE "RELEASE"
-#define HKU_VERSION_GIT "2.5.6 release.2e933ae9 (RELEASE)"
+#define HKU_VERSION_GIT "2.6.0 release.3bd470a3 (RELEASE)"
 // clang-format on
 
 #endif /* HKU_VERSION_H */

hikyuu/plugin/__init__.py

@@ -0,0 +1 @@
+

hikyuu/strategy/strategy_demo1.py

@@ -7,24 +7,23 @@
 #      供自行实现程序化交易时参考，请自行负责程序化交易可能造成的损失。
 #
 
-from hikyuu import Strategy, Query, Datetime, Seconds, Minutes
-from hikyuu import sm
+from hikyuu import *
 
 
-def on_change(stk, spot):
+def on_change(stg: Strategy, stk: Stock, spot: SpotRecord):
     print("[on_change]:", stk.market_code, stk.name, spot.close, spot.bid1, spot.ask1)
 
 
-def on_spot(rev_time):
+def on_spot(stg: Strategy, rev_time: Datetime):
     print("[on_received_spot] rev_time:", rev_time)
 
 
-def my_func1():
-    print("[my_func1]", str(Datetime.now()))
+def my_func1(stg: Strategy):
+    print("[my_func1]", str(stg.now()))
 
 
-def my_func2():
-    print("[my_func2] calculate:", Datetime.now())
+def my_func2(stg: Strategy):
+    print("[my_func2] calculate:", stg.now())
     for s in sm:
         print(s)
 

hikyuu/strategy/strategy_demo2.py

@@ -24,7 +24,7 @@ sys.set_param("sell_delay", False)
 
 
 # 执行策略主体
-def my_func():
+def my_func(stg: Strategy):
     # 这里示例使用的是 TC_Zero() 零成本算法，但实际建议使用接近实际的成本算法
     # 因为 sys 不依赖于成交单中的实际成本，而是使用成本算法预算需要买入的数量
     run_in_strategy(sys, sm['sz000001'], Query(Datetime(20240101)), broker, TC_Zero())