hikyuu 2.3.1__py3-none-macosx_11_1_arm64.whl

hikyuu/include/hikyuu/strategy/BrokerTradeManager.h

@@ -0,0 +1,433 @@
+/*
+ *  Copyright (c) 2024 hikyuu.org
+ *
+ *  Created on: 2024-08-16
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "hikyuu/trade_manage/TradeManagerBase.h"
+
+namespace hku {
+
+class HKU_API BrokerTradeManager : public TradeManagerBase {
+public:
+    BrokerTradeManager() = default;
+    explicit BrokerTradeManager(const OrderBrokerPtr& broker,
+                                const TradeCostPtr& costfunc = TC_Zero(),
+                                const string& name = "SYS");
+    virtual ~BrokerTradeManager() {}
+
+    virtual void _reset() override;
+
+    virtual shared_ptr<TradeManagerBase> _clone() override;
+
+    virtual void fetchAssetInfoFromBroker(const OrderBrokerPtr& broker) override;
+
+    /**
+     * 根据权息信息更新当前持仓与交易情况
+     * @note 必须按时间顺序调用
+     * @param datetime 当前时刻
+     */
+    virtual void updateWithWeight(const Datetime& datetime) override {}
+
+    /**
+     * 获取指定对象的保证金比率
+     * @param datetime 日期
+     * @param stock 指定对象
+     */
+    virtual double getMarginRate(const Datetime& datetime, const Stock& stock) override {
+        HKU_WARN("The subclass does not implement a getMarginRate method");
+        return 0.0;
+    }
+
+    /** 初始资金 */
+    virtual price_t initCash() const override {
+        return m_cash;
+    }
+
+    /** 账户建立日期 */
+    virtual Datetime initDatetime() const override {
+        return m_datetime;
+    }
+
+    /** 第一笔买入交易发生日期，如未发生交易返回Null<Datetime>() */
+    virtual Datetime firstDatetime() const override {
+        return m_datetime;
+    }
+
+    /** 最后一笔交易日期，注意和交易类型无关，如未发生交易返回账户建立日期 */
+    virtual Datetime lastDatetime() const override {
+        return m_datetime;
+    }
+
+    /**
+     * 返回当前现金
+     * @note 仅返回当前信息，不会根据权息进行调整
+     */
+    virtual price_t currentCash() const override {
+        return m_cash;
+    }
+
+    /**
+     * 获取指定日期的现金
+     * @note 如果不带日期参数，无法根据权息信息调整持仓
+     */
+    virtual price_t cash(const Datetime& datetime, KQuery::KType ktype = KQuery::DAY) override {
+        return m_cash;
+    }
+
+    /**
+     * 当前是否持有指定的证券
+     * @note 这里未使用日期参数，必须保证是按日期顺序执行
+     * @param stock 指定证券
+     * @return true 是 | false 否
+     */
+    virtual bool have(const Stock& stock) const override {
+        return m_position.count(stock.id()) ? true : false;
+    }
+
+    /**
+     * 当前空头仓位是否持有指定的证券
+     * @note 这里未使用日期参数，必须保证是按日期顺序执行
+     * @param stock 指定证券
+     * @return true 是 | false 否
+     */
+    virtual bool haveShort(const Stock& stock) const override {
+        HKU_WARN("The subclass does not implement this method");
+        return false;
+    }
+
+    /** 当前持有的证券种类数量 */
+    virtual size_t getStockNumber() const override {
+        return m_position.size();
+    }
+
+    /** 当前空头持有的证券种类数量 */
+    virtual size_t getShortStockNumber() const override {
+        HKU_WARN("The subclass does not implement this method");
+        return 0;
+    }
+
+    /** 获取指定时刻的某证券持有数量 */
+    virtual double getHoldNumber(const Datetime& datetime, const Stock& stock) override {
+        HKU_WARN("The subclass does not implement this method");
+        return 0.0;
+    }
+
+    /** 获取指定时刻的空头某证券持有数量 */
+    virtual double getShortHoldNumber(const Datetime& datetime, const Stock& stock) override {
+        HKU_WARN("The subclass does not implement this method");
+        return 0.0;
+    }
+
+    /** 获取指定时刻已借入的股票数量 */
+    virtual double getDebtNumber(const Datetime& datetime, const Stock& stock) override {
+        HKU_WARN("The subclass does not implement this method");
+        return 0.0;
+    }
+
+    /** 获取指定时刻已借入的现金额 */
+    virtual price_t getDebtCash(const Datetime& datetime) override {
+        HKU_WARN("The subclass does not implement this method");
+        return 0.0;
+    }
+
+    /** 获取全部交易记录 */
+    virtual TradeRecordList getTradeList() const override {
+        HKU_WARN("The subclass does not implement this method");
+        return TradeRecordList();
+    }
+
+    /**
+     * 获取指定日期范围内的交易记录[start, end)
+     * @param start 起始日期
+     * @param end 结束日期
+     * @return 交易记录列表
+     */
+    virtual TradeRecordList getTradeList(const Datetime& start,
+                                         const Datetime& end) const override {
+        HKU_WARN("The subclass does not implement this method");
+        return TradeRecordList();
+    }
+
+    /** 获取当前全部持仓记录 */
+    virtual PositionRecordList getPositionList() const override;
+
+    /** 获取全部历史持仓记录，即已平仓记录 */
+    virtual PositionRecordList getHistoryPositionList() const override {
+        HKU_WARN("The subclass does not implement this method");
+        return PositionRecordList();
+    }
+
+    /** 获取当前全部空头仓位记录 */
+    virtual PositionRecordList getShortPositionList() const override {
+        HKU_WARN("The subclass does not implement this method");
+        return PositionRecordList();
+    }
+
+    /** 获取全部空头历史仓位记录 */
+    virtual PositionRecordList getShortHistoryPositionList() const override {
+        HKU_WARN("The subclass does not implement this method");
+        return PositionRecordList();
+    }
+
+    /**
+     * 获取指定证券的持仓记录
+     * @param date 指定日期
+     * @param stock 指定的证券
+     */
+    virtual PositionRecord getPosition(const Datetime& date, const Stock& stock) override;
+
+    /**
+     * 获取指定证券的空头持仓记录
+     * @param stock 指定的证券
+     */
+    virtual PositionRecord getShortPosition(const Stock& stock) const override {
+        HKU_WARN("The subclass does not implement this method");
+        return PositionRecord();
+    }
+
+    /** 获取当前借入的股票列表 */
+    virtual BorrowRecordList getBorrowStockList() const override {
+        HKU_WARN("The subclass does not implement this method");
+        return BorrowRecordList();
+    }
+
+    /**
+     * 存入资金
+     * @param datetime 存入时间
+     * @param cash 存入的资金量
+     * @return true | false
+     */
+    virtual bool checkin(const Datetime& datetime, price_t cash) override;
+
+    /**
+     * 取出资金
+     * @param datetime 取出时间
+     * @param cash 取出的资金量
+     * @return true | false
+     */
+    virtual bool checkout(const Datetime& datetime, price_t cash) override {
+        m_cash = (cash > m_cash) ? 0.0 : m_cash - cash;
+        return true;
+    }
+
+    /**
+     * 存入资产
+     * @param datetime 存入日期
+     * @param stock 待存入的股票
+     * @param price 存入股票的每股价格
+     * @param number 存入股票的数量
+     * @return true | false
+     */
+    virtual bool checkinStock(const Datetime& datetime, const Stock& stock, price_t price,
+                              double number) override {
+        HKU_WARN("The subclass does not implement this method");
+        return false;
+    }
+
+    /**
+     * 取出当前资产
+     * @param datetime 取出日期
+     * @param stock 待取出的股票
+     * @param price 取出的每股价格
+     * @param number 取出的数量
+     * @return true | false
+     * @note 应该不会被用到
+     */
+    virtual bool checkoutStock(const Datetime& datetime, const Stock& stock, price_t price,
+                               double number) override {
+        HKU_WARN("The subclass does not implement this method");
+        return false;
+    }
+
+    /**
+     * 买入操作
+     * @param datetime 买入时间
+     * @param stock 买入的证券
+     * @param realPrice 实际买入价格
+     * @param number 买入数量
+     * @param stoploss 止损价
+     * @param goalPrice 目标价格
+     * @param planPrice 计划买入价格
+     * @param from 记录是哪个系统部件发出的买入指示
+     * @return 返回对应的交易记录，如果操作失败，business等于BUSINESS_INVALID
+     */
+    virtual TradeRecord buy(const Datetime& datetime, const Stock& stock, price_t realPrice,
+                            double number, price_t stoploss = 0.0, price_t goalPrice = 0.0,
+                            price_t planPrice = 0.0, SystemPart from = PART_INVALID) override;
+
+    /**
+     * 卖出操作
+     * @param datetime 卖出时间
+     * @param stock 卖出的证券
+     * @param realPrice 实际卖出价格
+     * @param number 卖出数量，如果是 MAX_DOUBLE, 表示全部卖出
+     * @param stoploss 新的止损价
+     * @param goalPrice 新的目标价格
+     * @param planPrice 原计划卖出价格
+     * @param from 记录是哪个系统部件发出的卖出指示
+     * @return 返回对应的交易记录，如果操作失败，business等于BUSINESS_INVALID
+     */
+    virtual TradeRecord sell(const Datetime& datetime, const Stock& stock, price_t realPrice,
+                             double number = MAX_DOUBLE, price_t stoploss = 0.0,
+                             price_t goalPrice = 0.0, price_t planPrice = 0.0,
+                             SystemPart from = PART_INVALID) override;
+
+    /**
+     * 卖空
+     * @param datetime 卖空时间
+     * @param stock 卖空的证券
+     * @param realPrice 实际卖空价格
+     * @param number 卖出数量
+     * @param stoploss 止损价
+     * @param goalPrice 目标价格
+     * @param planPrice 计划卖空价格
+     * @param from 记录是哪个系统部件发出的买入指示
+     * @return 返回对应的交易记录，如果操作失败，business等于BUSINESS_INVALID
+     */
+    virtual TradeRecord sellShort(const Datetime& datetime, const Stock& stock, price_t realPrice,
+                                  double number, price_t stoploss = 0.0, price_t goalPrice = 0.0,
+                                  price_t planPrice = 0.0,
+                                  SystemPart from = PART_INVALID) override {
+        HKU_WARN("The subclass does not implement this method");
+        return TradeRecord();
+    }
+
+    /**
+     * 卖空后回补
+     * @param datetime 买入时间
+     * @param stock 买入的证券
+     * @param realPrice 实际买入价格
+     * @param number 卖出数量，如果是 MAX_DOUBLE, 表示全部卖出
+     * @param stoploss 止损价
+     * @param goalPrice 目标价格
+     * @param planPrice 计划买入价格
+     * @param from 记录是哪个系统部件发出的卖出指示
+     * @return 返回对应的交易记录，如果操作失败，business等于BUSINESS_INVALID
+     */
+    virtual TradeRecord buyShort(const Datetime& datetime, const Stock& stock, price_t realPrice,
+                                 double number = MAX_DOUBLE, price_t stoploss = 0.0,
+                                 price_t goalPrice = 0.0, price_t planPrice = 0.0,
+                                 SystemPart from = PART_INVALID) override {
+        HKU_WARN("The subclass does not implement this method");
+        return TradeRecord();
+    }
+
+    /**
+     * 借入资金，从其他来源借取的资金，如融资
+     * @param datetime 借入时间
+     * @param cash 借入的现金
+     * @return true | false
+     */
+    virtual bool borrowCash(const Datetime& datetime, price_t cash) override {
+        HKU_WARN("The subclass does not implement this method");
+        return false;
+    }
+
+    /**
+     * 归还资金
+     * @param datetime 归还日期
+     * @param cash 归还现金
+     * @return true | false
+     */
+    virtual bool returnCash(const Datetime& datetime, price_t cash) override {
+        HKU_WARN("The subclass does not implement this method");
+        return false;
+    }
+
+    /**
+     * 借入证券
+     * @param datetime 借入时间
+     * @param stock 借入的stock
+     * @param price 借入时单股价格
+     * @param number 借入时数量
+     * @return true | false
+     */
+    virtual bool borrowStock(const Datetime& datetime, const Stock& stock, price_t price,
+                             double number) override {
+        HKU_WARN("The subclass does not implement this method");
+        return false;
+    }
+
+    /**
+     * 归还证券
+     * @param datetime 归还时间
+     * @param stock 归还的stock
+     * @param price 归还时单股价格
+     * @param number 归还数量
+     * @return true | false
+     */
+    virtual bool returnStock(const Datetime& datetime, const Stock& stock, price_t price,
+                             double number) override {
+        HKU_WARN("The subclass does not implement this method");
+        return false;
+    }
+
+    /**
+     * 获取账户当前时刻的资产详情
+     * @param ktype 日期的类型
+     * @return 资产详情
+     */
+    virtual FundsRecord getFunds(KQuery::KType ktype = KQuery::DAY) const override;
+
+    /**
+     * 获取指定时刻的资产市值详情
+     * @param datetime 必须大于帐户建立的初始日期，或为Null<Datetime>()
+     * @param ktype 日期的类型
+     * @return 资产详情
+     * @note 当datetime等于Null<Datetime>()时，与getFunds(KType)同
+     */
+    virtual FundsRecord getFunds(const Datetime& datetime,
+                                 KQuery::KType ktype = KQuery::DAY) override;
+
+    /**
+     * 直接加入交易记录
+     * @note 如果加入初始化账户记录，将清除全部已有交易及持仓记录
+     * @param tr 待加入的交易记录
+     * @return bool true 成功 | false 失败
+     */
+    virtual bool addTradeRecord(const TradeRecord& tr) override {
+        HKU_WARN("The subclass does not implement this method");
+        return false;
+    }
+
+    /**
+     * 直接加入持仓记录
+     * @param pr 持仓记录
+     * @return true 成功
+     * @return false 失败
+     */
+    virtual bool addPosition(const PositionRecord& pr) override {
+        HKU_WARN("The subclass does not implement this method");
+        return false;
+    }
+
+    /** 字符串输出 */
+    virtual string str() const override;
+
+    /**
+     * 以csv格式输出交易记录、未平仓记录、已平仓记录、资产净值曲线
+     * @param path 输出文件所在目录
+     */
+    virtual void tocsv(const string& path) override {
+        HKU_WARN("The subclass does not implement this method");
+    }
+
+private:
+    Datetime m_datetime;  // 当前日期
+
+    price_t m_cash{0.0};  // 当前可用现金
+
+    typedef map<uint64_t, PositionRecord> position_map_type;
+    position_map_type m_position;  // 当前持仓交易对象的持仓记录
+};
+
+TradeManagerPtr HKU_API crtBrokerTM(const OrderBrokerPtr& broker,
+                                    const TradeCostPtr& costfunc = TC_Zero(),
+                                    const string& name = "SYS",
+                                    const std::vector<OrderBrokerPtr>& other_brokers = {});
+
+}  // namespace hku

