hikyuu 2.6.8__py3-none-manylinux2014_aarch64.whl

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 */

hikyuu/include/hikyuu/python/pickle_support.h

@@ -0,0 +1,90 @@
+/*
+ *  Copyright (c) 2019 hikyuu.org
+ *
+ *  Created on: 2020-5-24
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef PICKLE_SUPPORT_H_
+#define PICKLE_SUPPORT_H_
+
+#include <hikyuu/config.h>
+
+#if HKU_SUPPORT_BINARY_ARCHIVE || HKU_SUPPORT_XML_ARCHIVE || HKU_SUPPORT_TEXT_ARCHIVE
+#define HKU_PYTHON_SUPPORT_PICKLE 1
+#endif
+
+#if HKU_PYTHON_SUPPORT_PICKLE
+#if HKU_SUPPORT_BINARY_ARCHIVE
+#include <boost/archive/binary_oarchive.hpp>
+#include <boost/archive/binary_iarchive.hpp>
+#define OUTPUT_ARCHIVE boost::archive::binary_oarchive
+#define INPUT_ARCHIVE boost::archive::binary_iarchive
+
+#else
+#if HKU_SUPPORT_XML_ARCHIVE
+#include <boost/archive/xml_oarchive.hpp>
+#include <boost/archive/xml_iarchive.hpp>
+#define OUTPUT_ARCHIVE boost::archive::xml_oarchive
+#define INPUT_ARCHIVE boost::archive::xml_iarchive
+
+#else
+#include <boost/archive/text_oarchive.hpp>
+#include <boost/archive/text_iarchive.hpp>
+#define OUTPUT_ARCHIVE boost::archive::text_oarchive
+#define INPUT_ARCHIVE boost::archive::text_iarchive
+#endif /* HKU_SUPPORT_XML_ARCHIVE */
+
+#endif /* HKU_SUPPORT_BINARY_ARCHIVE */
+#endif /* HKU_PYTHON_SUPPORT_PICKLE */
+
+#if HKU_PYTHON_SUPPORT_PICKLE
+#include <string>
+#include <sstream>
+#include <pybind11/pybind11.h>
+
+namespace py = pybind11;
+
+#define DEF_PICKLE(classname)                                                                      \
+    .def(py::pickle(                                                                               \
+      [](const classname& p) {                                                                     \
+          std::ostringstream os;                                                                   \
+          OUTPUT_ARCHIVE oa(os);                                                                   \
+          oa << p;                                                                                 \
+          std::string tmp(os.str());                                                               \
+          return py::make_tuple(py::handle(PyBytes_FromStringAndSize(tmp.data(), tmp.size())));    \
+      },                                                                                           \
+      [](py::tuple t) {                                                                            \
+          classname result;                                                                        \
+          if (len(t) != 1) {                                                                       \
+              PyErr_SetObject(                                                                     \
+                PyExc_ValueError,                                                                  \
+                py::str("expected 1-item tuple in call to __setstate__; got {}").format(t).ptr()); \
+              throw py::error_already_set();                                                       \
+          }                                                                                        \
+          py::object obj = t[0];                                                                   \
+          if (py::isinstance<py::str>(obj)) {                                                      \
+              std::string st = obj.cast<py::str>();                                                \
+              std::istringstream is(st);                                                           \
+              INPUT_ARCHIVE ia(is);                                                                \
+              ia >> result;                                                                        \
+          } else if (PyBytes_Check(py::object(t[0]).ptr())) {                                      \
+              py::object obj = t[0];                                                               \
+              char* data = PyBytes_AsString(obj.ptr());                                            \
+              auto num = PyBytes_Size(obj.ptr());                                                  \
+              std::istringstream sin(std::string(data, num));                                      \
+              INPUT_ARCHIVE ia(sin);                                                               \
+              ia >> result;                                                                        \
+              return result;                                                                       \
+          } else {                                                                                 \
+              throw std::runtime_error("Unable to unpickle, error in input file.");                \
+          }                                                                                        \
+          return result;                                                                           \
+      }))
+
+#else
+#define DEF_PICKLE(classname)
+#endif /* HKU_PYTHON_SUPPORT_PICKLE */
+
+#endif /* PICKLE_SUPPORT_H_ */

hikyuu/include/hikyuu/python/pybind_utils.h

