trade_sys finish

hikyuu_cpp/hikyuu/trade_manage/OrderBrokerBase.h

@@ -37,7 +37,7 @@ public:
     virtual ~OrderBrokerBase();
 
     /** 获取名称 */
-    string name() const;
+    const string& name() const;
 
     /** 设置名称 */
     void name(const string& name);
@@ -106,7 +106,7 @@ HKU_API std::ostream& operator<<(std::ostream& os, const OrderBrokerBase&);
 /** @ingroup OrderBroker */
 HKU_API std::ostream& operator<<(std::ostream& os, const OrderBrokerPtr&);
 
-inline string OrderBrokerBase::name() const {
+inline const string& OrderBrokerBase::name() const {
     return m_name;
 }
 

hikyuu_cpp/hikyuu/trade_sys/signal/SignalBase.h

@@ -98,7 +98,7 @@ public:
     SignalPtr clone();
 
     /** 获取名称 */
-    string name() const;
+    const string& name() const;
 
     /** 设置名称 */
     void name(const string& name);
@@ -208,7 +208,7 @@ inline KData SignalBase::getTO() const {
     return m_kdata;
 }
 
-inline string SignalBase::name() const {
+inline const string& SignalBase::name() const {
     return m_name;
 }
 

hikyuu_cpp/hikyuu/trade_sys/slippage/SlippageBase.h

@@ -39,7 +39,7 @@ public:
     KData getTO() const;
 
     /** 获取名称 */
-    string name() const;
+    const string& name() const;
 
     /** 设置名称 */
     void name(const string& name);
@@ -150,7 +150,7 @@ typedef shared_ptr<SlippageBase> SPPtr;
 HKU_API std::ostream& operator<<(std::ostream&, const SlippageBase&);
 HKU_API std::ostream& operator<<(std::ostream&, const SlippagePtr&);
 
-inline string SlippageBase::name() const {
+inline const string& SlippageBase::name() const {
     return m_name;
 }
 

hikyuu_cpp/hikyuu/trade_sys/stoploss/StoplossBase.h

@@ -35,7 +35,7 @@ public:
     virtual ~StoplossBase();
 
     /** 获取名称 */
-    string name() const;
+    const string& name() const;
 
     /** 设置名称 */
     void name(const string& name);
@@ -171,7 +171,7 @@ typedef shared_ptr<StoplossBase> TPPtr;
 HKU_API std::ostream& operator<<(std::ostream& os, const StoplossBase&);
 HKU_API std::ostream& operator<<(std::ostream& os, const StoplossPtr&);
 
-inline string StoplossBase::name() const {
+inline const string& StoplossBase::name() const {
     return m_name;
 }
 

hikyuu_pywrap/trade_manage/_OrderBroker.cpp

@@ -42,7 +42,8 @@ void export_OrderBroker(py::module& m) {
       .def("__repr__", to_py_str<OrderBrokerBase>)
 
       .def_property("name", py::overload_cast<void>(&OrderBrokerBase::name, py::const_),
-                    py::overload_cast<const string&>(&OrderBrokerBase::name), "名称（可读写）")
+                    py::overload_cast<const string&>(&OrderBrokerBase::name),
+                    py::return_value_policy::copy, "名称（可读写）")
 
       .def("buy", &OrderBrokerBase::buy, R"(buy(self, datetime, market, code, price, num)
 

hikyuu_pywrap/trade_manage/_TradeManager.cpp

@@ -242,9 +242,6 @@ FundsRecord (TradeManagerBase::*getFunds_2)(const Datetime&,
 TradeCostPtr (TradeManagerBase::*get_costFunc)() const = &TradeManagerBase::costFunc;
 void (TradeManagerBase::*set_costFunc)(const TradeCostPtr&) = &TradeManagerBase::costFunc;
 
-const string& (TradeManagerBase::*tm_get_name)() const = &TradeManagerBase::name;
-void (TradeManagerBase::*tm_set_name)(const string&) = &TradeManagerBase::name;
-
 TradeRecordList (TradeManagerBase::*_getTradeList_1)() const = &TradeManagerBase::getTradeList;
 TradeRecordList (TradeManagerBase::*_getTradeList_2)(const Datetime&, const Datetime&) const =
   &TradeManagerBase::getTradeList;
@@ -269,9 +266,10 @@ void export_TradeManager(py::module& m) {
       .def("__str__", &TradeManagerBase::str)
       .def("__repr__", &TradeManagerBase::str)
 
-      // .def_property("name", make_function(tm_get_name,
+      .def_property("name", py::overload_cast<>(&TradeManagerBase::name, py::const_),
-      // return_value_policy<copy_const_reference>()),
+                    py::overload_cast<const string&>(&TradeManagerBase::name),
-      //               tm_set_name, "名称")
+                    py::return_value_policy::copy, "名称")
+
       .def_property_readonly("init_cash", &TradeManagerBase::initCash, "（只读）初始资金")
       .def_property_readonly("current_cash", &TradeManagerBase::currentCash, "（只读）当前资金")
       .def_property_readonly("init_datetime", &TradeManagerBase::initDatetime,

hikyuu_pywrap/trade_sys/_Selector.cpp

@@ -5,95 +5,67 @@
  *      Author: fasiondog
  */
 
-#include <boost/python.hpp>
 #include <hikyuu/trade_sys/selector/build_in.h>
-#include "../_Parameter.h"
 #include "../pybind_utils.h"
-#include "../pickle_support.h"
 
-using namespace boost::python;
+namespace py = pybind11;
 using namespace hku;
 
-class SelectorWrap : public SelectorBase, public wrapper<SelectorBase> {
+class PySelectorBase : public SelectorBase {
+    PY_CLONE(PySelectorBase, SelectorBase)
+
 public:
-    SelectorWrap() : SelectorBase() {}
+    using SelectorBase::SelectorBase;
-    SelectorWrap(const string& name) : SelectorBase(name) {}
-    virtual ~SelectorWrap() {}
 
-    void _reset() {
+    void _reset() override {
-        if (override func = this->get_override("_reset")) {
+        PYBIND11_OVERLOAD(void, SelectorBase, _reset, );
-            func();
-        } else {
-            SelectorBase::_reset();
-        }
     }
 
-    void default_reset() {
+    void _calculate() override {
-        this->SelectorBase::_reset();
+        PYBIND11_OVERLOAD_PURE(void, SelectorBase, _calculate, );
     }
 
-    bool isMatchAF(const AFPtr& af) {
+    SystemList getSelectedOnOpen(Datetime date) override {
-        return this->get_override("is_match_af")(af);
+        PYBIND11_OVERLOAD_PURE_NAME(SystemList, SelectorBase, "get_selected_on_open",
+                                    getSelectedOnOpen, date);
     }
 
-    SystemList getSelectedOnOpen(Datetime date) {
+    SystemList getSelectedOnClose(Datetime date) override {
-        return this->get_override("get_selected_on_open")(date);
+        PYBIND11_OVERLOAD_PURE_NAME(SystemList, SelectorBase, "get_selected_on_close",
+                                    getSelectedOnClose, date);
     }
 
-    SystemList getSelectedOnClose(Datetime date) {
+    bool isMatchAF(const AFPtr& af) override {
-        return this->get_override("get_selected_on_close")(date);
+        PYBIND11_OVERLOAD_PURE_NAME(bool, SelectorBase, "is_match_af", isMatchAF, af);
-    }
-
-    SelectorPtr _clone() {
-        return this->get_override("_clone")();
-    }
-
-    void _calculate() {
-        this->get_override("_calculate")();
     }
 };
 
-const string& (SelectorBase::*se_get_name)() const = &SelectorBase::name;
+void export_Selector(py::module& m) {
-void (SelectorBase::*se_set_name)(const string&) = &SelectorBase::name;
+    py::class_<SelectorBase, SEPtr, PySelectorBase>(
-
+      m, "SelectorBase",
-SelectorPtr (*SE_Fixed_1)() = SE_Fixed;
-SelectorPtr py_SE_Fixed(py::list stock_list, const SystemPtr& sys) {
-    return SE_Fixed(python_list_to_vector<StockList>(stock_list), sys);
-}
-
-SEPtr (*SE_Signal_1)() = SE_Signal;
-SelectorPtr py_SE_Signal(py::list stock_list, const SystemPtr& sys) {
-    return SE_Signal(python_list_to_vector<StockList>(stock_list), sys);
-}
-
-bool py_se_add_stock_list(SelectorBase& se, py::list stock_list, const SystemPtr& protoSys) {
-    return se.addStockList(python_list_to_vector<StockList>(stock_list), protoSys);
-}
-
-void export_Selector() {
-    class_<SelectorWrap, boost::noncopyable>(
-      "SelectorBase",
       R"(选择器策略基类，实现标的、系统策略的评估和选取算法，自定义选择器策略子类接口：
 
     - get_selected_on_open - 【必须】获取指定时刻开盘时选择的系统实例列表
     - get_selected_on_close - 【必须】获取指定时刻收盘时选择的系统实例列表
     - _calculate - 【必须】计算接口
     - _reset - 【可选】重置私有属性
-    - _clone - 【必须】克隆接口)",
+    - _clone - 【必须】克隆接口)")
-      init<>())
+
-      .def(init<const string&>())
+      .def(py::init<>())
-      .def(self_ns::str(self))
+      .def(py::init<const string&>(), R"(初始化构造函数
-      .def(self_ns::repr(self))
+        
-      .add_property("name", make_function(se_get_name, return_value_policy<copy_const_reference>()),
+    :param str name: 名称)")
-                    se_set_name, "算法名称")
+
-      .add_property("proto_sys_list",
+      .def("__str__", to_py_str<SelectorBase>)
-                    make_function(&SelectorBase::getProtoSystemList,
+      .def("__repr__", to_py_str<SelectorBase>)
-                                  return_value_policy<copy_const_reference>()),
+
-                    "原型系统列表")
+      .def_property("name", py::overload_cast<void>(&SelectorBase::name, py::const_),
-      .add_property("real_sys_list",
+                    py::overload_cast<const string&>(&SelectorBase::name),
-                    make_function(&SelectorBase::getRealSystemList,
+                    py::return_value_policy::copy, "算法名称")
-                                  return_value_policy<copy_const_reference>()),
+      .def_property_readonly("proto_sys_list", &SelectorBase::getProtoSystemList,
-                    "由 PF 运行时设定的实际运行系统列表")
+                             py::return_value_policy::copy, "原型系统列表")
+      .def_property_readonly("real_sys_list", &SelectorBase::getRealSystemList,
+                             py::return_value_policy::copy, "由 PF 运行时设定的实际运行系统列表")
 
       .def("get_param", &SelectorBase::getParam<boost::any>, R"(get_param(self, name)
 
@@ -103,7 +75,7 @@ void export_Selector() {
     :return: 参数值
     :raises out_of_range: 无此参数)")
 
-      .def("set_param", &SelectorBase::setParam<object>, R"(set_param(self, name, value)
+      .def("set_param", &SelectorBase::setParam<boost::any>, R"(set_param(self, name, value)
 
     设置参数
 
@@ -117,7 +89,7 @@ void export_Selector() {
       .def("clone", &SelectorBase::clone, "克隆操作")
       .def("remove_all", &SelectorBase::removeAll, "清除所有已加入的原型系统")
 
-      .def("add_stock", &SelectorBase::addStock, (arg("stock"), arg("sys")),
+      .def("add_stock", &SelectorBase::addStock, py::arg("stock"), py::arg("sys"),
            R"(add_stock(self, stock, sys)
 
     加入初始标的及其对应的系统策略原型
@@ -125,7 +97,7 @@ void export_Selector() {
     :param Stock stock: 加入的初始标的
     :param System sys: 系统策略原型)")
 
-      .def("add_stock_list", py_se_add_stock_list, (arg("stk_list"), arg("sys")),
+      .def("add_stock_list", &SelectorBase::addStockList, py::arg("stk_list"), py::arg("sys"),
            R"(add_stock_list(self, stk_list, sys)
 
     加入初始标的列表及其系统策略原型
@@ -133,17 +105,16 @@ void export_Selector() {
     :param StockList stk_list: 加入的初始标的列表
     :param System sys: 系统策略原型)")
 
-      .def("_reset", &SelectorBase::_reset, &SelectorWrap::default_reset, "子类复位操作实现")
+      .def("_reset", &SelectorBase::_reset, "子类复位操作实现")
-      .def("_clone", pure_virtual(&SelectorBase::_clone), "子类克隆操作实现接口")
+      .def("_calculate", &SelectorBase::_calculate, "【重载接口】子类计算接口")
-      .def("_calculate", pure_virtual(&SelectorBase::_calculate), "【重载接口】子类计算接口")
 
-      .def("is_match_af", pure_virtual(&SelectorBase::isMatchAF), R"(is_match_af(self)
+      .def("is_match_af", &SelectorBase::isMatchAF, R"(is_match_af(self)
 
     【重载接口】判断是否和 AF 匹配
 
     :param AllocateFundsBase af: 资产分配算法)")
 
-      .def("get_selected_on_open", pure_virtual(&SelectorBase::getSelectedOnOpen),
+      .def("get_selected_on_open", &SelectorBase::getSelectedOnOpen,
            R"(get_selected_on_open(self, datetime)
 
     【重载接口】获取指定时刻开盘时选取的系统实例
@@ -152,7 +123,7 @@ void export_Selector() {
     :return: 选取的系统实例列表
     :rtype: SystemList)")
 
-      .def("get_selected_on_close", pure_virtual(&SelectorBase::getSelectedOnClose),
+      .def("get_selected_on_close", &SelectorBase::getSelectedOnClose,
            R"(get_selected_on_close(self, datetime)
 
     【重载接口】获取指定时刻收盘时选取的系统实例
@@ -161,15 +132,11 @@ void export_Selector() {
     :return: 选取的系统实例列表
     :rtype: SystemList)")
 
-#if HKU_PYTHON_SUPPORT_PICKLE
+        DEF_PICKLE(SEPtr);
-      .def_pickle(name_init_pickle_suite<SelectorBase>())
-#endif
-      ;
 
-    register_ptr_to_python<SelectorPtr>();
+    m.def("SE_Fixed", py::overload_cast<void>(SE_Fixed));
-
+    m.def("SE_Fixed", py::overload_cast<const StockList&, const SystemPtr&>(SE_Fixed),
-    def("SE_Fixed", SE_Fixed_1);
+          R"(SE_Fixed([stk_list, sys])
-    def("SE_Fixed", py_SE_Fixed, R"(SE_Fixed([stk_list, sys])
 
     固定选择器，即始终选择初始划定的标的及其系统策略原型
 
@@ -177,8 +144,9 @@ void export_Selector() {
     :param System sys: 系统策略原型
     :return: SE选择器实例)");
 
-    def("SE_Signal", SE_Signal_1);
+    m.def("SE_Signal", py::overload_cast<void>(SE_Signal));
-    def("SE_Signal", py_SE_Signal, R"(SE_Signal([stk_list, sys])
+    m.def("SE_Signal", py::overload_cast<const StockList&, const SystemPtr&>(SE_Signal),
+          R"(SE_Signal([stk_list, sys])
 
     信号选择器，仅依靠系统买入信号进行选中
 

hikyuu_pywrap/trade_sys/_Signal.cpp

@@ -5,45 +5,29 @@
  *      Author: fasiondog
  */
 
-#include <boost/python.hpp>
 #include <hikyuu/trade_sys/signal/build_in.h>
-#include "../_Parameter.h"
+#include "../pybind_utils.h"
-#include "../pickle_support.h"
 
-using namespace boost::python;
+namespace py = pybind11;
 using namespace hku;
 
-class SignalWrap : public SignalBase, public wrapper<SignalBase> {
+class PySignalBase : public SignalBase {
+    PY_CLONE(PySignalBase, SignalBase)
+
 public:
-    SignalWrap() : SignalBase() {}
+    using SignalBase::SignalBase;
-    SignalWrap(const string& name) : SignalBase(name) {}
 
-    void _reset() {
+    void _calculate() override {
-        if (override func = this->get_override("_reset")) {
+        PYBIND11_OVERLOAD_PURE(void, SignalBase, _calculate, );
-            func();
-        } else {
-            SignalBase::_reset();
-        }
     }
 
-    void default_reset() {
+    void _reset() override {
-        this->SignalBase::_reset();
+        PYBIND11_OVERLOAD(void, SignalBase, _reset, );
-    }
-
-    SignalPtr _clone() {
-        return this->get_override("_clone")();
-    }
-
-    void _calculate() {
-        this->get_override("_calculate")();
     }
 };
 
-string (SignalBase::*sg_get_name)() const = &SignalBase::name;
+void export_Signal(py::module& m) {
-void (SignalBase::*sg_set_name)(const string&) = &SignalBase::name;
+    py::class_<SignalBase, SGPtr, PySignalBase>(m, "SignalBase", R"(信号指示器基类
-
-void export_Signal() {
-    class_<SignalWrap, boost::noncopyable>("SignalBase", R"(信号指示器基类
     信号指示器负责产生买入、卖出信号。
 
 公共参数：
@@ -54,15 +38,18 @@ void export_Signal() {
 
     - _calculate : 【必须】子类计算接口
     - _clone : 【必须】克隆接口
-    - _reset : 【可选】重载私有变量)",
+    - _reset : 【可选】重载私有变量)")
-                                           init<>())
-      .def(init<const string&>())
 
-      .def(self_ns::str(self))
+      .def(py::init<>())
-      .def(self_ns::repr(self))
+      .def(py::init<const string&>())
 
-      .add_property("name", sg_get_name, sg_set_name, "名称")
+      .def("__str__", to_py_str<SignalBase>)
-      .add_property("to", &SignalBase::getTO, &SignalBase::setTO, "设置或获取交易对象")
+      .def("__repr__", to_py_str<SignalBase>)
+
+      .def_property("name", py::overload_cast<void>(&SignalBase::name, py::const_),
+                    py::overload_cast<const string&>(&SignalBase::name),
+                    py::return_value_policy::copy, "名称")
+      .def_property("to", &SignalBase::getTO, &SignalBase::setTO, "设置或获取交易对象")
 
       .def("get_param", &SignalBase::getParam<boost::any>, R"(get_param(self, name)
 
@@ -72,7 +59,7 @@ void export_Signal() {
     :return: 参数值
     :raises out_of_range: 无此参数)")
 
-      .def("set_param", &SignalBase::setParam<object>, R"(set_param(self, name, value)
+      .def("set_param", &SignalBase::setParam<boost::any>, R"(set_param(self, name, value)
 
     设置参数
 
@@ -131,20 +118,13 @@ void export_Signal() {
 
       .def("reset", &SignalBase::reset, "复位操作")
       .def("clone", &SignalBase::clone, "克隆操作")
-      .def("_calculate", pure_virtual(&SignalBase::_calculate), "【重载接口】子类计算接口")
+      .def("_calculate", &SignalBase::_calculate, "【重载接口】子类计算接口")
-      .def("_reset", &SignalBase::_reset, &SignalWrap::default_reset,
+      .def("_reset", &SignalBase::_reset, "【重载接口】子类复位接口，复位内部私有变量")
-           "【重载接口】子类复位接口，复位内部私有变量")
-      .def("_clone", pure_virtual(&SignalBase::_clone), "【重载接口】子类克隆接口")
 
-#if HKU_PYTHON_SUPPORT_PICKLE
+        DEF_PICKLE(SGPtr);
-      .def_pickle(name_init_pickle_suite<SignalBase>())
-#endif
-      ;
 
-    register_ptr_to_python<SignalPtr>();
+    m.def("SG_Bool", SG_Bool, py::arg("buy"), py::arg("sell"),
-
+          R"(SG_Bool(buy, sell)
-    def("SG_Bool", SG_Bool, (arg("buy"), arg("sell")),
-        R"(SG_Bool(buy, sell)
 
     布尔信号指示器，使用运算结果为类似bool数组的Indicator分别作为买入、卖出指示。
 
@@ -152,8 +132,9 @@ void export_Signal() {
     :param Indicator sell: 卖出指示（结果Indicator中相应位置>0则代表卖出）
     :return: 信号指示器)");
 
-    def("SG_Single", SG_Single, (arg("ind"), arg("filter_n") = 10, arg("filter_p") = 0.1),
+    m.def("SG_Single", SG_Single, py::arg("ind"), py::arg("filter_n") = 10,
-        R"(SG_Single(ind[, filter_n = 10, filter_p = 0.1])
+          py::arg("filter_p") = 0.1,
+          R"(SG_Single(ind[, filter_n = 10, filter_p = 0.1])
     
     生成单线拐点信号指示器。使用《精明交易者》 [BOOK1]_ 中给出的曲线拐点算法判断曲线趋势，公式见下::
 
@@ -168,8 +149,9 @@ void export_Signal() {
     :param float filter_p: 过滤器百分比
     :return: 信号指示器)");
 
-    def("SG_Single2", SG_Single2, (arg("ind"), arg("filter_n") = 10, arg("filter_p") = 0.1),
+    m.def("SG_Single2", SG_Single2, py::arg("ind"), py::arg("filter_n") = 10,
-        R"(SG_Single2(ind[, filter_n = 10, filter_p = 0.1])
+          py::arg("filter_p") = 0.1,
+          R"(SG_Single2(ind[, filter_n = 10, filter_p = 0.1])
     
     生成单线拐点信号指示器2 [BOOK1]_::
 
@@ -183,8 +165,8 @@ void export_Signal() {
     :param float filter_p: 过滤器百分比
     :return: 信号指示器)");
 
-    def("SG_Cross", SG_Cross, (arg("fast"), arg("slow")),
+    m.def("SG_Cross", SG_Cross, py::arg("fast"), py::arg("slow"),
-        R"(SG_Cross(fast, slow)
+          R"(SG_Cross(fast, slow)
 
     双线交叉指示器，当快线从下向上穿越慢线时，买入；当快线从上向下穿越慢线时，卖出。如：5日MA上穿10日MA时买入，5日MA线下穿MA10日线时卖出:: 
 
@@ -194,8 +176,8 @@ void export_Signal() {
     :param Indicator slow: 慢线
     :return: 信号指示器)");
 
-    def("SG_CrossGold", SG_CrossGold, (arg("fast"), arg("slow")),
+    m.def("SG_CrossGold", SG_CrossGold, py::arg("fast"), py::arg("slow"),
-        R"(SG_CrossGold(fast, slow)
+          R"(SG_CrossGold(fast, slow)
 
     金叉指示器，当快线从下向上穿越慢线且快线和慢线的方向都是向上时为金叉，买入；
     当快线从上向下穿越慢线且快线和慢线的方向都是向下时死叉，卖出。::
@@ -206,8 +188,8 @@ void export_Signal() {
     :param Indicator slow: 慢线
     :return: 信号指示器)");
 
-    def("SG_Flex", SG_Flex, (arg("op"), arg("slow_n")),
+    m.def("SG_Flex", SG_Flex, py::arg("op"), py::arg("slow_n"),
-        R"(SG_Flex(ind, slow_n)
+          R"(SG_Flex(ind, slow_n)
 
     使用自身的EMA(slow_n)作为慢线，自身作为快线，快线向上穿越慢线买入，快线向下穿越慢线卖出。
 
@@ -215,8 +197,8 @@ void export_Signal() {
     :param int slow_n: 慢线EMA周期
     :return: 信号指示器)");
 
-    def("SG_Band", SG_Band, (arg("ind"), arg("lower"), arg("upper")),
+    m.def("SG_Band", SG_Band, py::arg("ind"), py::arg("lower"), py::arg("upper"),
-        R"(SG_Band(ind, lower, upper)
+          R"(SG_Band(ind, lower, upper)
     指标区间指示器, 当指标超过上轨时，买入；
     当指标低于下轨时，卖出。::
 

hikyuu_pywrap/trade_sys/_Slippage.cpp

@@ -5,55 +5,40 @@
  *      Author: fasiondog
  */
 
-#include <boost/python.hpp>
 #include <hikyuu/trade_sys/slippage/SlippageBase.h>
 #include <hikyuu/trade_sys/slippage/build_in.h>
-#include "../_Parameter.h"
+#include "../pybind_utils.h"
-#include "../pickle_support.h"
 
-using namespace boost::python;
+namespace py = pybind11;
 using namespace hku;
 
-class SlippageWrap : public SlippageBase, public wrapper<SlippageBase> {
+class PySlippageBase : public SlippageBase {
+    PY_CLONE(PySlippageBase, SlippageBase)
+
 public:
-    SlippageWrap() : SlippageBase() {}
+    using SlippageBase::SlippageBase;
-    SlippageWrap(const string& name) : SlippageBase(name) {}
-    virtual ~SlippageWrap() {}
 
-    void _reset() {
+    void _calculate() override {
-        if (override func = get_override("_reset")) {
+        PYBIND11_OVERLOAD_PURE(void, SlippageBase, _calculate, );
-            func();
-        } else {
-            SlippageBase::_reset();
-        }
     }
 
-    void default_reset() {
+    void _reset() override {
-        this->SlippageBase::_reset();
+        PYBIND11_OVERLOAD(void, SlippageBase, _reset, );
     }
 
-    SlippagePtr _clone() {
+    price_t getRealBuyPrice(const Datetime& datetime, price_t planPrice) override {
-        return this->get_override("_clone")();
+        PYBIND11_OVERLOAD_PURE_NAME(price_t, SlippageBase, "get_real_buy_price", getRealBuyPrice,
+                                    datetime, planPrice);
     }
 
-    void _calculate() {
+    price_t getRealSellPrice(const Datetime& datetime, price_t planPrice) override {
-        this->get_override("_calculate");
+        PYBIND11_OVERLOAD_PURE_NAME(price_t, SlippageBase, "get_real_sell_price", getRealSellPrice,
-    }
+                                    datetime, planPrice);
-
-    price_t getRealBuyPrice(const Datetime& datetime, price_t price) {
-        return this->get_override("get_real_buy_price")(datetime, price);
-    }
-
-    price_t getRealSellPrice(const Datetime& datetime, price_t price) {
-        return this->get_override("get_real_sell_price")(datetime, price);
     }
 };
 
-string (SlippageBase::*sp_get_name)() const = &SlippageBase::name;
+void export_Slippage(py::module& m) {
-void (SlippageBase::*sp_set_name)(const string&) = &SlippageBase::name;
+    py::class_<SlippageBase, SPPtr, PySlippageBase>(m, "SlippageBase", R"(移滑价差算法基类
-
-void export_Slippage() {
-    class_<SlippageWrap, boost::noncopyable>("SlippageBase", R"(移滑价差算法基类
 
 自定义移滑价差接口：
 
@@ -61,14 +46,20 @@ void export_Slippage() {
     - getRealSellPrice : 【必须】计算实际卖出价格
     - _calculate : 【必须】子类计算接口
     - _clone : 【必须】克隆接口
-    - _reset : 【可选】重载私有变量)",
+    - _reset : 【可选】重载私有变量)")
-                                             init<>())
-      .def(init<const string&>())
-      .def(self_ns::str(self))
-      .def(self_ns::repr(self))
 
-      .add_property("name", sp_get_name, sp_set_name, "名称")
+      .def(py::init<>())
-      .add_property("to", &SlippageBase::getTO, &SlippageBase::setTO, "设置或获取交易对象")
+      .def(py::init<const string&>(), R"(初始化构造函数
+        
+    :param str name: 名称)")
+
+      .def("__str__", to_py_str<SlippageBase>)
+      .def("__repr__", to_py_str<SlippageBase>)
+
+      .def_property("name", py::overload_cast<void>(&SlippageBase::name, py::const_),
+                    py::overload_cast<const string&>(&SlippageBase::name),
+                    py::return_value_policy::copy, "名称")
+      .def_property("to", &SlippageBase::getTO, &SlippageBase::setTO, "关联交易对象")
 
       .def("get_param", &SlippageBase::getParam<boost::any>, R"(get_param(self, name)
 
@@ -78,7 +69,7 @@ void export_Slippage() {
     :return: 参数值
     :raises out_of_range: 无此参数)")
 
-      .def("set_param", &SlippageBase::setParam<object>, R"(set_param(self, name, value)
+      .def("set_param", &SlippageBase::setParam<boost::any>, R"(set_param(self, name, value)
 
     设置参数
 
@@ -88,7 +79,7 @@ void export_Slippage() {
 
       .def("have_param", &SlippageBase::haveParam, "是否存在指定参数")
 
-      .def("get_real_buy_price", pure_virtual(&SlippageBase::getRealBuyPrice),
+      .def("get_real_buy_price", &SlippageBase::getRealBuyPrice,
            R"(get_real_buy_price(self, datetime, price)
 
     【重载接口】计算实际买入价格
@@ -98,7 +89,7 @@ void export_Slippage() {
     :return: 实际买入价格
     :rtype: float)")
 
-      .def("get_real_sell_price", pure_virtual(&SlippageBase::getRealSellPrice),
+      .def("get_real_sell_price", &SlippageBase::getRealSellPrice,
            R"(get_real_sell_price(self, datetime, price)
 
     【重载接口】计算实际卖出价格
@@ -110,21 +101,20 @@ void export_Slippage() {
 
       .def("reset", &SlippageBase::reset, "复位操作")
       .def("clone", &SlippageBase::clone, "克隆操作")
-      .def("_calculate", pure_virtual(&SlippageBase::_calculate), "【重载接口】子类计算接口")
+      .def("_calculate", &SlippageBase::_calculate, "【重载接口】子类计算接口")
-      .def("_reset", &SlippageBase::_reset, &SlippageWrap::default_reset,
+      .def("_reset", &SlippageBase::_reset, "【重载接口】子类复位接口，复位内部私有变量")
-           "【重载接口】子类复位接口，复位内部私有变量")
-      .def("_clone", pure_virtual(&SlippageBase::_clone), "【重载接口】子类克隆接口");
 
-    register_ptr_to_python<SlippagePtr>();
+        DEF_PICKLE(SPPtr);
 
-    def("SP_FixedPercent", SP_FixedPercent, (arg("p") = 0.001), R"(SP_FixedPercent([p=0.001])
+    m.def("SP_FixedPercent", SP_FixedPercent, py::arg("p") = 0.001,
+          R"(SP_FixedPercent([p=0.001])
 
     固定百分比移滑价差算法，买入实际价格 = 计划买入价格 * (1 + p)，卖出实际价格 = 计划卖出价格 * (1 - p)
 
     :param float p: 偏移的固定百分比
     :return: 移滑价差算法实例)");
 
-    def("SP_FixedValue", SP_FixedValue, (arg("value") = 0.01), R"(SP_FixedValuet([p=0.001])
+    m.def("SP_FixedValue", SP_FixedValue, py::arg("value") = 0.01, R"(SP_FixedValuet([p=0.001])
 
     固定价格移滑价差算法，买入实际价格 = 计划买入价格 + 偏移价格，卖出实际价格 = 计划卖出价格 - 偏移价格
 

hikyuu_pywrap/trade_sys/_Stoploss.cpp

@@ -5,74 +5,57 @@
  *      Author: fasiondog
  */
 
-#include <boost/python.hpp>
 #include <hikyuu/trade_sys/stoploss/build_in.h>
-#include "../_Parameter.h"
+#include "../pybind_utils.h"
-#include "../pickle_support.h"
 
-using namespace boost::python;
+namespace py = pybind11;
 using namespace hku;
 
-class StoplossWrap : public StoplossBase, public wrapper<StoplossBase> {
+class PyStoplossBase : public StoplossBase {
+    PY_CLONE(PyStoplossBase, StoplossBase)
+
 public:
-    StoplossWrap() : StoplossBase() {}
+    using StoplossBase::StoplossBase;
-    StoplossWrap(const string& name) : StoplossBase(name) {}
-    virtual ~StoplossWrap() {}
 
-    void _reset() {
+    void _calculate() override {
-        if (override func = this->get_override("_reset")) {
+        PYBIND11_OVERLOAD_PURE(void, StoplossBase, _calculate, );
-            func();
-        } else {
-            StoplossBase::_reset();
-        }
     }
 
-    void default_reset() {
+    void _reset() override {
-        this->StoplossBase::_reset();
+        PYBIND11_OVERLOAD(void, StoplossBase, _reset, );
     }
 
-    StoplossPtr _clone() {
+    price_t getPrice(const Datetime& datetime, price_t price) override {
-        return this->get_override("_clone")();
+        PYBIND11_OVERLOAD_PURE_NAME(price_t, StoplossBase, "get_price", getPrice, datetime, price);
     }
 
-    void _calculate() {
+    price_t getShortPrice(const Datetime& datetime, price_t price) override {
-        this->get_override("_calculate")();
+        PYBIND11_OVERLOAD_NAME(price_t, StoplossBase, "get_short_price", getShortPrice, datetime,
-    }
+                               price);
-
-    price_t getPrice(const Datetime& datetime, price_t price) {
-        return this->get_override("get_price")(datetime, price);
-    }
-
-    price_t getShortPrice(const Datetime& datetime, price_t price) {
-        if (override getShortPrice = get_override("get_short_price")) {
-            return getShortPrice(datetime, price);
-        }
-        return StoplossBase::getShortPrice(datetime, price);
-    }
-
-    price_t default_getShortPrice(const Datetime& datetime, price_t price) {
-        return this->StoplossBase::getShortPrice(datetime, price);
     }
 };
 
-string (StoplossBase::*st_get_name)() const = &StoplossBase::name;
+void export_Stoploss(py::module& m) {
-void (StoplossBase::*st_set_name)(const string&) = &StoplossBase::name;
+    py::class_<StoplossBase, StoplossPtr, PyStoplossBase>(m, "StoplossBase",
-
+                                                          R"(止损/止赢算法基类
-void export_Stoploss() {
-    class_<StoplossWrap, boost::noncopyable>("StoplossBase", R"(止损/止赢算法基类
 自定义止损/止赢策略接口：
 
     - _calculate : 【必须】子类计算接口
     - _clone : 【必须】克隆接口
-    - _reset : 【可选】重载私有变量)",
+    - _reset : 【可选】重载私有变量)")
-                                             init<>())
+      .def(py::init<>())
-      .def(init<const string&>())
+      .def(py::init<const string&>(), R"(初始化构造函数
-      .def(self_ns::str(self))
-      .def(self_ns::repr(self))
         
-      .add_property("name", st_get_name, st_set_name, "名称")
+    :param str name: 名称)")
-      .add_property("to", &StoplossBase::getTO, &StoplossBase::setTO, "设置或获取交易对象")
+
-      .add_property("tm", &StoplossBase::getTM, &StoplossBase::setTM, "设置或获取交易管理实例")
+      .def("__str__", to_py_str<StoplossBase>)
+      .def("__repr__", to_py_str<StoplossBase>)
+
+      .def_property("name", py::overload_cast<void>(&StoplossBase::name, py::const_),
+                    py::overload_cast<const string&>(&StoplossBase::name),
+                    py::return_value_policy::copy, "名称")
+      .def_property("tm", &StoplossBase::getTM, &StoplossBase::setTM, "关联交易管理实例")
+      .def_property("to", &StoplossBase::getTO, &StoplossBase::setTO, "关联交易对象")
 
       .def("get_param", &StoplossBase::getParam<boost::any>, R"(get_param(self, name)
 
@@ -82,7 +65,7 @@ void export_Stoploss() {
     :return: 参数值
     :raises out_of_range: 无此参数)")
 
-      .def("set_param", &StoplossBase::setParam<object>, R"(set_param(self, name, value)
+      .def("set_param", &StoplossBase::setParam<boost::any>, R"(set_param(self, name, value)
 
     设置参数
 
@@ -92,7 +75,7 @@ void export_Stoploss() {
 
       .def("have_param", &StoplossBase::haveParam, "是否存在指定参数")
 
-      .def("get_price", pure_virtual(&StoplossBase::getPrice), R"(get_price(self, datetime, price)
+      .def("get_price", &StoplossBase::getPrice, R"(get_price(self, datetime, price)
 
     【重载接口】获取本次预期交易（买入）时的计划止损价格，如果不存在止损价，则返回0。用于系统在交易执行前向止损策略模块查询本次交易的计划止损价。
 
@@ -104,31 +87,24 @@ void export_Stoploss() {
     :return: 止损价格
     :rtype: float)")
 
-      //.def("getShortPrice", &StoplossBase::getShortPrice, &StoplossWrap::default_getShortPrice)
+      .def("get_short_price", &StoplossBase::getShortPrice)
 
       .def("reset", &StoplossBase::reset, "复位操作")
       .def("clone", &StoplossBase::clone, "克隆操作")
-      .def("_calculate", pure_virtual(&StoplossBase::_calculate), "【重载接口】子类计算接口")
+      .def("_calculate", &StoplossBase::_calculate, "【重载接口】子类计算接口")
-      .def("_reset", &StoplossBase::_reset, &StoplossWrap::default_reset,
+      .def("_reset", &StoplossBase::_reset, "【重载接口】子类复位接口，复位内部私有变量")
-           "【重载接口】子类复位接口，复位内部私有变量")
-      .def("_clone", pure_virtual(&StoplossBase::_clone), "【重载接口】子类克隆接口")
 
-#if HKU_PYTHON_SUPPORT_PICKLE
+        DEF_PICKLE(StoplossPtr);
-      .def_pickle(name_init_pickle_suite<StoplossBase>())
-#endif
-      ;
 
-    register_ptr_to_python<StoplossPtr>();
+    m.def("ST_FixedPercent", ST_FixedPercent, py::arg("p") = 0.03, R"(ST_FixedPercent([p=0.03])
-
-    def("ST_FixedPercent", ST_FixedPercent, (arg("p") = 0.03), R"(ST_FixedPercent([p=0.03])
 
     固定百分比止损策略，即当价格低于买入价格的某一百分比时止损
 
     :param float p: 百分比(0,1]
     :return: 止损/止赢策略实例)");
 
-    def("ST_Indicator", ST_Indicator, (arg("op"), arg("kpart") = "CLOSE"),
+    m.def("ST_Indicator", ST_Indicator, py::arg("op"), py::arg("kpart") = "CLOSE",
-        R"(ST_Indicator(op[, kpart="CLOSE"])
+          R"(ST_Indicator(op[, kpart="CLOSE"])
 
     使用技术指标作为止损价。如使用10日EMA作为止损：::
 
@@ -138,8 +114,8 @@ void export_Stoploss() {
     :param string kpart: KDATA|OPEN|HIGH|LOW|CLOSE|AMO|VOL
     :return: 止损/止赢策略实例)");
 
-    def("ST_Saftyloss", ST_Saftyloss, (arg("n1") = 10, arg("n2") = 3, arg("p") = 2.0),
+    m.def("ST_Saftyloss", ST_Saftyloss, py::arg("n1") = 10, py::arg("n2") = 3, py::arg("p") = 2.0,
-        R"(ST_Saftyloss([n1=10, n2=3, p=2.0])
+          R"(ST_Saftyloss([n1=10, n2=3, p=2.0])
 
     参见《走进我的交易室》（2007年 地震出版社） 亚历山大.艾尔德(Alexander Elder) P202
     计算说明：在回溯周期内（一般为10到20天），将所有向下穿越的长度相加除以向下穿越的次数，

hikyuu_pywrap/trade_sys/_System.cpp

@@ -5,36 +5,28 @@
  *      Author: fasiondog
  */
 
-#include <boost/python.hpp>
 #include <hikyuu/trade_sys/system/build_in.h>
-#include <boost/python/suite/indexing/vector_indexing_suite.hpp>
+#include "../pybind_utils.h"
-#include "../_Parameter.h"
-#include "../pickle_support.h"
 
-using namespace boost::python;
+namespace py = pybind11;
 using namespace hku;
 
 #if defined(_MSC_VER)
 #pragma warning(disable : 4267)
 #endif
 
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(run_overload, run, 2, 3);
-
-const string& (System::*sys_get_name)() const = &System::name;
-void (System::*sys_set_name)(const string&) = &System::name;
-
 void (System::*run_1)(const KQuery&, bool) = &System::run;
 void (System::*run_2)(const KData&, bool) = &System::run;
 void (System::*run_3)(const Stock&, const KQuery&, bool reset) = &System::run;
 
 TradeRecord (System::*runMoment_1)(const Datetime&) = &System::runMoment;
 
-void export_System() {
+void export_System(py::module& m) {
-    def(
+    m.def(
-      "SYS_Simple", SYS_Simple,
+      "SYS_Simple", SYS_Simple, py::arg("tm") = TradeManagerPtr(),
-      (arg("tm") = TradeManagerPtr(), arg("mm") = MoneyManagerPtr(), arg("ev") = EnvironmentPtr(),
+      py::arg("mm") = MoneyManagerPtr(), py::arg("ev") = EnvironmentPtr(),
-       arg("cn") = ConditionPtr(), arg("sg") = SignalPtr(), arg("st") = StoplossPtr(),
+      py::arg("cn") = ConditionPtr(), py::arg("sg") = SignalPtr(), py::arg("st") = StoplossPtr(),
-       arg("tp") = StoplossPtr(), arg("pg") = ProfitGoalPtr(), arg("sp") = SlippagePtr()),
+      py::arg("tp") = StoplossPtr(), py::arg("pg") = ProfitGoalPtr(), py::arg("sp") = SlippagePtr(),
       R"(SYS_Simple([tm=None, mm=None, ev=None, cn=None, sg=None, st=None, tp=None, pg=None, sp=None])
 
   创建简单系统实例（每次交易不进行多次加仓或减仓，即每次买入后在卖出时全部卖出），  系统实例在运行时(调用run方法），至少需要一个配套的交易管理实例、一个资金管理策略
@@ -65,7 +57,7 @@ void export_System() {
     :param SlippageBase sp: 移滑价差算法
     :return: system实例)");
 
-    def("get_system_part_name", getSystemPartName, R"(get_system_part_name(part)
+    m.def("get_system_part_name", getSystemPartName, R"(get_system_part_name(part)
 
     获取部件的字符串名称
     
@@ -82,21 +74,22 @@ void export_System() {
     :param int part: System.Part 枚举值
     :rtype: str)");
 
-    def("get_system_part_enum", getSystemPartEnum, R"(get_system_part_enum(part_name)
+    m.def("get_system_part_enum", getSystemPartEnum, R"(get_system_part_enum(part_name)
 
      根据系统部件的字符串名称获取相应的枚举值
 
     :param str part_name: 系统部件的字符串名称，参见：:py:func:`getSystemPartName`
     :rtype: System.Part)");
 
-    class_<TradeRequest>(
+    py::class_<TradeRequest>(
-      "TradeRequest",
+      m, "TradeRequest",
-      R"(交易请求记录。系统内部在实现延迟操作时登记的交易请求信息。暴露该结构的主要目的是用于在“delay”模式（延迟到下一个bar开盘时进行交易）的情况下，系统实际已知下一个Bar将要进行交易，此时可通过 :py:meth:`System.getBuyTradeRequest` 、 :py:meth:`System.getSellTradeRequest` 来获知下一个BAR是否需要买入/卖出。主要用于提醒或打印下一个Bar需要进行操作。对于系统本身的运行没有影响。)",
+      R"(交易请求记录。系统内部在实现延迟操作时登记的交易请求信息。暴露该结构的主要目的是用于
-      init<>())
+在“delay”模式（延迟到下一个bar开盘时进行交易）的情况下，系统实际已知下一个Bar将要
-
+进行交易，此时可通过 System.getBuyTradeRequest() 、 System.getSellTradeRequest()
-      //.def(self_ns::str(self))
+来获知下一个BAR是否需要买入/卖出。主要用于提醒或打印下一个Bar需要进行操作。对于系统
-      //.def(self_ns::repr(self))
+本身的运行没有影响。)")
 
+      .def(py::init<>())
       .def_readwrite("valid", &TradeRequest::valid, "该交易请求记录是否有效（True | False）")
       .def_readwrite("business", &TradeRequest::business,
                      "交易业务类型，参见：:py:class:`hikyuu.trade_manage.BUSINESS`")
@@ -105,17 +98,11 @@ void export_System() {
       .def_readwrite("part", &TradeRequest::from,
                      "发出交易请求的来源，参见：:py:class:`System.Part`")
       .def_readwrite("count", &TradeRequest::count, "因操作失败，连续延迟的次数")
-#if HKU_PYTHON_SUPPORT_PICKLE
+        DEF_PICKLE(TradeRequest);
-      .def_pickle(normal_pickle_suite<TradeRequest>())
-#endif
-      ;
 
-    class_<SystemList>("SystemList").def(vector_indexing_suite<SystemList>());
+    py::class_<System, SystemPtr>(
-
+      m, "System",
-    scope in_System =
+      R"(系统基类。需要扩展或实现更复杂的系统交易行为，可从此类继承。
-      class_<System>(
-        "System",
-        R"(系统基类。需要扩展或实现更复杂的系统交易行为，可从此类继承。
 
 系统是指针对单个交易对象的完整策略，包括环境判断、系统有效条件、资金管理、止损、止盈、盈利目标、移滑价差的完整策略，用于模拟回测。
 
@@ -128,29 +115,30 @@ void export_System() {
   - tp_delay_n=3 (int) : 止盈延迟开始的天数，即止盈策略判断从实际交易几天后开始生效
   - ignore_sell_sg=False (bool) : 忽略卖出信号，只使用止损/止赢等其他方式卖出
   - ev_open_position=False (bool): 是否使用市场环境判定进行初始建仓
-  - cn_open_position=False (bool): 是否使用系统有效性条件进行初始建仓)",
+  - cn_open_position=False (bool): 是否使用系统有效性条件进行初始建仓)")
-        init<const string&>())
-        .def(init<const TradeManagerPtr&, const MoneyManagerPtr&, const EnvironmentPtr&,
-                  const ConditionPtr&, const SignalPtr&, const StoplossPtr&, const StoplossPtr&,
-                  const ProfitGoalPtr&, const SlippagePtr&, const string&>())
-        .def(self_ns::str(self))
-        .def(self_ns::repr(self))
 
-        .add_property("name",
+      .def(py::init<const string&>())
-                      make_function(sys_get_name, return_value_policy<copy_const_reference>()),
+      .def(py::init<const TradeManagerPtr&, const MoneyManagerPtr&, const EnvironmentPtr&,
-                      sys_set_name, "系统名称")
+                    const ConditionPtr&, const SignalPtr&, const StoplossPtr&, const StoplossPtr&,
-        .add_property("tm", &System::getTM, &System::setTM, "关联的交易管理实例")
+                    const ProfitGoalPtr&, const SlippagePtr&, const string&>())
-        .add_property("to", &System::getTO, &System::setTO, "交易对象 KData")
+      .def("__str__", to_py_str<System>)
-        .add_property("mm", &System::getMM, &System::setMM, "资金管理策略")
+      .def("__repr__", to_py_str<System>)
-        .add_property("ev", &System::getEV, &System::setEV, "市场环境判断策略")
-        .add_property("cn", &System::getCN, &System::setCN, "系统有效条件")
-        .add_property("sg", &System::getSG, &System::setSG, "信号指示器")
-        .add_property("st", &System::getST, &System::setST, "止损策略")
-        .add_property("tp", &System::getTP, &System::setTP, "止盈策略")
-        .add_property("pg", &System::getPG, &System::setPG, "盈利目标策略")
-        .add_property("sp", &System::getSP, &System::setSP, "移滑价差算法")
 
-        .def("get_param", &System::getParam<boost::any>, R"(get_param(self, name)
+      .def_property("name", py::overload_cast<void>(&System::name, py::const_),
+                    py::overload_cast<const string&>(&System::name), py::return_value_policy::copy,
+                    "系统名称")
+      .def_property("tm", &System::getTM, &System::setTM, "关联的交易管理实例")
+      .def_property("to", &System::getTO, &System::setTO, "交易对象 KData")
+      .def_property("mm", &System::getMM, &System::setMM, "资金管理策略")
+      .def_property("ev", &System::getEV, &System::setEV, "市场环境判断策略")
+      .def_property("cn", &System::getCN, &System::setCN, "系统有效条件")
+      .def_property("sg", &System::getSG, &System::setSG, "信号指示器")
+      .def_property("st", &System::getST, &System::setST, "止损策略")
+      .def_property("tp", &System::getTP, &System::setTP, "止盈策略")
+      .def_property("pg", &System::getPG, &System::setPG, "盈利目标策略")
+      .def_property("sp", &System::getSP, &System::setSP, "移滑价差算法")
+
+      .def("get_param", &System::getParam<boost::any>, R"(get_param(self, name)
 
     获取指定的参数
 
@@ -158,7 +146,7 @@ void export_System() {
     :return: 参数值
     :raises out_of_range: 无此参数)")
 
-        .def("set_param", &System::setParam<object>, R"(set_param(self, name, value)
+      .def("set_param", &System::setParam<boost::any>, R"(set_param(self, name, value)
 
     设置参数
 
@@ -166,56 +154,55 @@ void export_System() {
     :param value: 参数值
     :raises logic_error: Unsupported type! 不支持的参数类型)")
 
-        .def("have_param", &System::haveParam, "是否存在指定参数")
+      .def("have_param", &System::haveParam, "是否存在指定参数")
 
-        .def("get_stock", &System::getStock, R"(get_stock(self)
+      .def("get_stock", &System::getStock, R"(get_stock(self)
 
     获取关联的证券
 
     :rtype: Stock)")
 
-        .def("get_trade_record_list", &System::getTradeRecordList,
+      .def("get_trade_record_list", &System::getTradeRecordList, py::return_value_policy::copy,
-             return_value_policy<copy_const_reference>(), R"(get_trade_record_list(self)
+           R"(get_trade_record_list(self)
 
     获取实际执行的交易记录，和 TM 的区别是不包含权息调整带来的交易记录
 
     :rtype: TradeRecordList)")
 
-        .def("get_buy_trade_request", &System::getBuyTradeRequest,
+      .def("get_buy_trade_request", &System::getBuyTradeRequest, py::return_value_policy::copy,
-             return_value_policy<copy_const_reference>(), R"(get_buy_trade_request(self)
+           R"(get_buy_trade_request(self)
   
     获取买入请求，“delay”模式下查看下一时刻是否存在买入操作
 
     :rtype: TradeRequest)")
 
-        .def("get_sell_trade_request", &System::getSellTradeRequest,
+      .def("get_sell_trade_request", &System::getSellTradeRequest, py::return_value_policy::copy,
-             return_value_policy<copy_const_reference>(), R"(get_sell_trade_request(self)
+           R"(get_sell_trade_request(self)
 
     获取卖出请求，“delay”模式下查看下一时刻是否存在卖出操作
 
     :rtype: TradeRequest)")
 
-        /*.def("getSellShortTradeRequest", &System::getSellShortTradeRequest,
+      .def("get_sell_short_trade_request", &System::getSellShortTradeRequest,
-             return_value_policy<copy_const_reference>())
+           py::return_value_policy::copy)
-        .def("getBuyShortTradeRequest", &System::getBuyShortTradeRequest,
+      .def("get_buy_short_trade_request", &System::getBuyShortTradeRequest,
-             return_value_policy<copy_const_reference>())*/
+           py::return_value_policy::copy)
 
-        .def("reset", &System::reset, R"(reset(self, with_tm, with_ev)
+      .def("reset", &System::reset, R"(reset(self, with_tm, with_ev)
 
     复位操作。TM、EV是和具体系统无关的策略组件，可以在不同的系统中进行共享，复位将引起系统运行时被重新清空并计算。尤其是在共享TM时需要注意！
 
     :param bool with_tm: 是否复位TM组件
     :param bool with_ev: 是否复位EV组件)")
 
-        .def("clone", &System::clone, R"(clone(self)
+      .def("clone", &System::clone, R"(clone(self)
 
     克隆操作。)")
 
-        //.def("run", &System::run, run_overload(args("stock", "query", "reset")))
+      .def("run", run_1, py::arg("query"), py::arg("reset") = true)
-        .def("run", run_1, (arg("query"), arg("reset") = true))
+      .def("run", run_2, py::arg("kdata"), py::arg("reset") = true)
-        .def("run", run_2, (arg("kdata"), arg("reset") = true))
+      .def("run", run_3, py::arg("stock"), py::arg("query"), py::arg("reset") = true,
-        .def("run", run_3, (arg("stock"), arg("query"), arg("reset") = true),
+           R"(run(self, stock, query[, reset=True])
-             R"(run(self, stock, query[, reset=True])
   
     运行系统，执行回测
 
@@ -223,14 +210,11 @@ void export_System() {
     :param Query query: K线数据查询条件
     :param bool reset: 是否同时复位所有组件，尤其是tm实例)")
 
-        .def("ready", &System::readyForRun)
+      .def("ready", &System::readyForRun)
 
-#if HKU_PYTHON_SUPPORT_PICKLE
+        DEF_PICKLE(System);
-        .def_pickle(name_init_pickle_suite<System>())
-#endif
-      ;
 
-    enum_<SystemPart>("Part")
+    py::enum_<SystemPart>(m, "Part")
       .value("ENVIRONMENT", PART_ENVIRONMENT)
       .value("CONDITION", PART_CONDITION)
       .value("SIGNAL", PART_SIGNAL)
@@ -241,6 +225,4 @@ void export_System() {
       .value("SLIPPAGE", PART_SLIPPAGE)
       .value("ALLOCATEFUNDS", PART_ALLOCATEFUNDS)
       .value("INVALID", PART_INVALID);
-
-    register_ptr_to_python<SystemPtr>();
 }

hikyuu_pywrap/trade_sys/trade_sys_main.cpp

@@ -12,12 +12,12 @@ namespace py = pybind11;
 void export_Environment(py::module& m);
 void export_Condition(py::module& m);
 void export_MoneyManager(py::module& m);
-// void export_Signal(py::module& m);
+void export_Signal(py::module& m);
-// void export_Stoploss(py::module& m);
+void export_Stoploss(py::module& m);
 void export_ProfitGoal(py::module& m);
-// void export_Slippage(py::module& m);
+void export_Slippage(py::module& m);
-// void export_System(py::module& m);
+void export_System(py::module& m);
-// void export_Selector(py::module& m);
+void export_Selector(py::module& m);
 void export_Portfolio(py::module& m);
 void export_AllocateFunds(py::module& m);
 
@@ -25,12 +25,12 @@ void export_trade_sys_main(py::module& m) {
     export_Environment(m);
     export_Condition(m);
     export_MoneyManager(m);
-    // export_Signal(m);
+    export_Signal(m);
-    // export_Stoploss(m);
+    export_Stoploss(m);
     export_ProfitGoal(m);
-    // export_Slippage(m);
+    export_Slippage(m);
-    // export_System(m);
+    export_System(m);
-    // export_Selector(m);
+    export_Selector(m);
     export_AllocateFunds(m);
     export_Portfolio(m);
 }

hikyuu_pywrap/xmake.lua

@@ -44,14 +44,8 @@ target("core")
     add_files("./global/*.cpp")
     add_files("./trade_instance/*.cpp")
     add_files("./trade_manage/*.cpp")
-    add_files("./trade_sys/trade_sys_main.cpp")
+    add_files("./trade_sys/*.cpp")
-    add_files("./trade_sys/_AllocateFunds.cpp")
+
-    add_files("./trade_sys/_Condition.cpp")
-    add_files("./trade_sys/_Environment.cpp")
-    add_files("./trade_sys/_MoneyManager.cpp")
-    add_files("./trade_sys/_Portfolio.cpp")
-    add_files("./trade_sys/_ProfitGoal.cpp")
-    -- add_files("./trade_sys/_ProfitGoal.cpp")
 
     add_rpathdirs("$ORIGIN", "$ORIGIN/lib", "$ORIGIN/../lib")