plainmp 0.3.5.dev1__tar.gz → 0.3.6__tar.gz

plainmp-0.3.6/.gitattributes

@@ -0,0 +1,2 @@
+# Keep the lockfile in Git without expanding thousands of lines in diffs.
+uv.lock -diff

{plainmp-0.3.5.dev1 → plainmp-0.3.6}/.github/workflows/build_and_test.yaml

@@ -17,6 +17,8 @@ on:
 jobs:
   build:
     runs-on: ${{ matrix.os }}
+    env:
+      UV_PYTHON: ${{ matrix.python-version }}
     strategy:
       matrix:
         os: [ubuntu-latest, macos-latest]
@@ -30,6 +32,11 @@ jobs:
         with:
           python-version: ${{ matrix.python-version }}
 
+      - name: Install the latest version of uv
+        uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
+        with:
+          enable-cache: true
+
       - name: Update Submodules
         run: git submodule update --init --recursive
 
@@ -38,37 +45,32 @@ jobs:
         run: |
           sudo apt-get update
           sudo apt-get install libspatialindex-dev freeglut3-dev libsuitesparse-dev libblas-dev liblapack-dev
-          pip install scikit-robot
 
       - name: Install scikit-robot (macOS)
         if: matrix.os == 'macos-latest'
         run: |
           brew install spatialindex suite-sparse openblas lapack
-          pip install scikit-robot
 
       - name: Install This Package (Ubuntu)
         if: matrix.os == 'ubuntu-latest'
         run: |
           sudo apt-get install libeigen3-dev libboost-all-dev libompl-dev