@@ -0,0 +1,128 @@
+/*
+ *  Copyright (c) 2019 hikyuu.org
+ *
+ *  Created on: 2020-5-25
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef HIKYUU_PYTHON_BIND_UTILS_H
+#define HIKYUU_PYTHON_BIND_UTILS_H
+
+#include <pybind11/pybind11.h>
+
+#include <pybind11/operators.h>
+#include <pybind11/stl.h>
+#include <pybind11/numpy.h>
+#include <vector>
+#include <string>
+#include "convert_any.h"
+#include "pickle_support.h"
+#include "ioredirect.h"
+
+namespace py = pybind11;
+
+namespace hku {
+
+template <typename T>
+py::bytes vector_to_python_bytes(const std::vector<T>& vect) {
+    return py::bytes((char*)vect.data(), vect.size() * sizeof(T));
+}
+
+template <typename T>
+std::vector<T> python_bytes_to_vector(const py::bytes& obj) {
+    auto bytes_len = len(obj);
+    if (bytes_len % sizeof(T) != 0) {
+        throw std::runtime_error("The length bytes not match!");
+    }
+    auto vect_len = bytes_len / sizeof(T);
+    std::vector<T> result(vect_len);
+
+    char* buffer = nullptr;
+    Py_ssize_t length = 0;
+    if (PyBytes_AsStringAndSize(obj.ptr(), &buffer, &length) != 0) {
+        throw std::runtime_error("trans bytes to vector failed!");
+    }
+
+    if (length != static_cast<Py_ssize_t>(vect_len * sizeof(T))) {
+        throw std::runtime_error("The length bytes not match!");
+    }
+
+    memcpy(result.data(), buffer, length);
+    return result;
+}
+
+template <typename T>
+std::vector<T> python_list_to_vector(const py::sequence& obj) {
+    // 如果 len(obj) 长度为零，即使类型不是所期望的也可能成功，但无风险
+    auto total = len(obj);
+    std::vector<T> vect(total);
+    for (auto i = 0; i < total; ++i) {
+        vect[i] = py::cast<T>(obj[i]);
+    }
+    return vect;
+}
+
+template <typename T>
+py::list vector_to_python_list(const std::vector<T>& vect) {
+    py::list obj;
+    for (unsigned long i = 0; i < vect.size(); ++i)
+        obj.append(vect[i]);
+    return obj;
+}
+
+template <typename T>
+void extend_vector_with_python_list(std::vector<T>& v, const py::sequence& l) {
+    for (const auto& item : l)
+        v.push_back(item.cast<T>());
+}
+
+template <typename T>
+std::string to_py_str(const T& item) {
+    std::stringstream out;
+    out << item;
+    return out.str();
+}
+
+// 直接使用 pybind11 重载 _clone，在 C++ 中会丢失 python 中的类型
+// 参考：https://github.com/pybind/pybind11/issues/1049 进行修改
+// PYBIND11_OVERLOAD(IndicatorImpPtr, IndicatorImp, _clone, );
+#define PY_CLONE(pyclassname, classname)                                         \
+public:                                                                          \
+    std::shared_ptr<classname> _clone() override {                               \
+        if (isPythonObject()) {                                                  \
+            py::gil_scoped_acquire acquire;                                      \
+            auto self = py::cast(this);                                          \
+            auto cloned = self.attr("_clone")();                                 \
+            auto keep_python_state_alive = std::make_shared<py::object>(cloned); \
+            auto ptr = cloned.cast<pyclassname*>();                              \
+            return std::shared_ptr<classname>(keep_python_state_alive, ptr);     \
+        }                                                                        \
+        return this->_clone();                                                   \
+    }                                                                            \
+                                                                                 \
+protected:                                                                       \
+    inline bool isPythonObject() const override {                                \
+        return true;                                                             \
+    }
+
+// 用于检查已 py::object 方式传递的函数参数个数是否符合预期
+inline bool check_pyfunction_arg_num(py::object& func, size_t arg_num) {
+    py::module_ inspect = py::module_::import("inspect");
+    py::object sig = inspect.attr("signature")(func);
+    py::object params = sig.attr("parameters");
+    return len(params) == arg_num;
+}
+
+/*
+ * 将utf8编码的字符串转换为utf32编码
+ * @param utf8_str 待转换的字符串
+ * @param out 存储转换结果的数组(需自行预先分配内存)
+ * @param out_len out数组的长度
+ * @return 实际转码点数
+ */
+size_t utf8_to_utf32(const std::string& utf8_str, int32_t* out, size_t out_len) noexcept;
+
+}  // namespace hku
+
+#endif  // HIKYUU_PYTHON_BIND_UTILS_H

hikyuu/include/hikyuu/serialization/Block_serialization.h

