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

hikyuu/include/hikyuu/indicator_talib/imp/TaStochf.h

@@ -13,12 +13,10 @@ namespace hku {
 
 class TaStochf : public IndicatorImp {
     INDICATOR_IMP(TaStochf)
-    INDICATOR_NEED_CONTEXT
     INDICATOR_IMP_NO_PRIVATE_MEMBER_SERIALIZATION
 
 public:
     TaStochf();
-    explicit TaStochf(const KData&, int fastk_n, int fastd_n, int fastd_matype);
     virtual ~TaStochf() = default;
     virtual void _checkParam(const string& name) const override;
 };

hikyuu/include/hikyuu/indicator_talib/imp/TaUltosc.h

@@ -13,12 +13,10 @@ namespace hku {
 
 class TaUltosc : public IndicatorImp {
     INDICATOR_IMP(TaUltosc)
-    INDICATOR_NEED_CONTEXT
     INDICATOR_IMP_NO_PRIVATE_MEMBER_SERIALIZATION
 
 public:
     TaUltosc();
-    explicit TaUltosc(const KData&, int n1, int n2, int n3);
     virtual ~TaUltosc() = default;
     virtual void _checkParam(const string& name) const override;
 };

hikyuu/include/hikyuu/indicator_talib/imp/ta_defines.h

@@ -22,7 +22,8 @@
 
 #define TA_IN1_OUT_DYN_DEF(func)                                     \
     class Cls_##func : public IndicatorImp {                         \
-        INDICATOR_IMP_SUPPORT_DYNAMIC_STEP(Cls_##func)               \
+        INDICATOR_IMP(Cls_##func)                                    \
+        INDICATOR_IMP_SUPPORT_DYNAMIC_CYCLE                          \
         INDICATOR_IMP_NO_PRIVATE_MEMBER_SERIALIZATION                \
                                                                      \
     public:                                                          \
@@ -56,7 +57,6 @@
 #define TA_K_OUT_DEF(func)                            \
     class Cls_##func : public IndicatorImp {          \
         INDICATOR_IMP(Cls_##func)                     \
-        INDICATOR_NEED_CONTEXT                        \
         INDICATOR_IMP_NO_PRIVATE_MEMBER_SERIALIZATION \
     public:                                           \
         Cls_##func();                                 \
@@ -67,7 +67,6 @@
 #define TA_K_OUT_N_DEF(func)                                         \
     class Cls_##func : public IndicatorImp {                         \
         INDICATOR_IMP(Cls_##func)                                    \
-        INDICATOR_NEED_CONTEXT                                       \
         INDICATOR_IMP_NO_PRIVATE_MEMBER_SERIALIZATION                \
     public:                                                          \
         Cls_##func();                                                \
@@ -79,7 +78,6 @@
 #define TA_K_OUT_P_D_DEF(func)                                       \
     class Cls_##func : public IndicatorImp {                         \
         INDICATOR_IMP(Cls_##func)                                    \
-        INDICATOR_NEED_CONTEXT                                       \
         INDICATOR_IMP_NO_PRIVATE_MEMBER_SERIALIZATION                \
     public:                                                          \
         Cls_##func();                                                \

hikyuu/include/hikyuu/indicator_talib/imp/ta_imp.h

@@ -113,7 +113,7 @@
                                                                                            \
     void Cls_##func::_dyn_run_one_step(const Indicator &ind, size_t curPos, size_t step) { \
         int back = func_lookback(step);                                                    \
-        HKU_IF_RETURN(back<0 || back + ind.discard()> curPos, void());                     \
+        HKU_IF_RETURN(back < 0 || back + ind.discard() > curPos, void());                  \
                                                                                            \
         std::unique_ptr<double[]> buf = std::make_unique<double[]>(curPos);                \
         auto const *src = ind.data();                                                      \
@@ -181,7 +181,7 @@
                                                                                            \
     void Cls_##func::_dyn_run_one_step(const Indicator &ind, size_t curPos, size_t step) { \
         int back = func_lookback(step);                                                    \
-        HKU_IF_RETURN(back<0 || back + ind.discard()> curPos, void());                     \
+        HKU_IF_RETURN(back < 0 || back + ind.discard() > curPos, void());                  \
                                                                                            \
         std::unique_ptr<int[]> buf = std::make_unique<int[]>(curPos);                      \
         auto const *src = ind.data();                                                      \
@@ -283,7 +283,7 @@
                                                                                            \
     void Cls_##func::_dyn_run_one_step(const Indicator &ind, size_t curPos, size_t step) { \
         int back = func_lookback(step);                                                    \
-        HKU_IF_RETURN(back<0 || back + ind.discard()> curPos, void());                     \
+        HKU_IF_RETURN(back < 0 || back + ind.discard() > curPos, void());                  \
                                                                                            \
         std::unique_ptr<int[]> buf = std::make_unique<int[]>(2 * curPos);                  \
         int *buf0 = buf.get();                                                             \
@@ -350,7 +350,7 @@
                                                                                            \
     void Cls_##func::_dyn_run_one_step(const Indicator &ind, size_t curPos, size_t step) { \
         int back = func_lookback(step);                                                    \
-        HKU_IF_RETURN(back<0 || back + ind.discard()> curPos, void());                     \
+        HKU_IF_RETURN(back < 0 || back + ind.discard() > curPos, void());                  \
                                                                                            \
         std::unique_ptr<double[]> buf = std::make_unique<double[]>(2 * curPos);            \
         double *dst0 = buf.get();                                                          \
@@ -418,7 +418,7 @@
                                                                                            \
     void Cls_##func::_dyn_run_one_step(const Indicator &ind, size_t curPos, size_t step) { \
         int back = func_lookback(step);                                                    \
-        HKU_IF_RETURN(back<0 || back + ind.discard()> curPos, void());                     \
+        HKU_IF_RETURN(back < 0 || back + ind.discard() > curPos, void());                  \
                                                                                            \
         std::unique_ptr<double[]> buf = std::make_unique<double[]>(3 * curPos);            \
         double *dst0 = buf.get();                                                          \
@@ -558,11 +558,8 @@
     }
 
 #define TA_OHLC_OUT1_IMP(func, func_lookback)                                           \
-    Cls_##func::Cls_##func() : IndicatorImp(#func, 1) {}                                \
-                                                                                        \
-    Cls_##func::Cls_##func(const KData &k) : IndicatorImp(#func, 1) {                   \
-        setParam<KData>("kdata", k);                                                    \
-        Cls_##func::_calculate(Indicator());                                            \
+    Cls_##func::Cls_##func() : IndicatorImp(#func, 1) {                                 \
+        m_need_context = true;                                                          \
     }                                                                                   \
                                                                                         \
     void Cls_##func::_calculate(const Indicator &data) {                                \
@@ -607,15 +604,14 @@
     }                                                                                   \
                                                                                         \
     Indicator HKU_API func(const KData &k) {                                            \
-        return Indicator(make_shared<Cls_##func>(k));                                   \
+        auto p = make_shared<Cls_##func>();                                             \
+        p->setContext(k);                                                               \
+        return Indicator(p);                                                            \
     }
 
 #define TA_OHLC_OUT1_INT_IMP(func, func_lookback)                                       \
-    Cls_##func::Cls_##func() : IndicatorImp(#func, 1) {}                                \
-                                                                                        \
-    Cls_##func::Cls_##func(const KData &k) : IndicatorImp(#func, 1) {                   \
-        setParam<KData>("kdata", k);                                                    \
-        Cls_##func::_calculate(Indicator());                                            \
+    Cls_##func::Cls_##func() : IndicatorImp(#func, 1) {                                 \
+        m_need_context = true;                                                          \
     }                                                                                   \
                                                                                         \
     void Cls_##func::_calculate(const Indicator &data) {                                \
@@ -665,21 +661,18 @@
     }                                                                                   \
                                                                                         \
     Indicator HKU_API func(const KData &k) {                                            \
-        return Indicator(make_shared<Cls_##func>(k));                                   \
+        auto p = make_shared<Cls_##func>();                                             \
+        p->setContext(k);                                                               \
+        return Indicator(p);                                                            \
     }
 
 #define TA_OHLC_OUT1_INT_P1_D_IMP(func, func_lookback, param1, param1_value, param1_min,          \
                                   param1_max)                                                     \
     Cls_##func::Cls_##func() : IndicatorImp(#func, 1) {                                           \
+        m_need_context = true;                                                                    \
         setParam<double>(#param1, param1_value);                                                  \
     }                                                                                             \
                                                                                                   \
-    Cls_##func::Cls_##func(const KData &k, double p) : IndicatorImp(#func, 1) {                   \
-        setParam<KData>("kdata", k);                                                              \
-        setParam<double>(#param1, p);                                                             \
-        Cls_##func::_calculate(Indicator());                                                      \
-    }                                                                                             \
-                                                                                                  \
     void Cls_##func::_checkParam(const string &name) const {                                      \
         if (name == #param1) {                                                                    \
             double p = getParam<double>(#param1);                                                 \
@@ -737,15 +730,15 @@
     }                                                                                             \
                                                                                                   \
     Indicator HKU_API func(const KData &k, double p) {                                            \
-        return Indicator(make_shared<Cls_##func>(k, p));                                          \
+        auto ptr = make_shared<Cls_##func>();                                                     \
+        ptr->setParam<double>(#param1, p);                                                        \
+        ptr->setContext(k);                                                                       \
+        return Indicator(ptr);                                                                    \
     }
 
 #define TA_HLCV_OUT1_IMP(func, func_lookback)                                           \
-    Cls_##func::Cls_##func() : IndicatorImp(#func, 1) {}                                \
-                                                                                        \
-    Cls_##func::Cls_##func(const KData &k) : IndicatorImp(#func, 1) {                   \
-        setParam<KData>("kdata", k);                                                    \
-        Cls_##func::_calculate(Indicator());                                            \
+    Cls_##func::Cls_##func() : IndicatorImp(#func, 1) {                                 \
+        m_need_context = true;                                                          \
     }                                                                                   \
                                                                                         \
     void Cls_##func::_calculate(const Indicator &data) {                                \
@@ -790,15 +783,14 @@
     }                                                                                   \
                                                                                         \
     Indicator HKU_API func(const KData &k) {                                            \
-        return Indicator(make_shared<Cls_##func>(k));                                   \
+        auto ptr = make_shared<Cls_##func>();                                           \
+        ptr->setContext(k);                                                             \
+        return Indicator(ptr);                                                          \
     }
 
 #define TA_HL_OUT1_IMP(func, func_lookback)                                                \
-    Cls_##func::Cls_##func() : IndicatorImp(#func, 1) {}                                   \
-                                                                                           \
-    Cls_##func::Cls_##func(const KData &k) : IndicatorImp(#func, 1) {                      \
-        setParam<KData>("kdata", k);                                                       \
-        Cls_##func::_calculate(Indicator());                                               \
+    Cls_##func::Cls_##func() : IndicatorImp(#func, 1) {                                    \
+        m_need_context = true;                                                             \
     }                                                                                      \
                                                                                            \
     void Cls_##func::_calculate(const Indicator &data) {                                   \
@@ -838,15 +830,14 @@
     }                                                                                      \
                                                                                            \
     Indicator HKU_API func(const KData &k) {                                               \
-        return Indicator(make_shared<Cls_##func>(k));                                      \
+        auto ptr = make_shared<Cls_##func>();                                              \
+        ptr->setContext(k);                                                                \
+        return Indicator(ptr);                                                             \
     }
 
 #define TA_CV_OUT1_IMP(func, func_lookback)                                                 \
-    Cls_##func::Cls_##func() : IndicatorImp(#func, 1) {}                                    \
-                                                                                            \
-    Cls_##func::Cls_##func(const KData &k) : IndicatorImp(#func, 1) {                       \
-        setParam<KData>("kdata", k);                                                        \
-        Cls_##func::_calculate(Indicator());                                                \
+    Cls_##func::Cls_##func() : IndicatorImp(#func, 1) {                                     \
+        m_need_context = true;                                                              \
     }                                                                                       \
                                                                                             \
     void Cls_##func::_calculate(const Indicator &data) {                                    \
@@ -886,15 +877,14 @@
     }                                                                                       \
                                                                                             \
     Indicator HKU_API func(const KData &k) {                                                \
-        return Indicator(make_shared<Cls_##func>(k));                                       \
+        auto ptr = make_shared<Cls_##func>();                                               \
+        ptr->setContext(k);                                                                 \
+        return Indicator(ptr);                                                              \
     }
 
 #define TA_HLC_OUT1_IMP(func, func_lookback)                                                      \
-    Cls_##func::Cls_##func() : IndicatorImp(#func, 1) {}                                          \
-                                                                                                  \
-    Cls_##func::Cls_##func(const KData &k) : IndicatorImp(#func, 1) {                             \
-        setParam<KData>("kdata", k);                                                              \
-        Cls_##func::_calculate(Indicator());                                                      \
+    Cls_##func::Cls_##func() : IndicatorImp(#func, 1) {                                           \
+        m_need_context = true;                                                                    \
     }                                                                                             \
                                                                                                   \
     void Cls_##func::_calculate(const Indicator &data) {                                          \
@@ -936,20 +926,17 @@
     }                                                                                             \
                                                                                                   \
     Indicator HKU_API func(const KData &k) {                                                      \
-        return Indicator(make_shared<Cls_##func>(k));                                             \
+        auto ptr = make_shared<Cls_##func>();                                                     \
+        ptr->setContext(k);                                                                       \
+        return Indicator(ptr);                                                                    \
     }
 
 #define TA_HLC_OUT1_N_IMP(func, func_lookback, period, period_min, period_max)          \
     Cls_##func::Cls_##func() : IndicatorImp(#func, 1) {                                 \
+        m_need_context = true;                                                          \
         setParam<int>("n", period);                                                     \
     }                                                                                   \
                                                                                         \
-    Cls_##func::Cls_##func(const KData &k, int n) : IndicatorImp(#func, 1) {            \
-        setParam<KData>("kdata", k);                                                    \
-        setParam<int>("n", n);                                                          \
-        Cls_##func::_calculate(Indicator());                                            \
-    }                                                                                   \
-                                                                                        \
     void Cls_##func::_checkParam(const string &name) const {                            \
         if (name == "n") {                                                              \
             int n = getParam<int>("n");                                                 \
@@ -1001,20 +988,18 @@
     }                                                                                   \
                                                                                         \
     Indicator HKU_API func(const KData &k, int n) {                                     \
-        return Indicator(make_shared<Cls_##func>(k, n));                                \
+        auto p = make_shared<Cls_##func>();                                             \
+        p->setParam<int>("n", n);                                                       \
+        p->setContext(k);                                                               \
+        return Indicator(p);                                                            \
     }
 
 #define TA_HLCV_OUT1_N_IMP(func, func_lookback, period, period_min, period_max)         \
     Cls_##func::Cls_##func() : IndicatorImp(#func, 1) {                                 \
+        m_need_context = true;                                                          \
         setParam<int>("n", period);                                                     \
     }                                                                                   \
                                                                                         \
