策略 Demo3:

#include <pybind11/pybind11.h>
#include <pybind11/stl.h>

#include <kungfu/yijinjing/common.h>
#include <kungfu/yijinjing/log/setup.h>
#include <kungfu/wingchun/strategy/context.h>
#include <kungfu/wingchun/strategy/strategy.h>

#include <thread_pool.h>

namespace py = pybind11;

using std::placeholders::_1;
using std::placeholders::_2;
using std::placeholders::_3;

using namespace kungfu;
using namespace kungfu::wingchun;
using namespace kungfu::wingchun::strategy;


std::string info_bar(const wingchun::msg::data::Bar& bar) {
    nlohmann::json bar_json;
    wingchun::msg::data::to_json(bar_json, bar);
    return safe_dump(bar_json);
}

std::string info_quote(const wingchun::msg::data::Quote& quote) {
    nlohmann::json quote_json;
    wingchun::msg::data::to_json(quote_json, quote);
    return safe_dump(quote_json);
}

void today_bar_callback(Context_ptr context, const std::map<std::string, std::vector<wingchun::msg::data::Bar>>& bar_map) {
    SPDLOG_INFO("{} called", __func__);
    for (const auto& item : bar_map) {
        SPDLOG_INFO("code: {}", item.first);
        for (const wingchun::msg::data::Bar& bar : item.second) {
            SPDLOG_INFO("code: {}, open: {}, close: {}", bar.code, bar.open, bar.close);
        }
    }
}

class DemoStrategy : public StrategyWithBook
{
public:
    DemoStrategy(yijinjing::data::location_ptr home):StrategyWithBook(home), count_(0)
    {
        yijinjing::log::copy_log_settings(home, home->name);
    };

    // bar 分钟级别行情回调
    void on_bar(Context_ptr context, const wingchun::msg::data::Bar &bar) override
    {
        SPDLOG_INFO("{} called, data: {}", __func__, info_bar(bar));
    }

    void on_indicator(Context_ptr context, const std::string& type, const nlohmann::json& indicator) override {
        SPDLOG_INFO("{} called, type: {}, data: {}", __func__, type, safe_dump(indicator));
    }

    // 启动前
    void pre_start(Context_ptr context) override
    {
        SPDLOG_INFO("pre run strategy");
        StrategyWithBook::pre_start(context);
    }

    // 启动后
    void post_start(Context_ptr context) override
    {
        SPDLOG_INFO("cpp demo post start");
        test(context);
    }

    std::string info_bar(const wingchun::msg::data::Bar& bar) {
        std::ostringstream ostr;
        ostr << "Bar data, trading_day: " << bar.trading_day
            << ", source_id: " << bar.source_id
            << ", instrument_id: " << bar.instrument_id
            << ", exchange_id: " << bar.exchange_id
            << ", code: " << bar.code
            << ", type: " << bar.type
            << ", start_time: " << bar.start_time
            << ", end_time: " << bar.end_time
            << ", time_interval: " << bar.time_interval
            << ", open: " << bar.open
            << ", close: " << bar.close
            << ", low: " << bar.low
            << ", high: " << bar.high
            << ", volume: " << bar.volume
            << ", start_volume: " << bar.start_volume
            << ", turnover: " << bar.turnover
            << ", start_turnover: " << bar.start_turnover
            << ", period: " << bar.period;

        return ostr.str();
    }

    std::string info_quote(const wingchun::msg::data::Quote& quote) {
        std::ostringstream ostr;
        ostr << "Quote data, source_id: " << quote.source_id
            << ", trading_day: " << quote.trading_day
            << ", data_time: " << quote.data_time
            << ", instrument_id: " << quote.instrument_id
            << ", exchange_id: " << quote.exchange_id
            << ", instrument_type: " << int(quote.instrument_type)
            << ", kungfu_time_flag: " << quote.kungfu_time_flag
            << ", pre_close_price: " << quote.pre_close_price
            << ", pre_settlement_price: " << quote.pre_settlement_price
            << ", last_price: " << quote.last_price
            << ", volume: " << quote.volume
            << ", turnover: " << quote.turnover
            << ", pre_open_interest: " << quote.pre_open_interest
            << ", open_interest: " << quote.open_interest
            << ", open_price: " << quote.open_price
            << ", high_price: " << quote.high_price
            << ", low_price: " << quote.low_price
            << ", upper_limit_price: " << quote.upper_limit_price
            << ", lower_limit_price: " << quote.lower_limit_price
            << ", close_price: " << quote.close_price
            << ", settlement_price: " << quote.settlement_price
            << ", iopv: " << quote.iopv
            << ", pre_iopv: " << quote.pre_iopv
            << ", ticker_status: " << quote.ticker_status
            << ", total_bid_volume: " << quote.total_bid_volume
            << ", total_ask_volume: " << quote.total_ask_volume
            << ", ma_bid_price: " << quote.ma_bid_price
            << ", ma_ask_price: " << quote.ma_ask_price
            << ", bid_price: ";


        for (double price : quote.bid_price) {
            ostr << price << ",";
        }

        ostr << " ask_price: ";
        for (double price : quote.ask_price) {
            ostr << price << ",";
        }

        ostr << " bid_volume: ";

        for (int64_t volume : quote.bid_volume) {
            ostr << volume << ",";
        }

        ostr << " ask_volume: ";

        for (int64_t volume : quote.ask_volume) {
            ostr << volume << ",";
        }

        // return ostr.str().pop_back();
        return ostr.str();
    }