hikyuu/include/hikyuu/strategy/RunPortfolioInStrategy.h

@@ -0,0 +1,37 @@
+/*
+ *  Copyright (c) 2024 hikyuu.org
+ *
+ *  Created on: 2024-08-25
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "hikyuu/trade_sys/portfolio/Portfolio.h"
+#include "Strategy.h"
+
+namespace hku {
+
+class HKU_API RunPortfolioInStrategy {
+public:
+    RunPortfolioInStrategy() = default;
+    RunPortfolioInStrategy(const PFPtr& pf, const KQuery& query, int adjust_cycle,
+                           const OrderBrokerPtr& broker, const TradeCostPtr& costfunc);
+    virtual ~RunPortfolioInStrategy() = default;
+
+    void run();
+
+private:
+    PFPtr m_pf;
+    OrderBrokerPtr m_broker;
+    KQuery m_query;
+    int m_adjust_cycle = 1;
+};
+
+StrategyPtr HKU_API crtPFStrategy(const PFPtr& pf, const KQuery& query, int adjust_cycle,
+                                  const OrderBrokerPtr& broker, const TradeCostPtr& costfunc,
+                                  const string& name = "PFStrategy",
+                                  const std::vector<OrderBrokerPtr>& other_brokers = {},
+                                  const string& config_file = "");
+
+}  // namespace hku

hikyuu/include/hikyuu/strategy/RunSystemInStrategy.h

@@ -0,0 +1,38 @@
+/*
+ *  Copyright (c) 2024 hikyuu.org
+ *
+ *  Created on: 2024-08-24
+ *      Author: fasiondog
+ */
+
+#pragma once
+#include "hikyuu/trade_sys/system/System.h"
+#include "Strategy.h"
+
+namespace hku {
+
+class HKU_API RunSystemInStrategy {
+public:
+    RunSystemInStrategy() = default;
+    RunSystemInStrategy(const SYSPtr& sys, const OrderBrokerPtr& broker, const KQuery& query,
+                        const TradeCostPtr& costfunc);
+    virtual ~RunSystemInStrategy() = default;
+
+    void run(const Stock& stock);
+
+private:
+    SYSPtr m_sys;
+    OrderBrokerPtr m_broker;
+    KQuery m_query;
+
+    TradeRequest m_buyRequest;
+    TradeRequest m_sellRequest;
+};
+
+StrategyPtr HKU_API crtSysStrategy(const SYSPtr& sys, const string& stk_market_code,
+                                   const KQuery& query, const OrderBrokerPtr& broker,
+                                   const TradeCostPtr& costfunc, const string& name = "SYSStrategy",
+                                   const std::vector<OrderBrokerPtr>& other_brokers = {},
+                                   const string& config_file = "");
+
+}  // namespace hku

