hikyuu 2.7.1__py3-none-win_amd64.whl → 2.7.2__py3-none-win_amd64.whl

hikyuu/include/hikyuu/plugin/KDataToMySQLImporter.h

@@ -0,0 +1,40 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-05-06
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "hikyuu/DataType.h"
+#include "interface/ImportKDataToMySQLPluginInterface.h"
+
+namespace hku {
+
+class HKU_API KDataToMySQLImporter {
+public:
+    KDataToMySQLImporter();
+    virtual ~KDataToMySQLImporter();
+
+    bool setConfig(const string& host, int port, const string& user, const string& pwd);
+
+    Datetime getLastDatetime(const string& market, const string& code, const KQuery::KType& ktype);
+
+    void addKRecordList(const string& market, const string& code, const vector<KRecord>& krecords,
+                        const KQuery::KType& ktype);
+
+    void addTimeLineList(const string& market, const string& code, const TimeLineList& timeline);
+
+    void addTransList(const string& market, const string& code, const TransRecordList& translist);
+
+    void updateIndex(const string& market, const string& code, const KQuery::KType& ktype);
+
+    void remove(const string& market, const string& code, const KQuery::KType& ktype,
+                Datetime start);
+
+private:
+    ImportKDataToMySQLPluginInterface* m_plugin{nullptr};
+};
+
+}  // namespace hku

hikyuu/include/hikyuu/plugin/checkdata.h

@@ -0,0 +1,20 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-12-20
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "hikyuu/DataType.h"
+#include "interface/CheckDataPluginInterface.h"
+
+namespace hku {
+
+std::pair<std::string, vector<std::string>> HKU_API checkData(const StockList& stock_list,
+                                                              const Datetime& start_date,
+                                                              const Datetime& end_date,
+                                                              const KQuery::KType& check_ktype);
+
+}

hikyuu/include/hikyuu/plugin/hkuextra.h

@@ -56,4 +56,6 @@ bool getStockExtraIndexRange(const Stock& stk, const KQuery& query, size_t& out_
 
 KDataImpPtr getKDataImp(const Stock& stk, const KQuery& query);
 
+bool canLazyLoad(const KQuery::KType& ktype);
+
 }  // namespace hku

hikyuu/include/hikyuu/plugin/interface/CheckDataPluginInterface.h

@@ -0,0 +1,25 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-05-19
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "hikyuu/Stock.h"
+#include "hikyuu/utilities/plugin/PluginBase.h"
+
+namespace hku {
+
+class CheckDataPluginInterface : public PluginBase {
+public:
+    CheckDataPluginInterface() = default;
+    virtual ~CheckDataPluginInterface() = default;
+
+    virtual std::pair<std::string, vector<std::string>> checkData(
+      const StockList& stock_list, const Datetime& start_date, const Datetime& end_date,
+      const KQuery::KType& check_ktype) = 0;
+};
+
+}  // namespace hku

hikyuu/include/hikyuu/plugin/interface/HkuExtraPluginInterface.h

@@ -35,6 +35,8 @@ public:
                                          size_t& out_end) = 0;
 
     virtual KDataImpPtr getKDataImp(const Stock& stk, const KQuery& query) = 0;
+
+    virtual bool canLazyLoad(const KQuery::KType& ktype) = 0;
 };
 
 }  // namespace hku

hikyuu/include/hikyuu/plugin/interface/ImportKDataToClickHousePluginInterface.h

@@ -0,0 +1,44 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-04-08
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "hikyuu/KRecord.h"
+#include "hikyuu/KQuery.h"
+#include "hikyuu/TimeLineRecord.h"
+#include "hikyuu/TransRecord.h"
+#include "hikyuu/utilities/plugin/PluginBase.h"
+
+namespace hku {
+
+class ImportKDataToClickHousePluginInterface : public PluginBase {
+public:
+    ImportKDataToClickHousePluginInterface() = default;
+    virtual ~ImportKDataToClickHousePluginInterface() = default;
+
+    virtual bool setConfig(const string& host, int port, const string& user, const string& pwd) = 0;
+
+    virtual Datetime getLastDatetime(const string& market, const string& code,
+                                     const KQuery::KType& ktype) = 0;
+
+    virtual void addKRecordList(const string& market, const string& code,
+                                const vector<KRecord>& krecords, const KQuery::KType& ktype) = 0;
+
+    virtual void addTimeLineList(const string& market, const string& code,
+                                 const TimeLineList& timeline) = 0;
+
+    virtual void addTransList(const string& market, const string& code,
+                              const TransRecordList& translist) = 0;
+
+    virtual void updateIndex(const string& market, const string& code,
+                             const KQuery::KType& ktype) = 0;
+
+    virtual void remove(const string& market, const string& code, const KQuery::KType& ktype,
+                        Datetime start) = 0;
+};
+
+}  // namespace hku

