flox-py 0.5.0__tar.gz

flox_py-0.5.0/CMakeLists.txt

@@ -0,0 +1,16 @@
+find_package(pybind11 REQUIRED)
+
+pybind11_add_module(flox_py flox_py.cpp)
+
+target_link_libraries(flox_py PRIVATE flox)
+target_include_directories(flox_py PRIVATE
+  ${CMAKE_CURRENT_SOURCE_DIR}/../include
+)
+
+if(NOT MSVC)
+  target_compile_options(flox_py PRIVATE
+    $<$<CONFIG:Release>:-O3 -march=native -flto>
+  )
+endif()
+
+install(TARGETS flox_py LIBRARY DESTINATION . COMPONENT python_module)

flox_py-0.5.0/PKG-INFO

@@ -0,0 +1,80 @@
+Metadata-Version: 2.4
+Name: flox-py
+Version: 0.5.0
+Summary: Python bindings for the Flox indicator library
+Keywords: trading,backtest,indicators,technical-analysis
+Author: FLOX Foundation
+License-Expression: MIT
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: Programming Language :: C++
+Classifier: Programming Language :: Python :: 3
+Project-URL: Repository, https://github.com/FLOX-Foundation/flox
+Requires-Python: >=3.9
+Requires-Dist: numpy
+Description-Content-Type: text/markdown
+
+# flox-py
+
+Python bindings for the Flox indicator library. Tested against TA-Lib.
+
+## Install
+
+```bash
+pip install flox-py
+```
+
+## Usage
+
+```python
+import flox_py as flox
+import numpy as np
+
+close = np.array([...])
+high = np.array([...])
+low = np.array([...])
+
+ema50 = flox.ema(close, 50)
+atr14 = flox.atr(high, low, close, 14)
+rsi14 = flox.rsi(close, 14)
+
+signal_long = (rsi14 > 70).astype(np.int8)
+signal_short = ((rsi14 < 30) * -1).astype(np.int8)
+
+returns = flox.bar_returns(signal_long, signal_short, log_returns)
+trades = flox.trade_pnl(signal_long, signal_short, log_returns)
+pf = flox.profit_factor(returns)
+wr = flox.win_rate(trades)
+```
+
+## Indicators
+
+| Function | Description |
+|----------|-------------|
+| `flox.ema(input, period)` | Exponential Moving Average |
+| `flox.sma(input, period)` | Simple Moving Average |
+| `flox.rma(input, period)` | Wilder Moving Average |
+| `flox.rsi(input, period)` | Relative Strength Index |
+| `flox.atr(high, low, close, period)` | Average True Range |
+| `flox.adx(high, low, close, period)` | ADX, +DI, -DI |
+| `flox.macd(input, fast, slow, signal)` | MACD line, signal, histogram |
+| `flox.bollinger(input, period, stddev)` | upper, middle, lower bands |
+| `flox.stochastic(high, low, close, k, d)` | %K and %D |
+| `flox.cci(high, low, close, period)` | Commodity Channel Index |
+| `flox.slope(input, length)` | price slope |
+| `flox.kama(input, period)` | Kaufman Adaptive MA |
+| `flox.dema(input, period)` | Double EMA |
+| `flox.tema(input, period)` | Triple EMA |
+| `flox.chop(high, low, close, period)` | Choppiness Index |
+| `flox.obv(close, volume)` | On-Balance Volume |
+| `flox.vwap(close, volume, window)` | rolling VWAP |
+| `flox.cvd(open, high, low, close, volume)` | Cumulative Volume Delta |
+
+## Metrics
+
+| Function | Description |
+|----------|-------------|
+| `flox.bar_returns(sig_long, sig_short, log_ret)` | per-bar returns with signal shift |
+| `flox.trade_pnl(sig_long, sig_short, log_ret)` | per-trade PnL array |
+| `flox.profit_factor(returns)` | sum positive / abs sum negative |
+| `flox.win_rate(trade_pnls)` | fraction of winning trades |

flox_py-0.5.0/README.md

