hikyuu 2.6.7__py3-none-win_amd64.whl → 2.6.8__py3-none-win_amd64.whl

hikyuu/include/hikyuu/indicator/crt/ICIR.h

@@ -16,6 +16,9 @@ namespace hku {
  * @brief 计算指定的因子相对于参考证券的 ICIR （实际为 RankIC）
  * @details IR:信息比率(Information Ratio,简称IR)=
  * IC的多周期均值/IC的标准方差，代表因子获取稳定Alpha的能力。
+ * @note IC 原本需要 “t 时刻因子值→t+1 时刻收益”，改为计算 “t 时刻因子值→t 时刻之前 N
+ *       天的收益”（比如过去 5 天的收益），并称之为 “当前 IC”。(否则当前值都会是缺失NA)
+ *       如需严格“t 时刻因子值→t+1 时刻收益“计算，请设置 strict=True (注意此模式下, 后n位为 NA)
  * @param ind 因子公式
  * @param stks 证券组合
  * @param query 查询条件
@@ -23,13 +26,14 @@ namespace hku {
  * @param n IC对应的N日收益率
  * @param rolling_n 滚动时间窗口
  * @param spearman 使用 spearman 相关系数，否则为 pearson
+ * @param strict 是否严格模式
  * @return Indicator
  * @ingroup Indicator
  */
 inline Indicator ICIR(const Indicator& ind, const StockList& stks, const KQuery& query,
                       const Stock& ref_stk = getStock("sh000300"), int n = 1, int rolling_n = 120,
-                      bool spearman = true) {
-    Indicator ic = IC(ind, stks, query, ref_stk, n, spearman);
+                      bool spearman = true, bool strict = false) {
+    Indicator ic = IC(ind, stks, query, ref_stk, n, spearman, strict);
     Indicator x = MA(ic, rolling_n) / STDEV(ic, rolling_n);
     x.name("ICIR");
     x.setParam<int>("n", n);
@@ -39,8 +43,8 @@ inline Indicator ICIR(const Indicator& ind, const StockList& stks, const KQuery&
 
 inline Indicator ICIR(const Indicator& ind, const Block& blk, const KQuery& query,
                       const Stock& ref_stk = getStock("sh000300"), int n = 1, int rolling_n = 120,
-                      bool spearman = true) {
-    Indicator ic = IC(ind, blk, query, ref_stk, n, spearman);
+                      bool spearman = true, bool strict = false) {
+    Indicator ic = IC(ind, blk, query, ref_stk, n, spearman, strict);
     Indicator x = MA(ic, rolling_n) / STDEV(ic, rolling_n);
     x.name("ICIR");
     x.setParam<int>("n", n);

hikyuu/include/hikyuu/indicator/crt/INSUM.h

@@ -28,4 +28,6 @@ Indicator HKU_API INSUM(const Block& block, const KQuery& query, const Indicator
 
 Indicator HKU_API INSUM(const Block& block, const Indicator& ind, int mode, bool fill_null = true);
 
+Indicator HKU_API INSUM(const Block& block, int mode, bool fill_null);
+
 }  // namespace hku

hikyuu/include/hikyuu/indicator/crt/PRICELIST.h

@@ -23,6 +23,8 @@ namespace hku {
  */
 Indicator HKU_API PRICELIST(const PriceList& data, int discard = 0);
 Indicator HKU_API PRICELIST(const PriceList& data, const DatetimeList& ds, int discard = 0);
+Indicator HKU_API PRICELIST(size_t size, double value, int discard = 0);
+Indicator HKU_API PRICELIST(const DatetimeList& dates, double value, int discard = 0);
 Indicator HKU_API PRICELIST();
 
 /**

hikyuu/include/hikyuu/indicator/crt/REFX.h

@@ -0,0 +1,25 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-08-22
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "../Indicator.h"
+
+namespace hku {
+
+/**
+ * REF增强（不安全引用）, 用于数据左移或右移，周期为整数时，功能同 REF
+ * @note 不应用于回测，通常用于AI模型训练等场景
+ * @param n 引用周期
+ * @ingroup Indicator
+ */
+Indicator HKU_API REFX(int n);
+inline Indicator HKU_API REFX(const Indicator& ind, int n) {
+    return REFX(n)(ind);
+}
+
+}  // namespace hku

hikyuu/include/hikyuu/indicator/crt/SLICE.h

@@ -24,20 +24,20 @@ Indicator HKU_API SLICE(const PriceList& data, int64_t start, int64_t end);
  * 获取某指标中指定范围的数据
  * @param start 起始范围，可为负数
  * @param end 终止范围（不包含本身），可为负数
- * @param result_index 源数据中指定的结果集
+ * @param result_index 源数据中指定的结果集, 小于0时表示全部
  * @ingroup Indicator
  */
-Indicator HKU_API SLICE(int64_t start, int64_t end, int result_index = 0);
+Indicator HKU_API SLICE(int64_t start, int64_t end, int result_index = -1);
 
 /**
  * 获取某指标中指定范围的数据
  * @param ind 源数据
  * @param start 起始范围，可为负数
  * @param end 终止范围（不包含本身），可为负数
- * @param result_index 源数据中指定的结果集
+ * @param result_index 源数据中指定的结果集，小于0时表示全部
  * @ingroup Indicator
  */
-inline Indicator SLICE(const Indicator& ind, int64_t start, int64_t end, int result_index = 0) {
+inline Indicator SLICE(const Indicator& ind, int64_t start, int64_t end, int result_index = -1) {
     return SLICE(start, end, result_index)(ind);
 }
 

hikyuu/include/hikyuu/indicator/crt/SPEARMAN.h

@@ -12,9 +12,10 @@ namespace hku {
 
 /**
  * Spearman 相关系数
- * @param ind1 指标1
- * @param ind2 指标2
+ * @param ind 指标1
+ * @param ref_ind 指标2
  * @param n 滚动窗口(大于2 或 等于0)，等于0时，代表 n 实际使用 ind 的长度
+ * @param fill_null 填充缺失值
  * @ingroup Indicator
  */
 Indicator HKU_API SPEARMAN(const Indicator& ind, const Indicator& ref_ind, int n = 0,

hikyuu/include/hikyuu/indicator/imp/IContext.h

@@ -21,6 +21,11 @@ public:
     virtual string formula() const override;
     virtual void _calculate(const Indicator& data) override;
     virtual IndicatorImpPtr _clone() override;
+    virtual bool needSelfAlikeCompare() const noexcept override {
+        return true;
+    }
+
+    virtual bool selfAlike(const IndicatorImp& other) const noexcept override;
 
     KData getContextKdata() const;
 

hikyuu/include/hikyuu/indicator/imp/ICval.h

@@ -22,6 +22,12 @@ public:
     ICval(double value, size_t discard);
     virtual ~ICval();
     virtual void _checkParam(const string& name) const override;
+
+    virtual bool needSelfAlikeCompare() const noexcept override {
+        return true;
+    }
+
+    virtual bool selfAlike(const IndicatorImp& other) const noexcept override;
 };
 
 } /* namespace hku */

hikyuu/include/hikyuu/indicator/imp/IDropna.h

@@ -22,6 +22,15 @@ class IDropna : public IndicatorImp {
 public:
     IDropna();
     virtual ~IDropna();
+
+    virtual bool needSelfAlikeCompare() const noexcept override {
+        return true;
+    }
+
+    // 禁止子节点合并, 上级默认已为 false
+    // virtual bool selfAlike(const IndicatorImp& other) const noexcept override {
+    //     return false;
+    // }
 };
 
 } /* namespace hku */

hikyuu/include/hikyuu/indicator/imp/IIc.h

@@ -14,7 +14,8 @@ namespace hku {
 class IIc : public IndicatorImp {
 public:
     IIc();
-    IIc(const StockList& stks, const KQuery& query, int n, const Stock& ref_stk, bool spearman);
+    IIc(const StockList& stks, const KQuery& query, int n, const Stock& ref_stk, bool spearman,
+        bool strict);
     virtual ~IIc();
 
     virtual void _checkParam(const string& name) const override;

hikyuu/include/hikyuu/indicator/imp/IPriceList.h

@@ -21,6 +21,7 @@ class IPriceList : public IndicatorImp {
 public:
     IPriceList();
     IPriceList(const PriceList&, int discard);
+    IPriceList(size_t size, double value, int discard);
     virtual ~IPriceList();
     virtual void _checkParam(const string& name) const override;
 };

hikyuu/include/hikyuu/indicator/imp/IRefX.h

@@ -0,0 +1,23 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-08-22
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "../Indicator.h"
+
+namespace hku {
+
+class IRefX : public IndicatorImp {
+    INDICATOR_IMP(IRefX)
+    INDICATOR_IMP_NO_PRIVATE_MEMBER_SERIALIZATION
+
+public:
+    IRefX();
+    virtual ~IRefX();
+};
+
+} /* namespace hku */

hikyuu/include/hikyuu/plugin/backtest.h

@@ -22,6 +22,8 @@ namespace hku {
  * @param ref_market 所属市场
  * @param mode 模式  0: 当前bar收盘价执行买卖操作；1: 下一bar开盘价执行买卖操作;
  * @param support_short 是否支持做空
+ * @param slip 滑点算法
+ * @ingroup Strategy
  */
 void HKU_API backtest(const StrategyContext& context, const std::function<void(Strategy*)>& on_bar,
                       const TradeManagerPtr& tm, const Datetime& start_date,

hikyuu/include/hikyuu/plugin/extind.h

@@ -11,6 +11,11 @@
 
 namespace hku {
 
+/**
+ * @ingroup Indicator
+ * @{
+ */
+
 /**
  * @brief 将指标数据转换到指定周期
  * @param ktype 指定周期
@@ -146,5 +151,45 @@ inline Indicator WITHHOUR4(const Indicator& ind, bool fill_null = false) {
  */
 Indicator HKU_API RANK(const Block& block, const Indicator& ref_ind, int mode = 0,
                        bool fill_null = true, const string& market = "SH");
+Indicator HKU_API RANK(const Block& block, int mode = 0, bool fill_null = true,
+                       const string& market = "SH");
 
+/**
+ * @brief 聚合其他K线周期统计值，聚合计算指定K线类型数据均值到以上下文中的K线周期
+ * @param ktype 指定K线周期
+ * @param fill_null 是否填充null数据
+ * @param unit 聚合周期单位，默认为1。按上下文K线 unit 个周期计算
+ * @return Indicator
+ */
+#define AGG_FUNC_DEFINE(agg_name)                                                              \
+    Indicator HKU_API agg_name(const Indicator& ind, const KQuery::KType& ktype = KQuery::MIN, \
+                               bool fill_null = false, int unit = 1);
+
+#define AGG_FUNC_IMP(agg_name)                                                                   \
+    Indicator HKU_API agg_name(const Indicator& ind, const KQuery::KType& ktype, bool fill_null, \
+                               int unit) {                                                       \
+        Parameter params;                                                                        \
+        params.set<string>("ktype", ktype);                                                      \
+        params.set<bool>("fill_null", fill_null);                                                \
+        params.set<int>("unit", unit);                                                           \
+        return getExtIndicator(#agg_name, ind, params);                                          \
+    }
+
+AGG_FUNC_DEFINE(AGG_MEAN)
+AGG_FUNC_DEFINE(AGG_COUNT)
+AGG_FUNC_DEFINE(AGG_SUM)
+AGG_FUNC_DEFINE(AGG_MAX)
+AGG_FUNC_DEFINE(AGG_MIN)
+AGG_FUNC_DEFINE(AGG_MAD)
+AGG_FUNC_DEFINE(AGG_MEDIAN)
+AGG_FUNC_DEFINE(AGG_PROD)
+
+Indicator HKU_API AGG_STD(const Indicator& ind, const KQuery::KType& ktype = KQuery::MIN,
+                          bool fill_null = false, int unit = 1, int ddof = 1);
+Indicator HKU_API AGG_VAR(const Indicator& ind, const KQuery::KType& ktype = KQuery::MIN,
+                          bool fill_null = false, int unit = 1, int ddof = 1);
+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);
+
+/** @} */
 }  // namespace hku

hikyuu/include/hikyuu/plugin/hkuextra.h

@@ -7,7 +7,9 @@
 
 #pragma once
 
+#include <arrow/api.h>
 #include "hikyuu/Stock.h"
+#include "hikyuu/indicator/Indicator.h"
 
 namespace hku {
 
@@ -53,4 +55,23 @@ size_t getStockExtraCount(const Stock& stk, const string& ktype);
 bool getStockExtraIndexRange(const Stock& stk, const KQuery& query, size_t& out_start,
                              size_t& out_end);
 
+KDataImpPtr getKDataImp(const Stock& stk, const KQuery& query);
+
+//-------------------------------
+// Views 扩展
+//-------------------------------
+
+std::shared_ptr<arrow::Table> getIndicatorsViewParallel(const StockList& stks,
+                                                        const IndicatorList& inds,
+                                                        const KQuery& query, const string& market);
+
+std::shared_ptr<arrow::Table> getIndicatorsViewParallel(const StockList& stks,
+                                                        const IndicatorList& inds,
+                                                        const Datetime& date, size_t cal_len,
+                                                        const KQuery::KType& ktype,
+                                                        const string& market);
+
+std::shared_ptr<arrow::Table> getMarketViewParallel(const StockList& stks, const Datetime& date,
+                                                    const string& market);
+
 }  // namespace hku

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

@@ -7,6 +7,7 @@
 
 #pragma once
 
+#include <arrow/api.h>
 #include "hikyuu/utilities/plugin/PluginBase.h"
 
 namespace hku {
@@ -33,6 +34,21 @@ public:
 
     virtual bool getStockExtraIndexRange(const Stock& stk, const KQuery& query, size_t& out_start,
                                          size_t& out_end) = 0;
+
+    virtual KDataImpPtr getKDataImp(const Stock& stk, const KQuery& query) = 0;
+
+    virtual std::shared_ptr<arrow::Table> getIndicatorsViewParallel(const StockList& stks,
+                                                                    const IndicatorList& inds,
+                                                                    const KQuery& query,
+                                                                    const string& market) = 0;
+
+    virtual std::shared_ptr<arrow::Table> getIndicatorsViewParallel(
+      const StockList& stks, const IndicatorList& inds, const Datetime& date, size_t cal_len,
+      const KQuery::KType& ktype, const string& market) = 0;
+
+    virtual std::shared_ptr<arrow::Table> getMarketViewParallel(const StockList& stks,
+                                                                const Datetime& date,
+                                                                const string& market) = 0;
 };
 
 }  // namespace hku

hikyuu/include/hikyuu/plugin/interface/TMReportPluginInterface.h

@@ -54,6 +54,7 @@ public:
      * 以便用于计算当前市值
      * @param tm 指定的交易管理实例
      * @param datetime 统计截止时刻
+     * @param ktype k线类型
      */
     virtual Performance getExtPerformance(const TMPtr& tm, const Datetime& datetime,
                                           const KQuery::KType& ktype) = 0;

hikyuu/include/hikyuu/python/pybind_utils.h

@@ -54,10 +54,11 @@ std::vector<T> python_bytes_to_vector(const py::bytes& obj) {
 
 template <typename T>
 std::vector<T> python_list_to_vector(const py::sequence& obj) {
+    // 如果 len(obj) 长度为零，即使类型不是所期望的也可能成功，但无风险
     auto total = len(obj);
     std::vector<T> vect(total);
     for (auto i = 0; i < total; ++i) {
-        vect[i] = obj[i].cast<T>();
+        vect[i] = py::cast<T>(obj[i]);
     }
     return vect;
 }
@@ -86,16 +87,23 @@ std::string to_py_str(const T& item) {
 // 直接使用 pybind11 重载 _clone，在 C++ 中会丢失 python 中的类型
 // 参考：https://github.com/pybind/pybind11/issues/1049 进行修改
 // PYBIND11_OVERLOAD(IndicatorImpPtr, IndicatorImp, _clone, );
-#define PY_CLONE(pyclassname, classname)                                     \
-public:                                                                      \
-    std::shared_ptr<classname> _clone() override {                           \
-        auto self = py::cast(this);                                          \
-        auto cloned = self.attr("_clone")();                                 \
-                                                                             \
-        auto keep_python_state_alive = std::make_shared<py::object>(cloned); \
-        auto ptr = cloned.cast<pyclassname*>();                              \
-                                                                             \
-        return std::shared_ptr<classname>(keep_python_state_alive, ptr);     \
+#define PY_CLONE(pyclassname, classname)                                         \
+public:                                                                          \
+    std::shared_ptr<classname> _clone() override {                               \
+        if (isPythonObject()) {                                                  \
+            py::gil_scoped_acquire acquire;                                      \
+            auto self = py::cast(this);                                          \
+            auto cloned = self.attr("_clone")();                                 \
+            auto keep_python_state_alive = std::make_shared<py::object>(cloned); \
+            auto ptr = cloned.cast<pyclassname*>();                              \
+            return std::shared_ptr<classname>(keep_python_state_alive, ptr);     \
+        }                                                                        \
+        return this->_clone();                                                   \
+    }                                                                            \
+                                                                                 \
+protected:                                                                       \
+    inline bool isPythonObject() const override {                                \
+        return true;                                                             \
     }
 
 // 用于检查已 py::object 方式传递的函数参数个数是否符合预期

hikyuu/include/hikyuu/trade_manage/Performance.h

@@ -47,7 +47,6 @@ public:
     /**
      * 简单的文本统计报告，用于直接输出打印。
      * @note 只有运行 statistics 后或 Performance 本身为从 TM 获取的结果时才生效
-     * @param datetime 指定的截止时刻
      * @return
      */
     string report();

hikyuu/include/hikyuu/trade_manage/TradeCostBase.h

@@ -106,6 +106,11 @@ public:
     /** 继承子类必须实现私有变量的克隆接口 */
     virtual TradeCostPtr _clone() = 0;
 
+protected:
+    virtual bool isPythonObject() const {
+        return false;
+    }
+
 private:
     string m_name;
 

hikyuu/include/hikyuu/trade_manage/TradeManager.h

@@ -225,6 +225,7 @@ public:
      * @param goalPrice 目标价格
      * @param planPrice 计划买入价格
      * @param from 记录是哪个系统部件发出的买入指示
+     * @param remark 买入备注
      * @return 返回对应的交易记录，如果操作失败，business等于BUSINESS_INVALID
      */
     virtual TradeRecord buy(const Datetime& datetime, const Stock& stock, price_t realPrice,
@@ -242,6 +243,7 @@ public:
      * @param goalPrice 新的目标价格
      * @param planPrice 原计划卖出价格
      * @param from 记录是哪个系统部件发出的卖出指示
+     * @param remark 卖出备注
      * @return 返回对应的交易记录，如果操作失败，business等于BUSINESS_INVALID
      */
     virtual TradeRecord sell(const Datetime& datetime, const Stock& stock, price_t realPrice,
@@ -259,6 +261,7 @@ public:
      * @param goalPrice 目标价格
      * @param planPrice 计划卖空价格
      * @param from 记录是哪个系统部件发出的买入指示
+     * @param remark 备注
      * @return 返回对应的交易记录，如果操作失败，business等于BUSINESS_INVALID
      */
     virtual TradeRecord sellShort(const Datetime& datetime, const Stock& stock, price_t realPrice,
@@ -276,6 +279,7 @@ public:
      * @param goalPrice 目标价格
      * @param planPrice 计划买入价格
      * @param from 记录是哪个系统部件发出的卖出指示
+     * @param remark 备注
      * @return 返回对应的交易记录，如果操作失败，business等于BUSINESS_INVALID
      */
     virtual TradeRecord buyShort(const Datetime& datetime, const Stock& stock, price_t realPrice,

hikyuu/include/hikyuu/trade_manage/TradeManagerBase.h

@@ -521,6 +521,7 @@ public:
      * @param goalPrice 目标价格
      * @param planPrice 计划买入价格
      * @param from 记录是哪个系统部件发出的买入指示
+     * @param remark 备注
      * @return 返回对应的交易记录，如果操作失败，business等于BUSINESS_INVALID
      */
     virtual TradeRecord buy(const Datetime& datetime, const Stock& stock, price_t realPrice,
@@ -541,6 +542,7 @@ public:
      * @param goalPrice 新的目标价格
      * @param planPrice 原计划卖出价格
      * @param from 记录是哪个系统部件发出的卖出指示
+     * @param remark 卖出备注
      * @return 返回对应的交易记录，如果操作失败，business等于BUSINESS_INVALID
      */
     virtual TradeRecord sell(const Datetime& datetime, const Stock& stock, price_t realPrice,
@@ -561,6 +563,7 @@ public:
      * @param goalPrice 目标价格
      * @param planPrice 计划卖空价格
      * @param from 记录是哪个系统部件发出的买入指示
+     * @param remark 备注
      * @return 返回对应的交易记录，如果操作失败，business等于BUSINESS_INVALID
      */
     virtual TradeRecord sellShort(const Datetime& datetime, const Stock& stock, price_t realPrice,
@@ -581,6 +584,7 @@ public:
      * @param goalPrice 目标价格
      * @param planPrice 计划买入价格
      * @param from 记录是哪个系统部件发出的卖出指示
+     * @param remark 备注
      * @return 返回对应的交易记录，如果操作失败，business等于BUSINESS_INVALID
      */
     virtual TradeRecord buyShort(const Datetime& datetime, const Stock& stock, price_t realPrice,
@@ -716,13 +720,13 @@ public:
      * 统计截至某一时刻的系统绩效, datetime必须大于等于lastDatetime，
      * 以便用于计算当前市值
      * @param datetime 统计截止时刻
+     * @param ktype k线类型
      */
     Performance getPerformance(const Datetime& datetime = Datetime::now(),
                                const KQuery::KType& ktype = KQuery::DAY);
 
     /**
      * @brief 获取指定时刻时账户的最大回撤百分比（负数）（仅根据收盘价计算）
-     * @param tm 指定账户
      * @param date 指定日期（包含该时刻）
      * @param ktype k线类型
      * @return price_t
@@ -765,6 +769,11 @@ public:
     std::vector<std::pair<Datetime, double>> getProfitPercentYearly(
       const Datetime& datetime = Datetime::now());
 
+protected:
+    virtual bool isPythonObject() const {
+        return false;
+    }
+
 protected:
     string m_name;            // 账户名称
     TradeCostPtr m_costfunc;  // 成本算法

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

@@ -101,6 +101,11 @@ public:
     static void adjustWeight(SystemWeightList& sw_list, double can_allocate_weight,
                              bool auto_adjust, bool ignore_zero);
 
+protected:
+    virtual bool isPythonObject() const {
+        return false;
+    }
+
 private:
     void initParam();
 

hikyuu/include/hikyuu/trade_sys/condition/ConditionBase.h

@@ -109,6 +109,11 @@ public:
         return m_values.cend();
     }
 
+protected:
+    virtual bool isPythonObject() const {
+        return false;
+    }
+
 protected:
     string m_name;
     KData m_kdata;

hikyuu/include/hikyuu/trade_sys/environment/EnvironmentBase.h

@@ -93,6 +93,11 @@ public:
     /** 子类克隆接口 */
     virtual EnvironmentPtr _clone() = 0;
 
+protected:
+    virtual bool isPythonObject() const {
+        return false;
+    }
+
 protected:
     string m_name;
     KQuery m_query;

hikyuu/include/hikyuu/trade_sys/moneymanager/MoneyManagerBase.h

@@ -152,6 +152,11 @@ public:
     /** 子类克隆私有变量接口 */
     virtual MoneyManagerPtr _clone() = 0;
 
+protected:
+    virtual bool isPythonObject() const {
+        return false;
+    }
+
 protected:
     string m_name;
     KQuery m_query;

hikyuu/include/hikyuu/trade_sys/multifactor/MultiFactorBase.h

@@ -10,8 +10,6 @@
 #include "hikyuu/KData.h"
 #include "ScoreRecord.h"
 
-#define MF_USE_MULTI_THREAD 1
-
 namespace hku {
 
 /**
@@ -114,7 +112,7 @@ public:
     const vector<ScoreRecordList>& getAllScores();
 
     /**
-     * 获取合成因子的IC, 长度与参考日期同
+     * 获取合成因子的IC, 长度与参考日期同 (非严格IC模式)
      * @note ndays 对于使用 IC/ICIR 加权的新因子，最好保持好 ic_n 一致，
      *       但对于等权计算的新因子，不一定非要使用 ic_n 计算。
      *       所以，ndays 增加了一个特殊值 0, 表示直接使用 ic_n 参数计算 IC
@@ -145,6 +143,11 @@ public:
     virtual MultiFactorPtr _clone() = 0;
     virtual IndicatorList _calculate(const vector<IndicatorList>&) = 0;
 
+protected:
+    virtual bool isPythonObject() const {
+        return false;
+    }
+
 private:
     /** 执行计算 */
     void calculate();

hikyuu/include/hikyuu/trade_sys/portfolio/Portfolio.h

@@ -115,6 +115,10 @@ private:
                                      const string& mode);
 
 protected:
+    virtual bool isPythonObject() const {
+        return false;
+    }
+
     // 跟踪打印当前TM持仓情况
     void traceMomentTMAfterRunAtOpen(const Datetime& date);
     void traceMomentTMAfterRunAtClose(const Datetime& date);

hikyuu/include/hikyuu/trade_sys/profitgoal/ProfitGoalBase.h

@@ -82,6 +82,11 @@ public:
     /** 子类计算接口，由setTO调用 */
     virtual void _calculate() = 0;
 
+protected:
+    virtual bool isPythonObject() const {
+        return false;
+    }
+
 protected:
     string m_name;
     KData m_kdata;

hikyuu/include/hikyuu/trade_sys/selector/SelectorBase.h

@@ -48,7 +48,6 @@ public:
      * 添加备选股票及其交易策略原型
      * @param stock 备选股票
      * @param protoSys 交易系统策略原型
-     * @return 如果 protoSys 无效 或 stock 无效，则返回 false， 否则返回 true
      */
     void addStock(const Stock& stock, const SystemPtr& protoSys);
 
@@ -57,7 +56,6 @@ public:
      * @note 如果存在无效的stock，则自动忽略，不会返回false
      * @param stkList 备选股票列表
      * @param protoSys 交易系统策略原型
-     * @return 如果 protoSys 无效则返回false，否则返回 true
      */
     void addStockList(const StockList& stkList, const SystemPtr& protoSys);
 
@@ -134,6 +132,11 @@ public:
 
     virtual string str() const;
 
+protected:
+    virtual bool isPythonObject() const {
+        return false;
+    }
+
 private:
     void initParam();
 

hikyuu/include/hikyuu/trade_sys/signal/SignalBase.h

@@ -130,6 +130,11 @@ public:
     /** 子类计算接口，在setTO中调用 */
     virtual void _calculate(const KData&) = 0;
 
+protected:
+    virtual bool isPythonObject() const {
+        return false;
+    }
+
 private:
     void initParam();