mirror of
https://gitee.com/fasiondog/hikyuu.git
synced 2024-11-30 02:48:57 +08:00
294 lines
10 KiB
C++
294 lines
10 KiB
C++
/*
|
||
* 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 (!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 (isinstance<price_t>(pyseq[0])) {
|
||
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)) {
|
||
const 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 */ |