@@ -0,0 +1,64 @@
+# flox-py
+
+Python bindings for the Flox indicator library. Tested against TA-Lib.
+
+## Install
+
+```bash
+pip install flox-py
+```
+
+## Usage
+
+```python
+import flox_py as flox
+import numpy as np
+
+close = np.array([...])
+high = np.array([...])
+low = np.array([...])
+
+ema50 = flox.ema(close, 50)
+atr14 = flox.atr(high, low, close, 14)
+rsi14 = flox.rsi(close, 14)
+
+signal_long = (rsi14 > 70).astype(np.int8)
+signal_short = ((rsi14 < 30) * -1).astype(np.int8)
+
+returns = flox.bar_returns(signal_long, signal_short, log_returns)
+trades = flox.trade_pnl(signal_long, signal_short, log_returns)
+pf = flox.profit_factor(returns)
+wr = flox.win_rate(trades)
+```
+
+## Indicators
+
+| Function | Description |
+|----------|-------------|
+| `flox.ema(input, period)` | Exponential Moving Average |
+| `flox.sma(input, period)` | Simple Moving Average |
+| `flox.rma(input, period)` | Wilder Moving Average |
+| `flox.rsi(input, period)` | Relative Strength Index |
+| `flox.atr(high, low, close, period)` | Average True Range |
+| `flox.adx(high, low, close, period)` | ADX, +DI, -DI |
+| `flox.macd(input, fast, slow, signal)` | MACD line, signal, histogram |
+| `flox.bollinger(input, period, stddev)` | upper, middle, lower bands |
+| `flox.stochastic(high, low, close, k, d)` | %K and %D |
+| `flox.cci(high, low, close, period)` | Commodity Channel Index |
+| `flox.slope(input, length)` | price slope |
+| `flox.kama(input, period)` | Kaufman Adaptive MA |
+| `flox.dema(input, period)` | Double EMA |
+| `flox.tema(input, period)` | Triple EMA |
+| `flox.chop(high, low, close, period)` | Choppiness Index |
+| `flox.obv(close, volume)` | On-Balance Volume |
+| `flox.vwap(close, volume, window)` | rolling VWAP |
+| `flox.cvd(open, high, low, close, volume)` | Cumulative Volume Delta |
+
+## Metrics
+
+| Function | Description |
+|----------|-------------|
+| `flox.bar_returns(sig_long, sig_short, log_ret)` | per-bar returns with signal shift |
+| `flox.trade_pnl(sig_long, sig_short, log_ret)` | per-trade PnL array |
+| `flox.profit_factor(returns)` | sum positive / abs sum negative |
+| `flox.win_rate(trade_pnls)` | fraction of winning trades |

flox_py-0.5.0/aggregator_bindings.h