hikyuu/include/hikyuu/plugin/interface/ImportKDataToMySQLPluginInterface.h

@@ -0,0 +1,42 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-04-08
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "hikyuu/KRecord.h"
+#include "hikyuu/KQuery.h"
+#include "hikyuu/utilities/plugin/PluginBase.h"
+
+namespace hku {
+
+class ImportKDataToMySQLPluginInterface : public PluginBase {
+public:
+    ImportKDataToMySQLPluginInterface() = default;
+    virtual ~ImportKDataToMySQLPluginInterface() = default;
+
+    virtual bool setConfig(const string& host, int port, const string& user, const string& pwd) = 0;
+
+    virtual Datetime getLastDatetime(const string& market, const string& code,
+                                     const KQuery::KType& ktype) = 0;
+
+    virtual void addKRecordList(const string& market, const string& code,
+                                const vector<KRecord>& krecords, const KQuery::KType& ktype) = 0;
+
+    virtual void updateIndex(const string& market, const string& code,
+                             const KQuery::KType& ktype) = 0;
+
+    virtual void addTimeLineList(const string& market, const string& code,
+                                 const TimeLineList& timeline) = 0;
+
+    virtual void addTransList(const string& market, const string& code,
+                              const TransRecordList& translist) = 0;
+
+    virtual void remove(const string& market, const string& code, const KQuery::KType& ktype,
+                        Datetime start) = 0;
+};
+
+}  // namespace hku

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

@@ -13,10 +13,13 @@
 #include "DevicePluginInterface.h"
 #include "DataServerPluginInterface.h"
 #include "ImportKDataToHdf5PluginInterface.h"
+#include "ImportKDataToClickHousePluginInterface.h"
+#include "ImportKDataToMySQLPluginInterface.h"
 #include "ExtendIndicatorsPluginInterface.h"
 #include "TMReportPluginInterface.h"
 #include "DataDriverPluginInterface.h"
 #include "HkuExtraPluginInterface.h"
+#include "CheckDataPluginInterface.h"
 
 namespace hku {
 
@@ -24,9 +27,12 @@ namespace hku {
 #define HKU_PLUGIN_DEVICE "device"
 #define HKU_PLUGIN_DATASERVER "dataserver"
 #define HKU_PLUGIN_IMPORTKDATATOHDF5 "import2hdf5"
+#define HKU_PLUGIN_IMPORTKDATATOCLICKHOUSE "import2ch"
+#define HKU_PLUGIN_IMPORTKDATATOMYSQL "import2mysql"
 #define HKU_PLUGIN_EXTEND_INDICATOR "extind"
 #define HKU_PLUGIN_TMREPORT "tmreport"
 #define HKU_PLUGIN_CLICKHOUSE_DRIVER "clickhousedriver"
 #define HKU_PLUGIN_HKU_EXTRA "hkuextra"
+#define HKU_PLUGIN_CHECK_DATA "checkdata"
 
 }  // namespace hku

hikyuu/include/hikyuu/python/convert_any.h

@@ -104,12 +104,12 @@ public:
         }
 
         if (PyLong_Check(src)) {
-            int overflow;
-            long tmp = PyLong_AsLongAndOverflow(src, &overflow);
-            if (overflow == 0) {
-                value = static_cast<int>(tmp);
+            long long ll_val = PyLong_AsLongLong(src);
+            if (ll_val < std::numeric_limits<int>::min() ||
+                ll_val > std::numeric_limits<int>::max()) {
+                value = static_cast<int64_t>(ll_val);
             } else {
-                value = PyLong_AsLongLong(src);
+                value = static_cast<int>(ll_val);
             }
             return true;
         }
@@ -192,8 +192,11 @@ public:
             } else {
                 Py_RETURN_FALSE;
             }