-    Cls_##func::Cls_##func(const KData &k, int n) : IndicatorImp(#func, 1) {            \
-        setParam<KData>("kdata", k);                                                    \
-        setParam<int>("n", n);                                                          \
-        Cls_##func::_calculate(Indicator());                                            \
-    }                                                                                   \
-                                                                                        \
     void Cls_##func::_checkParam(const string &name) const {                            \
         if (name == "n") {                                                              \
             int n = getParam<int>("n");                                                 \
@@ -1069,20 +1054,18 @@
     }                                                                                   \
                                                                                         \
     Indicator HKU_API func(const KData &k, int n) {                                     \
-        return Indicator(make_shared<Cls_##func>(k, n));                                \
+        auto p = make_shared<Cls_##func>();                                             \
+        p->setParam<int>("n", n);                                                       \
+        p->setContext(k);                                                               \
+        return Indicator(p);                                                            \
     }
 
 #define TA_HL_OUT1_N_IMP(func, func_lookback, period, period_min, period_max)                 \
     Cls_##func::Cls_##func() : IndicatorImp(#func, 1) {                                       \
+        m_need_context = true;                                                                \
         setParam<int>("n", period);                                                           \
     }                                                                                         \
                                                                                               \
-    Cls_##func::Cls_##func(const KData &k, int n) : IndicatorImp(#func, 1) {                  \
-        setParam<KData>("kdata", k);                                                          \
-        setParam<int>("n", n);                                                                \
-        Cls_##func::_calculate(Indicator());                                                  \
-    }                                                                                         \
-                                                                                              \
     void Cls_##func::_checkParam(const string &name) const {                                  \
         if (name == "n") {                                                                    \
             int n = getParam<int>("n");                                                       \
@@ -1131,20 +1114,18 @@
     }                                                                                         \
                                                                                               \
     Indicator HKU_API func(const KData &k, int n) {                                           \
-        return Indicator(make_shared<Cls_##func>(k, n));                                      \
+        auto p = make_shared<Cls_##func>();                                                   \
+        p->setParam<int>("n", n);                                                             \
+        p->setContext(k);                                                                     \
+        return Indicator(p);                                                                  \
     }
 
 #define TA_HL_OUT2_N_IMP(func, func_lookback, period, period_min, period_max)                 \
     Cls_##func::Cls_##func() : IndicatorImp(#func, 2) {                                       \
+        m_need_context = true;                                                                \
         setParam<int>("n", period);                                                           \
     }                                                                                         \
                                                                                               \