@@ -0,0 +1,210 @@
+// python/aggregator_bindings.h
+
+#pragma once
+
+#include <pybind11/numpy.h>
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+
+#include "flox/aggregator/aggregation_policy.h"
+#include "flox/aggregator/bar.h"
+#include "flox/aggregator/policies/heikin_ashi_bar_policy.h"
+#include "flox/aggregator/policies/range_bar_policy.h"
+#include "flox/aggregator/policies/renko_bar_policy.h"
+#include "flox/aggregator/policies/tick_bar_policy.h"
+#include "flox/aggregator/policies/time_bar_policy.h"
+#include "flox/aggregator/policies/volume_bar_policy.h"
+#include "flox/book/events/trade_event.h"
+#include "flox/book/trade.h"
+#include "flox/common.h"
+#include "flox/util/base/time.h"
+
+#include <chrono>
+#include <cstring>
+#include <vector>
+
+namespace py = pybind11;
+
+namespace
+{
+
+using namespace flox;
+
+#pragma pack(push, 1)
+struct PyExtBar
+{
+  int64_t start_time_ns;
+  int64_t end_time_ns;
+  int64_t open_raw;
+  int64_t high_raw;
+  int64_t low_raw;
+  int64_t close_raw;
+  int64_t volume_raw;
+  int64_t buy_volume_raw;
+  int64_t trade_count;
+};
+#pragma pack(pop)
+static_assert(sizeof(PyExtBar) == 72);
+
+inline int64_t toUnixNs(TimePoint tp)
+{
+  return tp.time_since_epoch().count() - unix_to_flox_offset_ns().load(std::memory_order_relaxed);
+}
+
+inline PyExtBar barToExtBar(const Bar& b)
+{
+  return {.start_time_ns = toUnixNs(b.startTime),
+          .end_time_ns = toUnixNs(b.endTime),
+          .open_raw = b.open.raw(),
+          .high_raw = b.high.raw(),
+          .low_raw = b.low.raw(),
+          .close_raw = b.close.raw(),
+          .volume_raw = b.volume.raw(),
+          .buy_volume_raw = b.buyVolume.raw(),
+          .trade_count = b.tradeCount.raw()};
+}
+
+// Batch aggregation: takes pre-extracted vectors (no GIL needed)
+template <typename Policy>
+std::vector<PyExtBar> doAggregate(Policy& policy, const int64_t* ts, const double* px,
+                                  const double* qty, const uint8_t* ib, size_t n)
+{
+  std::vector<PyExtBar> bars;
+  bars.reserve(n / 10);  // rough estimate
+  Bar currentBar;
+  bool initialized = false;
+
+  for (size_t i = 0; i < n; ++i)
+  {
+    TradeEvent trade;
+    trade.trade.price = Price::fromDouble(px[i]);
+    trade.trade.quantity = Quantity::fromDouble(qty[i]);
+    trade.trade.isBuy = (ib[i] != 0);
+    trade.trade.exchangeTsNs = ts[i];
+    trade.trade.symbol = 1;
+    trade.trade.instrument = InstrumentType::Spot;
+
+    if (!initialized)
+    {
+      policy.initBar(trade, currentBar);
+      initialized = true;
+      continue;
+    }
+
+    if (policy.shouldClose(trade, currentBar))
+    {
+      bars.push_back(barToExtBar(currentBar));
+      policy.initBar(trade, currentBar);
+      continue;
+    }
+
+    policy.update(trade, currentBar);
+  }
+
+  if (initialized)
+  {
+    bars.push_back(barToExtBar(currentBar));
+  }
+
+  return bars;
+}
+
+template <typename Policy>
+py::array_t<PyExtBar> aggregateBars(Policy policy, py::array_t<int64_t> timestamps,
+                                    py::array_t<double> prices, py::array_t<double> quantities,
+                                    py::array_t<uint8_t> isBuy)
+{
+  size_t n = timestamps.size();
+  const auto* ts = timestamps.data();
+  const auto* px = prices.data();
+  const auto* qt = quantities.data();
+  const auto* ib = isBuy.data();
+
+  std::vector<PyExtBar> bars;
+  {
+    py::gil_scoped_release release;
+    bars = doAggregate(policy, ts, px, qt, ib, n);
+  }
+
+  py::array_t<PyExtBar> result(bars.size());
+  if (!bars.empty())
+  {
+    std::memcpy(result.mutable_data(), bars.data(), bars.size() * sizeof(PyExtBar));
+  }
+  return result;
+}
+
+}  // namespace
+
+inline void bindAggregators(py::module_& m)
+{
+  PYBIND11_NUMPY_DTYPE(PyExtBar, start_time_ns, end_time_ns, open_raw, high_raw, low_raw,
+                       close_raw, volume_raw, buy_volume_raw, trade_count);
+
+  // Ensure time mapping is initialized
+  flox::init_timebase_mapping();
+
+  m.def(
+      "aggregate_time_bars",
+      [](py::array_t<int64_t> ts, py::array_t<double> px, py::array_t<double> qty,
+         py::array_t<uint8_t> is_buy, double interval_seconds)
+      {
+        auto policy = flox::TimeBarPolicy(
+            std::chrono::duration_cast<std::chrono::nanoseconds>(
+                std::chrono::duration<double>(interval_seconds)));
+        return aggregateBars(std::move(policy), ts, px, qty, is_buy);
+      },
+      "Aggregate trades into time bars",
+      py::arg("timestamps"), py::arg("prices"), py::arg("quantities"),
+      py::arg("is_buy"), py::arg("interval_seconds"));
+
+  m.def(
+      "aggregate_tick_bars",
+      [](py::array_t<int64_t> ts, py::array_t<double> px, py::array_t<double> qty,
+         py::array_t<uint8_t> is_buy, uint32_t tick_count)
+      { return aggregateBars(flox::TickBarPolicy(tick_count), ts, px, qty, is_buy); },
+      "Aggregate trades into tick bars",
+      py::arg("timestamps"), py::arg("prices"), py::arg("quantities"),
+      py::arg("is_buy"), py::arg("tick_count"));
+
+  m.def(
+      "aggregate_volume_bars",
+      [](py::array_t<int64_t> ts, py::array_t<double> px, py::array_t<double> qty,
+         py::array_t<uint8_t> is_buy, double volume_threshold)
+      { return aggregateBars(flox::VolumeBarPolicy::fromDouble(volume_threshold), ts, px, qty, is_buy); },
+      "Aggregate trades into volume bars",
+      py::arg("timestamps"), py::arg("prices"), py::arg("quantities"),
+      py::arg("is_buy"), py::arg("volume_threshold"));
+
+  m.def(
+      "aggregate_range_bars",
+      [](py::array_t<int64_t> ts, py::array_t<double> px, py::array_t<double> qty,
+         py::array_t<uint8_t> is_buy, double range_size)
+      { return aggregateBars(flox::RangeBarPolicy::fromDouble(range_size), ts, px, qty, is_buy); },
+      "Aggregate trades into range bars",
+      py::arg("timestamps"), py::arg("prices"), py::arg("quantities"),
+      py::arg("is_buy"), py::arg("range_size"));
+
+  m.def(
+      "aggregate_renko_bars",
+      [](py::array_t<int64_t> ts, py::array_t<double> px, py::array_t<double> qty,
+         py::array_t<uint8_t> is_buy, double brick_size)
+      { return aggregateBars(flox::RenkoBarPolicy::fromDouble(brick_size), ts, px, qty, is_buy); },
+      "Aggregate trades into renko bars",
+      py::arg("timestamps"), py::arg("prices"), py::arg("quantities"),
+      py::arg("is_buy"), py::arg("brick_size"));
+
+  m.def(
+      "aggregate_heikin_ashi_bars",
+      [](py::array_t<int64_t> ts, py::array_t<double> px, py::array_t<double> qty,
+         py::array_t<uint8_t> is_buy, double interval_seconds)
+      {
+        auto policy = flox::HeikinAshiBarPolicy(
+            std::chrono::duration_cast<std::chrono::nanoseconds>(
+                std::chrono::duration<double>(interval_seconds)));
+        return aggregateBars(std::move(policy), ts, px, qty, is_buy);
+      },
+      "Aggregate trades into Heikin-Ashi bars",
+      py::arg("timestamps"), py::arg("prices"), py::arg("quantities"),
+      py::arg("is_buy"), py::arg("interval_seconds"));
+}

