hikyuu 2.1.2__cp39-none-win_amd64.whl → 2.1.4__cp39-none-win_amd64.whl

hikyuu/gui/data/ImportWeightToSqliteTask.py

@@ -42,7 +42,7 @@ from hikyuu.util.check import hku_catch, hku_check
 
 
 class ImportWeightToSqliteTask:
-    def __init__(self, log_queue, queue, config, dest_dir):
+    def __init__(self, log_queue, queue, config, dest_dir, market, cmd, host, port):
         self.logger = logging.getLogger(self.__class__.__name__)
         self.log_queue = log_queue
         self.queue = queue
@@ -50,6 +50,10 @@ class ImportWeightToSqliteTask:
         self.dest_dir = dest_dir
         self.msg_name = 'IMPORT_WEIGHT'
         self.status = "no run"
+        self.market = market
+        self.cmd = cmd  # "weight" | "finance"
+        self.host = host
+        self.port = port
 
     @hku_catch(trace=True)
     def __call__(self):
@@ -76,44 +80,31 @@ class ImportWeightToSqliteTask:
                 self.logger.debug('use mysql import weight')
 
         except Exception as e:
-            #self.queue.put([self.msg_name, str(e), -1, 0, total_count])
+            # self.queue.put([self.msg_name, str(e), -1, 0, total_count])
             self.queue.put([self.msg_name, 'INFO', str(e), 0, 0])
             self.queue.put([self.msg_name, '', 0, None, total_count])
             self.status = "failure"
             return
 
         try:
-            hosts = search_best_tdx()
             api = TdxHq_API()
-            hku_check(api.connect(hosts[0][2], hosts[0][3]), "failed connect pytdx {}:{}!", hosts[0][2], hosts[0][3])
-
-            self.logger.info('正在导入权息数据')
-            self.queue.put([self.msg_name, '正在导入权息数据...', 0, 0, 0])
-
-            total_count = 0
-            for market in g_market_list:
-                count = pytdx_import_weight(api, connect, market)
-                self.logger.info("导入 {} 权息记录数: {}".format(market, count))
-                total_count += count
-
-            self.queue.put([self.msg_name, '导入权息数据完毕!', 0, 0, total_count])
-            self.logger.info('导入权息数据完毕')
-
-            self.queue.put([self.msg_name, '下载通达信财务信息(上证)...', 0, 0, 0])
-            x = pytdx_import_finance(connect, api, "SH")
-
-            self.queue.put([self.msg_name, '下载通达信财务信息(深证)...', 0, 0, 0])
-            x += pytdx_import_finance(connect, api, "SZ")
-
-            self.queue.put([self.msg_name, '下载通达信财务信息(北证)...', 0, 0, 0])
-            x += pytdx_import_finance(connect, api, "BJ")
-            self.queue.put([self.msg_name, '导入通达信财务信息完毕!', 0, 0, x])
+            hku_check(api.connect(self.host, self.port), "failed connect pytdx {}:{}!", self.host, self.port)
+
+            if self.cmd == 'weight':
+                count = pytdx_import_weight(api, connect, self.market)
+                self.logger.info("导入 {} 权息记录数: {}".format(self.market, count))
+                self.queue.put([self.msg_name, '导入权息数据完毕!', 0, 0, f'{self.market} {total_count}'])
+            elif self.cmd == 'finance':
+                self.queue.put([self.msg_name, f'下载通达信当前财务信息({self.market})...', 0, 0, 0])
+                x = pytdx_import_finance(connect, api, self.market)
+                self.logger.info(f'导入 {self.market} 通达信当前财务信息数: {x}')
+                self.queue.put([self.msg_name, '导入通达信财务信息完毕!', 0, 0, f'{self.market} {x}'])
 
             api.disconnect()
 
         except Exception as e:
             self.logger.error(e)
-            #self.queue.put([self.msg_name, str(e), -1, 0, total_count])
+            # self.queue.put([self.msg_name, str(e), -1, 0, total_count])
             self.queue.put([self.msg_name, 'INFO', str(e), 0, 0])
         finally:
             connect.commit()

hikyuu/gui/data/UsePytdxImportToH5Thread.py

