treeweave 0.0.0__tar.gz

treeweave-0.0.0/CMakeLists.txt

@@ -0,0 +1,62 @@
+# bindings/python — nanobind extension linking treeweave_c_static + a pytest
+# CTest. Added by cmake/treeweave_bindings.cmake when TREEWEAVE_BUILD_PYTHON=ON.
+# The pip/scikit-build wheel build reaches this same file: pyproject sets
+# cmake.source-dir = "../../" and configures the root with TREEWEAVE_BUILD_PYTHON=ON.
+
+# Development.SABIModule (optional) lets nanobind emit a CPython stable-ABI
+# (abi3) extension on 3.12+, which is what the wheel build ships.
+find_package(
+    Python
+    3.9
+    QUIET
+    COMPONENTS Interpreter Development.Module
+    OPTIONAL_COMPONENTS Development.SABIModule
+)
+if(NOT Python_FOUND)
+    message(
+        STATUS
+        "treeweave[python]: Python 3.9+ (Development.Module) not found — skipping."
+    )
+    return()
+endif()
+
+# Shared module definition (also used by the pip wheel build) — locates nanobind
+# (interpreter or FetchContent) and defines the `_treeweave` target.
+include("${CMAKE_CURRENT_SOURCE_DIR}/treeweave_python.cmake")
+treeweave_add_python_module(treeweave::treeweave_c_static)
+
+# Install the extension into the wheel's `treeweave/` package. Scoped to its own
+# component so the scikit-build-core wheel build installs ONLY this
+# (install.components = ["python_ext"] in pyproject.toml) and never drags in the
+# C++ dev tree (headers / libtreeweave_c / CMake config).
+install(TARGETS _treeweave LIBRARY DESTINATION treeweave COMPONENT python_ext)
+
+# Assemble an importable package *in the build tree* — never write the .so (or
+# copy .py) into the source tree. Layout: <build>/python-pkg/treeweave/.
+set(_treeweave_pypkg "${CMAKE_BINARY_DIR}/python-pkg")
+set_target_properties(
+    _treeweave
+    PROPERTIES LIBRARY_OUTPUT_DIRECTORY "${_treeweave_pypkg}/treeweave"
+)
+# Stage the pure-Python sources next to the extension (re-copied on reconfigure
+# if they change, via the configure_file input dependency).
+file(GLOB _treeweave_py "${CMAKE_CURRENT_SOURCE_DIR}/treeweave/*.py")
+foreach(_f IN LISTS _treeweave_py)
+    get_filename_component(_n "${_f}" NAME)
+    configure_file("${_f}" "${_treeweave_pypkg}/treeweave/${_n}" COPYONLY)
+endforeach()
+
+add_test(
+    NAME python_treeweave
+    COMMAND
+        "${Python_EXECUTABLE}" -m pytest -q "${CMAKE_CURRENT_SOURCE_DIR}/tests"
+)
+set_tests_properties(
+    python_treeweave
+    PROPERTIES ENVIRONMENT "PYTHONPATH=${_treeweave_pypkg}"
+)
+message(
+    STATUS
+    "treeweave[python]: extension + pytest 'python_treeweave' registered "
+    "(build-tree package at ${_treeweave_pypkg})."
+)

