hikyuu 2.1.0__cp310-none-win_amd64.whl → 2.1.2__cp310-none-win_amd64.whl

hikyuu/include/hikyuu/global/GlobalSpotAgent.h

@@ -5,6 +5,7 @@
  *     Author: fasiondog
  */
 
+#pragma once
 #include "agent/SpotAgent.h"
 
 namespace hku {

hikyuu/include/hikyuu/global/GlobalTaskGroup.h

@@ -11,15 +11,17 @@
 #ifndef HKU_GLOBAL_TASK_GROUP
 #define HKU_GLOBAL_TASK_GROUP
 
-#include "../utilities/thread/StealThreadPool.h"
+#include "../utilities/thread/thread.h"
 
 namespace hku {
 
+using TaskGroup = ThreadPool;
+
 /**
  * 获取全局线程池任务组
  * @note 请使用 future 获取任务返回
  */
-StealThreadPool* getGlobalTaskGroup();
+TaskGroup* getGlobalTaskGroup();
 
 template <typename ResultType>
 using task_handle = std::future<ResultType>;

hikyuu/include/hikyuu/global/SpotRecord.h

@@ -0,0 +1,52 @@
+/*
+ *  Copyright (c) 2024 hikyuu.org
+ *
+ *  Created on: 2024-08-15
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "hikyuu/DataType.h"
+
+namespace hku {
+
+/**
+ * 接收外部实时数据结构
+ * @ingroup Agent
+ */
+struct HKU_API SpotRecord {
+    string market;            ///< 市场标识
+    string code;              ///< 证券代码
+    string name;              ///< 证券名称
+    Datetime datetime;        ///< 数据时间
+    price_t yesterday_close;  ///< 昨日收盘价
+    price_t open;             ///< 开盘价
+    price_t high;             ///< 最高价
+    price_t low;              ///< 最低价
+    price_t close;            ///< 收盘价
+    price_t amount;           ///< 成交金额 （千元）
+    price_t volume;           ///< 成交量（手）
+    price_t bid1;             ///< 买一价
+    price_t bid1_amount;      ///< 买一数量（手）
+    price_t bid2;             ///< 买二价
+    price_t bid2_amount;      ///< 买二数量
+    price_t bid3;             ///< 买三价
+    price_t bid3_amount;      ///< 买三数量
+    price_t bid4;             ///< 买四价
+    price_t bid4_amount;      ///< 买四数量
+    price_t bid5;             ///< 买五价
+    price_t bid5_amount;      ///< 买五数量
+    price_t ask1;             ///< 卖一价
+    price_t ask1_amount;      ///< 卖一数量
+    price_t ask2;             ///< 卖二价
+    price_t ask2_amount;      ///< 卖二数量
+    price_t ask3;             ///< 卖三价
+    price_t ask3_amount;      ///< 卖三数量
+    price_t ask4;             ///< 卖四价
+    price_t ask4_amount;      ///< 卖四数量
+    price_t ask5;             ///< 卖五价
+    price_t ask5_amount;      ///< 卖五数量
+};
+
+}  // namespace hku

hikyuu/include/hikyuu/global/agent/SpotAgent.h

@@ -9,49 +9,17 @@
 
 #include <thread>
 #include <functional>
-#include "spot_generated.h"
 #include "../../DataType.h"
 #include "../../utilities/thread/ThreadPool.h"
+#include "../SpotRecord.h"
 
-namespace hku {
+namespace hikyuu {
+namespace flat {
+struct Spot;
+}
+}  // namespace hikyuu
 
-/**
- * 接收外部实时数据结构
- * @ingroup Agent
- */
-struct HKU_API SpotRecord {
-    string market;            ///< 市场标识
-    string code;              ///< 证券代码
-    string name;              ///< 证券名称
-    Datetime datetime;        ///< 数据时间
-    price_t yesterday_close;  ///< 昨日收盘价
-    price_t open;             ///< 开盘价
-    price_t high;             ///< 最高价
-    price_t low;              ///< 最低价
-    price_t close;            ///< 收盘价
-    price_t amount;           ///< 成交金额 （千元）
-    price_t volume;           ///< 成交量（手）
-    price_t bid1;             ///< 买一价
-    price_t bid1_amount;      ///< 买一数量（手）
-    price_t bid2;             ///< 买二价
-    price_t bid2_amount;      ///< 买二数量
-    price_t bid3;             ///< 买三价
-    price_t bid3_amount;      ///< 买三数量
-    price_t bid4;             ///< 买四价
-    price_t bid4_amount;      ///< 买四数量
-    price_t bid5;             ///< 买五价
-    price_t bid5_amount;      ///< 买五数量
-    price_t ask1;             ///< 卖一价
-    price_t ask1_amount;      ///< 卖一数量
-    price_t ask2;             ///< 卖二价
-    price_t ask2_amount;      ///< 卖二数量
-    price_t ask3;             ///< 卖三价
-    price_t ask3_amount;      ///< 卖三数量
-    price_t ask4;             ///< 卖四价
-    price_t ask4_amount;      ///< 卖四数量
-    price_t ask5;             ///< 卖五价
-    price_t ask5_amount;      ///< 卖五数量
-};
+namespace hku {
 
 /**
  * 接收外部实时数据代理
@@ -77,6 +45,7 @@ public:
 
     /** 设置是否打印数据接收进展情况，主要用于在交互环境下关闭打印 */
     void setPrintFlag(bool print) {
+        std::lock_guard<std::mutex> lock(m_mutex);
         m_print = print;
     }
 
@@ -136,14 +105,18 @@ private:
     enum STATUS { WAITING, RECEIVING };  // 等待新的批次数据，正在接收批次数据中
     enum STATUS m_status = WAITING;      // 当前内部状态
     std::atomic_bool m_stop = true;      // 结束代理工作标识
-    bool m_print = true;          // 是否打印接收进度，防止的交互模式的影响
+
     int m_revTimeout = 100;       // 连接数据服务超时时长（毫秒）
     size_t m_batch_count = 0;     // 记录本次批次接收的数据数量
     std::thread m_receiveThread;  // 数据接收线程
     ThreadPool m_tg;              // 数据处理任务线程池
+    vector<std::future<void>> m_process_task_list;
+
+    // 下面属性被修改时需要加锁，以便可以使用多线程方式运行 strategy
+    std::mutex m_mutex;
+    bool m_print = true;  // 是否打印接收进度，防止的交互模式的影响
     list<std::function<void(const SpotRecord&)>> m_processList;  // 已注册的 spot 处理函数列表
     list<std::function<void(Datetime)>> m_postProcessList;  // 已注册的批次后处理函数列表
-    vector<std::future<void>> m_process_task_list;
 };
 
 }  // namespace hku

hikyuu/include/hikyuu/hikyuu.h

@@ -16,6 +16,7 @@
 #include "indicator/build_in.h"
 #include "trade_manage/build_in.h"
 #include "trade_sys/all.h"
+#include "strategy/Strategy.h"
 
 namespace hku {
 

hikyuu/include/hikyuu/strategy/{AccountTradeManager.h → BrokerTradeManager.h}

@@ -1,28 +1,36 @@
 /*
- *  Copyright(C) 2021 hikyuu.org
+ *  Copyright (c) 2024 hikyuu.org
  *
- *  Create on: 2021-03-23
- *     Author: fasiondog
+ *  Created on: 2024-08-16
+ *      Author: fasiondog
  */
 
 #pragma once
 
-#include <httplib.h>
-#include "../trade_manage/TradeManagerBase.h"
+#include "hikyuu/trade_manage/TradeManagerBase.h"
 
 namespace hku {
 
-class HKU_API AccountTradeManager : public TradeManagerBase {
+class HKU_API BrokerTradeManager : public TradeManagerBase {
 public:
-    AccountTradeManager() = default;
-    AccountTradeManager(const string& name, const string& pwd);
-    virtual ~AccountTradeManager() = default;
+    BrokerTradeManager() = default;
+    explicit BrokerTradeManager(const OrderBrokerPtr& broker,
+                                const TradeCostPtr& costfunc = TC_Zero(),
+                                const string& name = "SYS");
+    virtual ~BrokerTradeManager() {}
 
-    virtual void _reset() override {}
+    virtual void _reset() override;
 
-    virtual shared_ptr<TradeManagerBase> _clone() override {
-        return std::make_shared<AccountTradeManager>();
-    }
+    virtual shared_ptr<TradeManagerBase> _clone() override;
+
+    virtual void fetchAssetInfoFromBroker(const OrderBrokerPtr& broker) override;
+
+    /**
+     * 根据权息信息更新当前持仓与交易情况
+     * @note 必须按时间顺序调用
+     * @param datetime 当前时刻
+     */
+    virtual void updateWithWeight(const Datetime& datetime) override {}
 
     /**
      * 获取指定对象的保证金比率
@@ -36,26 +44,22 @@ public:
 
     /** 初始资金 */
     virtual price_t initCash() const override {
-        HKU_WARN("The subclass does not implement this method");
-        return 0.0;
+        return m_cash;
     }
 
     /** 账户建立日期 */
     virtual Datetime initDatetime() const override {
-        HKU_WARN("The subclass does not implement this method");
-        return Datetime();
+        return m_datetime;
     }
 
     /** 第一笔买入交易发生日期，如未发生交易返回Null<Datetime>() */
     virtual Datetime firstDatetime() const override {
-        HKU_WARN("The subclass does not implement this method");
-        return Datetime();
+        return m_datetime;
     }
 
     /** 最后一笔交易日期，注意和交易类型无关，如未发生交易返回账户建立日期 */
     virtual Datetime lastDatetime() const override {
-        HKU_WARN("The subclass does not implement this method");
-        return Datetime();
+        return m_datetime;
     }
 
     /**
@@ -63,8 +67,7 @@ public:
      * @note 仅返回当前信息，不会根据权息进行调整
      */
     virtual price_t currentCash() const override {
-        HKU_WARN("The subclass does not implement this method");
-        return 0.0;
+        return m_cash;
     }
 
     /**
@@ -72,8 +75,7 @@ public:
      * @note 如果不带日期参数，无法根据权息信息调整持仓
      */
     virtual price_t cash(const Datetime& datetime, KQuery::KType ktype = KQuery::DAY) override {
-        HKU_WARN("The subclass does not implement this method");
-        return 0.0;
+        return m_cash;
     }
 
     /**
@@ -83,8 +85,7 @@ public:
      * @return true 是 | false 否
      */
     virtual bool have(const Stock& stock) const override {
-        HKU_WARN("The subclass does not implement this method");
-        return false;
+        return m_position.count(stock.id()) ? true : false;
     }
 
     /**
@@ -93,49 +94,48 @@ public:
      * @param stock 指定证券
      * @return true 是 | false 否
      */
-    virtual bool haveShort(const Stock& stock) const override {
+    virtual bool haveShort(const Stock& stock) const {
         HKU_WARN("The subclass does not implement this method");
         return false;
     }
 
     /** 当前持有的证券种类数量 */
-    virtual size_t getStockNumber() const override {
-        HKU_WARN("The subclass does not implement this method");
-        return 0;
+    virtual size_t getStockNumber() const {
+        return m_position.size();
     }
 
     /** 当前空头持有的证券种类数量 */
-    virtual size_t getShortStockNumber() const override {
+    virtual size_t getShortStockNumber() const {
         HKU_WARN("The subclass does not implement this method");
         return 0;
     }
 
     /** 获取指定时刻的某证券持有数量 */
-    virtual double getHoldNumber(const Datetime& datetime, const Stock& stock) override {
+    virtual double getHoldNumber(const Datetime& datetime, const Stock& stock) {
         HKU_WARN("The subclass does not implement this method");
         return 0.0;
     }
 
     /** 获取指定时刻的空头某证券持有数量 */
-    virtual double getShortHoldNumber(const Datetime& datetime, const Stock& stock) override {
+    virtual double getShortHoldNumber(const Datetime& datetime, const Stock& stock) {
         HKU_WARN("The subclass does not implement this method");
         return 0.0;
     }
 
     /** 获取指定时刻已借入的股票数量 */
-    virtual double getDebtNumber(const Datetime& datetime, const Stock& stock) override {
+    virtual double getDebtNumber(const Datetime& datetime, const Stock& stock) {
         HKU_WARN("The subclass does not implement this method");
         return 0.0;
     }
 
     /** 获取指定时刻已借入的现金额 */
-    virtual price_t getDebtCash(const Datetime& datetime) override {
+    virtual price_t getDebtCash(const Datetime& datetime) {
         HKU_WARN("The subclass does not implement this method");
         return 0.0;
     }
 
     /** 获取全部交易记录 */
-    virtual TradeRecordList getTradeList() const override {
+    virtual TradeRecordList getTradeList() const {
         HKU_WARN("The subclass does not implement this method");
         return TradeRecordList();
     }
@@ -146,50 +146,51 @@ public:
      * @param end 结束日期
      * @return 交易记录列表
      */
-    virtual TradeRecordList getTradeList(const Datetime& start,
-                                         const Datetime& end) const override {
+    virtual TradeRecordList getTradeList(const Datetime& start, const Datetime& end) const {
         HKU_WARN("The subclass does not implement this method");
         return TradeRecordList();
     }
 
     /** 获取当前全部持仓记录 */
-    virtual PositionRecordList getPositionList() const override {
-        HKU_WARN("The subclass does not implement this method");
-        return PositionRecordList();
-    }
+    virtual PositionRecordList getPositionList() const override;
 
     /** 获取全部历史持仓记录，即已平仓记录 */
-    virtual PositionRecordList getHistoryPositionList() const override {
+    virtual PositionRecordList getHistoryPositionList() const {
         HKU_WARN("The subclass does not implement this method");
         return PositionRecordList();
     }
 
     /** 获取当前全部空头仓位记录 */
-    virtual PositionRecordList getShortPositionList() const override {
+    virtual PositionRecordList getShortPositionList() const {
         HKU_WARN("The subclass does not implement this method");
         return PositionRecordList();
     }
 
     /** 获取全部空头历史仓位记录 */
-    virtual PositionRecordList getShortHistoryPositionList() const override {
+    virtual PositionRecordList getShortHistoryPositionList() const {
         HKU_WARN("The subclass does not implement this method");
         return PositionRecordList();
     }
 
-    /** 获取指定证券的当前持仓记录，如当前未持有该票，返回Null<PositionRecord>() */
-    virtual PositionRecord getPosition(const Datetime&, const Stock&) override {
-        HKU_WARN("The subclass does not implement this method");
-        return PositionRecord();
-    }
+    /**
+     * 获取指定证券的持仓记录
+     * @param date 指定日期
+     * @param stock 指定的证券
+     */
+    virtual PositionRecord getPosition(const Datetime& date, const Stock& stock) override;
 
-    /** 获取指定证券的当前空头仓位持仓记录，如当前未持有该票，返回Null<PositionRecord>() */
-    virtual PositionRecord getShortPosition(const Stock&) const override {
+    /**
+     * 获取指定证券的空头持仓记录
+     * @param date 指定日期
+     * @param stock 指定的证券
+     */
+    virtual PositionRecord getShortPosition(const Stock&) const {
         HKU_WARN("The subclass does not implement this method");
         return PositionRecord();
     }
 
     /** 获取当前借入的股票列表 */
-    virtual BorrowRecordList getBorrowStockList() const override {
+    virtual BorrowRecordList getBorrowStockList() const {
         HKU_WARN("The subclass does not implement this method");
         return BorrowRecordList();
     }
@@ -200,10 +201,7 @@ public:
      * @param cash 存入的资金量
      * @return true | false
      */
-    virtual bool checkin(const Datetime& datetime, price_t cash) override {
-        HKU_WARN("The subclass does not implement this method");
-        return false;
-    }
+    virtual bool checkin(const Datetime& datetime, price_t cash) override;
 
     /**
      * 取出资金
@@ -212,8 +210,8 @@ public:
      * @return true | false
      */
     virtual bool checkout(const Datetime& datetime, price_t cash) override {
-        HKU_WARN("The subclass does not implement this method");
-        return false;
+        m_cash = (cash > m_cash) ? 0.0 : m_cash - cash;
+        return true;
     }
 
     /**
@@ -225,7 +223,7 @@ public:
      * @return true | false
      */
     virtual bool checkinStock(const Datetime& datetime, const Stock& stock, price_t price,
-                              double number) override {
+                              double number) {
         HKU_WARN("The subclass does not implement this method");
         return false;
     }
@@ -240,7 +238,7 @@ public:
      * @note 应该不会被用到
      */
     virtual bool checkoutStock(const Datetime& datetime, const Stock& stock, price_t price,
-                               double number) override {
+                               double number) {
         HKU_WARN("The subclass does not implement this method");
         return false;
     }
@@ -259,10 +257,7 @@ public:
      */
     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 {
-        HKU_WARN("The subclass does not implement this method");
-        return TradeRecord();
-    }
+                            price_t planPrice = 0.0, SystemPart from = PART_INVALID) override;
 
     /**
      * 卖出操作
@@ -279,10 +274,7 @@ public:
     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 {
-        HKU_WARN("The subclass does not implement this method");
-        return TradeRecord();
-    }
+                             SystemPart from = PART_INVALID) override;
 
     /**
      * 卖空
@@ -298,8 +290,7 @@ public:
      */
     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 {
+                                  price_t planPrice = 0.0, SystemPart from = PART_INVALID) {
         HKU_WARN("The subclass does not implement this method");
         return TradeRecord();
     }
@@ -319,7 +310,7 @@ public:
     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 {
+                                 SystemPart from = PART_INVALID) {
         HKU_WARN("The subclass does not implement this method");
         return TradeRecord();
     }
@@ -330,7 +321,7 @@ public:
      * @param cash 借入的现金
      * @return true | false
      */
-    virtual bool borrowCash(const Datetime& datetime, price_t cash) override {
+    virtual bool borrowCash(const Datetime& datetime, price_t cash) {
         HKU_WARN("The subclass does not implement this method");
         return false;
     }
@@ -341,7 +332,7 @@ public:
      * @param cash 归还现金
      * @return true | false
      */
-    virtual bool returnCash(const Datetime& datetime, price_t cash) override {
+    virtual bool returnCash(const Datetime& datetime, price_t cash) {
         HKU_WARN("The subclass does not implement this method");
         return false;
     }
@@ -355,7 +346,7 @@ public:
      * @return true | false
      */
     virtual bool borrowStock(const Datetime& datetime, const Stock& stock, price_t price,
-                             double number) override {
+                             double number) {
         HKU_WARN("The subclass does not implement this method");
         return false;
     }
@@ -369,11 +360,18 @@ public:
      * @return true | false
      */
     virtual bool returnStock(const Datetime& datetime, const Stock& stock, price_t price,
-                             double number) override {
+                             double number) {
         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>()
@@ -382,10 +380,7 @@ public:
      * @note 当datetime等于Null<Datetime>()时，与getFunds(KType)同
      */
     virtual FundsRecord getFunds(const Datetime& datetime,
-                                 KQuery::KType ktype = KQuery::DAY) override {
-        HKU_WARN("The subclass does not implement this method");
-        return FundsRecord();
-    }
+                                 KQuery::KType ktype = KQuery::DAY) override;
 
     /**
      * 直接加入交易记录
@@ -393,37 +388,44 @@ public:
      * @param tr 待加入的交易记录
      * @return bool true 成功 | false 失败
      */
-    virtual bool addTradeRecord(const TradeRecord& tr) override {
+    virtual bool addTradeRecord(const TradeRecord& tr) {
         HKU_WARN("The subclass does not implement this method");
         return false;
     }
 
-    /** 字符串输出 */
-    virtual string str() const override {
+    /**
+     * 直接加入持仓记录
+     * @param pr 持仓记录
+     * @return true 成功
+     * @return false 失败
+     */
+    virtual bool addPosition(const PositionRecord& pr) {
         HKU_WARN("The subclass does not implement this method");
-        return string();
+        return false;
     }
 
+    /** 字符串输出 */
+    virtual string str() const override;
+
     /**
      * 以csv格式输出交易记录、未平仓记录、已平仓记录、资产净值曲线
      * @param path 输出文件所在目录
      */
-    virtual void tocsv(const string& path) override {
+    virtual void tocsv(const string& path) {
         HKU_WARN("The subclass does not implement this method");
     }
 
 private:
-    string getToken();
+    Datetime m_datetime;  // 当前日期
 
-private:
-    std::unique_ptr<httplib::Client> m_client;
-    string m_user;
-    string m_password;
-    string m_token;
+    price_t m_cash{0.0};  // 当前可用现金
+
+    typedef map<uint64_t, PositionRecord> position_map_type;
+    position_map_type m_position;  // 当前持仓交易对象的持仓记录
 };
 
-inline TMPtr crtAccountTM(const string& name, const string& pwd) {
-    return std::make_shared<AccountTradeManager>(name, pwd);
-}
+TradeManagerPtr HKU_API crtBrokerTM(const OrderBrokerPtr& broker,
+                                    const TradeCostPtr& costfunc = TC_Zero(),
+                                    const string& name = "SYS");
 
 }  // namespace hku

hikyuu/include/hikyuu/strategy/RunPortfolioInStrategy.h

@@ -0,0 +1,36 @@
+/*
+ *  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;
+};
+
+StrategyPtr HKU_API crtPFStrategy(const PFPtr& pf, const KQuery& query, int adjust_cycle,
+                                  const OrderBrokerPtr& broker, const TradeCostPtr& costfunc,
+                                  const string& name = "PFStrategy",
+                                  const string& config_file = "");
+
+}  // namespace hku