@@ -0,0 +1,55 @@
+/*
+ * Block_serialization.h
+ *
+ *  Created on: 2015年2月9日
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef BLOCK_SERIALIZATION_H_
+#define BLOCK_SERIALIZATION_H_
+
+#include "../config.h"
+#include "../Block.h"
+
+#if HKU_SUPPORT_SERIALIZATION
+#include "Stock_serialization.h"
+
+namespace boost {
+namespace serialization {
+template <class Archive>
+void save(Archive& ar, const hku::Block& blk, unsigned int version) {
+    hku::string category = blk.category();
+    hku::string name = blk.name();
+    ar& boost::serialization::make_nvp("category", category);
+    ar& boost::serialization::make_nvp("name", name);
+    hku::StockList stock_list;
+    stock_list.reserve(blk.size());
+    for (auto iter = blk.begin(); iter != blk.end(); ++iter) {
+        stock_list.push_back(*iter);
+    }
+    ar& boost::serialization::make_nvp("stock_list", stock_list);
+}
+
+template <class Archive>
+void load(Archive& ar, hku::Block& blk, unsigned int version) {
+    hku::string category, name;
+    ar& boost::serialization::make_nvp("category", category);
+    ar& boost::serialization::make_nvp("name", name);
+    hku::StockList stock_list;
+    ar& boost::serialization::make_nvp("stock_list", stock_list);
+    HKU_IF_RETURN(category.empty() && name.empty(), void());
+    blk.category(category);
+    blk.name(name);
+    for (auto iter = stock_list.begin(); iter != stock_list.end(); ++iter) {
+        blk.add(*iter);
+    }
+}
+}  // namespace serialization
+}  // namespace boost
+
+BOOST_SERIALIZATION_SPLIT_FREE(hku::Block)
+
+#endif /* HKU_SUPPORT_SERIALIZATION */
+
+#endif /* BLOCK_SERIALIZATION_H_ */

hikyuu/include/hikyuu/serialization/Datetime_serialization.h

@@ -0,0 +1,40 @@
+/*
+ * Datetime_Serialization.h
+ *
+ *  Created on: 2013-4-29
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef DATETIME_SERIALIZATION_H_
+#define DATETIME_SERIALIZATION_H_
+
+#include "hikyuu/utilities/datetime/Datetime.h"
+#include "../config.h"
+
+#if HKU_SUPPORT_SERIALIZATION
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/split_free.hpp>
+
+namespace boost {
+namespace serialization {
+template <class Archive>
+void save(Archive& ar, const hku::Datetime& date, unsigned int version) {
+    std::string datetime = date.str();
+    ar& BOOST_SERIALIZATION_NVP(datetime);
+}
+
+template <class Archive>
+void load(Archive& ar, hku::Datetime& date, unsigned int version) {
+    std::string datetime;
+    ar& BOOST_SERIALIZATION_NVP(datetime);
+    date = hku::Datetime(datetime);
+}
+}  // namespace serialization
+}  // namespace boost
+
+BOOST_SERIALIZATION_SPLIT_FREE(hku::Datetime)
+
+#endif /* HKU_SUPPORT_SERIALIZATION */
+
+#endif /* DATETIME_SERIALIZATION_H_ */

hikyuu/include/hikyuu/serialization/KData_serialization.h

@@ -0,0 +1,45 @@
+/*
+ * KData.h
+ *
+ *  Created on: 2013-5-1
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef KDATA_SERIALIZATION_H_
+#define KDATA_SERIALIZATION_H_
+
+#include "../config.h"
+#include "../KData.h"
+
+#if HKU_SUPPORT_SERIALIZATION
+#include "Stock_serialization.h"
+#include "KQuery_serialization.h"
+
+namespace boost {
+namespace serialization {
+template <class Archive>
+void save(Archive& ar, const hku::KData& kdata, unsigned int version) {
+    hku::Stock stock = kdata.getStock();
+    hku::KQuery query = kdata.getQuery();
+    ar& BOOST_SERIALIZATION_NVP(stock);
+    ar& BOOST_SERIALIZATION_NVP(query);
+}
+
+template <class Archive>
+void load(Archive& ar, hku::KData& kdata, unsigned int version) {
+    hku::Stock stock;
+    hku::KQuery query;
+    ar& BOOST_SERIALIZATION_NVP(stock);
+    ar& BOOST_SERIALIZATION_NVP(query);
+    kdata = stock.isNull() ? hku::KData() : hku::KData(stock, query);
+}
+
+}  // namespace serialization
+}  // namespace boost
+
+BOOST_SERIALIZATION_SPLIT_FREE(hku::KData)
+
+#endif /* HKU_SUPPORT_SERIALIZATION */
+
+#endif /* KDATA_SERIALIZATION_H_ */