flox_py-0.5.0/backtest_bindings.h

@@ -0,0 +1,210 @@
+// python/backtest_bindings.h
+
+#pragma once
+
+#include <pybind11/numpy.h>
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+
+#include "flox/backtest/backtest_result.h"
+#include "flox/backtest/simulated_clock.h"
+#include "flox/backtest/simulated_executor.h"
+#include "flox/common.h"
+
+#include <cstring>
+#include <memory>
+#include <vector>
+
+namespace py = pybind11;
+
+namespace
+{
+
+using namespace flox;
+
+#pragma pack(push, 1)
+struct PyFill
+{
+  uint64_t order_id;
+  uint32_t symbol;
+  uint8_t side;
+  uint8_t _pad[3];
+  int64_t price_raw;
+  int64_t quantity_raw;
+  int64_t timestamp_ns;
+};
+#pragma pack(pop)
+static_assert(sizeof(PyFill) == 40);
+
+#pragma pack(push, 1)
+struct PyTradeRecord
+{
+  uint32_t symbol;
+  uint8_t side;
+  uint8_t _pad[3];
+  int64_t entry_price_raw;
+  int64_t exit_price_raw;
+  int64_t quantity_raw;
+  int64_t entry_time_ns;
+  int64_t exit_time_ns;
+  int64_t pnl_raw;
+  int64_t fee_raw;
+};
+#pragma pack(pop)
+static_assert(sizeof(PyTradeRecord) == 64);
+
+inline PyFill fillToPyFill(const Fill& f)
+{
+  return {.order_id = f.orderId,
+          .symbol = f.symbol,
+          .side = static_cast<uint8_t>(f.side == Side::BUY ? 0 : 1),
+          ._pad = {},
+          .price_raw = f.price.raw(),
+          .quantity_raw = f.quantity.raw(),
+          .timestamp_ns = static_cast<int64_t>(f.timestampNs)};
+}
+
+inline PyTradeRecord tradeRecToPy(const TradeRecord& t)
+{
+  return {.symbol = t.symbol,
+          .side = static_cast<uint8_t>(t.side == Side::BUY ? 0 : 1),
+          ._pad = {},
+          .entry_price_raw = t.entryPrice.raw(),
+          .exit_price_raw = t.exitPrice.raw(),
+          .quantity_raw = t.quantity.raw(),
+          .entry_time_ns = static_cast<int64_t>(t.entryTimeNs),
+          .exit_time_ns = static_cast<int64_t>(t.exitTimeNs),
+          .pnl_raw = t.pnl.raw(),
+          .fee_raw = t.fee.raw()};
+}
+
+// Wraps SimulatedExecutor + SimulatedClock for standalone use
+class PySimulatedExecutor
+{
+ public:
+  PySimulatedExecutor() : _executor(_clock) { _executor.start(); }
+
+  void submitOrder(uint64_t id, const std::string& sideStr, double price, double qty,
+                   const std::string& typeStr, uint32_t symbol)
+  {
+    Order order;
+    order.id = id;
+    order.side = (sideStr == "buy") ? Side::BUY : Side::SELL;
+    order.price = Price::fromDouble(price);
+    order.quantity = Quantity::fromDouble(qty);
+    order.symbol = symbol;
+    order.type = parseOrderType(typeStr);
+    _executor.submitOrder(order);
+  }
+
+  void cancelOrder(uint64_t id) { _executor.cancelOrder(id); }
+  void cancelAll(uint32_t symbol) { _executor.cancelAllOrders(symbol); }
+
+  void onBar(uint32_t symbol, double closePrice)
+  {
+    _executor.onBar(symbol, Price::fromDouble(closePrice));
+  }
+
+  void onTrade(uint32_t symbol, double price, bool isBuy)
+  {
+    _executor.onTrade(symbol, Price::fromDouble(price), isBuy);
+  }
+
+  void advanceClock(int64_t timestampNs) { _clock.advanceTo(timestampNs); }
+
+  py::array_t<PyFill> fills() const
+  {
+    const auto& f = _executor.fills();
+    py::array_t<PyFill> result(f.size());
+    auto* out = result.mutable_data();
+    for (size_t i = 0; i < f.size(); ++i)
+    {
+      out[i] = fillToPyFill(f[i]);
+    }
+    return result;
+  }
+
+  py::list fillsList() const
+  {
+    py::list result;
+    for (const auto& f : _executor.fills())
+    {
+      py::dict d;
+      d["order_id"] = f.orderId;
+      d["symbol"] = f.symbol;
+      d["side"] = (f.side == Side::BUY) ? "buy" : "sell";
+      d["price"] = f.price.toDouble();
+      d["quantity"] = f.quantity.toDouble();
+      d["timestamp_ns"] = static_cast<int64_t>(f.timestampNs);
+      result.append(d);
+    }
+    return result;
+  }
+
+  size_t fillCount() const { return _executor.fills().size(); }
+
+ private:
+  static OrderType parseOrderType(const std::string& s)
+  {
+    if (s == "limit")
+    {
+      return OrderType::LIMIT;
+    }
+    if (s == "stop_market")
+    {
+      return OrderType::STOP_MARKET;
+    }
+    if (s == "stop_limit")
+    {
+      return OrderType::STOP_LIMIT;
+    }
+    if (s == "take_profit_market")
+    {
+      return OrderType::TAKE_PROFIT_MARKET;
+    }
+    if (s == "take_profit_limit")
+    {
+      return OrderType::TAKE_PROFIT_LIMIT;
+    }
+    if (s == "trailing_stop")
+    {
+      return OrderType::TRAILING_STOP;
+    }
+    return OrderType::MARKET;
+  }
+
+  SimulatedClock _clock;
+  SimulatedExecutor _executor;
+};
+
+}  // namespace
+
+inline void bindBacktest(py::module_& m)
+{
+  PYBIND11_NUMPY_DTYPE(PyFill, order_id, symbol, side, price_raw, quantity_raw, timestamp_ns);
+  PYBIND11_NUMPY_DTYPE(PyTradeRecord, symbol, side, entry_price_raw, exit_price_raw,
+                       quantity_raw, entry_time_ns, exit_time_ns, pnl_raw, fee_raw);
+
+  py::class_<PySimulatedExecutor>(m, "SimulatedExecutor")
+      .def(py::init<>())
+      .def("submit_order", &PySimulatedExecutor::submitOrder,
+           "Submit an order to the simulated exchange",
+           py::arg("id"), py::arg("side"), py::arg("price"), py::arg("quantity"),
+           py::arg("type") = "market", py::arg("symbol") = 1)
+      .def("cancel_order", &PySimulatedExecutor::cancelOrder, py::arg("order_id"))
+      .def("cancel_all", &PySimulatedExecutor::cancelAll, py::arg("symbol"))
+      .def("on_bar", &PySimulatedExecutor::onBar,
+           "Feed a bar close price for order matching",
+           py::arg("symbol"), py::arg("close_price"))
+      .def("on_trade", &PySimulatedExecutor::onTrade,
+           "Feed a trade for order matching",
+           py::arg("symbol"), py::arg("price"), py::arg("is_buy"))
+      .def("advance_clock", &PySimulatedExecutor::advanceClock,
+           "Advance simulation clock to timestamp",
+           py::arg("timestamp_ns"))
+      .def("fills", &PySimulatedExecutor::fills,
+           "Get all fills as numpy structured array")
+      .def("fills_list", &PySimulatedExecutor::fillsList,
+           "Get all fills as list of dicts")
+      .def_property_readonly("fill_count", &PySimulatedExecutor::fillCount);
+}