-          python3 -m pip install --upgrade pip
-          python3 -m pip install build
-          python3 -m build . --sdist  # install sdist version to detect packaging-related issues
-          MAKEFLAGS="-j$(nproc)" pip install dist/*.tar.gz
 
       - name: Install This Package (macOS)
         if: matrix.os == 'macos-latest'
         run: |
           brew install eigen boost ompl
-          python3 -m pip install --upgrade pip
-          python3 -m pip install build
-          python3 -m build . --sdist  # install sdist version to detect packaging-related issues
-          MAKEFLAGS="-j$(sysctl -n hw.ncpu)" pip install dist/*.tar.gz
+
+      - name: Build and install source distribution
+        run: |
+          uv build --sdist
+          uv sync --locked --no-install-project
+          uv pip install --python .venv/bin/python dist/*.tar.gz
 
       - name: Test
         run: |
-          pip install pytest
           for i in {1..3}; do
-            if pytest tests; then
+            if uv run --no-sync pytest tests; then
               exit 0
             fi
             echo "Test failed... retrying ($i)"
@@ -81,7 +83,7 @@ jobs:
         run: |
           run_example() {
             for i in {1..3}; do
-              if python3 "$1" $2; then
+              if uv run --no-sync python "$1" $2; then
                 return 0
               fi
               echo "$1 failed... retrying ($i)"

{plainmp-0.3.5.dev1 → plainmp-0.3.6}/.github/workflows/check_format.yaml

@@ -13,6 +13,8 @@ on:
 jobs:
   lint:
     runs-on: ubuntu-latest
+    env:
+      UV_PYTHON: "3.8"
     steps:
         - name: Checkout Code
           uses: actions/checkout@v2
@@ -20,19 +22,25 @@ jobs:
           uses: actions/setup-python@v5
           with:
               python-version: 3.8
-        - name: pip install formatters
-          run: |
-              pip3 install black==22.6.0 isort flake8 autoflake codespell
+        - name: Install the latest version of uv
+          uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
+          with:
+              enable-cache: true
+
+        - name: Install formatters
+          run: uv sync --locked --only-group lint
 
         - name: install clang-format
           run: |
               sudo apt-get update
               sudo apt-get install clang-format-14
-              clang-format --version
+              clang-format-14 --version
 
         - name: check
+          env:
+            CLANG_FORMAT: clang-format-14
           run: |
-            bash format.sh
+            uv run --no-sync bash format.sh
 
         - name: Fail if format.sh modified files
           run: |

{plainmp-0.3.5.dev1 → plainmp-0.3.6}/.github/workflows/check_pypi_install.yaml

@@ -17,6 +17,11 @@ jobs:
         with:
           python-version: ${{ matrix.python-version }}
 
+      - name: Install the latest version of uv
+        uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
+        with:
+          enable-cache: true
+
       - name: Install system dependencies
         run: |
           sudo apt-get update
@@ -24,17 +29,16 @@ jobs:
 
       - name: Install plainmp from PyPI
         run: |
-          python3 -m pip install --upgrade pip
-          pip install plainmp
+          uv venv --python "${{ matrix.python-version }}" "$RUNNER_TEMP/plainmp-pypi-venv"
+          uv pip install --python "$RUNNER_TEMP/plainmp-pypi-venv/bin/python" plainmp pytest
 
       - name: Checkout Code (for examples and tests)
         uses: actions/checkout@v3
 
       - name: Test
         run: |
-          pip install pytest
           for i in {1..3}; do
-            if pytest tests; then
+            if "$RUNNER_TEMP/plainmp-pypi-venv/bin/python" -m pytest tests; then
               exit 0
             fi
             echo "Test failed... retrying ($i)"

{plainmp-0.3.5.dev1 → plainmp-0.3.6}/.github/workflows/release.yaml

@@ -14,13 +14,13 @@ jobs:
       uses: actions/setup-python@v5
       with:
         python-version: '3.x'
-    - name: Install publishing dependencies
-      run: |
-        python -m pip install --upgrade pip
-        pip install wheel twine scikit-build build
+    - name: Install the latest version of uv
+      uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
 
     - name: Build and publish
+      env:
+        UV_PUBLISH_TOKEN: ${{ secrets.PYPI_TOKEN }}
       run: |
         git submodule update --init
-        python -m build . --sdist
-        twine upload --skip-existing -u __token__ -p ${{ secrets.PYPI_TOKEN }} dist/*
+        uv build --sdist
+        uv publish --check-url https://pypi.org/simple dist/*.tar.gz

{plainmp-0.3.5.dev1 → plainmp-0.3.6}/CMakeLists.txt

@@ -1,4 +1,5 @@
-cmake_minimum_required(VERSION 3.10)
+cmake_minimum_required(VERSION 3.15)
+project(plainmp LANGUAGES C CXX)
 set(CMAKE_CXX_STANDARD 17)
 if(NOT CMAKE_BUILD_TYPE)
     set(CMAKE_BUILD_TYPE Release)
@@ -45,8 +46,25 @@ add_custom_target(generate_sequence_table
 
 file(GLOB_RECURSE SRC_FILES cpp/*.cpp)
 include_directories(cpp)
-add_subdirectory(pybind11)
-pybind11_add_module(_plainmp ${SRC_FILES})
+if(CMAKE_VERSION VERSION_LESS 3.18)
+    set(DEV_MODULE Development)
+else()
+    set(DEV_MODULE Development.Module)
+endif()
+find_package(Python 3.8 COMPONENTS Interpreter ${DEV_MODULE} REQUIRED)
+execute_process(
+    COMMAND "${Python_EXECUTABLE}" -m nanobind --cmake_dir
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+    OUTPUT_VARIABLE nanobind_ROOT
+    RESULT_VARIABLE nanobind_result
+)
+if(NOT nanobind_result EQUAL 0)
+    message(FATAL_ERROR "Could not locate nanobind for ${Python_EXECUTABLE}")
+endif()
+find_package(nanobind CONFIG REQUIRED)
+# Match the optimization of the former pybind11 target. LTO is also needed by
+# the statically linked ERTConnect planner with OMPL 1.6 and GCC 9.
+nanobind_add_module(_plainmp NOMINSIZE LTO ${SRC_FILES})
 add_dependencies(_plainmp generate_sequence_table)
 
 if (TARGET ompl::ompl)

{plainmp-0.3.5.dev1 → plainmp-0.3.6}/PKG-INFO

@@ -1,9 +1,10 @@
 Metadata-Version: 2.2
 Name: plainmp
-Version: 0.3.5.dev1
+Version: 0.3.6
 Summary: Very fast motion planning for articulated robot, through a bit of premature-optimization (C++ core with Python bindings) *less than 1ms for moderate problems
 Author: Hirokazu Ishida
 License: MPL2.0 for C++ core and BSD3 for Python bindings
+Requires-Python: >=3.8
 Requires-Dist: rospkg
 Requires-Dist: numpy
 Requires-Dist: scipy
@@ -12,4 +13,5 @@ Requires-Dist: pyyaml
 Requires-Dist: robot_descriptions
 Requires-Dist: osqp<1.0.0
 Requires-Dist: tyro
+Requires-Dist: matplotlib>=3.7.5
 

{plainmp-0.3.5.dev1 → plainmp-0.3.6}/README.md

@@ -41,26 +41,37 @@ panda dual bars: median 0.17 ms | panda ceiled dual bars: median 0.65 ms | fetch
 
 The plots are generated by the following commands:
 ```bash
-python3 example/bench/panda_plan.py  # panda dual bars
-python3 example/bench/panda_plan.py --difficult  # panda ceiled dual bars
-python3 example/bench/fetch_plan.py  # fetch table
+uv run python example/bench/panda_plan.py  # panda dual bars
+uv run python example/bench/panda_plan.py --difficult  # panda ceiled dual bars
+uv run python example/bench/fetch_plan.py  # fetch table
 ```
 
-## installation and usage (Ubuntu/macOS)
+## Installation and development (Ubuntu/macOS)
+Install [uv](https://docs.astral.sh/uv/getting-started/installation/) first. The C++ extension also needs system libraries.
+
 On Ubuntu:
 ```bash
 sudo apt install libeigen3-dev libboost-all-dev libompl-dev libspatialindex-dev freeglut3-dev libsuitesparse-dev libblas-dev liblapack-dev
-pip install plainmp  # or build from source after git submodules update --init
 ```
 On macOS:
 ```bash
 brew install eigen boost ompl spatialindex suite-sparse openblas lapack
-pip install plainmp  # or build from source after git submodules update --init
 ```
 
-Then try examples in [example directory](./example) with `--visualize` option. Note that you may need to install the following for visualization:
+To use the published package in another uv project, run `uv add plainmp`. To work on this repository:
+
+```bash
+git submodule update --init --recursive
+uv sync --locked
+uv run pytest tests
+uv run python example/fetch_ik.py
+```
+
+`uv sync` builds and installs the C++ extension through scikit-build-core. After changing C++ sources, rebuild it with `uv sync --reinstall-package plainmp`. To run the formatter, install its dependency group with `uv sync --locked --group lint`, then run `uv run --no-sync bash format.sh`.
+
+Try examples in the [example directory](./example) with `--visualize` if desired. Visualization may need a patched `pyrender`:
 ```bash
-pip uninstall -y pyrender && pip install git+https://github.com/mmatl/pyrender.git --no-cache-dir
+uv pip install --python .venv/bin/python --reinstall git+https://github.com/mmatl/pyrender.git
 ```
 
 ## Troubleshooting
@@ -73,7 +84,7 @@ pip uninstall -y pyrender && pip install git+https://github.com/mmatl/pyrender.g
 - (step 3) Write yaml file defining urdf location/collision information/control joints/end effector in (see [example yaml files](./src/plainmp/conf/)). For determining the sphere locations, tools like [bheijden/bubblify](https://github.com/bheijden/bubblify) or [CoMMALab/form](https://github.com/CoMMALab/foam) will be useful.
 Note that we provides convenience script to convert bubblify output yaml file to plainmp format:
 ```bash
-python3 -m plainmp.script.bubblify_to_plainmp --path <path_to_bubblify_output_yaml>
+uv run python -m plainmp.script.bubblify_to_plainmp --path <path_to_bubblify_output_yaml>
 ```
 
 ## Note on motion validator of motion planning

plainmp-0.3.6/cpp/plainmp/bindings/bindings.hpp

@@ -0,0 +1,50 @@
+/*
+ * plainmp - library for fast motion planning
+ *
+ * Copyright (C) 2024 Hirokazu Ishida
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <nanobind/eigen/dense.h>
+#include <nanobind/eigen/sparse.h>
+#include <nanobind/nanobind.h>
+#include <nanobind/stl/function.h>
+#include <nanobind/stl/optional.h>
+#include <nanobind/stl/pair.h>
+#include <nanobind/stl/shared_ptr.h>
+#include <nanobind/stl/string.h>
+#include <nanobind/stl/vector.h>
+#include <stdexcept>
+
+namespace plainmp::bindings {
+
+namespace nb = nanobind;
+
+inline Eigen::VectorXd vector_from_sequence(nb::sequence values) {
+  Eigen::VectorXd vector(nb::len(values));
+  for (size_t i = 0; i < nb::len(values); ++i) {
+    vector[i] = nb::cast<double>(values[i]);
+  }
+  return vector;
+}
+
+inline Eigen::Vector3d vector3_from_sequence(nb::sequence values) {
+  if (nb::len(values) != 3) {
+    throw std::invalid_argument("expected a 3-element vector");
+  }
+  Eigen::Vector3d vector;
+  for (size_t i = 0; i < 3; ++i) {
+    vector[i] = nb::cast<double>(values[i]);
+  }
+  return vector;
+}
+void bind_kdtree_submodule(nb::module_& m);
+void bind_primitive_submodule(nb::module_& m);
+void bind_constraint_submodule(nb::module_& m);
+void bind_kinematics_submodule(nb::module_& m);
+void bind_ompl_wrapper_submodule(nb::module_& m);
+
+}  // namespace plainmp::bindings

plainmp-0.3.6/cpp/plainmp/bindings/constraint.cpp

@@ -0,0 +1,165 @@
+/*
+ * plainmp - library for fast motion planning
+ *
+ * Copyright (C) 2024 Hirokazu Ishida
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include "plainmp/bindings/bindings.hpp"
+#include "plainmp/constraints/composite_constraint.hpp"
+#include "plainmp/constraints/primitive.hpp"
+#include "plainmp/constraints/primitive_com_in_polytope.hpp"
+#include "plainmp/constraints/primitive_config_point.hpp"
+#include "plainmp/constraints/primitive_fixed_zaxis.hpp"
+#include "plainmp/constraints/primitive_link_pose.hpp"
+#include "plainmp/constraints/primitive_link_position_bound.hpp"
+#include "plainmp/constraints/primitive_relative_pose.hpp"
+#include "plainmp/constraints/primitive_sphere_collision.hpp"
+#include "plainmp/constraints/sequential_constraint.hpp"
+
+using namespace plainmp::constraint;
+using namespace plainmp::collision;
+using namespace plainmp::kinematics;
+
+namespace plainmp::bindings {
+
+using OutputValues = nb::ndarray<double, nb::numpy, nb::ndim<1>, nb::c_contig>;
+using OutputJacobian =
+    nb::ndarray<double, nb::numpy, nb::ndim<2>, nb::f_contig>;
+
+template <typename Constraint>
+void evaluate_into(Constraint& self,
+                   const Eigen::VectorXd& q,
+                   OutputValues values,
+                   OutputJacobian jacobian) {
+  const size_t rows = self.cst_dim();
+  if (values.shape(0) != rows || jacobian.shape(0) != rows ||
+      jacobian.shape(1) != static_cast<size_t>(q.size())) {
+    throw std::invalid_argument("evaluate_into output shape mismatch");
+  }
+  Eigen::Map<Eigen::VectorXd> result_values(values.data(), rows);
+  Eigen::Map<Eigen::MatrixXd> result_jacobian(jacobian.data(), rows, q.size());
+  self.evaluate_into(q, result_values, result_jacobian);
+}
+
+void bind_constraint_submodule(nb::module_& m) {
+  auto cst_m = m.def_submodule("constraint");
+  nb::class_<ConstraintBase>(cst_m, "ConstraintBase")
+      .def("update_kintree", &ConstraintBase::update_kintree)
+      .def("evaluate", &ConstraintBase::evaluate)
+      .def("evaluate_into", &evaluate_into<ConstraintBase>, nb::arg("q"),
+           nb::arg("values").noconvert(), nb::arg("jacobian").noconvert())
+      .def("cst_dim", &ConstraintBase::cst_dim)
+      .def("get_kin", &ConstraintBase::get_kin)
+      .def("get_control_joint_names", &ConstraintBase::get_control_joint_names);
+  nb::class_<EqConstraintBase, ConstraintBase>(cst_m, "EqConstraintBase");
+  nb::class_<IneqConstraintBase, ConstraintBase>(cst_m, "IneqConstraintBase");
+  nb::class_<ConfigPointCst, EqConstraintBase>(cst_m, "ConfigPointCst")
+      .def(nb::init<std::shared_ptr<kin::KinematicModel<double>>,
+                    const std::vector<std::string>&, BaseType,
+                    const Eigen::VectorXd&>())
+      .def("cst_dim", &ConfigPointCst::cst_dim);
+  nb::class_<LinkPoseCst, EqConstraintBase>(cst_m, "LinkPoseCst")
+      .def("__init__",
+           [](LinkPoseCst* self,
+              std::shared_ptr<kin::KinematicModel<double>> kin,
+              const std::vector<std::string>& control_joint_names,
+              BaseType base_type, const std::vector<std::string>& link_names,
+              nb::sequence poses) {
+             std::vector<Eigen::VectorXd> converted;
+             converted.reserve(nb::len(poses));
+             for (nb::handle pose : poses) {
+               nb::sequence values = nb::cast<nb::sequence>(pose);
+               converted.push_back(vector_from_sequence(values));
+             }
+             new (self) LinkPoseCst(std::move(kin), control_joint_names,
+                                    base_type, link_names, converted);
+           })
+      .def("cst_dim", &LinkPoseCst::cst_dim)
+      .def("get_desired_poses", &LinkPoseCst::get_desired_poses);
+  nb::class_<RelativePoseCst, EqConstraintBase>(cst_m, "RelativePoseCst")
+      .def(nb::init<std::shared_ptr<kin::KinematicModel<double>>,
+                    const std::vector<std::string>&, BaseType,
+                    const std::string&, const std::string&,
+                    const Eigen::Vector3d&>());
+  nb::class_<FixedZAxisCst, EqConstraintBase>(cst_m, "FixedZAxisCst")
+      .def(nb::init<std::shared_ptr<kin::KinematicModel<double>>,
+                    const std::vector<std::string>&, BaseType,
+                    const std::string&>());
+  nb::class_<SphereAttachmentSpec>(cst_m, "SphereAttachmentSpec")
+      .def(nb::init<const std::string&, const Eigen::Matrix3Xd&,
+                    Eigen::VectorXd, bool>())
+      .def_ro("parent_link_name", &SphereAttachmentSpec::parent_link_name)
+      .def_rw("relative_positions", &SphereAttachmentSpec::relative_positions)
+      .def_rw("radii", &SphereAttachmentSpec::radii);
+
+  nb::class_<SphereCollisionCst, IneqConstraintBase>(cst_m,
+                                                     "SphereCollisionCst")
+      .def(nb::init<std::shared_ptr<kin::KinematicModel<double>>,
+                    const std::vector<std::string>&, BaseType,
+                    const std::vector<SphereAttachmentSpec>&,
+                    const std::vector<std::pair<std::string, std::string>>&,
+                    std::optional<SDFBase::Ptr>, bool>(),
+           nb::arg("kin"), nb::arg("control_joint_names"), nb::arg("base_type"),
+           nb::arg("attachments"), nb::arg("self_collision_pairs"),
+           nb::arg("sdf").none(), nb::arg("use_mesh"))
+      .def("set_sdf", &SphereCollisionCst::set_sdf)
+      .def("get_sdf", &SphereCollisionCst::get_sdf)
+      .def("is_valid", &SphereCollisionCst::is_valid)
+      .def("get_group_spheres", &SphereCollisionCst::get_group_spheres)
+      .def("get_all_spheres", &SphereCollisionCst::get_all_spheres);
+
+  nb::class_<AppliedForceSpec>(cst_m, "AppliedForceSpec")
+      .def(nb::init<const std::string&, double>())
+      .def_ro("link_name", &AppliedForceSpec::link_name)
+      .def_ro("force", &AppliedForceSpec::force);
+
+  nb::class_<ComInPolytopeCst, IneqConstraintBase>(cst_m, "ComInPolytopeCst")
+      .def(nb::init<std::shared_ptr<kin::KinematicModel<double>>,
+                    const std::vector<std::string>&, BaseType, BoxSDF::Ptr,
+                    const std::vector<AppliedForceSpec>&>())
+      .def("is_valid", &ComInPolytopeCst::is_valid);
+  nb::class_<LinkPositionBoundCst, IneqConstraintBase>(cst_m,
+                                                       "LinkPositionBoundCst")
+      .def(nb::init<std::shared_ptr<kin::KinematicModel<double>>,
+                    const std::vector<std::string>&, BaseType,
+                    const std::string&, size_t, const std::optional<double>&,
+                    const std::optional<double>&>(),
+           nb::arg("kin"), nb::arg("control_joint_names"), nb::arg("base_type"),
+           nb::arg("link_name"), nb::arg("axis"), nb::arg("lower_bound").none(),
+           nb::arg("upper_bound").none())
+      .def("is_valid", &LinkPositionBoundCst::is_valid);
+  nb::class_<EqCompositeCst>(cst_m, "EqCompositeCst")
+      .def(nb::init<std::vector<EqConstraintBase::Ptr>>())
+      .def("evaluate", &EqCompositeCst::evaluate)
+      .def("evaluate_into", &evaluate_into<EqCompositeCst>, nb::arg("q"),
+           nb::arg("values").noconvert(), nb::arg("jacobian").noconvert())
+      .def("cst_dim", &EqCompositeCst::cst_dim)
+      .def_ro("constraints", &EqCompositeCst::constraints_);
+  nb::class_<IneqCompositeCst>(cst_m, "IneqCompositeCst")
+      .def(nb::init<std::vector<IneqConstraintBase::Ptr>>())
+      .def("evaluate", &IneqCompositeCst::evaluate)
+      .def("evaluate_into", &evaluate_into<IneqCompositeCst>, nb::arg("q"),
+           nb::arg("values").noconvert(), nb::arg("jacobian").noconvert())
+      .def("cst_dim", &IneqCompositeCst::cst_dim)
+      .def("is_valid", &IneqCompositeCst::is_valid)
+      .def("__str__", &IneqCompositeCst::to_string)
+      .def_ro("constraints", &IneqCompositeCst::constraints_);
+  nb::class_<SequentialCst>(cst_m, "SequentialCst")
+      .def(nb::init<size_t, size_t>())
+      .def("add_globally", &SequentialCst::add_globally)
+      .def("add_at", &SequentialCst::add_at)
+      .def("add_motion_step_box_constraint",
+           &SequentialCst::add_motion_step_box_constraint)
+      .def("add_fixed_point_at", &SequentialCst::add_fixed_point_at)
+      .def("finalize", &SequentialCst::finalize)
+      .def("evaluate", &SequentialCst::evaluate)
+      .def("__str__", &SequentialCst::to_string)
+      .def("x_dim", &SequentialCst::x_dim)
+      .def("cst_dim", &SequentialCst::cst_dim);
+}
+
+}  // namespace plainmp::bindings

{plainmp-0.3.5.dev1 → plainmp-0.3.6}/cpp/plainmp/bindings/kdtree.cpp

@@ -15,10 +15,10 @@
 using namespace plainmp::collision;
 
 namespace plainmp::bindings {
-void bind_kdtree_submodule(py::module& m) {
+void bind_kdtree_submodule(nb::module_& m) {
   auto m_kdtree = m.def_submodule("kdtree");
-  py::class_<KDTree>(m_kdtree, "KDTree")
-      .def(py::init<const std::vector<Eigen::Vector3d>&>())
+  nb::class_<KDTree>(m_kdtree, "KDTree")
+      .def(nb::init<const std::vector<Eigen::Vector3d>&>())
       .def("query", &KDTree::query)
       .def("sqdist", &KDTree::sqdist);
 }

plainmp-0.3.6/cpp/plainmp/bindings/kinematics.cpp

@@ -0,0 +1,84 @@
+/*
+ * plainmp - library for fast motion planning
+ *
+ * Copyright (C) 2024 Hirokazu Ishida
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include "plainmp/kinematics/kinematics.hpp"
+#include "plainmp/bindings/bindings.hpp"
+#include "plainmp/kinematics/kinematic_model_wrapper.hpp"
+
+using namespace plainmp::kinematics;
+
+namespace plainmp::bindings {
+
+void bind_kinematics_submodule(nb::module_& m) {
+  auto m_kin = m.def_submodule("kinematics");
+  nb::class_<urdf::Link>(m_kin, "Link")
+      .def_ro("name", &urdf::Link::name)
+      .def_ro("id", &urdf::Link::id);
+
+  nb::enum_<BaseType>(m_kin, "BaseType")
+      .value("FIXED", BaseType::FIXED)
+      .value("FLOATING", BaseType::FLOATING)
+      .value("PLANAR", BaseType::PLANAR);
+
+  // parent class
+  nb::class_<KinematicModel<double>>(m_kin, "KinematicModel_cpp");
+
+  // child "binding" class
+  nb::class_<utils::_KinematicModel, KinematicModel<double>>(m_kin,
+                                                             "KinematicModel")
+      .def(nb::init<std::string&>())
+      .def("add_new_link",
+           [](utils::_KinematicModel& self, const std::string& link_name,
+              const std::string& parent_name, nb::sequence position,
+              nb::sequence rpy, bool consider_rotation) {
+             const Eigen::Vector3d position_vec =
+                 vector3_from_sequence(position);
+             const Eigen::Vector3d rpy_vec = vector3_from_sequence(rpy);
+             return self.add_new_link_py(
+                 link_name, parent_name,
+                 {position_vec.x(), position_vec.y(), position_vec.z()},
+                 {rpy_vec.x(), rpy_vec.y(), rpy_vec.z()}, consider_rotation);
+           })
+      .def("debug_get_link_pose", &utils::_KinematicModel::debug_get_link_pose)
+      .def("set_joint_positions", &utils::_KinematicModel::set_joint_angles,
+           nb::arg("joint_ids"), nb::arg("positions"),
+           nb::arg("accurate") = true)
+      .def(
+          "set_joint_positions",
+          [](utils::_KinematicModel& self, const std::vector<size_t>& joint_ids,
+             nb::sequence positions, bool accurate) {
+            Eigen::VectorXd vector = vector_from_sequence(positions);
+            self.set_joint_angles(joint_ids, vector, accurate);
+          },
+          nb::arg("joint_ids"), nb::arg("positions"),
+          nb::arg("accurate") = true)
+      .def("get_joint_positions", &utils::_KinematicModel::get_joint_angles)
+      .def("set_base_pose", &utils::_KinematicModel::set_base_pose)
+      .def("set_base_pose",
+           [](utils::_KinematicModel& self, nb::sequence values) {
+             if (nb::len(values) != 7) {
+               throw std::invalid_argument("expected a 7-element pose");
+             }
+             const Eigen::VectorXd vector = vector_from_sequence(values);
+             self.set_base_pose(vector);
+           })
+      .def("get_base_pose", &utils::_KinematicModel::get_base_pose)
+      .def("get_joint_position_limits",
+           &utils::_KinematicModel::get_joint_position_limits)
+      .def("get_gravity_term", &utils::_KinematicModel::get_gravity_term,
+           nb::arg("joint_ids"), nb::arg("base_type") = BaseType::FIXED)
+      .def("get_gravity_term2", &utils::_KinematicModel::get_gravity_term2,
+           nb::arg("joint_ids"), nb::arg("positions"),
+           nb::arg("base_type") = BaseType::FIXED, nb::arg("accurate") = true)
+      .def("get_link_ids", &utils::_KinematicModel::get_link_ids)
+      .def("get_joint_ids", &utils::_KinematicModel::get_joint_ids);
+}
+
+}  // namespace plainmp::bindings