treeweave-0.0.0/PKG-INFO

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: treeweave
+Version: 0.0.0
+Summary: Python bindings for the treeweave piecewise-polynomial approximator
+License-Expression: BSD-3-Clause
+Requires-Python: >=3.9
+Requires-Dist: numpy
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Description-Content-Type: text/markdown
+
+# treeweave Python bindings
+
+Python (nanobind) wrapper for the [treeweave](../../README.md) piecewise-polynomial
+function approximator.
+
+## Installation
+
+```bash
+pip install scikit-build-core nanobind numpy
+pip install .          # regular install
+# or for development:
+pip install -e . --no-build-isolation
+```
+
+## Quick start
+
+```python
+import math
+import numpy as np
+import treeweave
+
+# Fit exp(x) on [0, 1] to 1e-10 relative tolerance.
+def func(x):
+    return math.exp(x[0])   # x is a (dim,) ndarray
+
+approx = treeweave.fit(func, 0.0, 1.0, tol=1e-10)   # dim & out_dim inferred
+
+# Scalar eval
+print(approx(0.5))          # ≈ exp(0.5)
+
+# Batch eval
+xs = np.linspace(0, 1, 1000)
+ys = approx(xs)                  # shape (1000,)
+ys = approx(xs, sorted=True)     # 1-D ascending fast path
+```
+
+## API
+
+### `treeweave.fit(f, a, b, tol, *, dim=None, out_dim=None, dtype="f64", ...)`
+
+Fits callable `f` and returns a callable `TreeweaveFunction`.
+
+- `a`, `b`: domain corners (scalars for 1D, length-`dim` lists otherwise).
+- `tol`: approximation tolerance (drives adaptive tree refinement).
+- `dim`: input dimension; inferred from `len(a)` (scalar corners ⇒ 1) when omitted.
+- `out_dim`: number of output components; inferred by probing `f` once at the
+  box midpoint (`np.asarray(f(mid)).size`, scalar ⇒ 1) when omitted.
+- `dtype`: `"f64"` (default) or `"f32"`.
+
+The C ABI auto-selects a register-optimal leaf polynomial degree per detected CPU; accuracy is controlled entirely by `tol`.
+
+### `TreeweaveFunction`
+
+The fitted object is **called** — there are no named eval methods. A point
+gives a point result; a batch gives a batch result; two optional keyword flags
+select alternate batch modes.
+
+| Call / property | Description |
+|---|---|
+| `fn(x)` | Evaluate. Point: scalar (`dim==1`) or `(dim,)` → scalar / `(out_dim,)`. Batch: `(N,)` (`dim==1`) or `(N, dim)` → `(N,)` / `(N, out_dim)` |
+| `fn(x, sorted=True)` | 1-D ascending-batch fast path (requires `dim == 1`) |
+| `fn(x, transposed=True)` | Batch returning `(out_dim, N)` (requires `out_dim > 1`) |
+| `.dim` | Input dimensionality |
+| `.out_dim` | Output dimensionality |
+| `.dtype` | `"f64"` or `"f32"` |
+| `.memory_usage` | Bytes used by the approximation |
+| `.print_stats()` | Print internal tree statistics |
+
+A point whose length `!= dim`, a batch whose column count `!= dim`,
+`sorted=True` with `dim != 1`, or `transposed=True` with `out_dim == 1` each
+raise `ValueError` rather than silently mis-shaping the result.
+
+## Running tests
+
+```bash
+pip install pytest
+pytest tests/ -q
+```

treeweave-0.0.0/README.md

@@ -0,0 +1,78 @@
+# treeweave Python bindings
+
+Python (nanobind) wrapper for the [treeweave](../../README.md) piecewise-polynomial
+function approximator.
+
+## Installation
+
+```bash
+pip install scikit-build-core nanobind numpy
+pip install .          # regular install
+# or for development:
+pip install -e . --no-build-isolation
+```
+
+## Quick start
+
+```python
+import math
+import numpy as np
+import treeweave
+
+# Fit exp(x) on [0, 1] to 1e-10 relative tolerance.
+def func(x):
+    return math.exp(x[0])   # x is a (dim,) ndarray
+
+approx = treeweave.fit(func, 0.0, 1.0, tol=1e-10)   # dim & out_dim inferred
+
+# Scalar eval
+print(approx(0.5))          # ≈ exp(0.5)
+
+# Batch eval
+xs = np.linspace(0, 1, 1000)
+ys = approx(xs)                  # shape (1000,)
+ys = approx(xs, sorted=True)     # 1-D ascending fast path
+```
+
+## API
+
+### `treeweave.fit(f, a, b, tol, *, dim=None, out_dim=None, dtype="f64", ...)`
+
+Fits callable `f` and returns a callable `TreeweaveFunction`.
+
+- `a`, `b`: domain corners (scalars for 1D, length-`dim` lists otherwise).
+- `tol`: approximation tolerance (drives adaptive tree refinement).
+- `dim`: input dimension; inferred from `len(a)` (scalar corners ⇒ 1) when omitted.
+- `out_dim`: number of output components; inferred by probing `f` once at the
+  box midpoint (`np.asarray(f(mid)).size`, scalar ⇒ 1) when omitted.
+- `dtype`: `"f64"` (default) or `"f32"`.
+
+The C ABI auto-selects a register-optimal leaf polynomial degree per detected CPU; accuracy is controlled entirely by `tol`.
+
+### `TreeweaveFunction`
+
+The fitted object is **called** — there are no named eval methods. A point
+gives a point result; a batch gives a batch result; two optional keyword flags
+select alternate batch modes.
+
+| Call / property | Description |
+|---|---|
+| `fn(x)` | Evaluate. Point: scalar (`dim==1`) or `(dim,)` → scalar / `(out_dim,)`. Batch: `(N,)` (`dim==1`) or `(N, dim)` → `(N,)` / `(N, out_dim)` |
+| `fn(x, sorted=True)` | 1-D ascending-batch fast path (requires `dim == 1`) |
+| `fn(x, transposed=True)` | Batch returning `(out_dim, N)` (requires `out_dim > 1`) |
+| `.dim` | Input dimensionality |
+| `.out_dim` | Output dimensionality |
+| `.dtype` | `"f64"` or `"f32"` |
+| `.memory_usage` | Bytes used by the approximation |
+| `.print_stats()` | Print internal tree statistics |
+
+A point whose length `!= dim`, a batch whose column count `!= dim`,
+`sorted=True` with `dim != 1`, or `transposed=True` with `out_dim == 1` each
+raise `ValueError` rather than silently mis-shaping the result.
+
+## Running tests
+
+```bash
+pip install pytest
+pytest tests/ -q
+```