hikyuu/include/hikyuu/strategy/Strategy.h

@@ -0,0 +1,191 @@
+/*
+ *  Copyright(C) 2021 hikyuu.org
+ *
+ *  Create on: 2021-02-16
+ *     Author: fasiondog
+ */
+
+#pragma once
+
+#include <future>
+#include "hikyuu/DataType.h"
+#include "hikyuu/StrategyContext.h"
+#include "hikyuu/global/SpotRecord.h"
+#include "hikyuu/utilities/thread/FuncWrapper.h"
+#include "hikyuu/utilities/thread/ThreadSafeQueue.h"
+#include "hikyuu/trade_sys/portfolio/Portfolio.h"
+#include "BrokerTradeManager.h"
+
+namespace hku {
+
+/**
+ * @ingroup Strategy
+ * @{
+ */
+
+/**
+ * @brief 策略运行时
+ */
+class HKU_API Strategy {
+    CLASS_LOGGER_IMP(Strategy)
+    PARAMETER_SUPPORT_WITH_CHECK
+
+public:
+    Strategy();
+    explicit Strategy(const string& name, const string& config_file = "");
+    Strategy(const vector<string>& codeList, const vector<KQuery::KType>& ktypeList,
+             const string& name = "Strategy", const string& config_file = "");
+    explicit Strategy(const StrategyContext& context, const string& name = "Strategy",
+                      const string& config_file = "");
+
+    Strategy(const Strategy&) = delete;
+    Strategy& operator=(const Strategy&) = delete;
+
+    virtual ~Strategy();
+
+    const string& name() const {
+        return m_name;
+    }
+
+    void name(const string& name) {
+        m_name = name;
+    }
+
+    const StrategyContext& context() const {
+        return m_context;
+    }
+
+    /**
+     * 每日开盘时间内，以 delta 为周期循环定时执行指定任务
+     * @param func 待执行的任务
+     * @param delta 间隔时间
+     * @param market 指定的市场
+     * @param ignoreMarket 是否忽略市场时间限制，如为 true，则为定时循环不受开闭市时间限制
+     */
+    void runDaily(std::function<void()>&& func, const TimeDelta& delta,
+                  const std::string& market = "SH", bool ignoreMarket = false);
+
+    /**
+     * 每日在指定时刻执行任务
+     * @param func 待执行的任务
+     * @param delta 指定时刻
+     * @param ignoreHoliday 忽略节假日，即节假日不执行
+     */
+    void runDailyAt(std::function<void()>&& func, const TimeDelta& delta,
+                    bool ignoreHoliday = true);
+
+    /**
+     * 正确数据发生变化调用，即接收到相应行情数据变更
+     * @note 通常用于调试。且只要收到行情采集消息就会触发，不受开、闭市时间限制
+     * @param changeFunc 回调函数
+     */
+    void onChange(std::function<void(const Stock&, const SpotRecord& spot)>&& changeFunc);
+
+    /**
+     * 一批行情数据接受完毕后通知
+     * @note 通常仅用于调试打印，该批行情数据中不一定含有上下文中包含的 stock
+     *       且只要收到行情采集消息就会触发，不受开、闭市时间限制。
+     * @param recievedFucn 回调函数
+     */
+    void onReceivedSpot(std::function<void(const Datetime&)>&& recievedFucn);
+
+    /**
+     * 启动策略执行，必须在已注册相关处理函数后执行
+     */
+    void start(bool autoRecieveSpot = true);
+
+private:
+    string m_name;
+    string m_config_file;
+    StrategyContext m_context;
+    std::function<void(const Datetime&)> m_on_recieved_spot;
+    std::function<void(const Stock&, const SpotRecord& spot)> m_on_change;
+
+    std::function<void()> m_run_daily_func;
+    TimeDelta m_run_daily_delta;
+    string m_run_daily_market;
+    bool m_ignoreMarket{false};
+
+    std::map<TimeDelta, std::function<void()>> m_run_daily_at_funcs;
+
+private:
+    void _initParam();
+    void _init();
+    void _receivedSpot(const SpotRecord& spot);
+    void _runDaily();
+    void _runDailyAt();
+
+private:
+    static std::atomic_bool ms_keep_running;
+    static void sig_handler(int sig);
+
+    typedef FuncWrapper event_type;
+    ThreadSafeQueue<event_type> m_event_queue;  // 消息队列
+
+    /** 先消息队列提交任务后返回的对应 future 的类型 */
+    template <typename ResultType>
+    using event_handle = std::future<ResultType>;
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4996)
+#endif
+
+    /** 向线程池提交任务 */
+    template <typename FunctionType>
+    event_handle<typename std::result_of<FunctionType()>::type> event(FunctionType f) {
+        typedef typename std::result_of<FunctionType()>::type result_type;
+        std::packaged_task<result_type()> task(f);
+        event_handle<result_type> res(task.get_future());
+        m_event_queue.push(std::move(task));
+        return res;
+    }
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+    void _startEventLoop();
+};
+
+typedef shared_ptr<Strategy> StrategyPtr;
+
+/**
+ * @brief 在策略运行时中执行系统交易 SYS
+ * @note 目前仅支持 buy_delay| sell_delay 均为 false 的系统，即 close 时执行交易
+ * @param sys 交易系统
+ * @param stk 交易对象
+ * @param query 查询条件
+ * @param broker 订单代理（专用与和账户资产同步的订单代理）
+ * @param costfunc 成本函数
+ * @param other_brokers 其他的订单代理
+ */
+void HKU_API runInStrategy(const SYSPtr& sys, const Stock& stk, const KQuery& query,
+                           const OrderBrokerPtr& broker, const TradeCostPtr& costfunc,
+                           const std::vector<OrderBrokerPtr>& other_brokers = {});
+
+/**
+ * @brief 在策略运行时中执行组合策略 PF
+ * @note 目前仅支持 buy_delay| sell_delay 均为 false 的系统，即 close 时执行交易
+ * @param pf 资产组合
+ * @param query 查询条件
+ * @param adjust_cycle 调仓周期
+ * @param broker 订单代理（专用与和账户资产同步的订单代理）
+ * @param costfunc 成本函数
+ * @param other_brokers 其他的订单代理
+ */
+void HKU_API runInStrategy(const PFPtr& pf, const KQuery& query, int adjust_cycle,
+                           const OrderBrokerPtr& broker, const TradeCostPtr& costfunc,
+                           const std::vector<OrderBrokerPtr>& other_brokers = {});
+
+/**
+ * 从 hikyuu 数据缓存服务器拉取更新最新的缓存数据
+ * @param addr 缓存服务地址，如: tcp://192.168.1.1:9201
+ * @param stklist 待更新的股票列表
+ * @param ktype 指定更新的K线类型
+ */
+void HKU_API getDataFromBufferServer(const std::string& addr, const StockList& stklist,
+                                     const KQuery::KType& ktype);
+
+/** @} */
+}  // namespace hku

hikyuu/include/hikyuu/strategy/__init__.py

@@ -0,0 +1 @@
+