hikyuu 2.5.5__py3-none-win_amd64.whl → 2.6.0__py3-none-win_amd64.whl

hikyuu/include/hikyuu/strategy/RunPortfolioInStrategy.h

@@ -25,6 +25,7 @@ private:
     PFPtr m_pf;
     OrderBrokerPtr m_broker;
     KQuery m_query;
+    std::unordered_set<Stock> m_stocks;
 };
 
 StrategyPtr HKU_API crtPFStrategy(const PFPtr& pf, const KQuery& query,

hikyuu/include/hikyuu/strategy/Strategy.h

@@ -8,6 +8,7 @@
 #pragma once
 
 #include <future>
+#include <forward_list>
 #include "hikyuu/DataType.h"
 #include "hikyuu/StrategyContext.h"
 #include "hikyuu/global/SpotRecord.h"
@@ -34,7 +35,8 @@ 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 = "");
+             const unordered_map<string, int>& preloadNum = {}, const string& name = "Strategy",
+             const string& config_file = "");
     explicit Strategy(const StrategyContext& context, const string& name = "Strategy",
                       const string& config_file = "");
 
@@ -55,14 +57,16 @@ public:
         return m_context;
     }
 
+    bool running() const;
+
     /**
      * 每日开盘时间内，以 delta 为周期循环定时执行指定任务
      * @param func 待执行的任务
      * @param delta 间隔时间
-     * @param market 指定的市场
+     * @param market 指定的市场, 用于获取开/收盘时间
      * @param ignoreMarket 是否忽略市场时间限制，如为 true，则为定时循环不受开闭市时间限制
      */
