hikyuu 2.5.6__py3-none-macosx_11_0_arm64.whl

hikyuu/include/hikyuu/indicator_talib/ta_crt.h

@@ -0,0 +1,322 @@
+/*
+ *  Copyright (c) 2024 hikyuu.org
+ *
+ *  Created on: 2024-12-18
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "hikyuu/config.h"
+#include "hikyuu/indicator/Indicator.h"
+#include "hikyuu/indicator/crt/CVAL.h"
+
+#if HKU_ENABLE_TA_LIB
+
+#define TA_IN1_OUT_CRT(func)                        \
+    Indicator HKU_API func();                       \
+    inline Indicator func(const Indicator& ind) {   \
+        return func()(ind);                         \
+    }                                               \
+    inline Indicator func(Indicator::value_t val) { \
+        return func(CVAL(val));                     \
+    }
+
+#define TA_IN1_OUT_N_CRT(func, period)                                 \
+    Indicator HKU_API func(int n = period);                            \
+    Indicator HKU_API func(const IndParam& n);                         \
+    inline Indicator func(const Indicator& ind, int n = period) {      \
+        return func(n)(ind);                                           \
+    }                                                                  \
+    inline Indicator func(const Indicator& data, const IndParam& n) {  \
+        return func(n)(data);                                          \
+    }                                                                  \
+    inline Indicator func(const Indicator& data, const Indicator& n) { \
+        return func(IndParam(n))(data);                                \
+    }
+
+#define TA_IN2_OUT_CRT(func)                                                                     \
+    Indicator HKU_API func(const Indicator& ind1, const Indicator& ind2, bool fill_null = true); \
+    Indicator HKU_API func(bool fill_null = true);
+
+#define TA_IN2_OUT_N_CRT(func, period)                                                   \
+    Indicator HKU_API func(const Indicator& ind1, const Indicator& ind2, int n = period, \
+                           bool fill_null = true);                                       \
+    Indicator HKU_API func(int n = period, bool fill_null = true);
+
+#define TA_K_OUT_CRT(func)    \
+    Indicator HKU_API func(); \
+    Indicator HKU_API func(const KData& k);
+
+#define TA_K_OUT_N_CRT(func, period)        \
+    Indicator HKU_API func(int n = period); \
+    Indicator HKU_API func(const KData& k, int n = period);
+
+#define TA_K_OUT_P_D_CRT(func, param_val)         \
+    Indicator HKU_API func(double p = param_val); \
+    Indicator HKU_API func(const KData& k, double p = param_val);
+
+namespace hku {
+
+TA_K_OUT_N_CRT(TA_ACCBANDS, 20)
+TA_IN1_OUT_CRT(TA_ACOS)
+TA_K_OUT_CRT(TA_AD)
+TA_IN2_OUT_CRT(TA_ADD)
+
+Indicator HKU_API TA_ADOSC(int fast_n = 3, int slow_n = 10);
+Indicator HKU_API TA_ADOSC(const KData& k, int fast_n = 3, int slow_n = 10);
+
+TA_K_OUT_N_CRT(TA_ADX, 14)
+TA_K_OUT_N_CRT(TA_ADXR, 14)
+
+Indicator HKU_API TA_APO(int fast_n = 12, int slow_n = 26, int matype = 0);
+inline Indicator TA_APO(const Indicator& ind, int fast_n = 12, int slow_n = 26, int matype = 0) {
+    return TA_APO(fast_n, slow_n, matype)(ind);
+}
+
+TA_K_OUT_N_CRT(TA_AROON, 14)
+TA_K_OUT_N_CRT(TA_AROONOSC, 14)
+
+TA_IN1_OUT_CRT(TA_ASIN)
+TA_IN1_OUT_CRT(TA_ATAN)
+TA_K_OUT_N_CRT(TA_ATR, 14)
+
+TA_IN1_OUT_N_CRT(TA_AVGDEV, 14)
+TA_K_OUT_CRT(TA_AVGPRICE)
+
+Indicator HKU_API TA_AVGPRICE();
+Indicator HKU_API TA_AVGPRICE(const KData& k);
+
+Indicator HKU_API TA_BBANDS(int n = 5, double nbdevup = 2., double nbdevdn = 2., int matype = 0);
+inline Indicator TA_BBANDS(const Indicator& ind, int n = 5, double nbdevup = 2.,
+                           double nbdevdn = 2., int matype = 0) {
+    return TA_BBANDS(n, nbdevup, nbdevdn, matype)(ind);
+}
+
+TA_IN2_OUT_N_CRT(TA_BETA, 5)
+TA_K_OUT_CRT(TA_BOP)
+TA_K_OUT_N_CRT(TA_CCI, 14)
+TA_K_OUT_CRT(TA_CDL2CROWS)
+TA_K_OUT_CRT(TA_CDL3BLACKCROWS)
+TA_K_OUT_CRT(TA_CDL3INSIDE)
+TA_K_OUT_CRT(TA_CDL3LINESTRIKE)
+TA_K_OUT_CRT(TA_CDL3OUTSIDE)
+TA_K_OUT_CRT(TA_CDL3STARSINSOUTH)
+TA_K_OUT_CRT(TA_CDL3WHITESOLDIERS)
+TA_K_OUT_P_D_CRT(TA_CDLABANDONEDBABY, 3.000000e-1)
+TA_K_OUT_CRT(TA_CDLADVANCEBLOCK)
+TA_K_OUT_CRT(TA_CDLBELTHOLD)
+TA_K_OUT_CRT(TA_CDLBREAKAWAY)
+TA_K_OUT_CRT(TA_CDLCLOSINGMARUBOZU)
+TA_K_OUT_CRT(TA_CDLCONCEALBABYSWALL)
+TA_K_OUT_CRT(TA_CDLCOUNTERATTACK)
+TA_K_OUT_P_D_CRT(TA_CDLDARKCLOUDCOVER, 5.000000e-1)
+TA_K_OUT_CRT(TA_CDLDOJI)
+TA_K_OUT_CRT(TA_CDLDOJISTAR)
+TA_K_OUT_CRT(TA_CDLDRAGONFLYDOJI)
+TA_K_OUT_CRT(TA_CDLENGULFING)
+TA_K_OUT_P_D_CRT(TA_CDLEVENINGDOJISTAR, 3.000000e-1)
+TA_K_OUT_P_D_CRT(TA_CDLEVENINGSTAR, 3.000000e-1)
+TA_K_OUT_CRT(TA_CDLGAPSIDESIDEWHITE)
+TA_K_OUT_CRT(TA_CDLGRAVESTONEDOJI)
+TA_K_OUT_CRT(TA_CDLHAMMER)
+TA_K_OUT_CRT(TA_CDLHANGINGMAN)
+TA_K_OUT_CRT(TA_CDLHARAMI)
+TA_K_OUT_CRT(TA_CDLHARAMICROSS)
+TA_K_OUT_CRT(TA_CDLHIGHWAVE)
+TA_K_OUT_CRT(TA_CDLHIKKAKE)
+TA_K_OUT_CRT(TA_CDLHIKKAKEMOD)
+TA_K_OUT_CRT(TA_CDLHOMINGPIGEON)
+TA_K_OUT_CRT(TA_CDLIDENTICAL3CROWS)
+TA_K_OUT_CRT(TA_CDLINNECK)
+TA_K_OUT_CRT(TA_CDLINVERTEDHAMMER)
+TA_K_OUT_CRT(TA_CDLKICKING)
+TA_K_OUT_CRT(TA_CDLKICKINGBYLENGTH)
+TA_K_OUT_CRT(TA_CDLLADDERBOTTOM)
+TA_K_OUT_CRT(TA_CDLLONGLEGGEDDOJI)
+TA_K_OUT_CRT(TA_CDLLONGLINE)
+TA_K_OUT_CRT(TA_CDLMARUBOZU)
+TA_K_OUT_CRT(TA_CDLMATCHINGLOW)
+TA_K_OUT_P_D_CRT(TA_CDLMATHOLD, 5.000000e-1)
+TA_K_OUT_P_D_CRT(TA_CDLMORNINGDOJISTAR, 3.000000e-1)
+TA_K_OUT_P_D_CRT(TA_CDLMORNINGSTAR, 3.000000e-1)
+TA_K_OUT_CRT(TA_CDLONNECK)
+TA_K_OUT_CRT(TA_CDLPIERCING)
+TA_K_OUT_CRT(TA_CDLRICKSHAWMAN)
+TA_K_OUT_CRT(TA_CDLRISEFALL3METHODS)
+TA_K_OUT_CRT(TA_CDLSEPARATINGLINES)
+TA_K_OUT_CRT(TA_CDLSHOOTINGSTAR)
+TA_K_OUT_CRT(TA_CDLSHORTLINE)
+TA_K_OUT_CRT(TA_CDLSPINNINGTOP)
+TA_K_OUT_CRT(TA_CDLSTALLEDPATTERN)
+TA_K_OUT_CRT(TA_CDLSTICKSANDWICH)
+TA_K_OUT_CRT(TA_CDLTAKURI)
+TA_K_OUT_CRT(TA_CDLTASUKIGAP)
+TA_K_OUT_CRT(TA_CDLTHRUSTING)
+TA_K_OUT_CRT(TA_CDLTRISTAR)
+TA_K_OUT_CRT(TA_CDLUNIQUE3RIVER)
+TA_K_OUT_CRT(TA_CDLUPSIDEGAP2CROWS)
+TA_K_OUT_CRT(TA_CDLXSIDEGAP3METHODS)
+
+TA_IN1_OUT_CRT(TA_CEIL)
+TA_IN1_OUT_N_CRT(TA_CMO, 14)
+TA_IN2_OUT_N_CRT(TA_CORREL, 30)
+TA_IN1_OUT_CRT(TA_COS)
+TA_IN1_OUT_CRT(TA_COSH)
+TA_IN1_OUT_N_CRT(TA_DEMA, 30)
+TA_IN2_OUT_CRT(TA_DIV)
+TA_K_OUT_N_CRT(TA_DX, 14)
+TA_IN1_OUT_N_CRT(TA_EMA, 30)
+TA_IN1_OUT_CRT(TA_EXP)
+TA_IN1_OUT_CRT(TA_FLOOR)
+TA_IN1_OUT_CRT(TA_HT_DCPERIOD)
+TA_IN1_OUT_CRT(TA_HT_DCPHASE)
+TA_IN1_OUT_CRT(TA_HT_PHASOR)
+TA_IN1_OUT_CRT(TA_HT_SINE)
+TA_IN1_OUT_CRT(TA_HT_TRENDLINE)
+TA_IN1_OUT_CRT(TA_HT_TRENDMODE)
+TA_K_OUT_N_CRT(TA_IMI, 14)
+TA_IN1_OUT_N_CRT(TA_KAMA, 30)
+TA_IN1_OUT_N_CRT(TA_LINEARREG_ANGLE, 14)
+TA_IN1_OUT_N_CRT(TA_LINEARREG_INTERCEPT, 14)
+TA_IN1_OUT_N_CRT(TA_LINEARREG_SLOPE, 14)
+TA_IN1_OUT_N_CRT(TA_LINEARREG, 14)
+TA_IN1_OUT_CRT(TA_LN)
+TA_IN1_OUT_CRT(TA_LOG10)
+
+Indicator HKU_API TA_MA(int n = 30, int matype = 0);
+inline Indicator TA_MA(const Indicator& ind, int n = 30, int matype = 0) {
+    return TA_MA(n, matype)(ind);
+}
+
+Indicator HKU_API TA_MACD(int fast_n = 12, int slow_n = 26, int signal_n = 9);
+inline Indicator TA_MACD(const Indicator& ind, int fast_n = 12, int slow_n = 26, int signal_n = 9) {
+    return TA_MACD(fast_n, slow_n, signal_n)(ind);
+}
+
+Indicator HKU_API TA_MACDEXT(int fast_n = 12, int slow_n = 26, int signal_n = 9,
+                             int fast_matype = 0, int slow_matype = 0, int signal_matype = 0);
+inline Indicator TA_MACDEXT(const Indicator& ind, int fast_n = 12, int slow_n = 26,
+                            int signal_n = 9, int fast_matype = 0, int slow_matype = 0,
+                            int signal_matype = 0) {
+    return TA_MACDEXT(fast_n, slow_n, signal_n, fast_matype, slow_matype, signal_matype)(ind);
+}
+
+TA_IN1_OUT_N_CRT(TA_MACDFIX, 9)
+
+Indicator HKU_API TA_MAMA(double fast_limit = 5.000000e-1, double slow_limit = 5.000000e-2);
+inline Indicator TA_MAMA(const Indicator& ind, double fast_limit = 5.000000e-1,
+                         double slow_limit = 5.000000e-2) {
+    return TA_MAMA(fast_limit, slow_limit)(ind);
+}
+
+Indicator HKU_API TA_MAVP(const Indicator& ref_ind, int min_n = 2, int max_n = 30, int matype = 0,
+                          bool fill_null = true);
+inline Indicator TA_MAVP(const Indicator& ind1, const Indicator& ind2, int min_n = 2,
+                         int max_n = 30, int matype = 0, bool fill_null = true) {
+    return TA_MAVP(ind2, min_n, max_n, matype, fill_null)(ind1);
+}
+
+TA_IN1_OUT_N_CRT(TA_MAX, 30)
+TA_IN1_OUT_N_CRT(TA_MAXINDEX, 30)
+
+TA_K_OUT_CRT(TA_MEDPRICE)
+TA_K_OUT_N_CRT(TA_MFI, 14)
+TA_IN1_OUT_N_CRT(TA_MIDPOINT, 14)
+
+Indicator HKU_API TA_MIDPRICE(int n = 14);
+Indicator HKU_API TA_MIDPRICE(const KData& k, int n = 14);
+
+TA_IN1_OUT_N_CRT(TA_MIN, 30)
+TA_IN1_OUT_N_CRT(TA_MININDEX, 30)
+TA_IN1_OUT_N_CRT(TA_MINMAX, 30)
+TA_IN1_OUT_N_CRT(TA_MINMAXINDEX, 30)
+
+TA_K_OUT_N_CRT(TA_MINUS_DI, 14)
+TA_K_OUT_N_CRT(TA_MINUS_DM, 14)
+TA_IN1_OUT_N_CRT(TA_MOM, 10)
+TA_IN2_OUT_CRT(TA_MULT)
+TA_K_OUT_N_CRT(TA_NATR, 14)
+TA_K_OUT_CRT(TA_OBV)
+TA_K_OUT_N_CRT(TA_PLUS_DI, 14)
+TA_K_OUT_N_CRT(TA_PLUS_DM, 14)
+
+Indicator HKU_API TA_PPO(int fast_n = 12, int slow_n = 26, int matype = 0);
+inline Indicator TA_PPO(const Indicator& ind, int fast_n = 12, int slow_n = 26, int matype = 0) {
+    return TA_PPO(fast_n, slow_n, matype)(ind);
+}
+
+TA_IN1_OUT_N_CRT(TA_ROC, 10)
+TA_IN1_OUT_N_CRT(TA_ROCP, 10)
+TA_IN1_OUT_N_CRT(TA_ROCR, 10)
+TA_IN1_OUT_N_CRT(TA_ROCR100, 10)
+TA_IN1_OUT_N_CRT(TA_RSI, 14)
+
+Indicator HKU_API TA_SAR(double acceleration = 0.02, double maximum = 0.2);
+Indicator HKU_API TA_SAR(const KData& k, double acceleration = 0.02, double maximum = 0.2);
+
+Indicator HKU_API TA_SAREXT(double startvalue = 0.0, double offsetonreverse = 0.0,
+                            double accelerationinitlong = 0.02, double accelerationlong = 0.02,
+                            double accelerationmaxlong = 0.2, double accelerationinitshort = 0.02,
+                            double accelerationshort = 0.02, double accelerationmaxshort = 0.2);
+Indicator HKU_API TA_SAREXT(const KData& k, double startvalue = 0.0, double offsetonreverse = 0.0,
+                            double accelerationinitlong = 0.02, double accelerationlong = 0.02,
+                            double accelerationmaxlong = 0.2, double accelerationinitshort = 0.02,
+                            double accelerationshort = 0.02, double accelerationmaxshort = 0.2);
+
+TA_IN1_OUT_CRT(TA_SIN)
+TA_IN1_OUT_CRT(TA_SINH)
+TA_IN1_OUT_N_CRT(TA_SMA, 30)
+TA_IN1_OUT_CRT(TA_SQRT)
+
+Indicator HKU_API TA_STDDEV(int n = 5, double nbdev = 1.0);
+inline Indicator TA_STDDEV(const Indicator& ind, int n = 5, double nbdev = 1.0) {
+    return TA_STDDEV(n, nbdev)(ind);
+}
+
+Indicator HKU_API TA_STOCH(int fastk_n = 5, int slowk_n = 3, int slowk_matype = 0, int slowd_n = 3,
+                           int slowd_matype = 0);
+Indicator HKU_API TA_STOCH(const KData& k, int fastk_n = 5, int slowk_n = 3, int slowk_matype = 0,
+                           int slowd_n = 3, int slowd_matype = 0);
+
+Indicator HKU_API TA_STOCHF(int fastk_n = 5, int fastd_n = 3, int fastd_matype = 0);
+Indicator HKU_API TA_STOCHF(const KData& k, int fastk_n = 5, int fastd_n = 3, int fastd_matype = 0);
+
+Indicator HKU_API TA_STOCHRSI(int n = 14, int fastk_n = 5, int fastd_n = 3, int matype = 0);
+inline Indicator TA_STOCHRSI(const Indicator& ind, int n = 14, int fastk_n = 5, int fastd_n = 3,
+                             int matype = 0) {
+    return TA_STOCHRSI(n, fastk_n, fastd_n, matype)(ind);
+}
+
+TA_IN2_OUT_CRT(TA_SUB)
+TA_IN1_OUT_N_CRT(TA_SUM, 30)
+
+Indicator HKU_API TA_T3(int n = 5, double vfactor = 7.000000e-1);
+inline Indicator TA_T3(const Indicator& ind, int n = 5, double vfactor = 7.000000e-1) {
+    return TA_T3(n, vfactor)(ind);
+}
+
+TA_IN1_OUT_CRT(TA_TAN)
+TA_IN1_OUT_CRT(TA_TANH)
+TA_IN1_OUT_N_CRT(TA_TEMA, 30)
+TA_K_OUT_CRT(TA_TRANGE)
+TA_IN1_OUT_N_CRT(TA_TRIMA, 30)
+TA_IN1_OUT_N_CRT(TA_TRIX, 30)
+TA_IN1_OUT_N_CRT(TA_TSF, 14)
+TA_K_OUT_CRT(TA_TYPPRICE)
+
+Indicator HKU_API TA_ULTOSC(int n1 = 7, int n2 = 14, int n3 = 28);
+Indicator HKU_API TA_ULTOSC(const KData& k, int n1 = 7, int n2 = 14, int n3 = 28);
+
+Indicator HKU_API TA_VAR(int n = 5, double nbdev = 1.0);
+inline Indicator TA_VAR(const Indicator& ind, int n = 5, double nbdev = 1.0) {
+    return TA_VAR(n, nbdev)(ind);
+}
+
+TA_K_OUT_CRT(TA_WCLPRICE)
+TA_K_OUT_N_CRT(TA_WILLR, 14)
+TA_IN1_OUT_N_CRT(TA_WMA, 30)
+
+}  // namespace hku
+
+#endif

hikyuu/include/hikyuu/python/__init__.py

@@ -0,0 +1 @@
+

hikyuu/include/hikyuu/python/convert_any.h

@@ -0,0 +1,299 @@
+/*
+ *  Copyright (c) 2019 hikyuu.org
+ *
+ *  Created on: 2020-5-24
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef HIKYUU_PYTHON_CONVERT_ANY_H
+#define HIKYUU_PYTHON_CONVERT_ANY_H
+
+#include <string>
+#include <pybind11/pybind11.h>
+#include <pybind11/eval.h>
+#include <hikyuu/hikyuu.h>
+#include <datetime.h>
+#include "bind_stl.h"
+
+using namespace hku;
+
+inline Datetime pydatetime_to_Datetime(const pybind11::object& source) {
+    Datetime value;
+    if (source.is_none()) {
+        return value;
+    }
+
+    if (pybind11::isinstance<Datetime>(source)) {
+        value = source.cast<Datetime>();
+        return value;
+    }
+
+    if (!PyDateTimeAPI) {
+        PyDateTime_IMPORT;
+    }
+
+    PyObject* src = source.ptr();
+
+    long year = 0, month = 0, day = 0, hour = 0, minute = 0, second = 0, microsecond = 0;
+    if (PyDateTime_Check(src)) {
+        second = PyDateTime_DATE_GET_SECOND(src);
+        minute = PyDateTime_DATE_GET_MINUTE(src);
+        hour = PyDateTime_DATE_GET_HOUR(src);
+        day = PyDateTime_GET_DAY(src);
+        month = PyDateTime_GET_MONTH(src);
+        year = PyDateTime_GET_YEAR(src);
+        microsecond = PyDateTime_DATE_GET_MICROSECOND(src);
+
+    } else if (PyDate_Check(src)) {
+        day = PyDateTime_GET_DAY(src);
+        month = PyDateTime_GET_MONTH(src);
+        year = PyDateTime_GET_YEAR(src);
+
+    } else if (PyTime_Check(src)) {
+        second = PyDateTime_TIME_GET_SECOND(src);
+        minute = PyDateTime_TIME_GET_MINUTE(src);
+        hour = PyDateTime_TIME_GET_HOUR(src);
+        day = 1;      // This date (day, month, year) = (1, 0, 70)
+        month = 1;    // represents 1-Jan-1940, which is the first
+        year = 1400;  // earliest available date for Datetime, not Python datetime
+        microsecond = PyDateTime_TIME_GET_MICROSECOND(src);
+
+    } else {
+        throw std::invalid_argument("Can't convert this python object to Datetime!");
+    }
+
+    // Datetime 最小只到 1400年 1 月 1日，最大只到 9999 年 12月 31 日 0点
+    if (year < 1400) {
+        value = Datetime::min();
+    } else if (Datetime(year, month, day) == Datetime::max()) {
+        value = Datetime::max();
+    } else {
+        long millisecond = microsecond / 1000;
+        microsecond = microsecond - millisecond * 1000;
+        value = Datetime(year, month, day, hour, minute, second, millisecond, microsecond);
+    }
+
+    return value;
+}
+
+namespace pybind11 {
+namespace detail {
+template <>
+struct type_caster<boost::any> {
+public:
+    PYBIND11_TYPE_CASTER(boost::any, _("any"));
+
+    /**
+     * Conversion part 1 (Python->C++)
+     */
+    bool load(handle source, bool) {
+        if (source.is_none()) {
+            return false;
+        }
+
+        /* Extract PyObject from handle */
+        PyObject* src = source.ptr();
+
+        object obj = reinterpret_borrow<object>(source);
+        if (PyBool_Check(src)) {
+            // value = bool(PyLong_AsLong(src));
+            bool tmp = obj.cast<bool>();
+            value = tmp;
+            return true;
+        }
+
+        if (PyLong_Check(src)) {
+            int overflow;
+            long tmp = PyLong_AsLongAndOverflow(src, &overflow);
+            if (overflow == 0) {
+                value = static_cast<int>(tmp);
+            } else {
+                value = PyLong_AsLongLong(src);
+            }
+            return true;
+        }
+
+        if (PyFloat_Check(src)) {
+            value = PyFloat_AsDouble(src);
+            return true;
+        }
+
+        if (PyUnicode_Check(src)) {
+            object temp = reinterpret_borrow<object>(PyUnicode_AsUTF8String(src));
+            if (!temp)
+                pybind11_fail("Unable to extract string contents! (encoding issue)");
+            char* buffer;
+            ssize_t length;
+            if (PYBIND11_BYTES_AS_STRING_AND_SIZE(temp.ptr(), &buffer, &length))
+                pybind11_fail("Unable to extract string contents! (invalid type)");
+            value = std::string(buffer, (size_t)length);
+            return true;
+        }
+
+        if (isinstance<Stock>(obj)) {
+            value = obj.cast<Stock>();
+            return true;
+
+        } else if (isinstance<Block>(obj)) {
+            value = obj.cast<Block>();
+            return true;
+
+        } else if (isinstance<KQuery>(obj)) {
+            value = obj.cast<KQuery>();
+            return true;
+
+        } else if (isinstance<KData>(obj)) {
+            value = obj.cast<KData>();
+            return true;
+
+        } else if (isinstance<sequence>(obj)) {
+            sequence pyseq = obj.cast<sequence>();
+            size_t total = pyseq.size();
+            HKU_CHECK(total > 0, "Can't support empty sequence!");
+            if (isinstance<Datetime>(pyseq[0])) {
+                std::vector<Datetime> vect(total);
+                for (size_t i = 0; i < total; i++) {
+                    vect[i] = pyseq[i].cast<Datetime>();
+                }
+                value = vect;
+
+            } else if (PyFloat_Check(pyseq[0].ptr()) || PyLong_Check(pyseq[0].ptr())) {
+                std::vector<price_t> vect(total);
+                for (size_t i = 0; i < total; i++) {
+                    vect[i] = pyseq[i].cast<price_t>();
+                }
+                value = vect;
+
+            } else {
+                // 尝试 python 原生 datetime 的转换
+                std::vector<Datetime> vect(total);
+                for (size_t i = 0; i < total; i++) {
+                    vect[i] = pydatetime_to_Datetime(pyseq[i]);
+                }
+                value = vect;
+            }
+            return true;
+        }
+
+        HKU_THROW_EXCEPTION(std::logic_error,
+                            "Faile convert this value to boost::any, it may be not supported!");
+        return false;
+    }
+
+    /**
+     * Conversion part 2 (C++ -> Python)
+     */
+    static handle cast(boost::any x, return_value_policy /* policy */, handle /* parent */) {
+        if (x.type() == typeid(bool)) {
+            bool tmp = boost::any_cast<bool>(x);
+            if (tmp) {
+                Py_RETURN_TRUE;
+            } else {
+                Py_RETURN_FALSE;
+            }
+        } else if (x.type() == typeid(int)) {
+            return Py_BuildValue("n", boost::any_cast<int>(x));
+        } else if (x.type() == typeid(double)) {
+            return Py_BuildValue("d", boost::any_cast<double>(x));
+        } else if (x.type() == typeid(std::string)) {
+            std::string s(boost::any_cast<std::string>(x));
+            return Py_BuildValue("s", s.c_str());
+
+        } else if (x.type() == typeid(KData)) {
+            const KData& k = boost::any_cast<KData>(x);
+            std::stringstream cmd;
+            if (k == Null<KData>()) {
+                cmd << "KData()";
+            } else {
+                auto stk = k.getStock();
+                auto query = k.getQuery();
+                std::stringstream q_cmd;
+                if (query.queryType() == KQuery::INDEX) {
+                    q_cmd << "Query(" << query.start() << "," << query.end() << ", Query."
+                          << KQuery::getKTypeName(query.kType()) << ", Query."
+                          << KQuery::getRecoverTypeName(query.recoverType()) << ")";
+                } else {
+                    q_cmd << "Query(Datetime('" << query.startDatetime() << "'), Datetime('"
+                          << query.endDatetime() << "'), " << "Query."
+                          << KQuery::getKTypeName(query.kType()) << ", Query."
+                          << KQuery::getRecoverTypeName(query.recoverType()) << ")";
+                }
+                cmd << "KData(get_stock('" << stk.market_code() << "'), " << q_cmd.str() << ")";
+            }
+            object o = eval(cmd.str());
+            o.inc_ref();
+            return o;
+
+        } else if (x.type() == typeid(Stock)) {
+            const Stock& stk = boost::any_cast<Stock>(x);
+            std::stringstream cmd;
+            if (stk.isNull()) {
+                cmd << "Stock()";
+            } else {
+                cmd << "get_stock('" << stk.market_code() << "')";
+            }
+            object o = eval(cmd.str());
+            o.inc_ref();
+            return o;
+
+        } else if (x.type() == typeid(Block)) {
+            const Block& blk = boost::any_cast<const Block&>(x);
+            std::stringstream cmd;
+            object o;
+            if (blk == Null<Block>()) {
+                cmd << "Block()";
+                o = eval(cmd.str());
+                o.inc_ref();
+            } else {
+                cmd << "Block('" << blk.category() << "','" << blk.name() << "')";
+                o = eval(cmd.str());
+                o.inc_ref();
+                Block out = o.cast<Block>();
+                out.add(blk.getStockList());
+            }
+            return o;
+
+        } else if (x.type() == typeid(KQuery)) {
+            const KQuery& query = boost::any_cast<KQuery>(x);
+            std::stringstream cmd;
+            if (query.queryType() == KQuery::INDEX) {
+                cmd << "Query(" << query.start() << "," << query.end() << ", Query."
+                    << KQuery::getKTypeName(query.kType()) << ", Query."
+                    << KQuery::getRecoverTypeName(query.recoverType()) << ")";
+            } else {
+                cmd << "Query(Datetime('" << query.startDatetime() << "'), Datetime('"
+                    << query.endDatetime() << "'), " << "Query."
+                    << KQuery::getKTypeName(query.kType()) << ", Query."
+                    << KQuery::getRecoverTypeName(query.recoverType()) << ")";
+            }
+            object o = eval(cmd.str());
+            o.inc_ref();
+            return o;
+
+        } else if (x.type() == typeid(PriceList)) {
+            PriceList price_list = boost::any_cast<PriceList>(x);
+            list o;
+            for (auto iter = price_list.begin(); iter != price_list.end(); ++iter) {
+                o.append(*iter);
+            }
+            o.inc_ref();
+            return o;
+
+        } else if (x.type() == typeid(DatetimeList)) {
+            const DatetimeList& date_list = boost::any_cast<DatetimeList>(x);
+            list o;
+            for (auto iter = date_list.begin(); iter != date_list.end(); ++iter) {
+                o.append(*iter);
+            }
+            o.inc_ref();
+            return o;
+        }
+
+        HKU_THROW_EXCEPTION(std::runtime_error, "convert failed! Unkown type!!");
+    }
+};
+}  // namespace detail
+}  // namespace pybind11
+
+#endif /* HIKYUU_PYTHON_CONVERT_ANY_H */