+        } else if (x.type() == typeid(int64_t)) {
+            long long ll_val = (long long)boost::any_cast<int64_t>(x);
+            return PyLong_FromLongLong(ll_val);
         } else if (x.type() == typeid(int)) {
-            return Py_BuildValue("n", boost::any_cast<int>(x));
+            return Py_BuildValue("i", boost::any_cast<int>(x));
         } else if (x.type() == typeid(double)) {
             return Py_BuildValue("d", boost::any_cast<double>(x));
         } else if (x.type() == typeid(std::string)) {

hikyuu/include/hikyuu/strategy/Strategy.h

@@ -35,7 +35,7 @@ public:
     Strategy();
     explicit Strategy(const string& name, const string& config_file = "");
     Strategy(const vector<string>& codeList, const vector<KQuery::KType>& ktypeList,
-             const unordered_map<string, int>& preloadNum = {}, const string& name = "Strategy",
+             const unordered_map<string, int64_t>& preloadNum = {}, const string& name = "Strategy",
              const string& config_file = "");
     explicit Strategy(const StrategyContext& context, const string& name = "Strategy",
                       const string& config_file = "");

hikyuu/include/hikyuu/trade_manage/TradeRecord.h

@@ -38,7 +38,8 @@ enum BUSINESS {
     BUSINESS_RETURN_STOCK = 12,  /**< 归还股票资产 */
     BUSINESS_SELL_SHORT = 13,    /**< 卖空 */
     BUSINESS_BUY_SHORT = 14,     /**< 卖空后回补 */
-    BUSINESS_INVALID = 15        /**< 无效类型 */
+    BUSINESS_SUOGU = 15,         /**< 缩扩股 */
+    BUSINESS_INVALID = 16        /**< 无效类型 */
 };
 
 /**

hikyuu/include/hikyuu/trade_sys/allocatefunds/build_in.h

@@ -13,5 +13,6 @@
 #include "crt/AF_FixedWeight.h"
 #include "crt/AF_FixedWeightList.h"
 #include "crt/AF_MultiFactor.h"
+#include "crt/AF_FixedAmount.h"
 
 #endif /* TRADE_SYS_ALLOCATEFUNDS_BUILD_IN_H_ */

hikyuu/include/hikyuu/trade_sys/allocatefunds/crt/AF_FixedAmount.h

@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2019 hikyuu.org
+ *
+ *  Created on: 2025年12月9日
+ *      Author: stone
+ */
+
+#pragma once
+#ifndef TRADE_SYS_ALLOCATEFUNDS_CRT_AF_FIXEDAMOUNT_H_
+#define TRADE_SYS_ALLOCATEFUNDS_CRT_AF_FIXEDAMOUNT_H_
+
+#include "../AllocateFundsBase.h"
+
+namespace hku {
+
+/**
+ * @brief 固定金额分配，每个选中的资产都不能超过此金额交易
+ * @param amount 指定的固定交易金额
+ * @return AFPtr
+ * @ingroup AllocateFunds
+ */
+AFPtr HKU_API AF_FixedAmount(double amount = 20000.0);
+
+} /* namespace hku */
+
+#endif /* TRADE_SYS_ALLOCATEFUNDS_CRT_AF_FIXEDAMOUNT_H_ */

hikyuu/include/hikyuu/trade_sys/allocatefunds/imp/FixAmountFunds.h

@@ -0,0 +1,18 @@
+#pragma once
+#include "../AllocateFundsBase.h"
+
+namespace hku {
+
+class FixedAmountFunds : public AllocateFundsBase {
+    ALLOCATEFUNDS_IMP(FixedAmountFunds)
+    ALLOCATEFUNDS_NO_PRIVATE_MEMBER_SERIALIZATION
+
+public:
+    FixedAmountFunds();
+    virtual ~FixedAmountFunds();
+    virtual void _checkParam(const string& name) const override;
+};
+
+} /* namespace hku */
+
+

hikyuu/include/hikyuu/utilities/Log.h

@@ -343,13 +343,12 @@ std::shared_ptr<spdlog::logger> HKU_UTILS_API getHikyuuLogger();
     }
 
 /** 用于 catch (...) 中打印，减少编译后代码大小 */