@@ -84,14 +84,8 @@ class UsePytdxImportToH5Thread(QThread):
     def init_task(self):
         config = self.config
         dest_dir = config['hdf5']['dir']
-        sqlite_file_name = dest_dir + "/stock.db"
 
         self.tasks = []
-        if self.config.getboolean('weight', 'enable', fallback=False):
-            self.tasks.append(
-                ImportWeightToSqliteTask(self.log_queue, self.queue,
-                                         self.config, dest_dir))
-
         if self.config.getboolean('finance', 'enable', fallback=True):
             self.tasks.append(
                 ImportHistoryFinanceTask(self.log_queue, self.queue, self.config, dest_dir))
@@ -112,6 +106,8 @@ class UsePytdxImportToH5Thread(QThread):
             task_count += market_count
         if self.config.getboolean('ktype', 'time', fallback=False):
             task_count += market_count
+        if self.config.getboolean('weight', 'enable', fallback=False):
+            task_count += (market_count*2)
 
         self.logger.info('搜索通达信服务器')
         self.send_message(['INFO', '搜索通达信服务器'])
@@ -210,6 +206,19 @@ class UsePytdxImportToH5Thread(QThread):
                         start_date.month * 1000000 + start_date.day * 10000))
                 cur_host += 1
 
+        if self.config.getboolean('weight', 'enable', fallback=False):
+            for market in g_market_list:
+                self.tasks.append(
+                    ImportWeightToSqliteTask(self.log_queue, self.queue,
+                                             self.config, dest_dir, market, 'weight', use_hosts[cur_host][0],
+                                             use_hosts[cur_host][1]))
+                cur_host += 1
+                self.tasks.append(
+                    ImportWeightToSqliteTask(self.log_queue, self.queue,
+                                             self.config, dest_dir, market, 'finance', use_hosts[cur_host][0],
+                                             use_hosts[cur_host][1]))
+                cur_host += 1
+
     def run(self):
         try:
             self.init_task()
@@ -298,6 +307,8 @@ class UsePytdxImportToH5Thread(QThread):
                         self.send_message([taskname, ktype])
                     elif taskname == 'IMPORT_ZH_BOND10':
                         self.send_message([taskname, ktype])
+                    elif taskname == 'IMPORT_WEIGHT':
+                        pass
                     else:
                         self.send_message([taskname, 'FINISHED'])
                     continue

hikyuu/gui/data/UseTdxImportToH5Thread.py

@@ -30,7 +30,10 @@ from hikyuu.gui.data.ImportTdxToH5Task import ImportTdxToH5Task
 from hikyuu.gui.data.ImportWeightToSqliteTask import ImportWeightToSqliteTask
 from hikyuu.gui.data.ImportHistoryFinanceTask import ImportHistoryFinanceTask
 
+from pytdx.hq import TdxHq_API
+from hikyuu.data.common import g_market_list
 from hikyuu.data.common_sqlite3 import create_database
+from hikyuu.data.common_pytdx import search_best_tdx
 from hikyuu.data.tdx_to_h5 import tdx_import_stock_name_from_file
 from hikyuu.util import *
 
@@ -57,18 +60,39 @@ class UseTdxImportToH5Thread(QThread):
             self.quotations.append('stock')
         if self.config['quotation']['fund']:
             self.quotations.append('fund')
-        #if self.config['quotation']['future']:
+        # if self.config['quotation']['future']:
         #    self.quotations.append('future')
 
-        #通达信盘后没有债券数据。另外，如果用Pytdx下载债券数据，
-        #每个债券本身的数据很少但债券种类太多占用空间和时间太多，用途较少不再考虑导入
-        #if self.config['quotation']['bond']:
+        # 通达信盘后没有债券数据。另外，如果用Pytdx下载债券数据，
+        # 每个债券本身的数据很少但债券种类太多占用空间和时间太多，用途较少不再考虑导入
+        # if self.config['quotation']['bond']:
         #    self.quotations.append('bond')
 
+        hosts = search_best_tdx()
+        api = TdxHq_API()
+        hku_check(api.connect(hosts[0][2], hosts[0][3]), "failed connect pytdx {}:{}!", hosts[0][2], hosts[0][3])
+
         self.queue = Queue()
         self.tasks = []