-    Cls_##func::Cls_##func(const KData &k, int n) : IndicatorImp(#func, 2) {                  \
-        setParam<KData>("kdata", k);                                                          \
-        setParam<int>("n", n);                                                                \
-        Cls_##func::_calculate(Indicator());                                                  \
-    }                                                                                         \
-                                                                                              \
     void Cls_##func::_checkParam(const string &name) const {                                  \
         if (name == "n") {                                                                    \
             int n = getParam<int>("n");                                                       \
@@ -1195,20 +1176,18 @@
     }                                                                                         \
                                                                                               \
     Indicator HKU_API func(const KData &k, int n) {                                           \
-        return Indicator(make_shared<Cls_##func>(k, n));                                      \
+        auto p = make_shared<Cls_##func>();                                                   \
+        p->setParam<int>("n", n);                                                             \
+        p->setContext(k);                                                                     \
+        return Indicator(p);                                                                  \
     }
 
 #define TA_HLC_OUT3_N_IMP(func, func_lookback, period, period_min, period_max)          \
     Cls_##func::Cls_##func() : IndicatorImp(#func, 3) {                                 \
+        m_need_context = true;                                                          \
         setParam<int>("n", period);                                                     \
     }                                                                                   \
                                                                                         \
-    Cls_##func::Cls_##func(const KData &k, int n) : IndicatorImp(#func, 3) {            \
-        setParam<KData>("kdata", k);                                                    \
-        setParam<int>("n", n);                                                          \
-        Cls_##func::_calculate(Indicator());                                            \
-    }                                                                                   \
-                                                                                        \
     void Cls_##func::_checkParam(const string &name) const {                            \
         if (name == "n") {                                                              \
             int n = getParam<int>("n");                                                 \
@@ -1262,20 +1241,18 @@
     }                                                                                   \
                                                                                         \
     Indicator HKU_API func(const KData &k, int n) {                                     \
-        return Indicator(make_shared<Cls_##func>(k, n));                                \
+        auto p = make_shared<Cls_##func>();                                             \
+        p->setParam<int>("n", n);                                                       \
+        p->setContext(k);                                                               \
+        return Indicator(p);                                                            \
     }
 
 #define TA_OC_OUT1_N_IMP(func, func_lookback, period, period_min, period_max)                   \
     Cls_##func::Cls_##func() : IndicatorImp(#func, 1) {                                         \
+        m_need_context = true;                                                                  \
         setParam<int>("n", period);                                                             \
     }                                                                                           \
                                                                                                 \