treeweave-0.0.0/pyproject.toml

@@ -0,0 +1,78 @@
+[build-system]
+requires = ["scikit-build-core>=0.10", "nanobind>=2.0"]
+build-backend = "scikit_build_core.build"
+
+[project]
+name = "treeweave"
+description = "Python bindings for the treeweave piecewise-polynomial approximator"
+readme = "README.md"
+license = "BSD-3-Clause"
+requires-python = ">=3.9"
+dependencies = ["numpy"]
+# Single-sourced from the root VERSION file via the regex provider below (the
+# same file the root CMakeLists project() reads), so the wheel metadata, the C++
+# core, and any future bump never drift apart.
+dynamic = ["version"]
+
+[project.optional-dependencies]
+test = ["pytest"]
+
+[tool.scikit-build]
+minimum-version = "0.10"
+cmake.build-type = "Release"
+# The Python package lives here in bindings/python, but the C++ core it links
+# is the whole repo. Point scikit-build-core at the root CMakeLists (built
+# with TREEWEAVE_BUILD_PYTHON=ON) so the wheel is self-contained — the same trick
+# finufft uses. cibuildwheel copies the repo root into the build container, so
+# "../../" resolves there too.
+cmake.source-dir = "../../"
+build.targets = ["_treeweave"]
+# Install ONLY the extension component into the wheel (the install() rule in
+# cmake/treeweave_bindings.cmake tags _treeweave with COMPONENT python_ext); without
+# this the root install would also stage the C++ headers / libtreeweave_c / CMake
+# config into the wheel.
+install.components = ["python_ext"]
+# The pure-Python package (treeweave/*.py) sits next to this pyproject.
+wheel.packages = ["treeweave"]
+# One abi3 wheel (CPython stable ABI) serves 3.12+; the nanobind module is
+# built STABLE_ABI (see treeweave_python.cmake). 3.9–3.11 get version-specific
+# wheels from the per-version cibuildwheel runs.
+wheel.py-api = "cp312"
+
+[tool.scikit-build.cmake.define]
+TREEWEAVE_BUILD_PYTHON   = "ON"
+TREEWEAVE_BUILD_TESTS    = "OFF"
+TREEWEAVE_BUILD_EXAMPLES = "OFF"
+# A stray warning on the wheel builder's compiler must never break `pip install`.
+TREEWEAVE_WARNINGS_AS_ERRORS = "OFF"
+
+[tool.scikit-build.metadata.version]
+provider = "scikit_build_core.metadata.regex"
+input = "../../VERSION"
+regex = '''(?P<value>[0-9]+\.[0-9]+\.[0-9]+)'''
+
+# The sdist is rooted at the repo (cmake.source-dir); drop everything the wheel
+# build doesn't need so it stays small and the build context is lean.
+[tool.scikit-build.sdist]
+exclude = [
+  ".git*", ".github", "bench", "docs", "examples",
+  "bindings/julia", "bindings/matlab",
+  "build", "build*", "*.whl",
+]
+
+[tool.cibuildwheel]
+# abi3 wheel once (cp312, covers 3.12+) plus version-specific 3.9–3.11. PyPy
+# and musllinux are out of scope for the C-ABI core.
+build = "cp39-* cp310-* cp311-* cp312-*"
+skip = "*-musllinux_* pp*"
+build-frontend = "build"
+# The C ABI is linked statically into _treeweave, so the only shared deps are the
+# system C/C++ runtimes — nothing external to vendor. The repair step still
+# runs (auditwheel/delocate) to stamp the platform tag. Per-arch baselines
+# (TREEWEAVE_ARCH / TREEWEAVE_C_MULTIARCH) are injected by wheels.yml.
+test-extras = ["test"]
+test-command = "pytest {project}/bindings/python/tests"
+
+[tool.cibuildwheel.linux]
+manylinux-x86_64-image = "manylinux_2_28"
+manylinux-aarch64-image = "manylinux_2_28"