pyproject.toml

[build-system]
requires = ["setuptools>=61"]
build-backend = "setuptools.build_meta"

[project]
name = "gato-mpc"           # import name: gato (PyPI's "gato" is an unrelated 2021 graph toolbox)
version = "0.1.1"
authors = [
    { name="Alexander Du" },
    { name="Emre Adabag" },
    { name="Gabriel Bravo" },
    { name="Brian Plancher" },
]
maintainers = [{ name="The Accessible and Accelerated Robotics Lab (A2R Lab)" }]
license = { text = "MIT" }
keywords = ["trajectory optimization", "model predictive control", "CUDA", "robotics", "SQP"]
classifiers = [
    "Development Status :: 3 - Alpha",
    "License :: OSI Approved :: MIT License",
    "Programming Language :: Python :: 3",
    "Programming Language :: C++",
    "Environment :: GPU :: NVIDIA CUDA",
    "Topic :: Scientific/Engineering",
]
description = "GPU-accelerated batched trajectory optimization"
readme = "README.md"
requires-python = ">=3.10"
# Lean base: everything needed to generate GRiD code (tools/regen_grid.py) and
# build the CUDA extension modules. The heavy runtime used only to *run* the MPC
# / benchmark examples (torch, pinocchio, viz) lives in the [examples] extra so
# the default install stays lightweight (mirrors GRiD's base_install).
dependencies = [
    # GRiD codegen (tools/regen_grid.py)
    "numpy>=1.17.4",
    "sympy>=1.7.1",
    "beautifulsoup4>=4.9.3",
    "lxml>=4.2.1",
    "trimesh>=4",              # GRiD's collision spherizer (mesh <collision> geometry -> spheres) at regen
    "scipy>=1.15.2",           # trimesh voxel fill; missing it changes the generated collision geometry
    # the code generator, URDFParser, the GLASS headers and GRiD's collision headers all
    # come from this one released wheel; gato._grid pins the exact version + bundled GLASS
    "grid-rbd==0.5.1",
    "platformdirs>=4.0",       # per-host cache of registered robots / compiled modules (gato.register_robot)
    # build the bsqpN{knot}_{plant}.so pybind11 extensions
    "pybind11>=2.13.6",
    "ninja>=1.11.1.4",
]

[project.urls]
Repository = "https://github.com/A2R-Lab/GATO"
Documentation = "https://github.com/A2R-Lab/GATO/blob/main/README.md"
Issues = "https://github.com/A2R-Lab/GATO/issues"
Paper = "https://arxiv.org/abs/2510.07625"

[project.optional-dependencies]
# Full runtime to actually run the MPC / benchmark examples and notebooks.
# Heavy (torch, pinocchio, Qt/meshcat viz). Install with: pip install -e ".[examples]"
examples = [
    "torch>=2.6.0",
    "pin>=3.4.0",
    "mujoco>=3.2,<3.14",   # 3.14.0 segfaults inside MjSpec compile of the go2 URDF (welded root); re-test on the next release
    "matplotlib>=3.10.1",
    "seaborn>=0.13.2",
    "osqp>=0.6.7.post3",
    "meshcat>=0.3.2",
    "pyqt5>=5.15.11",
    "tqdm>=4.60",
    "gymnasium>=0.29",
    "jupyter>=1.1.1",
    "ipykernel>=6.29.5",
]
# Test / lint tooling. Pinned plugin: the receipt schema, the verifier and the
# policy file must agree (schema 3 since 0.4.0) — bump all three together.
dev = [
    "tomli; python_version < '3.11'",
    "pytest",
    "pytest-xdist",
    "build>=1.0",              # test_distribution_artifacts runs `python -m build` (sdist/wheel gates)
    "pytest-gpu-proof==0.4.1", # signed GPU-CI receipts (schema 3; pinned, see test/gpu-proof-policy.yaml)
    "pyyaml",                  # test/gpu-proof-policy.yaml
]
# Everything the FULL test suite needs beyond dev, without the heavy example
# runtime (torch, Qt/meshcat, jupyter): the pinocchio/mujoco worlds, the scipy
# mechanism oracles, the gym policy. cpu-lane CI installs this so no host-tier
# test can skip silently; run_gpu_proof.sh refuses a python that lacks it.
test = [
    "pin>=3.4.0",
    "mujoco>=3.2,<3.14",   # see the [examples] pin
    "gymnasium>=0.29",
    # the array boundary (test_arrays.py): CPU builds suffice for the host tier; the
    # receipt box installs CUDA builds (torch cu*, jax[cuda*]) for the device path
    "torch>=2.6.0",
    "jax>=0.4.40",
]

[tool.setuptools]
package-dir = {"" = "python"}

[tool.setuptools.packages.find]
where = ["python"]
include = ["gato*"]

# DISTRIBUTION CONTRACT (0.1.1): the wheel carries the python layer plus GATO's
# own native SOURCES (gato/_native: CMakeLists, headers, the bindings TU, the
# vendored robot headers — staged by _build_resources.py) so that
# gato.register_robot can compile solver modules on the user's machine into a
# per-host cache. Solver modules (bsqpN{N}_{plant}.so) are arch/CUDA/ABI-specific
# CMake products and are NEVER packaged. GRiD/GLASS headers come from the pinned
# grid-rbd wheel. Gate: test/test_distribution_artifacts.py.
[tool.setuptools.package-data]
gato = ["_registry.json"]

[tool.pytest.ini_options]
testpaths = ["test"]
markers = [
    "gpu: needs a CUDA GPU with built solver modules (deselect with -m 'not gpu')",
    "slow: long-running codegen/build tests (deselect with -m 'not slow')",
    "gpu_proof: outcome recorded in the signed pytest-gpu-proof receipt (auto-applied to ALL tests by test/conftest.py)",
]

[tool.gpu_proof]
# The GPU suite runs locally on the lab box (test/run_gpu_proof.sh); the signed
# receipt (gpu-proof.json, repo root) is verified in CPU-only CI against
# github.com/plancherb1.keys. The receipt attests the FULL suite (host + gpu +
# slow tiers) — GATO's whole run is ~minutes warm, so no marker scoping is
# needed (unlike GRiD's hours-long equivalence receipt).
mode = "local"
output = "gpu-proof.json"
github_username = "plancherb1"     # org remotes (A2R-Lab) carry no SSH keys — sign as the keyholder
# Fingerprint tracked code, build/test harnesses and the dependency pin
# (pyproject + python/gato/_grid.py pin the grid-rbd release whose bundled GLASS
# and collision headers every module compiles against). Built modules are checked
# separately against embedded native-source identities before signing.
fingerprint_paths = ["gato", "python", "test", "tools", "examples", "CMakeLists.txt", "pyproject.toml", "MANIFEST.in", ".gitmodules", ".github"]
fingerprint_excluded_paths = ["gpu-proof.json"]   # never self-reference the receipt
max_age_days = 30
require_gpu = true