-    Cls_##func::Cls_##func(const KData &k, int n) : IndicatorImp(#func, 1) {                    \
-        setParam<KData>("kdata", k);                                                            \
-        setParam<int>("n", n);                                                                  \
-        Cls_##func::_calculate(Indicator());                                                    \
-    }                                                                                           \
-                                                                                                \
     void Cls_##func::_checkParam(const string &name) const {                                    \
         if (name == "n") {                                                                      \
             int n = getParam<int>("n");                                                         \
@@ -1324,5 +1301,8 @@
     }                                                                                           \
                                                                                                 \
     Indicator HKU_API func(const KData &k, int n) {                                             \
-        return Indicator(make_shared<Cls_##func>(k, n));                                        \
+        auto p = make_shared<Cls_##func>();                                                     \
+        p->setParam<int>("n", n);                                                               \
+        p->setContext(k);                                                                       \
+        return Indicator(p);                                                                    \
     }

hikyuu/include/hikyuu/plugin/extind.h

@@ -191,6 +191,9 @@ Indicator HKU_API AGG_VAR(const Indicator& ind, const KQuery::KType& ktype = KQu
 Indicator HKU_API AGG_QUANTILE(const Indicator& ind, const KQuery::KType& ktype = KQuery::MIN,
                                bool fill_null = false, int unit = 1, double quantile = 0.75);
 
+Indicator HKU_API AGG_VWAP(const KQuery::KType& ktype = KQuery::MIN, bool fill_null = false,
+                           int unit = 1);
+
 using agg_func_t = std::function<double(const DatetimeList& src_ds, const Indicator::value_t* src,
                                         size_t group_start, size_t group_last)>;
 Indicator HKU_API AGG_FUNC(const Indicator& ind, agg_func_t agg_func,

hikyuu/include/hikyuu/plugin/hkuextra.h

@@ -37,6 +37,8 @@ void HKU_API registerExtraKType(const string& ktype, const string& basetype, int
  */
 void HKU_API releaseExtraKType();
 
+void HKU_API enableKDataCache(bool enable);
+
 //-------------------------------
 // 以下函数为内部使用，无需引出
 //-------------------------------

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

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

hikyuu/include/hikyuu/python/pybind_utils.h

@@ -10,6 +10,7 @@
 #define HIKYUU_PYTHON_BIND_UTILS_H
 
 #include <hikyuu/config.h>
+#include <hikyuu/Stock.h>
 #include <pybind11/pybind11.h>
 
 #include <pybind11/operators.h>
@@ -100,11 +101,6 @@ public:
             return std::shared_ptr<classname>(keep_python_state_alive, ptr);     \
         }                                                                        \
         return this->_clone();                                                   \
-    }                                                                            \
-                                                                                 \
-protected:                                                                       \
-    inline bool isPythonObject() const override {                                \
-        return true;                                                             \
     }
 
 // 用于检查以 py::object 方式传递的函数参数个数是否符合预期
@@ -124,6 +120,27 @@ inline bool check_pyfunction_arg_num(const py::object& func, size_t arg_num) {
  */
 size_t utf8_to_utf32(const std::string& utf8_str, int32_t* out, size_t out_len) noexcept;
 
+// 从 python 对象获取 StockList 列表
+inline StockList get_stock_list_from_python(const py::object& stks) {
+    StockList ret;
+    HKU_IF_RETURN(stks.is_none(), ret);
+
+    if (py::isinstance<StockList>(stks)) {
+        ret = stks.cast<StockList>();
+    } else if (py::isinstance<Block>(stks)) {
+        const auto& blk = stks.cast<Block&>();
+        ret = blk.getStockList();
+    } else if (py::isinstance<StockManager>(stks)) {
+        const auto& sm = stks.cast<StockManager&>();
+        ret = sm.getStockList();
+    } else if (py::isinstance<py::sequence>(stks)) {
+        ret = python_list_to_vector<Stock>(stks);
+    } else {
+        HKU_THROW("Failed get StockList! Input stks must be Block, sm or sequenc(Stock)!");
+    }
+    return ret;
+}
+
 }  // namespace hku
 
 #endif  // HIKYUU_PYTHON_BIND_UTILS_H

hikyuu/include/hikyuu/trade_manage/TradeCostBase.h

@@ -107,12 +107,13 @@ public:
     virtual TradeCostPtr _clone() = 0;
 
 protected:
-    virtual bool isPythonObject() const {
-        return false;
+    bool isPythonObject() const noexcept {
+        return m_is_python_object;
     }
 
-private:
+protected:
     string m_name;
+    bool m_is_python_object{false};
 
 //============================================
 // 序列化支持
@@ -123,6 +124,7 @@ private:
     template <class Archive>
     void serialize(Archive& ar, const unsigned int version) {
         ar& BOOST_SERIALIZATION_NVP(m_name);
+        ar& BOOST_SERIALIZATION_NVP(m_is_python_object);
         ar& BOOST_SERIALIZATION_NVP(m_params);
     }
 #endif /* HKU_SUPPORT_SERIALIZATION */

hikyuu/include/hikyuu/trade_manage/TradeManagerBase.h

@@ -37,6 +37,8 @@ class HKU_API TradeManagerBase : public enable_shared_from_this<TradeManagerBase
 public:
     TradeManagerBase() : TradeManagerBase("", TC_Zero()) {}
 
+    explicit TradeManagerBase(const string& name) : TradeManagerBase(name, TC_Zero()) {}
+
     TradeManagerBase(const string& name, const TradeCostPtr& costFunc)
     : m_name(name), m_costfunc(costFunc), m_broker_last_datetime(Datetime::now()) {
         setParam<int>("precision", 2);  // 计算精度
@@ -169,6 +171,7 @@ public:
         HKU_CHECK(p, "Invalid ptr from _clone!");
         p->m_params = m_params;
         p->m_name = m_name;
+        p->m_is_python_object = m_is_python_object;
         p->m_broker_last_datetime = m_broker_last_datetime;
         p->m_costfunc = m_costfunc;
         p->m_broker_list = m_broker_list;
@@ -769,9 +772,8 @@ public:
     std::vector<std::pair<Datetime, double>> getProfitPercentYearly(
       const Datetime& datetime = Datetime::now());
 
-protected:
-    virtual bool isPythonObject() const {
-        return false;
+    bool isPythonObject() const noexcept {
+        return m_is_python_object;
     }
 
 protected:
@@ -781,6 +783,8 @@ protected:
     Datetime m_broker_last_datetime;     // 订单代理最近一次执行操作的时刻,当前启动运行时间
     list<OrderBrokerPtr> m_broker_list;  // 订单代理列表
 
+    bool m_is_python_object{false};
+
 //============================================
 // 序列化支持
 //============================================
@@ -794,6 +798,7 @@ private:
         ar& BOOST_SERIALIZATION_NVP(m_costfunc);
         ar& BOOST_SERIALIZATION_NVP(m_broker_last_datetime);
         ar& BOOST_SERIALIZATION_NVP(m_broker_list);
+        ar& BOOST_SERIALIZATION_NVP(m_is_python_object);
     }
 
     template <class Archive>
@@ -803,6 +808,7 @@ private:
         ar& BOOST_SERIALIZATION_NVP(m_costfunc);
         ar& BOOST_SERIALIZATION_NVP(m_broker_last_datetime);
         ar& BOOST_SERIALIZATION_NVP(m_broker_list);
+        ar& BOOST_SERIALIZATION_NVP(m_is_python_object);
     }
 
     BOOST_SERIALIZATION_SPLIT_MEMBER()

hikyuu/include/hikyuu/trade_sys/allocatefunds/AllocateFundsBase.h

@@ -101,9 +101,8 @@ public:
     static void adjustWeight(SystemWeightList& sw_list, double can_allocate_weight,
                              bool auto_adjust, bool ignore_zero);
 
-protected:
-    virtual bool isPythonObject() const {
-        return false;
+    bool isPythonObject() const noexcept {
+        return m_is_python_object;
     }
 
 private:
@@ -117,6 +116,9 @@ private:
     void _adjust_without_running(const Datetime& date, const SystemWeightList& se_list,
                                  const std::unordered_set<SYSPtr>& running_list);
 
+protected:
+    bool m_is_python_object{false};
+
 private:
     string m_name;    // 组件名称
     KQuery m_query;   // 查询条件
@@ -131,6 +133,7 @@ private:
     friend class boost::serialization::access;
     template <class Archive>
     void save(Archive& ar, const unsigned int version) const {
+        ar& BOOST_SERIALIZATION_NVP(m_is_python_object);
         ar& BOOST_SERIALIZATION_NVP(m_name);
         ar& BOOST_SERIALIZATION_NVP(m_params);
         ar& BOOST_SERIALIZATION_NVP(m_query);
@@ -138,6 +141,7 @@ private:
 
     template <class Archive>
     void load(Archive& ar, const unsigned int version) {
+        ar& BOOST_SERIALIZATION_NVP(m_is_python_object);
         ar& BOOST_SERIALIZATION_NVP(m_name);
         ar& BOOST_SERIALIZATION_NVP(m_params);
         ar& BOOST_SERIALIZATION_NVP(m_query);
@@ -148,7 +152,7 @@ private:
 };
 
 #if HKU_SUPPORT_SERIALIZATION
-BOOST_SERIALIZATION_ASSUME_ABSTRACT(SelectorBase)
+BOOST_SERIALIZATION_ASSUME_ABSTRACT(AllocateFundsBase)
 #endif
 
 #if HKU_SUPPORT_SERIALIZATION