    void test_query_bar_today(Context_ptr context) {
        SPDLOG_INFO("{} start", __func__);
        std::vector<std::string> codes = {"600000.SSE", "000002.SZ"};
        std::map<std::string, std::vector<wingchun::msg::data::Bar>> today_bar = context->query_bar_today(codes, "5m");

        for (auto& kv : today_bar) {
            for (auto& bar : kv.second) {
                SPDLOG_INFO("{}", info_bar(bar));
            }
        }

        SPDLOG_INFO("{} end", __func__);
    }

    void today_bar_callback(Context_ptr context, const std::map<std::string, std::vector<wingchun::msg::data::Bar>>& bar_map, uint64_t query_id) {
        SPDLOG_INFO("{} called, query id: {}", __func__, query_id);
        for (const auto& item : bar_map) {
            SPDLOG_INFO("code: {}", item.first);
            for (const wingchun::msg::data::Bar& bar : item.second) {
                SPDLOG_INFO("{}", info_bar(bar));
            }
        }
    }

    void test_query_bar_today_async(Context_ptr context) {
        SPDLOG_INFO("{} start", __func__);
        std::vector<std::string> codes = {"600000.SSE", "000002.SZ"};
        context->query_bar_today_async(codes, std::bind(&DemoStrategy::today_bar_callback, this, _1, _2, _3), "2m", 51);
        // context->query_bar_today_async(codes, today_bar_callback, "2m");
    }

    void test_query_bar(Context_ptr context) {
        SPDLOG_INFO("{} start", __func__);

        nlohmann::json params = {
            {"code", "000001.SZ"},
            {"start_date", "2013-01-04"},
            {"end_date", "2014-01-04"},
            {"period", "1d"},
            {"adjust_type", "pre"}
        };

        std::vector<wingchun::msg::data::Bar> bars = context->query_bar(params);

        for (const auto bar : bars) {
            SPDLOG_INFO("{}", info_bar(bar));
        }
    }


    void query_bar_callback(Context_ptr context, const std::vector<wingchun::msg::data::Bar>& bars, uint64_t query_id) {
        SPDLOG_INFO("{} called, query_id: {}", __func__, query_id);

        for (const auto bar : bars) {
            SPDLOG_INFO("receive bar: {}", info_bar(bar));
        }
    }


    void test_query_bar_async(Context_ptr context) {
        SPDLOG_INFO("{} start", __func__);

        nlohmann::json params = {
            {"code", "000001.SZ"},
            {"start_date", "2013-01-04"},
            {"end_date", "2014-01-04"},
            {"period", "1d"},
            {"adjust_type", "pre"}
        };

        context->query_bar_async(params, std::bind(&DemoStrategy::query_bar_callback, this, _1, _2, _3), 52);
    }

    void test_query_market_data(Context_ptr context) {
        SPDLOG_INFO("{} start", __func__);

        nlohmann::json params = {
            {"code", "000001.SZ"},
            {"start_date", "2013-01-04"},
            {"end_date", "2014-01-04"}
        };

        std::vector<wingchun::msg::data::Quote> quotes = context->query_market_data(params);

        for (const auto quote : quotes) {
            SPDLOG_INFO("quote data: {}", info_quote(quote));
        }
    }

    void query_market_data_callback(Context_ptr context, const std::vector<wingchun::msg::data::Quote>& quotes, uint64_t query_id) {
        SPDLOG_INFO("{} called, query id: {}", __func__, query_id);

        for (const auto quote : quotes) {
            SPDLOG_INFO("{}", info_quote(quote));
        }
    }

    void test_query_market_data_async(Context_ptr context) {
        SPDLOG_INFO("{} start", __func__);

        nlohmann::json params = {
            {"code", "000001.SZ"},
            {"start_date", "2014-01-04"},
            {"end_date", "2014-01-08"}
        };

        context->query_market_data_async(params, std::bind(&DemoStrategy::query_market_data_callback, this, _1, _2, _3), 53);

    }