-extern std::string g_unknown_error_msg;
-#define HKU_THROW_UNKNOWN HKU_THROW("{}", g_unknown_error_msg);
-#define HKU_TRACE_UNKNOWN HKU_TRACE("{}", g_unknown_error_msg)
-#define HKU_DEBUG_UNKNOWN HKU_DEBUG("{}", g_unknown_error_msg)
-#define HKU_INFO_UNKNOWN HKU_INFO("{}", g_unknown_error_msg)
-#define HKU_ERROR_UNKNOWN HKU_ERROR("{}", g_unknown_error_msg)
-#define HKU_FATAL_UNKNOWN HKU_FATAL("{}", g_unknown_error_msg)
+#define HKU_THROW_UNKNOWN HKU_THROW("Unknown error!")
+#define HKU_TRACE_UNKNOWN HKU_TRACE("Unknown error!")
+#define HKU_DEBUG_UNKNOWN HKU_DEBUG("Unknown error!")
+#define HKU_INFO_UNKNOWN HKU_INFO("Unknown error!");
+#define HKU_ERROR_UNKNOWN HKU_ERROR("Unknown error!");
+#define HKU_FATAL_UNKNOWN HKU_FATAL("Unknown error!");
 
 #if CPP_STANDARD >= CPP_STANDARD_20
 #define CLASS_LOGGER_IMP(cls) \

hikyuu/include/hikyuu/utilities/Parameter.h

@@ -503,6 +503,23 @@ inline void Parameter::set(const string& name, const boost::any& value) {
     m_params[name] = value;
 }
 
+template <>
+inline int64_t Parameter::get(const string& name) const {
+    param_map_t::const_iterator iter;
+    iter = m_params.find(name);
+    if (iter == m_params.end()) {
+        throw std::out_of_range("out_of_range in Parameter::get : " + name);
+    }
+    try {
+        if (iter->second.type() == typeid(int)) {
+            return boost::any_cast<int>(iter->second);
+        }
+        return boost::any_cast<int64_t>(iter->second);
+    } catch (...) {
+        throw std::runtime_error("failed conversion param: " + name);
+    }
+}
+
 HKU_API bool operator==(const Parameter&, const Parameter&);
 HKU_API bool operator!=(const Parameter&, const Parameter&);
 HKU_API bool operator<(const Parameter&, const Parameter&);

hikyuu/include/hikyuu/utilities/config.h

@@ -6,33 +6,61 @@
 
 // clang-format off
 
+#ifndef HKU_ENABLE_MYSQL
 #define HKU_ENABLE_MYSQL 1
 #if HKU_ENABLE_MYSQL && HKU_OS_WINDOWS
 #ifndef NOMINMAX
 #define NOMINMAX
 #endif
 #endif
+#endif
 
+#ifndef HKU_ENABLE_SQLITE
 #define HKU_ENABLE_SQLITE 1
+#endif
+#ifndef HKU_ENABLE_SQLCIPHER
 #define HKU_ENABLE_SQLCIPHER 0
+#endif
+#ifndef HKU_SQL_TRACE
 /* #define HKU_SQL_TRACE 0 */
+#endif
 
+#ifndef HKU_SUPPORT_DATETIME
 #define HKU_SUPPORT_DATETIME 1
+#endif
 
+#ifndef HKU_ENABLE_INI_PARSER
 #define HKU_ENABLE_INI_PARSER 1
+#endif
 
+#ifndef HKU_ENABLE_STACK_TRACE
 #define HKU_ENABLE_STACK_TRACE 0
+#endif
 
+#ifndef HKU_CLOSE_SPEND_TIME
 #define HKU_CLOSE_SPEND_TIME 0
+#endif
 
+#ifndef HKU_USE_SPDLOG_ASYNC_LOGGER
 #define HKU_USE_SPDLOG_ASYNC_LOGGER 0
+#endif
+#ifndef HKU_LOG_ACTIVE_LEVEL
 #define HKU_LOG_ACTIVE_LEVEL 2
+#endif
 
+#ifndef HKU_ENABLE_HTTP_CLIENT
 #define HKU_ENABLE_HTTP_CLIENT 1
+#endif
+#ifndef HKU_ENABLE_HTTP_CLIENT_SSL
 #define HKU_ENABLE_HTTP_CLIENT_SSL 0
+#endif
+#ifndef HKU_ENABLE_HTTP_CLIENT_ZIP
 #define HKU_ENABLE_HTTP_CLIENT_ZIP 0
+#endif
 
+#ifndef HKU_ENABLE_NODE
 #define HKU_ENABLE_NODE 1