+
+        cur_host = 0
         if self.config.getboolean('weight', 'enable', fallback=False):
-            self.tasks.append(ImportWeightToSqliteTask(self.log_queue, self.queue, self.config, dest_dir))
+            for market in g_market_list:
+                self.tasks.append(
+                    ImportWeightToSqliteTask(self.log_queue, self.queue,
+                                             self.config, dest_dir, market, 'weight', hosts[cur_host][2],
+                                             hosts[cur_host][3]))
+                cur_host += 1
+                if cur_host >= len(hosts):
+                    cur_host = 0
+                self.tasks.append(
+                    ImportWeightToSqliteTask(self.log_queue, self.queue,
+                                             self.config, dest_dir, market, 'finance', hosts[cur_host][2],
+                                             hosts[cur_host][3]))
+                cur_host += 1
+                if cur_host >= len(hosts):
+                    cur_host = 0
+
         if self.config.getboolean('finance', 'enable', fallback=True):
             self.tasks.append(ImportHistoryFinanceTask(self.log_queue, self.queue, self.config, dest_dir))
         if self.config.getboolean('ktype', 'day', fallback=False):
@@ -115,7 +139,7 @@ class UseTdxImportToH5Thread(QThread):
         dest_dir = self.config['hdf5']['dir']
         hdf5_import_progress = {'SH': {'DAY': 0, '1MIN': 0, '5MIN': 0}, 'SZ': {'DAY': 0, '1MIN': 0, '5MIN': 0}}
 
-        #正在导入代码表
+        # 正在导入代码表
         self.send_message(['START_IMPORT_CODE'])
 
         connect = sqlite3.connect(dest_dir + "/stock.db")

hikyuu/gui/spot_server.py

@@ -271,7 +271,9 @@ def collect(server, use_proxy, source, seconds, phase1, phase2, ignore_weekend):
 
     sm = StockManager.instance()
     if source == 'qmt':