    void test_query_data(Context_ptr context) {
        SPDLOG_INFO("{} start", __func__);
        std::string method = "bar";
        nlohmann::json params = {
            {"code", "000001.SZ"},
            {"start_date", "2014-01-04"},
            {"end_date", "2014-02-04"},
            {"period", "1d"},
            {"adjust_type", "pre"}
        };

        nlohmann::json result = context->query_data(method, params);

        int code = result["code"];
        std::string msg = result["msg"].get<std::string>();

        SPDLOG_INFO("query data, code: {}, msg: {}", code, msg);

        if (code == 200) {
            for (const auto& bar : result["data"]) {
                SPDLOG_INFO("Bar data: {}", safe_dump(bar));
            }
        }

        SPDLOG_INFO("{} end", __func__);
    }

    void query_data_callback(Context_ptr context, nlohmann::json result, uint64_t query_id) {
        SPDLOG_INFO("{} called", __func__);

        int code = result["code"];
        std::string msg = result["msg"].get<std::string>();

        SPDLOG_INFO("query data, code: {}, msg: {}", code, msg);

        if (code == 200) {
            for (const auto& data : result["data"]) {
                SPDLOG_INFO("data: {}", safe_dump(data));
            }
        }
    }

    void test_query_data_async(Context_ptr context) {
        SPDLOG_INFO("{} start", __func__);

        std::string method = "market_data";
        nlohmann::json params = {
            {"code", "000001.SZ"},
            {"start_date", "2013-01-04"},
            {"end_date", "2014-01-04"}
        };

        context->query_data_async(method, params, std::bind(&DemoStrategy::query_data_callback, this, _1, _2, _3), 54);

        SPDLOG_INFO("{} end", __func__);
    }

    void test_query_data_page(Context_ptr context) {
        SPDLOG_INFO("{} start", __func__);
        std::string method = "bar";
        int page_size = 100;
        int current_page = 1;
        nlohmann::json params = {
            {"code", "000001.SZ"},
            {"start_date", "2014-01-04"},
            {"end_date", "2014-02-04"},
            {"period", "1d"},
            {"adjust_type", "pre"},
            {"page_size", 100},
            {"current_page", 1}
        };
        wingchun::msg::data::DataPageInfo data_page_info = context->query_data_page(method, params);
        SPDLOG_INFO("{}, currentPage: {}, totalPage: {}, pageSize: {}, totalCount: {}", __func__, data_page_info.currentPage, data_page_info.totalPage, data_page_info.pageSize, data_page_info.totalCount);

        int code = data_page_info.data["code"];

        std::string msg = data_page_info.data["msg"].get<std::string>();

        SPDLOG_INFO("code: {}, msg: {}", code, msg);


        for (const auto& bar : data_page_info.data["data"]) {
            SPDLOG_INFO("{}, bar data: {}", __func__, safe_dump(bar));
        }

        SPDLOG_INFO("{} end", __func__);
    }

    void query_data_page_callback(Context_ptr context, const DataPageInfo& data_page_info, uint64_t query_id) {
        SPDLOG_INFO("{}, query id: {}, currentPage: {}, totalPage: {}, pageSize: {}, totalCount: {}", __func__, query_id, data_page_info.currentPage, data_page_info.totalPage, data_page_info.pageSize, data_page_info.totalCount);

        int code = data_page_info.data["code"];
        std::string msg = data_page_info.data["msg"].get<std::string>();

        SPDLOG_INFO("code: {}, msg: {}", code, msg);

        for (const auto& bar : data_page_info.data["data"]) {
            SPDLOG_INFO("{}, bar data: {}", __func__, safe_dump(bar));
        }

    }

    void test_query_data_page_async(Context_ptr context) {
        SPDLOG_INFO("{} start", __func__);
        std::string method = "bar";
        int page_size = 100;
        int current_page = 1;
        nlohmann::json params = {
            {"code", "000001.SZ"},
            {"start_date", "2014-01-04"},
            {"end_date", "2014-02-04"},
            {"period", "1d"},
            {"adjust_type", "pre"},
            {"page_size", 100},
            {"current_page", 1}
        };
        context->query_data_page_async(method, params, std::bind(&DemoStrategy::query_data_page_callback, this, _1, _2,_3), 55);

        SPDLOG_INFO("{} end", __func__);
    }

    void indicator_callback(Context_ptr context, const std::string& indicator_type, const nlohmann::json& indicator) {
        SPDLOG_INFO("indicator type: {}, data: {}", indicator_type, safe_dump(indicator));
    }