+#endif
 
 // clang-format on
 

hikyuu/include/hikyuu/utilities/plugin/PluginBase.h

@@ -12,6 +12,7 @@
 #include <string>
 #include "hikyuu/utilities/config.h"
 #include "hikyuu/utilities/osdef.h"
+#include "hikyuu/utilities/Log.h"
 
 namespace hku {
 
@@ -35,12 +36,26 @@ public:
 #if HKU_OS_WINDOWS
 #define HKU_PLUGIN_DEFINE(plugin)                                      \
     extern "C" __declspec(dllexport) hku::PluginBase* createPlugin() { \
-        return new plugin();                                           \
+        try {                                                          \
+            return new plugin();                                       \
+        } catch (const std::exception& e) {                            \
+            HKU_ERROR("{}", e.what());                                 \
+            return nullptr;                                            \
+        } catch (...) {                                                \
+            return nullptr;                                            \
+        }                                                              \
     }
 #else
 #define HKU_PLUGIN_DEFINE(plugin)                \
     extern "C" hku::PluginBase* createPlugin() { \
-        return new plugin();                     \
+        try {                                    \
+            return new plugin();                 \
+        } catch (const std::exception& e) {      \
+            HKU_ERROR("{}", e.what());           \
+            return nullptr;                      \
+        } catch (...) {                          \
+            return nullptr;                      \
+        }                                        \
     }
 #endif
 

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

@@ -10,7 +10,7 @@
 #include <string>
 #include <memory>
 #include <unordered_map>
-#include <mutex>
+#include <shared_mutex>
 #include "hikyuu/utilities/Log.h"
 #include "hikyuu/utilities/plugin/PluginLoader.h"
 
@@ -38,35 +38,54 @@ public:
     }
 
     template <typename PluginInterfaceT>
-    PluginInterfaceT* getPlugin(const std::string& pluginname) noexcept;
+    PluginInterfaceT* getPlugin(const std::string& pluginname) noexcept {
+        PluginInterfaceT* ret{nullptr};
+        try {
+            {
+                std::shared_lock<std::shared_mutex> read_lock(m_mutex);
+                auto it = m_plugins.find(pluginname);
+                if (it != m_plugins.end()) {
+                    ret = it->second->instance<PluginInterfaceT>();
+                    return ret;
+                }
+            }
 
-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;
+            std::unique_ptr<PluginLoader> loader = std::make_unique<PluginLoader>(m_plugin_path);
+            if (!loader->load(pluginname)) {
+                HKU_DEBUG("Load plugin {} failed: {}", pluginname, loader->getFileName(pluginname));
+                return ret;
+            }
+
+            {
+                std::unique_lock<std::shared_mutex> write_lock(m_mutex);
+                auto it = m_plugins.find(pluginname);
+                if (it != m_plugins.end()) {
+                    // 复用已插入的插件实例
+                    ret = it->second->instance<PluginInterfaceT>();
+                } else {
+                    // 插入新加载的插件
+                    auto [it, success] =
+                      m_plugins.insert(std::make_pair(pluginname, std::move(loader)));
+                    if (success) {
+                        ret = it->second->instance<PluginInterfaceT>();
+                    }
+                }
+                return ret;
             }
+        } catch (const std::exception& e) {
+            HKU_ERROR("Load plugin {} failed: {}", pluginname, e.what());
+            ret = nullptr;
+        } catch (...) {
+            HKU_ERROR("Load plugin {} failed: unknown exception", pluginname);
+            ret = nullptr;
         }
-        return m_plugins.end();
+        return ret;
     }
 
 private:
     std::string m_plugin_path;
     std::unordered_map<std::string, std::unique_ptr<PluginLoader>> m_plugins;
-    std::mutex m_mutex;
+    std::shared_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/utilities/thread/GlobalStealThreadPool.h

@@ -218,12 +218,11 @@ public:
             }
         }
 
+        m_done = true;
         m_master_work_queue.clear();
         for (size_t i = 0; i < m_worker_num; i++) {
             m_queues[i]->clear();
         }
-
-        m_done = true;
     }
 
 private:

hikyuu/include/hikyuu/utilities/thread/GlobalThreadPool.h

@@ -174,8 +174,8 @@ public:
             }
         }
 
-        m_master_work_queue.clear();
         m_done = true;
+        m_master_work_queue.clear();
     }
 
 private: