| #include <pybind11/pybind11.h> |
| #include <pybind11/stl.h> |
| #include "../include/fast_alpha_engine.hpp" |
| #include "../include/orderbook.hpp" |
| #include "../include/simd_alpha_calculator.hpp" |
| #include "../include/core/types.hpp" |
| #include "../include/order_book/order_book.hpp" |
| #include "../include/order_book/matching_engine.hpp" |
| #include "../include/risk/risk_engine.hpp" |
| #include "../include/engine/trading_engine.hpp" |
|
|
| namespace py = pybind11; |
| using namespace quant; |
|
|
| PYBIND11_MODULE(cpp_quant_engine, m) { |
| m.doc() = "Quant.ai High-Performance C++20 Low-Latency Alpha & Production Trading Engine"; |
|
|
| |
| |
| |
| py::class_<MarketTick>(m, "MarketTick") |
| .def(py::init<double, double, double, double, double, double, double>(), |
| py::arg("timestamp") = 0.0, |
| py::arg("bid_price") = 0.0, |
| py::arg("ask_price") = 0.0, |
| py::arg("bid_size") = 0.0, |
| py::arg("ask_size") = 0.0, |
| py::arg("last_price") = 0.0, |
| py::arg("last_volume") = 0.0) |
| .def_readwrite("timestamp", &MarketTick::timestamp) |
| .def_readwrite("bid_price", &MarketTick::bid_price) |
| .def_readwrite("ask_price", &MarketTick::ask_price) |
| .def_readwrite("bid_size", &MarketTick::bid_size) |
| .def_readwrite("ask_size", &MarketTick::ask_size) |
| .def_readwrite("last_price", &MarketTick::last_price) |
| .def_readwrite("last_volume", &MarketTick::last_volume); |
|
|
| py::class_<AlphaSignalPayload>(m, "AlphaSignalPayload") |
| .def_readonly("micro_price", &AlphaSignalPayload::micro_price) |
| .def_readonly("order_book_imbalance", &AlphaSignalPayload::order_book_imbalance) |
| .def_readonly("vwap", &AlphaSignalPayload::vwap) |
| .def_readonly("rolling_volatility", &AlphaSignalPayload::rolling_volatility) |
| .def_readonly("ema_9", &AlphaSignalPayload::ema_9) |
| .def_readonly("ema_21", &AlphaSignalPayload::ema_21) |
| .def_readonly("signal_score", &AlphaSignalPayload::signal_score); |
|
|
| py::class_<FastAlphaEngine>(m, "FastAlphaEngine") |
| .def(py::init<int>(), py::arg("window_size") = 20) |
| .def("process_tick", &FastAlphaEngine::process_tick, py::arg("tick")) |
| .def_static("calculate_micro_price", &FastAlphaEngine::calculate_micro_price) |
| .def_static("calculate_obi", &FastAlphaEngine::calculate_obi) |
| .def_static("fast_ema", &FastAlphaEngine::fast_ema) |
| .def_static("fast_vwap", &FastAlphaEngine::fast_vwap) |
| .def_static("fast_order_flow_imbalance", &FastAlphaEngine::fast_order_flow_imbalance); |
|
|
| py::class_<FastL2OrderBook>(m, "FastL2OrderBook") |
| .def(py::init<>()) |
| .def("update_bid", &FastL2OrderBook::update_bid, py::arg("level"), py::arg("price"), py::arg("volume"), py::arg("count") = 1) |
| .def("update_ask", &FastL2OrderBook::update_ask, py::arg("level"), py::arg("price"), py::arg("volume"), py::arg("count") = 1) |
| .def("get_best_bid", &FastL2OrderBook::get_best_bid) |
| .def("get_best_ask", &FastL2OrderBook::get_best_ask) |
| .def("get_mid_price", &FastL2OrderBook::get_mid_price) |
| .def("get_weighted_microprice", &FastL2OrderBook::get_weighted_microprice) |
| .def("calculate_book_imbalance", &FastL2OrderBook::calculate_book_imbalance); |
|
|
| py::class_<SIMDAlphaCalculator>(m, "SIMDAlphaCalculator") |
| .def_static("calculate_ofi_vectorized", &SIMDAlphaCalculator::calculate_ofi_vectorized) |
| .def_static("calculate_microprice_velocity", &SIMDAlphaCalculator::calculate_microprice_velocity) |
| .def_static("calculate_vpin_toxicity", &SIMDAlphaCalculator::calculate_vpin_toxicity); |
|
|
| |
| |
| |
| py::enum_<core::Side>(m, "Side") |
| .value("BUY", core::Side::BUY) |
| .value("SELL", core::Side::SELL) |
| .value("UNKNOWN", core::Side::UNKNOWN); |
|
|
| py::enum_<core::OrderType>(m, "OrderType") |
| .value("LIMIT", core::OrderType::LIMIT) |
| .value("MARKET", core::OrderType::MARKET) |
| .value("IOC", core::OrderType::IOC) |
| .value("FOK", core::OrderType::FOK); |
|
|
| py::class_<core::Price>(m, "Price") |
| .def(py::init<>()) |
| .def_static("from_double", &core::Price::from_double) |
| .def_static("from_raw", &core::Price::from_raw) |
| .def("to_double", &core::Price::to_double) |
| .def("raw", &core::Price::raw); |
|
|
| py::class_<order_book::OrderBook>(m, "OrderBook") |
| .def("get_mid_price", &order_book::OrderBook::get_mid_price) |
| .def("get_weighted_microprice", &order_book::OrderBook::get_weighted_microprice) |
| .def("get_book_imbalance", &order_book::OrderBook::get_book_imbalance) |
| .def("order_count", &order_book::OrderBook::order_count); |
|
|
| py::class_<order_book::MatchingEngine>(m, "MatchingEngine") |
| .def(py::init([](const std::string& symbol) { |
| return std::make_unique<order_book::MatchingEngine>(core::Symbol(symbol.c_str())); |
| }), py::arg("symbol") = "AAPL") |
| .def("process_new_order", [](order_book::MatchingEngine& me, uint32_t client_id, uint64_t client_order_id, |
| core::Side side, core::OrderType type, double price, uint32_t qty) { |
| me.process_new_order(client_id, client_order_id, side, type, core::Price::from_double(price), qty, 0); |
| }) |
| .def("cancel_order", &order_book::MatchingEngine::cancel_order, |
| py::arg("client_id"), py::arg("client_order_id"), py::arg("engine_order_id") = 0, py::arg("timestamp_ns") = 0) |
| .def("total_trades", &order_book::MatchingEngine::total_trades) |
| .def("total_volume", &order_book::MatchingEngine::total_volume) |
| .def("check_invariants", &order_book::MatchingEngine::check_invariants); |
|
|
| py::class_<risk::RiskLimits>(m, "RiskLimits") |
| .def(py::init<>()) |
| .def_readwrite("max_order_notional", &risk::RiskLimits::max_order_notional) |
| .def_readwrite("price_collar_pct", &risk::RiskLimits::price_collar_pct) |
| .def_readwrite("max_orders_per_sec", &risk::RiskLimits::max_orders_per_sec) |
| .def_readwrite("max_net_position", &risk::RiskLimits::max_net_position); |
|
|
| py::class_<engine::TradingEngine>(m, "TradingEngine") |
| .def(py::init<>([](const std::string& symbol, uint16_t tcp_port, uint16_t udp_port) { |
| engine::EngineConfig cfg; |
| cfg.symbol = core::Symbol(symbol.c_str()); |
| cfg.tcp_port = tcp_port; |
| cfg.udp_port = udp_port; |
| return std::make_unique<engine::TradingEngine>(cfg); |
| }), py::arg("symbol") = "AAPL", py::arg("tcp_port") = 9999, py::arg("udp_port") = 12345) |
| .def("start", &engine::TradingEngine::start) |
| .def("stop", &engine::TradingEngine::stop) |
| .def("submit_order_direct", [](engine::TradingEngine& te, uint32_t client_id, uint64_t client_order_id, |
| core::Side side, core::OrderType type, double price, uint32_t qty) { |
| te.submit_order_direct(client_id, client_order_id, side, type, core::Price::from_double(price), qty); |
| }) |
| .def("is_running", &engine::TradingEngine::is_running); |
| } |
|
|