    void test_sub_indicator(Context_ptr context) {
        SPDLOG_INFO("{} start", __func__);
        std::vector<std::string> codes = {"512160.SSE", "159631.SZ"};

        std::vector<std::string> failed_codes;

        failed_codes = context->subscribe_indicator("etf", codes, std::bind(&DemoStrategy::indicator_callback, this, _1, _2, _3));

        // 或者使用如下订阅方式, indicator 通过 on_indicator 接收
        // failed_codes = context->subscribe_indicator("etf", codes);

        SPDLOG_INFO("failed codes: {}", safe_dump(nlohmann::json(failed_codes)));

        SPDLOG_INFO("{} end", __func__);
    }


    void bar_callback(Context_ptr context, const wingchun::msg::data::Bar &bar)
    {
        SPDLOG_INFO("{} called, data: {}", __func__, info_bar(bar));
    }

    void test_sub_bar(Context_ptr context) {
        SPDLOG_INFO("{} start", __func__);
        std::vector<std::string> codes = {"000002.SZ", "600004.SSE"};

        std::vector<std::string> failed_codes;

        failed_codes = context->subscribe_bar(codes, "2m", std::bind(&DemoStrategy::bar_callback, this, _1, _2));

        // 或者使用如下方式订阅, Bar 通过 on_bar 接收
        // failed_codes = context->subscribe_bar(codes, "2m", std::bind(&DemoStrategy::bar_callback, this, _1, _2));

        SPDLOG_INFO("failed codes: {}", safe_dump(nlohmann::json(failed_codes)));

        SPDLOG_INFO("{} end", __func__);
    }


    void test(Context_ptr context) {
        // test_query_bar_today(context);
        // test_query_bar_today_async(context);
        // test_query_bar(context);
        // test_query_bar_async(context);
        // test_query_market_data(context);
        // test_query_market_data_async(context);
        // test_query_data(context);
        // test_query_data_async(context);
        // test_query_data_page(context);
        // test_query_data_page_async(context);
        test_sub_indicator(context);
        test_sub_bar(context);
    }


    // 获取编译策略的kungfu版本号，本函数不允许修改。
    virtual const std::string getCompileVersion() const override
    {
        std::ostringstream ver;
#ifdef ALPHAX_VERSION
        ver<<ALPHAX_VERSION;
#else
        ver<<DEFAULT_COMPILE_VERSION;
#endif
        SPDLOG_INFO("Version: {}.", ver.str());
        return ver.str();
    }

private:
    // 静态行情整个交易日都不会变，启动策略时取到所有证券的静态数据后，需要时直接使用
    // 而不需要用一次查一次，性能很差(因为需要读写文件)
    // add by zz on 20210112
    std::unordered_map<std::string, QuoteStaticFullInfo> quotes;

    uint64_t count_;

};

PYBIND11_MODULE(PY_MODULE, m)
{
    py::class_<DemoStrategy, Strategy, std::shared_ptr<DemoStrategy>>(m, "Strategy")
        .def(py::init<yijinjing::data::location_ptr>())
        .def("pre_start", &DemoStrategy::pre_start)
        .def("post_start", &DemoStrategy::post_start)
        .def("pre_stop", &DemoStrategy::pre_stop)
        .def("post_stop", &DemoStrategy::post_stop)
        .def("on_trading_day", &DemoStrategy::on_trading_day)
        .def("on_quote", &DemoStrategy::on_quote)
        .def("on_bar", &DemoStrategy::on_bar)
        .def("on_entrust", &DemoStrategy::on_entrust)
        .def("on_transaction", &DemoStrategy::on_transaction)
        .def("on_order", &DemoStrategy::on_order)
        .def("on_order_action_error", &DemoStrategy::on_order_action_error)
        .def("on_trade", &DemoStrategy::on_trade)
        .def("on_order_book", &DemoStrategy::on_order_book)
        .def("on_cancelorder_feedback", &DemoStrategy::on_cancelorder_feedback)
        .def("on_client_msg", &DemoStrategy::on_client_msg)
        .def("on_query_bondIPO_info", &DemoStrategy::on_query_bondIPO_info)
        .def("on_query_bondIPO_end", &DemoStrategy::on_query_bondIPO_end)
        .def("on_query_bondswapstock_info", &DemoStrategy::on_query_bondswapstock_info)
        .def("on_query_bondswapstock_end", &DemoStrategy::on_query_bondswapstock_end)
        .def("on_query_IPO_quota_info", &DemoStrategy::on_query_IPO_quota_info)
        .def("on_query_IPO_quota_info_end", &DemoStrategy::on_query_IPO_quota_info_end)
        .def("on_query_IPO_info_list", &DemoStrategy::on_query_IPO_info_list)
        .def("on_query_IPO_info_list_end", &DemoStrategy::on_query_IPO_info_list_end)
        .def("getCompileVersion", &DemoStrategy::getCompileVersion);
}

备注：“策略 Demo3”，从 2.1.2 版本开始支持