-        stk_list = [s for s in sm if s.valid]
+        stk_list = [s for s in sm if s.valid and s.type in (
+            constant.STOCKTYPE_A, constant.STOCKTYPE_INDEX, constant.STOCKTYPE_ETF,
+            constant.STOCKTYPE_GEM, constant.STOCKTYPE_START, constant.STOCKTYPE_A_BJ)]
     else:
         stk_list = [
             stk.market_code.lower() for stk in sm if stk.valid and stk.type in

hikyuu/include/hikyuu/KQuery.h

@@ -70,10 +70,13 @@ public:
     // static const string INVALID_KTYPE;
 
     /** 获取所有的 KType */
-    static vector<string>& getAllKType();
+    static const vector<KType>& getAllKType();
 
     static int32_t getKTypeInMin(KType);
 
+    /** 判断是否为有效 ktype */
+    static bool isKType(const string& ktype);
+
     /**
      * 复权类型
      * @note 日线以上，如周线/月线不支持复权
@@ -93,7 +96,7 @@ public:
       m_end(Null<int64_t>()),
       m_queryType(INDEX),
       m_dataType(DAY),
-      m_recoverType(NO_RECOVER){};
+      m_recoverType(NO_RECOVER) {};
 
     /**
      * K线查询，范围[start, end)

hikyuu/include/hikyuu/KRecord.h

@@ -24,7 +24,7 @@ public:
     price_t highPrice;    ///< 最高价
     price_t lowPrice;     ///< 最低价
     price_t closePrice;   ///< 收盘价
-    price_t transAmount;  ///< 成交金额（千元）
+    price_t transAmount;  ///< 成交金额（万元）
     price_t transCount;   ///< 成交量（手），日线以下为股数
 
     KRecord()

hikyuu/include/hikyuu/Stock.h

@@ -162,7 +162,7 @@ public:
      */
     bool getIndexRange(const KQuery& query, size_t& out_start, size_t& out_end) const;
 
-    /** 获取指定索引的K线数据记录，未作越界检查 */
+    /** 获取指定索引的K线数据记录，pos 无效时返回 Null<KRecord> */
     KRecord getKRecord(size_t pos, const KQuery::KType& dataType = KQuery::DAY) const;
 
     /** 根据数据类型（日线/周线等），获取指定日期的KRecord */

hikyuu/include/hikyuu/StockManager.h

@@ -10,8 +10,9 @@
 
 #include <mutex>
 #include <thread>
-#include "utilities/Parameter.h"
-#include "data_driver/DataDriverFactory.h"
+#include "hikyuu/utilities/Parameter.h"
+#include "hikyuu/utilities/thread/thread.h"
+#include "hikyuu/data_driver/DataDriverFactory.h"
 #include "Block.h"
 #include "MarketInfo.h"
 #include "StockTypeInfo.h"
@@ -21,9 +22,6 @@ namespace hku {
 
 typedef vector<string> MarketList;
 
-Parameter default_preload_param();
-Parameter default_other_param();
-
 /**
  * 证券信息统一管理类
  * @ingroup StockManage
@@ -47,8 +45,8 @@ public:
      * @param context 策略上下文
      */
     void init(const Parameter& baseInfoParam, const Parameter& blockParam,
-              const Parameter& kdataParam, const Parameter& preloadParam = default_preload_param(),
-              const Parameter& hikyuuParam = default_other_param(),
+              const Parameter& kdataParam, const Parameter& preloadParam,
+              const Parameter& hikyuuParam,
               const StrategyContext& context = StrategyContext({"all"}));
 
     /** 重新加载 */
@@ -90,6 +88,9 @@ public:
     /** 获取证券数量 */
     size_t size() const;
 
+    /** 是否所有数据准备完毕 */
+    bool dataReady() const;
+
     /**
      * 根据"市场简称证券代码"获取对应的证券实例
      * @param querystr 格式：“市场简称证券代码”，如"sh000001"
@@ -218,6 +219,11 @@ public:
         return m_thread_id;
     }
 
+    /** 仅由程序退出使使用！！！ */
+    ThreadPool* getLoadTaskGroup() {
+        return m_load_tg.get();
+    }
+
 public:
     typedef StockMapIterator const_iterator;
     const_iterator begin() const {
@@ -228,8 +234,8 @@ public:
     }
 
 private:
-    /* 设置K线驱动 */
-    void setKDataDriver(const KDataDriverConnectPoolPtr&);
+    /* 加载全部数据 */
+    void loadData();
 
     /* 加载 K线数据至缓存 */
     void loadAllKData();
@@ -255,15 +261,13 @@ private:
     /** 加载历史财经字段索引 */
     void loadHistoryFinanceField();
 
-    /** 加载历史财务数据 */
-    void loadHistoryFinance();
-
 private:
     StockManager();
 
 private:
     static StockManager* m_sm;
     std::atomic_bool m_initializing;
+    std::atomic_bool m_data_ready;  // 用于指示是否所有数据准备完毕
     std::thread::id m_thread_id;  // 记录线程id，用于判断Stratege是以独立进程方式还是线程方式运行
     string m_tmpdir;
     string m_datadir;
@@ -271,18 +275,18 @@ private:
     BlockInfoDriverPtr m_blockDriver;
 
     StockMapIterator::stock_map_t m_stockDict;  // SH000001 -> stock
-    std::mutex* m_stockDict_mutex;
+    std::shared_mutex* m_stockDict_mutex;
 
     typedef unordered_map<string, MarketInfo> MarketInfoMap;
     mutable MarketInfoMap m_marketInfoDict;
-    std::mutex* m_marketInfoDict_mutex;
+    std::shared_mutex* m_marketInfoDict_mutex;
 
     typedef unordered_map<uint32_t, StockTypeInfo> StockTypeInfoMap;
     mutable StockTypeInfoMap m_stockTypeInfo;
-    std::mutex* m_stockTypeInfo_mutex;
+    std::shared_mutex* m_stockTypeInfo_mutex;
 
     std::unordered_set<Datetime> m_holidays;  // 节假日
-    std::mutex* m_holidays_mutex;
+    std::shared_mutex* m_holidays_mutex;
 
     ZhBond10List m_zh_bond10;  // 10年期中国国债收益率数据
 
@@ -295,18 +299,20 @@ private:
     Parameter m_preloadParam;
     Parameter m_hikyuuParam;
     StrategyContext m_context;
+
+    std::unique_ptr<ThreadPool> m_load_tg;  // 异步数据加载辅助线程组
 };
 
 inline size_t StockManager::size() const {
     return m_stockDict.size();
 }
 
-inline Stock StockManager::operator[](const string& query) const {
-    return getStock(query);
+inline bool StockManager::dataReady() const {
+    return m_data_ready;
 }
 
-inline bool StockManager::isHoliday(const Datetime& d) const {
-    return m_holidays.count(d);
+inline Stock StockManager::operator[](const string& query) const {
+    return getStock(query);
 }
 
 inline const Parameter& StockManager::getBaseInfoDriverParameter() const {

hikyuu/include/hikyuu/StrategyContext.h

@@ -12,55 +12,96 @@
 
 namespace hku {
 
+/**
+ * 策略上下文，定义策略执行时包含的证券/K线级别信息
+ * @ingroup Strategy
+ *
+ */
 class HKU_API StrategyContext {
 public:
-    StrategyContext() {}
-    StrategyContext(const StrategyContext&) = default;
-
-    explicit StrategyContext(const vector<string>& stockCodeList)
-    : m_stockCodeList(stockCodeList) {}
-    explicit StrategyContext(vector<string>&& stockCodeList)
-    : m_stockCodeList(std::move(stockCodeList)) {}
-
-    StrategyContext(const vector<string>& stockCodeList, const vector<KQuery::KType>& ktypeList)
-    : m_stockCodeList(stockCodeList), m_ktypeList(ktypeList) {}
-
+    StrategyContext() = default;
     virtual ~StrategyContext() = default;
 
+    /**
+     * 构造函数
+     * @note 未指定 ktypelist 时，默认按预加载参数加载全部
+     * @param stockCodeList 指定的证券代码列表，如：如：{"sz000001", "sz000002"}
+     */
+    explicit StrategyContext(const vector<string>& stockCodeList);
+
+    /**
+     * 构造函数
+     * @note 证券列表中如果包含 ("ALL") 则表示全部证券;
+     * 指定K线类型列表同时影响着K线数据的优先加载顺序，靠前的将优先加载。同时受系统配置中预加载参数影响！
+     * @param stockCodeList 指定的证券代码列表，如：{"sh000001", "sz000001"}
+     * @param ktypeList 指定的 K线数据列表，如：{"day", "min"}
+     */
+    StrategyContext(const vector<string>& stockCodeList, const vector<KQuery::KType>& ktypeList);
+
+    // 自定义移动构造与赋值会引起 python 中无法正常退出
+    // StrategyContext(const StrategyContext&) = default;
+    // StrategyContext(StrategyContext&& rv) = delete;
+    // StrategyContext& operator=(const StrategyContext&) = default;
+    // StrategyContext& operator=(StrategyContext&&) = delete;
+
+    /**
+     * 是否为加载全部证券，只要 stockCodeList 包含 "ALL"(不区分大小写) ，即认为加载全部
+     * @return true
+     * @return false
+     */
     bool isAll() const noexcept;
 
-    bool isValid() const noexcept;
+    bool empty() const noexcept {
+        return m_stockCodeList.empty();
+    }
 
     Datetime startDatetime() const noexcept {
         return m_startDatetime;
     }
 
-    void startDatetime(const Datetime& d) {
-        HKU_CHECK(!d.isNull(), "Don't use null datetime!");
-        m_startDatetime = d;
-    }
-
-    void setStockCodeList(vector<string>&& stockList) {
-        m_stockCodeList = std::move(stockList);
+    void setStockCodeList(const vector<string>& stockList) {
+        _removeDuplicateCode(stockList);
     }
 
-    void setStockCodeList(const vector<string>& stockList);
-
-    const vector<string>& getStockCodeList() const {
+    const vector<string>& getStockCodeList() const noexcept {
         return m_stockCodeList;
     }
 
-    void setKTypeList(const vector<KQuery::KType>& ktypeList);
+    void setKTypeList(const vector<KQuery::KType>& ktypeList) {
+        _checkAndRemoveDuplicateKType(ktypeList);
+    }
 
-    /** 该返回的 ktype 列表，已经按从小到大进行排序 */
-    const vector<KQuery::KType>& getKTypeList() const {
+    const vector<KQuery::KType>& getKTypeList() const noexcept {
         return m_ktypeList;
     }
 
+    /**
+     * 隐含的默认必须被加载的证券列表
+     * @note 影响交易日历判断、和某些常被作为默认比较基准的证券，通常被作为某些函数的默认值
+     */
+    const vector<string>& getMustLoadStockCodeList() const noexcept {
+        return m_mustLoad;
+    }
+
+    /**
+     * 返回所有需要加载的证券列表（含指定的证券列表和默认包含必须加载的证券列表）
+     * @return vector<string>
+     */
+    vector<string> getAllNeedLoadStockCodeList() const noexcept;
+
+    string str() const;
+
+private:
+    void _removeDuplicateCode(const vector<string>& stockCodeList);
+    void _checkAndRemoveDuplicateKType(const vector<KQuery::KType>& ktypeList);
+
 private:
     Datetime m_startDatetime{19901219};
+    vector<string> m_mustLoad{"sh000001", "sh000300"};  // 默认必须加载的 stock
     vector<string> m_stockCodeList;
     vector<KQuery::KType> m_ktypeList;
 };
 
+HKU_API std::ostream& operator<<(std::ostream& os, const StrategyContext& context);
+
 }  // namespace hku

hikyuu/include/hikyuu/data_driver/BaseInfoDriver.h

@@ -123,6 +123,7 @@ public:
      * @param market 市场简称
      * @param code 证券代码
      * @param start 财务报告发布起始日期
+     * @param end 查询结束日期
      * @return vector<float> [[财务报告发布日期(ymd), 字段1, 字段2, ...], ...]
      */
     virtual vector<HistoryFinanceInfo> getHistoryFinance(const string& market, const string& code,

hikyuu/include/hikyuu/doc.h

@@ -137,7 +137,7 @@
  * @details 合成多因子
  * @ingroup TradeSystem
  *
- * @defgroup Stratgy Strategy 策略运行时
+ * @defgroup Strategy Strategy 策略运行时
  * @details 策略运行时
  * @ingroup Hikyuu
  *

hikyuu/include/hikyuu/global/GlobalSpotAgent.h

@@ -13,9 +13,12 @@ namespace hku {
 /**
  * 启动 Spot 数据接收代理，如果之前已经处于运行状态，将抛出异常
  * @param print 打印接收数据进展
+ * @param worker_num 接收数据后处理时的工作任务组线程数
+ * @param addr 服务端地址，为空表示使用 hikyuu 配置文件中的行情服务器地址
  * @ingroup Agent
  */
-void HKU_API startSpotAgent(bool print = true);
+void HKU_API startSpotAgent(bool print = true, size_t worker_num = 1,
+                            const string& addr = string());
 
 /**
  * 终止 Spot 数据接收代理
@@ -25,6 +28,6 @@ void HKU_API stopSpotAgent();
 
 SpotAgent* getGlobalSpotAgent();
 
-void releaseGlobalSpotAgent();
+void HKU_API releaseGlobalSpotAgent();
 
 }  // namespace hku

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

@@ -43,12 +43,31 @@ public:
         return !m_stop;
     }
 
+    void setWorkerNum(size_t worker_num) {
+        m_work_num = worker_num;
+    }
+
+    size_t getWorkerNum() const {
+        return m_work_num;
+    }
+
     /** 设置是否打印数据接收进展情况，主要用于在交互环境下关闭打印 */
     void setPrintFlag(bool print) {
-        std::lock_guard<std::mutex> lock(m_mutex);
         m_print = print;
     }
 
+    bool getPrintFlag() const {
+        return m_print;
+    }
+
+    void setServerAddr(const string& addr) {
+        m_server_addr = addr;
+    }
+
+    const string& getServerAddr() const {
+        return m_server_addr;
+    }
+
     /**
      * 增加收到 Spot 数据时的处理函数
      * @note 仅能在停止状态时执行此操作，否则将抛出异常
@@ -106,15 +125,18 @@ private:
     enum STATUS m_status = WAITING;      // 当前内部状态
     std::atomic_bool m_stop = true;      // 结束代理工作标识
 
-    int m_revTimeout = 100;       // 连接数据服务超时时长（毫秒）
-    size_t m_batch_count = 0;     // 记录本次批次接收的数据数量
-    std::thread m_receiveThread;  // 数据接收线程
-    ThreadPool m_tg;              // 数据处理任务线程池
+    int m_revTimeout = 100;            // 连接数据服务超时时长（毫秒）
+    size_t m_batch_count = 0;          // 记录本次批次接收的数据数量
+    std::thread m_receiveThread;       // 数据接收线程
+    std::unique_ptr<ThreadPool> m_tg;  // 数据处理任务线程池
+    size_t m_work_num = 1;             // 数据处理任务线程池线程数
     vector<std::future<void>> m_process_task_list;
 
+    bool m_print = true;   // 是否打印连接信息
+    string m_server_addr;  // 服务器地址
+
     // 下面属性被修改时需要加锁，以便可以使用多线程方式运行 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;  // 已注册的批次后处理函数列表
 };

hikyuu/include/hikyuu/hikyuu.h

@@ -35,6 +35,19 @@ namespace hku {
 void HKU_API hikyuu_init(const string& config_file_name, bool ignore_preload = false,
                          const StrategyContext& context = StrategyContext({"all"}));
 
+/**
+ * @brief 尝试从 ini 文件获取配置参数
+ * @param config_file_name ini 文件名
+ * @param baseParam [out]
+ * @param blockParam [out]
+ * @param kdataParam [out]
+ * @param preloadParam [out]
+ * @param hkuParam [out]
+ */
+void HKU_API getConfigFromIni(const string& config_file_name, Parameter& baseParam,
+                              Parameter& blockParam, Parameter& kdataParam, Parameter& preloadParam,
+                              Parameter& hkuParam);
+
 /** @} */
 
 }  // namespace hku

hikyuu/include/hikyuu/indicator/crt/AMA.h

@@ -32,7 +32,7 @@ Indicator HKU_API AMA(const IndParam& n, const IndParam& fast_n, const IndParam&
 
 /**
  * 佩里.J 考夫曼（Perry J.Kaufman）自适应移动平均，参见《精明交易者》（2006年 广东经济出版社）
- * @param indicator 待计算的数据
+ * @param ind 待计算的数据
  * @param n 计算均值的周期窗口，必须为大于2的整数，默认为10天
  * @param fast_n 对应快速周期N，默认为2
  * @param slow_n 对应慢速EMA线的N值，默认为30，不过当超过60左右该指标会收敛不会有太大的影响

hikyuu/include/hikyuu/indicator/crt/CORR.h

@@ -18,7 +18,7 @@ namespace hku {
  * @param n 滚动窗口 （大于2或等于0），等于0时使用输入的ind实际长度。
  * @ingroup Indicator
  */
-Indicator HKU_API CORR(int n = 10);
 Indicator HKU_API CORR(const Indicator& ind1, const Indicator& ind2, int n = 10);
+Indicator HKU_API CORR(int n = 10);
 
 }  // namespace hku

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

@@ -16,6 +16,7 @@ namespace hku {
  * @brief 计算指定的因子相对于参考证券的 ICIR （实际为 RankIC）
  * @details IR:信息比率(Information Ratio,简称IR)=
  * IC的多周期均值/IC的标准方差，代表因子获取稳定Alpha的能力。
+ * @param ind 因子公式
  * @param stks 证券组合
  * @param query 查询条件
  * @param ref_stk 参照证券，默认 sh000300 沪深300

hikyuu/include/hikyuu/indicator/crt/SMA.h

@@ -34,7 +34,7 @@ Indicator HKU_API SMA(const IndParam& n, const IndParam& m);
  * <pre>
  * 用法：若Y=SMA(X,N,M) 则 Y=[M*X+(N-M)*Y')/N,其中Y'表示上一周期Y值
  * </pre>
- * @param data 待计算的数据
+ * @param ind 待计算的数据
  * @param n 计算均值的周期窗口，必须为大于0的整数
  * @param m 系数
  * @ingroup Indicator