-    void runDaily(std::function<void()>&& func, const TimeDelta& delta,
+    void runDaily(const std::function<void(Strategy*)>& func, const TimeDelta& delta,
                   const std::string& market = "SH", bool ignoreMarket = false);
 
     /**
@@ -71,7 +75,7 @@ public:
      * @param delta 指定时刻
      * @param ignoreHoliday 忽略节假日，即节假日不执行
      */
-    void runDailyAt(std::function<void()>&& func, const TimeDelta& delta,
+    void runDailyAt(const std::function<void(Strategy*)>& func, const TimeDelta& delta,
                     bool ignoreHoliday = true);
 
     /**
@@ -79,7 +83,8 @@ public:
      * @note 通常用于调试。且只要收到行情采集消息就会触发，不受开、闭市时间限制
      * @param changeFunc 回调函数
      */
-    void onChange(std::function<void(const Stock&, const SpotRecord& spot)>&& changeFunc);
+    void onChange(
+      const std::function<void(Strategy*, const Stock&, const SpotRecord& spot)>& changeFunc);
 
     /**
      * 一批行情数据接受完毕后通知
@@ -87,36 +92,111 @@ public:
      *       且只要收到行情采集消息就会触发，不受开、闭市时间限制。
      * @param recievedFucn 回调函数
      */
-    void onReceivedSpot(std::function<void(const Datetime&)>&& recievedFucn);
+    void onReceivedSpot(const std::function<void(Strategy*, const Datetime&)>& recievedFucn);
 
     /**
      * 启动策略执行，必须在已注册相关处理函数后执行
      */
     void start(bool autoRecieveSpot = true);
 
-private:
+    //==========================================================================
+    // 以下为策略运行时对外接口，建议使用这些接口代替同名其他功能函数，已保证回测和实盘一致
+    //==========================================================================
+
+    TradeManagerPtr getTM() const noexcept {
+        return m_tm;
+    }
+
+    void setTM(const TradeManagerPtr& tm) noexcept {
+        m_tm = tm;
+    }
+
+    /** 仅在回测状态下使用 */
+    SlippagePtr getSP() const noexcept {
+        return m_sp;
+    }
+
+    void setSP(const SlippagePtr& slippage) noexcept {
+        m_sp = slippage;
+    }
+
+    KData getKData(const Stock& stk, const Datetime& start_date, const Datetime& end_date,
+                   const KQuery::KType& ktype,
+                   KQuery::RecoverType recover_type = KQuery::NO_RECOVER) const {
+        return stk.getKData(KQueryByDate(start_date, end_date, ktype, recover_type));
+    }
+
+    KData getLastKData(const Stock& stk, const Datetime& start_date, const KQuery::KType& ktype,
+                       KQuery::RecoverType recover_type = KQuery::NO_RECOVER) const {
+        return getKData(stk, start_date, Null<Datetime>(), ktype, recover_type);
+    }
+
+    KData getLastKData(const Stock& stk, size_t lastnum, const KQuery::KType& ktype,
+                       KQuery::RecoverType recover_type = KQuery::NO_RECOVER) const;
+
+    virtual Datetime today() const {
+        return Datetime::today();
+    }
+
+    virtual Datetime now() const {
+        return Datetime::now();
+    }
+
+    virtual Datetime nextDatetime() const {
+        return Null<Datetime>();
+    }
+
+    virtual TradeRecord buy(const Stock& stk, price_t price, double num, double stoploss = 0.0,
+                            double goal_price = 0.0,
+                            SystemPart part_from = SystemPart::PART_SIGNAL) {
+        HKU_ASSERT(m_tm);
+        return m_tm->buy(Datetime::now(), stk, price, num, stoploss, goal_price, price, part_from);
+    }
+
+    virtual TradeRecord sell(const Stock& stk, price_t price, double num, price_t stoploss = 0.0,
+                             price_t goal_price = 0.0,
+                             SystemPart part_from = SystemPart::PART_SIGNAL) {
+        HKU_ASSERT(m_tm);
+        return m_tm->sell(Datetime::now(), stk, price, num, stoploss, goal_price, price, part_from);
+    }
+
+    virtual bool isBacktesting() const {
+        return false;
+    }
+
+protected:
     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;
+    TradeManagerPtr m_tm;
+    SlippagePtr m_sp;
+
+    std::function<void(Strategy*, const Datetime&)> m_on_recieved_spot;
+    std::function<void(Strategy*, const Stock&, const SpotRecord& spot)> m_on_change;
+
+    struct RunDailyAt {
+        std::function<void()> func;
+        TimeDelta delta;
+        string market;
+        bool ignoreMarket{false};
+    };
+    std::forward_list<RunDailyAt> m_run_daily_at_list;
+
+    std::unordered_map<TimeDelta, std::function<void()>> m_run_daily_at_funcs;
 
-    std::function<void()> m_run_daily_func;
-    TimeDelta m_run_daily_delta;
-    string m_run_daily_market;
-    bool m_ignoreMarket{false};
+protected:
+    static std::atomic_bool ms_keep_running;
 
-    std::map<TimeDelta, std::function<void()>> m_run_daily_at_funcs;
+protected:
+    void _init();
 
 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;

hikyuu/include/hikyuu/trade_manage/TradeManagerBase.h

@@ -697,8 +697,10 @@ public:
     /**
      * 从订单代理实例同步当前账户资产信息（包含资金、持仓等）
      * @param broker 订单代理实例
+     * @param datetime 同步时，通常为当前时间（Null)，也可以强制为指定的时间点
      */
-    virtual void fetchAssetInfoFromBroker(const OrderBrokerPtr& broker) {
+    virtual void fetchAssetInfoFromBroker(const OrderBrokerPtr& broker,
+                                          const Datetime& datetime = Null<Datetime>()) {
         HKU_WARN("The subclass does not implement this method");
     }
 
@@ -706,7 +708,7 @@ protected:
     string m_name;            // 账户名称
     TradeCostPtr m_costfunc;  // 成本算法
 
-    Datetime m_broker_last_datetime;  // 订单代理最近一次执行操作的时刻,当前启动运行时间
+    Datetime m_broker_last_datetime;     // 订单代理最近一次执行操作的时刻,当前启动运行时间
     list<OrderBrokerPtr> m_broker_list;  // 订单代理列表
 
 //============================================

hikyuu/include/hikyuu/trade_sys/system/imp/WalkForwardTradeManager.h

@@ -437,8 +437,9 @@ public:
      * 从订单代理实例同步当前账户资产信息（包含资金、持仓等）
      * @param broker 订单代理实例
      */
-    virtual void fetchAssetInfoFromBroker(const OrderBrokerPtr& broker) override {
-        m_tm->fetchAssetInfoFromBroker(broker);
+    virtual void fetchAssetInfoFromBroker(const OrderBrokerPtr& broker,
+                                          const Datetime& datetime = Null<Datetime>()) override {
+        m_tm->fetchAssetInfoFromBroker(broker, datetime);
     }
 
 private:

hikyuu/include/hikyuu/utilities/config.h

@@ -26,7 +26,7 @@
 #define HKU_CLOSE_SPEND_TIME 0
 
 #define HKU_USE_SPDLOG_ASYNC_LOGGER 0
-#define HKU_LOG_ACTIVE_LEVEL "2"
+#define HKU_LOG_ACTIVE_LEVEL 2
 
 #define HKU_ENABLE_MO 0
 

hikyuu/include/hikyuu/utilities/datetime/Datetime.h

@@ -299,9 +299,9 @@ typedef std::vector<Datetime> DatetimeList;
 
 /**
  * 获取指定范围的日历日期列表[start,end)，仅仅是日，不含时分秒。
- * @note 为防止内存占用过大，end如果超出系统明日日期，则强制为系统明日日期
+ * @note 如果指定的结束日期过大，可能会耗费大量内存
  * @param start 起始日期
- * @param end 结束日期
+ * @param end 结束日期, 如果为空，将使用 Datetime::max
  * @return [start, end)范围内的日历日期
  */
 DatetimeList HKU_UTILS_API getDateRange(const Datetime &start, const Datetime &end);
@@ -412,7 +412,7 @@ template <>
 class hash<hku::Datetime> {
 public:
     size_t operator()(hku::Datetime const &d) const noexcept {
-        return d.ticks();  // or use boost::hash_combine
+        return std::hash<uint64_t>()(d.ticks());
     }
 };
 

hikyuu/include/hikyuu/utilities/datetime/TimeDelta.h

@@ -320,6 +320,14 @@ inline TimeDelta Microseconds(int64_t microsecs) {
 
 namespace std {
 
+template <>
+class hash<hku::TimeDelta> {
+public:
+    size_t operator()(hku::TimeDelta const &d) const noexcept {
+        return std::hash<int64_t>()(d.ticks());
+    }
+};
+
 inline string to_string(const hku::TimeDelta &delta) {
     return delta.str();
 }

hikyuu/include/hikyuu/utilities/plugin/PluginBase.h

@@ -0,0 +1,47 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-03-18
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef HKU_UTILS_PLUGIN_BASE_H_
+#define HKU_UTILS_PLUGIN_BASE_H_
+
+#include <string>
+#include "hikyuu/utilities/config.h"
+#include "hikyuu/utilities/osdef.h"
+
+namespace hku {
+
+class PluginBase {
+public:
+    PluginBase() = default;
+    virtual ~PluginBase() = default;
+
+    /**
+     * @brief 返回插件信息
+     * @details
+     * 插件信息为json格式，包含name(string)、version(int)、description(string)、author(string)字段
+     * 如：{"name":"unknown","version": 1.0,"description":"","author":"unknown"}
+     * @return std::string
+     */
+    virtual std::string info() const noexcept = 0;
+};
+
+}  // namespace hku
+
+#if HKU_OS_WINDOWS
+#define HKU_PLUGIN_DEFINE(plugin)                                      \
+    extern "C" __declspec(dllexport) hku::PluginBase* createPlugin() { \
+        return new plugin();                                           \
+    }
+#else
+#define HKU_PLUGIN_DEFINE(plugin)                \
+    extern "C" hku::PluginBase* createPlugin() { \
+        return new plugin();                     \
+    }
+#endif
+
+#endif /* HKU_UTILS_PLUGIN_BASE_H_ */

hikyuu/include/hikyuu/utilities/plugin/PluginClient.h

@@ -0,0 +1,55 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-04-06
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "PluginLoader.h"
+
+namespace hku {
+
+template <typename InterfaceT>
+class PluginClient : public InterfaceT {
+public:
+    PluginClient() = delete;
+    PluginClient(const std::string &path, const std::string &filename) {
+        m_loader = std::make_unique<PluginLoader>(path);
+        HKU_CHECK(m_loader->load(filename), "load plugin failed! {}/{}", path, filename);
+        m_impl = m_loader->instance<InterfaceT>();
+    }
+    virtual ~PluginClient() = default;
+
+    PluginClient(const PluginClient &) = delete;
+    PluginClient &operator=(const PluginClient &) = delete;
+
+    PluginClient(PluginClient &&rhs) : m_impl(rhs.m_impl), m_loader(std::move(rhs.m_loader)) {
+        rhs.m_impl = nullptr;
+    }
+
+    PluginClient &operator=(PluginClient &&rhs) {
+        if (this != &rhs) {
+            m_loader = std::move(rhs.m_loader);
+            m_impl = rhs.m_impl;
+            rhs.m_impl = nullptr;
+        }
+    }
+
+    std::string info() const noexcept override {
+        return m_impl->info();
+    }
+
+    InterfaceT *getPlugin() const {
+        return m_impl;
+    }
+
+protected:
+    InterfaceT *m_impl{nullptr};
+
+protected:
+    std::unique_ptr<PluginLoader> m_loader;
+};
+
+}  // namespace hku

hikyuu/include/hikyuu/utilities/plugin/PluginLoader.h

@@ -0,0 +1,117 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-03-18
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef HKU_UTILS_PLUGIN_LOADER_H_
+#define HKU_UTILS_PLUGIN_LOADER_H_
+
+#include <mutex>
+#include <string>
+#include <memory>
+#include "hikyuu/utilities/config.h"
+#include "hikyuu/utilities/osdef.h"
+#include "hikyuu/utilities/os.h"
+#include "hikyuu/utilities/Log.h"
+#include "PluginBase.h"
+
+#if HKU_OS_WINDOWS
+#include <windows.h>
+#else
+#include <dlfcn.h>
+#endif
+
+namespace hku {
+
+class PluginLoader final {
+public:
+    PluginLoader() : PluginLoader(".") {}
+    explicit PluginLoader(const std::string& path) : m_path(path) {}
+
+    PluginLoader(const PluginLoader&) = delete;
+    PluginLoader(PluginLoader&&) = delete;
+
+    ~PluginLoader() {
+        unload();
+    }
+
+    template <typename T>
+    T* instance() const noexcept {
+        HKU_IF_RETURN(!m_plugin, nullptr);
+        return dynamic_cast<T*>(m_plugin.get());
+    }
+
+    bool load(const std::string& pluginname) noexcept {
+        std::string filename = getFileName(pluginname);
+        HKU_WARN_IF_RETURN(!existFile(filename), false, "file({}) not exist!", filename);
+
+#if HKU_OS_WINDOWS
+        m_handle = LoadLibrary(HKU_PATH(filename).c_str());
+#else
+        m_handle = dlopen(filename.c_str(), RTLD_LAZY);
+#endif
+        HKU_WARN_IF_RETURN(!m_handle, false, "load plugin({}) failed!", filename);
+
+        typedef PluginBase* (*CreateFunction)();
+        CreateFunction createFunction =
+          reinterpret_cast<CreateFunction>(getFunciton("createPlugin"));
+        HKU_WARN_IF_RETURN(!createFunction, false, "Failed to get plugin({}) handle!", filename);
+
+        m_plugin.reset(createFunction());
+        if (!m_plugin) {
+            HKU_ERROR("Failed to create plugin ({})!", filename);
+            unload();
+            m_plugin.reset();
+            return false;
+        }
+
+        return true;
+    }
+
+private:
+    void unload() noexcept {
+        m_plugin.reset();
+        if (m_handle) {
+#if HKU_OS_WINDOWS
+            FreeLibrary(m_handle);
+#else
+            dlclose(m_handle);
+#endif
+        }
+    }
+
+    void* getFunciton(const char* symbol) noexcept {
+#if HKU_OS_WINDOWS
+        void* func = GetProcAddress(m_handle, symbol);
+#else
+        void* func = dlsym(m_handle, symbol);
+#endif
+        return func;
+    }
+
+    std::string getFileName(const std::string& pluginname) const noexcept {
+#if HKU_OS_WINDOWS
+        return fmt::format("{}/{}.dll", m_path, pluginname);
+#elif HKU_OS_LINUX
+        return fmt::format("{}/lib{}.so", m_path, pluginname);
+#elif HKU_OS_OSX
+        return fmt::format("{}/lib{}.dylib", m_path, pluginname);
+#endif
+    }
+
+private:
+#if HKU_OS_WINDOWS
+    HMODULE m_handle{nullptr};
+#else
+    void* m_handle{nullptr};
+#endif
+    std::string m_path;
+    std::unique_ptr<PluginBase> m_plugin{nullptr};
+};
+
+}  // namespace hku
+
+#endif /* HKU_UTILS_PLUGIN_LOADER_H_ */

hikyuu/include/hikyuu/utilities/plugin/PluginManager.h

@@ -0,0 +1,72 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-04-10
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include <string>
+#include <memory>
+#include <unordered_map>
+#include <mutex>
+#include "hikyuu/utilities/Log.h"
+#include "hikyuu/utilities/plugin/PluginLoader.h"
+
+namespace hku {
+
+class PluginManager final {
+public:
+    PluginManager() : m_plugin_path(".") {};
+    explicit PluginManager(const std::string& plugin_path) : m_plugin_path(plugin_path) {}
+
+    ~PluginManager() = default;
+    PluginManager(const PluginManager&) = delete;
+    PluginManager(PluginManager&&) = delete;
+    PluginManager& operator=(const PluginManager&) = delete;
+    PluginManager& operator=(PluginManager&&) = delete;
+
+    const std::string& pluginPath() const noexcept {
+        return m_plugin_path;
+    }
+
+    void pluginPath(const std::string& plugin_path) noexcept {
+        HKU_TRACE_IF_RETURN(!m_plugins.empty(), void(),
+                            "Existing loaded plugins, Ignore set plugin path: {}, ", plugin_path);
+        m_plugin_path = plugin_path;
+    }
+
+    template <typename PluginInterfaceT>
+    PluginInterfaceT* getPlugin(const std::string& pluginname) noexcept;
+
+private:
+    std::unordered_map<std::string, std::unique_ptr<PluginLoader>>::iterator load(
+      const std::string& pluginname) noexcept {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        std::unique_ptr<PluginLoader> loader = std::make_unique<PluginLoader>(m_plugin_path);
+        if (loader->load(pluginname)) {
+            auto [it, success] = m_plugins.insert(std::make_pair(pluginname, std::move(loader)));
+            if (success) {
+                return it;
+            }
+        }
+        return m_plugins.end();
+    }
+
+private:
+    std::string m_plugin_path;
+    std::unordered_map<std::string, std::unique_ptr<PluginLoader>> m_plugins;
+    std::mutex m_mutex;
+};
+
+template <typename PluginInterfaceT>
+PluginInterfaceT* PluginManager::getPlugin(const std::string& pluginname) noexcept {
+    auto it = m_plugins.find(pluginname);
+    if (it == m_plugins.end()) {
+        it = load(pluginname);
+    }
+    return it != m_plugins.end() ? it->second->instance<PluginInterfaceT>() : nullptr;
+}
+
+}  // namespace hku

hikyuu/include/hikyuu/utilities/plugin/__init__.py

@@ -0,0 +1 @@
+

hikyuu/include/hikyuu/utilities/thread/MQStealThreadPool.h

@@ -242,7 +242,7 @@ private:
     std::vector<std::thread> m_threads;                              // 工作线程
 
     // 线程本地变量
-#if CPP_STANDARD >= CPP_STANDARD_17
+#if CPP_STANDARD >= CPP_STANDARD_17 && !defined(__clang__)
     inline static thread_local MQStealQueue<task_type>* m_local_work_queue =
       nullptr;                                                    // 本地任务队列
     inline static thread_local int m_index = -1;                  // 在线程池中的序号

hikyuu/include/hikyuu/utilities/thread/MQThreadPool.h

@@ -235,7 +235,7 @@ private:
     std::vector<std::thread> m_threads;                                 // 工作线程
 
     // 线程本地变量
-#if CPP_STANDARD >= CPP_STANDARD_17
+#if CPP_STANDARD >= CPP_STANDARD_17 && !defined(__clang__)
     inline static thread_local ThreadSafeQueue<task_type>* m_local_work_queue =
       nullptr;                                                    // 本地任务队列
     inline static thread_local int m_index = -1;                  // 在线程池中的序号

hikyuu/include/hikyuu/utilities/thread/StealThreadPool.h

@@ -239,7 +239,7 @@ private:
     std::vector<std::thread> m_threads;                      // 工作线程
 
     // 线程本地变量
-#if CPP_STANDARD >= CPP_STANDARD_17
+#if CPP_STANDARD >= CPP_STANDARD_17 && !defined(__clang__)
     inline static thread_local WorkStealQueue* m_local_work_queue = nullptr;  // 本地任务队列
     inline static thread_local int m_index = -1;                              // 在线程池中的序号
     inline static thread_local InterruptFlag m_thread_need_stop;              // 线程停止运行指示

hikyuu/include/hikyuu/utilities/thread/ThreadPool.h

@@ -193,7 +193,7 @@ private:
     std::vector<InterruptFlag*> m_interrupt_flags;   // 线程中断标志
 
     // 线程本地变量
-#if CPP_STANDARD >= CPP_STANDARD_17
+#if CPP_STANDARD >= CPP_STANDARD_17 && !defined(__clang__)
     inline static thread_local InterruptFlag m_thread_need_stop;  // 线程停止运行指示
     inline static thread_local int m_index = -1;                  // 在线程池中的序号
 #else

hikyuu/include/hikyuu/version.h

@@ -12,13 +12,13 @@
 #define HKU_VERSION_H
 
 // clang-format off
-#define HKU_VERSION "2.5.5"
+#define HKU_VERSION "2.6.0"
 #define HKU_VERSION_MAJOR 2
-#define HKU_VERSION_MINOR 5
-#define HKU_VERSION_ALTER 5
-#define HKU_VERSION_BUILD 202503111534
+#define HKU_VERSION_MINOR 6
+#define HKU_VERSION_ALTER 0
+#define HKU_VERSION_BUILD 202504301710
 #define HKU_VERSION_MODE "RELEASE"
-#define HKU_VERSION_GIT "2.5.5 release.0664dca1 (RELEASE)"
+#define HKU_VERSION_GIT "2.6.0 release.3bd470a3 (RELEASE)"
 // clang-format on
 
 #endif /* HKU_VERSION_H */

hikyuu/indicator/indicator.py

@@ -90,7 +90,7 @@ def concat_to_df(dates, ind_list, head_stock_code=True, head_ind_name=False):
     示例:
         query = Query(-200)
         k_list = [stk.get_kdata(query) for stk in [sm['sz000001'], sm['sz000002']]]
-        ma_list = [MA(k) for k in k_list]
+        ma_list = [MA(CLOSE(k)) for k in k_list]
         concat_to_df(sm.get_trading_calendar(query), ma_list, head_stock_code=True, head_ind_name=False)
 
     输出：

hikyuu/plugin/__init__.py

@@ -0,0 +1 @@
+

hikyuu/strategy/strategy_demo1.py

@@ -7,24 +7,23 @@
 #      供自行实现程序化交易时参考，请自行负责程序化交易可能造成的损失。
 #
 
-from hikyuu import Strategy, Query, Datetime, Seconds, Minutes
-from hikyuu import sm
+from hikyuu import *
 
 
-def on_change(stk, spot):
+def on_change(stg: Strategy, stk: Stock, spot: SpotRecord):
     print("[on_change]:", stk.market_code, stk.name, spot.close, spot.bid1, spot.ask1)
 
 
-def on_spot(rev_time):
+def on_spot(stg: Strategy, rev_time: Datetime):
     print("[on_received_spot] rev_time:", rev_time)
 
 
-def my_func1():
-    print("[my_func1]", str(Datetime.now()))
+def my_func1(stg: Strategy):
+    print("[my_func1]", str(stg.now()))
 
 
-def my_func2():
-    print("[my_func2] calculate:", Datetime.now())
+def my_func2(stg: Strategy):
+    print("[my_func2] calculate:", stg.now())
     for s in sm:
         print(s)