roboticstoolbox-python 1.4.0__tar.gz → 1.4.2__tar.gz

roboticstoolbox_python-1.4.2/.github/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+    ".": "1.4.2"
+}

{roboticstoolbox_python-1.4.0 → roboticstoolbox_python-1.4.2}/.github/workflows/ci.yml

@@ -184,37 +184,47 @@ jobs:
           cd docs && make SPHINXOPTS="--keep-going" html
           touch build/html/.nojekyll
 
-      - name: Fetch pyodide wheel for JupyterLite
-        # A plain `pip wheel`/`build` here would produce a native
-        # macOS/Linux wheel with the compiled _fknm_c/_frne_c extensions --
-        # useless in Pyodide (WASM). release.yml already cross-compiles a
-        # genuine wasm32 wheel via cibuildwheel (CIBW_PLATFORM=pyodide) and
-        # attaches it to each GitHub Release (PyPI rejects the pyodide_*
-        # platform tag), so reuse that rather than rebuilding here. This
-        # means the "Try it Now" experience tracks the latest release, not
-        # bleeding-edge main -- deliberate, since a full Pyodide/Emscripten
-        # rebuild on every docs push would be slow.
-        #
-        # STOPGAP (see https://github.com/petercorke/robotics-toolbox-python/issues/579):
-        # only fetch the cp312 wheel, matching
-        # jupyterlite-pyodide-kernel==0.6.1 below. A release can carry wasm
-        # wheels for more than one CPython version (cibuildwheel's pyodide
-        # platform builds one per supported interpreter), and
-        # jupyterlite-pyodide-kernel's all.json generator keys entries by
-        # (name, version) and *overwrites* rather than accumulates, so
-        # fetching more than one wheel for the same package+version
-        # silently drops all but the alphabetically-last from the piplite
-        # index -- no build error, just a runtime "can't find a pure
-        # Python 3 wheel" in the browser. Confirmed still present in
-        # jupyterlite_pyodide_kernel 0.7.1 (latest as of 2026-07-21), not
-        # just 0.6.1 -- an upstream bug to route around, not a version to
-        # bump past. Intended to be removed once the pure-Python wasm
-        # wheel work lands and this whole fetch step goes away.
+      - name: Build pure-Python wheel for JupyterLite
+        # RTB_PURE_WHEEL=1 (see pyproject.toml's scikit-build-core override)
+        # skips _fknm_c/_frne_c and forces a py3-none-any tag -- both have
+        # complete, tested pure-Python fallbacks, so nothing is missing at
+        # runtime. This used to require fetching a wasm32 wheel
+        # cross-compiled by release.yml's build_pyodide job (via
+        # cibuildwheel's Pyodide platform) from the latest GitHub Release,
+        # since building that wheel here on every docs push would've been
+        # slow, and PyPI rejected its old-format tag outright. A pure wheel
+        # needs neither: it's fast enough to build fresh on every push (no
+        # compilation at all, see build_pyodide's comment in release.yml),
+        # so "Try it Now" now tracks bleeding-edge main instead of lagging
+        # behind the last release, and py3-none-any needs no cross-repo
+        # GitHub Release fetch at all.
+        run: |
+          mkdir -p docs/lite/pypi
+          pip install build
+          RTB_PURE_WHEEL=1 python3 -m build --wheel --outdir docs/lite/pypi
+
+      - name: Fetch spatialgeometry pyodide wheel for JupyterLite
+        # spatialgeometry is an unconditional runtime dependency of
+        # roboticstoolbox-python (since it stopped vendoring a pure-Python
+        # copy internally at 1.4.0), so `piplite.install` needs a wasm
+        # wheel for it too, staged in the same local index. Fetched from
+        # spatialgeometry's own GitHub Release (jhavl/spatialgeometry) --
+        # it doesn't publish this to PyPI at all. SG's own CMake build
+        # already skips its compiled nanobind extension entirely under
+        # Emscripten (same idea as RTB_PURE_WHEEL above), so this wheel's
+        # *content* is genuinely pure Python -- but SG hasn't adopted the
+        # scikit-build-core override that makes the wheel *itself*
+        # py3-none-any yet, so it's still tagged cp312-cp312-pyodide_wasm32
+        # and still needs this cross-repo GitHub Release fetch rather than
+        # a plain PyPI install. Tech debt raised upstream:
+        # jhavl/spatialgeometry#46 -- once SG applies the same fix RTB just
+        # did, this step (and the cp312 filter) can go away in favour of a
+        # plain `pip download`/PyPI dependency resolution.
         env:
           GH_TOKEN: ${{ github.token }}
         run: |
-          mkdir -p docs/lite/pypi
-          gh release download --repo "$GITHUB_REPOSITORY" --pattern '*cp312*pyodide*' --dir docs/lite/pypi --clobber
+          gh release download --repo jhavl/spatialgeometry \
+            --pattern '*cp312*pyodide*wasm32*' --dir docs/lite/pypi --clobber
 
       - name: Sync notebooks into JupyterLite content
         # Copies *.ipynb plus any local asset directories (e.g.
@@ -257,12 +267,23 @@ jobs:
           PY
 
       - name: Build JupyterLite site
-        # jupyterlite-pyodide-kernel is pinned deliberately: newer versions
-        # bundle a newer Pyodide runtime than the cp312 wasm wheel attached
-        # to releases targets, which manifests as a silent hang in the
-        # browser (no error, just a kernel that never responds) rather than
-        # a build-time failure. See toolbox-infrastructure.md for the full
-        # version-skew story before bumping this.
+        # jupyterlite-pyodide-kernel is pinned deliberately -- NOT just for
+        # wasm-ABI matching with the cp312 wheel fetched above, but because
+        # newer kernel releases bundle Pyodide >=0.27.7, which turned
+        # WebAssembly JSPI ("stack switching") on by default for
+        # run_until_complete(). Browsers without JSPI support (Safari has
+        # none as of 2026-08; Firefox only behind a flag) either crash the
+        # kernel outright or, with the enableRunUntilComplete: false
+        # workaround, turn run_until_complete into a fire-and-forget no-op --
+        # letting a cell's package/import machinery run before an install has
+        # actually finished landing (confirmed live on bdsim: intermittent
+        # ModuleNotFoundError despite a successful-looking install cell).
+        # jupyterlite-pyodide-kernel==0.6.1 bundles Pyodide 0.27.6, genuinely
+        # predating this whole mechanism -- matches MVTB's and bdsim's
+        # existing pins. See the toolbox-maintainer skill's JupyterLite
+        # version-pinning section for the full story before bumping this.
+        # Once Safari (and Firefox out-of-flag) ship JSPI, revisit this pin
+        # across RTB/MVTB/bdsim together.
         run: |
           pip install jupyterlite-core "jupyterlite-pyodide-kernel==0.6.1" jupyter-server
           cd docs/lite && jupyter lite build --output-dir ../build/html/lite

roboticstoolbox_python-1.4.2/.github/workflows/release.yml

@@ -0,0 +1,236 @@
+# Single workflow: release-please proposes/cuts releases, and the same run
+# builds + publishes wheels once a release is actually created.
+#
+# Previously release-please.yml and this file were separate workflows, with
+# this one triggered on `release: created`. That event never fired in
+# practice: release-please-action creates the GitHub Release using the
+# default GITHUB_TOKEN, and GitHub deliberately does not cascade events
+# triggered by that token to *other* workflows (anti-recursion protection).
+# Confirmed the hard way shipping v1.4.0 (2026-08-23): release-please's PR
+# merged, the tag+release were created, and release.yml simply never ran --
+# required a manual `workflow_dispatch` to publish, which in turn skipped
+# `upload_pyodide_asset` (gated on `github.event_name == 'release'`),
+# leaving the release with no wasm asset until a manual backfill.
+#
+# Fix: merge both into one workflow so the build/publish jobs are downstream
+# jobs of release-please's own job in the *same* run, gated on its
+# `release_created`/`tag_name` outputs -- this sidesteps the cross-workflow
+# trigger restriction entirely, since nothing needs to fire a second time.
+# This is release-please-action's own documented pattern for this problem.
+#
+# `workflow_dispatch` is kept for manual rebuilds (e.g. to regenerate
+# artifacts) -- on that trigger the release-please job is skipped and
+# `verify_version` skips its tag-match check (no fresh tag to check
+# against).
+#
+# Uses OIDC trusted publishing for PyPI -- no stored PyPI token required.
+# macOS uses macos-14 (arm64); cibuildwheel cross-compiles x86_64 as well
+# (see [tool.cibuildwheel.macos] archs in pyproject.toml).
+# Check for latest cibuildwheel: https://github.com/pypa/cibuildwheel/releases
+
+name: Release
+
+on:
+  push:
+    branches: [main]
+  workflow_dispatch:
+
+env:
+  FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: true
+
+permissions:
+  contents: write
+  pull-requests: write
+
+jobs:
+  release-please:
+    name: Release Please
+    if: github.event_name == 'push'
+    runs-on: ubuntu-latest
+    outputs:
+      release_created: ${{ steps.release.outputs.release_created }}
+      tag_name: ${{ steps.release.outputs.tag_name }}
+    steps:
+      - uses: googleapis/release-please-action@v5
+        id: release
+        with:
+          config-file: .github/release-please-config.json
+          manifest-file: .github/.release-please-manifest.json
+
+  verify_version:
+    name: Verify tag matches package version
+    needs: release-please
+    # Runs on workflow_dispatch (manual rebuild) or on a push that release-please
+    # just turned into a real release. `always()` is required here because the
+    # release-please job is skipped on workflow_dispatch, and a skipped `needs`
+    # job would otherwise auto-skip this one under the default `if: success()`.
+    if: >
+      always() &&
+      (github.event_name == 'workflow_dispatch' ||
+       (needs.release-please.result == 'success' && needs.release-please.outputs.release_created == 'true'))
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - name: Check version
+        # Skip on manual workflow_dispatch runs (no fresh tag to check against)
+        if: needs.release-please.outputs.release_created == 'true'
+        run: |
+          TAG="${{ needs.release-please.outputs.tag_name }}"
+          TAG="${TAG#v}"
+          PKG=$(python3 -c "import tomllib; print(tomllib.load(open('pyproject.toml','rb'))['project']['version'])")
+          echo "Tag version : $TAG"
+          echo "Package version: $PKG"
+          [ "$TAG" = "$PKG" ] || { echo "ERROR: tag v$TAG does not match pyproject.toml version $PKG"; exit 1; }
+
+  build_wheels:
+    name: Build wheels on ${{ matrix.os }} (${{ matrix.arch }})
+    needs: verify_version
+    # always() + explicit check, not the default if:success() -- success()
+    # walks the *entire transitive* needs chain, not just direct needs, so
+    # it would see release-please's skip (verify_version's own ancestor)
+    # and auto-skip this job too even though verify_version itself
+    # succeeded. Confirmed empirically via a workflow_dispatch rehearsal.
+    if: always() && needs.verify_version.result == 'success'
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        include:
+          - os: ubuntu-latest
+            arch: x86_64
+          - os: ubuntu-24.04-arm
+            arch: arm64
+          - os: windows-latest
+            arch: x86_64
+          - os: macos-latest
+            arch: arm64
+
+    steps:
+      - uses: actions/checkout@v7
+
+      - name: Build wheels
+        uses: pypa/cibuildwheel@v4.1.1
+
+      - uses: actions/upload-artifact@v7
+        with:
+          name: wheels-${{ matrix.os }}-${{ strategy.job-index }}
+          path: ./wheelhouse/*.whl
+
+  build_pyodide:
+    name: Build pure-Python wheel (for Pyodide/JupyterLite)
+    needs: verify_version
+    # See build_wheels' comment above for why always() + an explicit check
+    # is needed instead of the default if:success().
+    if: always() && needs.verify_version.result == 'success'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+
+      - uses: actions/setup-python@v7
+        with:
+          python-version: "3.12"
+
+      # Not a cross-compile: RTB_PURE_WHEEL=1 (see pyproject.toml's
+      # scikit-build-core override) skips both _fknm_c/_frne_c (they have
+      # complete, tested pure-Python fallbacks -- fknm.py/frne.py,
+      # tests/test_fknm_fallback.py) and forces the wheel tag to
+      # py3-none-any. No Emscripten SDK, no cibuildwheel Pyodide platform,
+      # no Pyodide-version coupling at all -- a plain wheel built on a
+      # normal runner. This replaced an earlier approach that cross-compiled
+      # a real wasm32 binary via cibuildwheel's Pyodide platform, which tied
+      # the wheel to one specific Pyodide/Emscripten ABI version and, worse,
+      # to a JSPI-safe-vs-unsafe split (Safari/Firefox lack WebAssembly JSPI,
+      # which Pyodide >=0.27.7 needs) -- see git history on this job and on
+      # pyproject.toml for that saga. A pure-Python wheel has no ABI to be
+      # wrong about, so none of that applies here.
+      - name: Build pure-Python wheel
+        run: |
+          pip install build
+          RTB_PURE_WHEEL=1 python3 -m build --wheel --outdir wheelhouse
+
+      - name: Verify wheel is genuinely pure Python
+        run: |
+          ls wheelhouse/
+          case "$(ls wheelhouse/)" in
+            *-py3-none-any.whl) echo "OK: py3-none-any" ;;
+            *) echo "ERROR: expected a py3-none-any wheel"; exit 1 ;;
+          esac
+
+      - uses: actions/upload-artifact@v7
+        with:
+          name: wheels-pyodide
+          path: ./wheelhouse/*.whl
+
+  build_sdist:
+    name: Build source distribution
+    needs: verify_version
+    # See build_wheels' comment above for why always() + an explicit check
+    # is needed instead of the default if:success().
+    if: always() && needs.verify_version.result == 'success'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+
+      - name: Build sdist
+        run: pipx run build --sdist
+
+      - uses: actions/upload-artifact@v7
+        with:
+          name: sdist
+          path: dist/*.tar.gz
+
+  smoke_test:
+    name: Smoke-test Linux wheel
+    needs: build_wheels
+    # See build_wheels' comment above for why always() + an explicit check
+    # is needed instead of the default if:success().
+    if: always() && needs.build_wheels.result == 'success'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/setup-python@v7
+        with:
+          python-version: "3.12"
+
+      - uses: actions/download-artifact@v8
+        with:
+          pattern: wheels-ubuntu-latest-*
+          merge-multiple: true
+          path: wheelhouse
+
+      - name: Install wheel (pulls all deps from PyPI)
+        run: pip install --find-links wheelhouse roboticstoolbox-python
+
+      - name: Smoke test
+        run: python -c "import roboticstoolbox; print('OK', roboticstoolbox.__version__)"
+
+  upload_pypi:
+    needs: [build_wheels, build_pyodide, build_sdist, smoke_test]
+    # See build_wheels' comment above for why always() + an explicit check
+    # is needed instead of the default if:success().
+    if: >
+      always() &&
+      needs.build_wheels.result == 'success' &&
+      needs.build_pyodide.result == 'success' &&
+      needs.build_sdist.result == 'success' &&
+      needs.smoke_test.result == 'success'
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write   # required for OIDC trusted publishing
+    steps:
+      - uses: actions/download-artifact@v8
+        with:
+          pattern: wheels-*
+          merge-multiple: true
+          path: dist
+
+      - uses: actions/download-artifact@v8
+        with:
+          name: sdist
+          path: dist
+
+      # The pyodide wheel (py3-none-any) uploads to PyPI like any other
+      # wheel now -- no tag rejection, no GitHub-Release-asset workaround.
+      # See build_pyodide's comment for why.
+      - uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          skip-existing: true

{roboticstoolbox_python-1.4.0 → roboticstoolbox_python-1.4.2}/CHANGELOG.md

@@ -1,5 +1,59 @@
 # Changelog
 
+## [1.4.2](https://github.com/petercorke/robotics-toolbox-python/compare/v1.4.1...v1.4.2) (2026-08-26)
+
+**Headline**: Fixes to inverse kinematics and forward kinematics for branched robots. Arising from a big trawl through long standing issues (thanks to all those users), many were resolved by recent work, but some were not.
+Issues down from 104 to 43 of which 20 are `tech-debt` to be worked through.
+
+### Features
+
+* **ets:** fkine/jacob0/jacobe/hessian0/hessiane accept compact q ([#653](https://github.com/petercorke/robotics-toolbox-python/issues/653)) ([d5b6990](https://github.com/petercorke/robotics-toolbox-python/commit/d5b699025e48afeca147fb2e8b246557d2059c47))
+* **examples:** add ikine_XX (C++ and pure-Python ETS) to ik_speed.py ([2f41a71](https://github.com/petercorke/robotics-toolbox-python/commit/2f41a711eba92f97ad1ed38dcd4fa69a87bccb26))
+* **examples:** add ikine_XX timing columns to ik_speed.py ([#654](https://github.com/petercorke/robotics-toolbox-python/issues/654)) ([2f41a71](https://github.com/petercorke/robotics-toolbox-python/commit/2f41a711eba92f97ad1ed38dcd4fa69a87bccb26))
+
+
+### Bug Fixes
+
+* **blocks:** FDyn_X.output() crashed/asserted on unset xdd before deriv() ran ([#647](https://github.com/petercorke/robotics-toolbox-python/issues/647)) ([8caa363](https://github.com/petercorke/robotics-toolbox-python/commit/8caa363a98c158621d6418ccad8f0bbdc93fee11))
+* **examples,dhrobot:** repair broken ikine_LMS/ikine_min example references ([#650](https://github.com/petercorke/robotics-toolbox-python/issues/650)) ([6691113](https://github.com/petercorke/robotics-toolbox-python/commit/66911133fdbdb5cf73cb24fcca058f457270099c))
+* **ik:** _random_q() silently produces garbage for non-finite joint limits ([#648](https://github.com/petercorke/robotics-toolbox-python/issues/648)) ([2f43a3c](https://github.com/petercorke/robotics-toolbox-python/commit/2f43a3c2812dc8f30d8601a54d453ef158c8b8e0))
+* **ik:** unify ik_XX/ikine_XX return types and fix IK docs ([#652](https://github.com/petercorke/robotics-toolbox-python/issues/652)) ([07a60f4](https://github.com/petercorke/robotics-toolbox-python/commit/07a60f4a9fe9bf3de94aaf2428f93f75a7d77d3f))
+* **kinematics:** fkine_all() computes wrong poses for links past a nominal end-effector ([#643](https://github.com/petercorke/robotics-toolbox-python/issues/643)) ([25eedcd](https://github.com/petercorke/robotics-toolbox-python/commit/25eedcd4294856cab0a8de346c72ce0a48a50b2e))
+* **mobile:** restore missing distance-transform diagonal ([835457e](https://github.com/petercorke/robotics-toolbox-python/commit/835457e0428ade74b68220395a09224737f40d79))
+* **models,ik:** correct YuMi gripper parents and IK failure-path q compaction ([#649](https://github.com/petercorke/robotics-toolbox-python/issues/649)) ([7c40242](https://github.com/petercorke/robotics-toolbox-python/commit/7c40242dec4dafcc12940c3eeb9da67f9d2aa7fa))
+* **pyplot:** robot.plot(..., movie=...) crashes on save ([#645](https://github.com/petercorke/robotics-toolbox-python/issues/645)) ([2e2bfe2](https://github.com/petercorke/robotics-toolbox-python/commit/2e2bfe2ada4c43f3212db48f052986b25da6254d))
+* **pyplot:** scalar plot options (jointaxislength, eelength) crash on override ([a4aea19](https://github.com/petercorke/robotics-toolbox-python/commit/a4aea193354631dc5e208f00f556ff181ba713bb))
+* **pyplot:** scalar plot options crash on override ([#642](https://github.com/petercorke/robotics-toolbox-python/issues/642)) ([a4aea19](https://github.com/petercorke/robotics-toolbox-python/commit/a4aea193354631dc5e208f00f556ff181ba713bb))
+
+
+### Documentation
+
+* fix broken PyPlot backend example in intro.rst ([#641](https://github.com/petercorke/robotics-toolbox-python/issues/641)) ([5e8d2f9](https://github.com/petercorke/robotics-toolbox-python/commit/5e8d2f96f557d2a0014217e8820cbadcd9136889))
+
+
+### Miscellaneous
+
+* release 1.4.2 ([440a9ec](https://github.com/petercorke/robotics-toolbox-python/commit/440a9eca955430e1fd6f97ed63781e86648d1026))
+
+## [1.4.1](https://github.com/petercorke/robotics-toolbox-python/compare/v1.4.0...v1.4.1) (2026-08-25)
+
+
+### Bug Fixes
+
+* **ci:** add CIBW_ENABLE=pyodide-eol, required to build the cp312 pyodide target ([2243fc2](https://github.com/petercorke/robotics-toolbox-python/commit/2243fc2990197baa5e60d53e49d8d32af8daa185))
+* **ci:** drop the explicit pyodide-version override, let cibuildwheel 3.4.1 self-resolve ([394d258](https://github.com/petercorke/robotics-toolbox-python/commit/394d258f9e65acebc94374eb1bf93fde980c2fd6))
+* **ci:** keep JupyterLite wasm build on JSPI-safe cp312, not cibuildwheel's new cp313 default ([a315095](https://github.com/petercorke/robotics-toolbox-python/commit/a3150958dee84285f147702b40e5fe3b13f2283c))
+* **ci:** pin cibuildwheel 3.4.1 for the pyodide build job, not 4.1.1 ([e428935](https://github.com/petercorke/robotics-toolbox-python/commit/e428935b9fdb8c33647bbcfb1e011999a147eb3a))
+* **ci:** stop skip-cascade from release-please poisoning downstream jobs ([f252325](https://github.com/petercorke/robotics-toolbox-python/commit/f2523251a95f19d73d4fb393a15878cc3fbc7803))
+* compute accel_x with analytical Jacobian derivative ([1c4ffe6](https://github.com/petercorke/robotics-toolbox-python/commit/1c4ffe6145ddc2a42584006a44147094d0f537b4))
+* **plot:** use matplotlib colormaps registry instead of removed cm.get_cmap ([ad14468](https://github.com/petercorke/robotics-toolbox-python/commit/ad1446895c15bb679acf0ff35ffd901e1d591362))
+* two real bugs found by running the suite against the pure-Python path ([d4d2af3](https://github.com/petercorke/robotics-toolbox-python/commit/d4d2af3a81dc18731019dbd04c562c588d628e81))
+
+
+### Build System
+
+* add RTB_PURE_WHEEL to build a genuine py3-none-any wheel ([d61729c](https://github.com/petercorke/robotics-toolbox-python/commit/d61729c38db2174fbe6933f59a9d85447a03339e))
+
 ## [1.4.0](https://github.com/petercorke/robotics-toolbox-python/compare/v1.3.1...v1.4.0) (2026-08-22)
 
 **Highlights**: using significantly reworked versions of [Swift](https://github.com/jhavl/swift) (v2.0.0) and [Spatial Geometry](https://github.com/jhavl/spatialgeometry) (v1.4.0) -- lots of bug fixes, new features and documentation.  Collision detection changed from PyBullet (no longer well maintained) to [Coal](https://github.com/coal-library/coal).  Integrates with [Robot Descriptions](https://github.com/robot-descriptions) for access to over 150 URDF models, loaded dynamically and cached locally -- this means that RTB can now ship with a very minimum set of mesh models.  Significant work on RNE models (DH Python, DH C, ETS Featherstone) all consistent and checked against analytic model.  `robot.teach()` now supports the Swift backend directly, and the docs site gained a JupyterLite-powered "Try it Now" in-browser notebook -- no install required.  Additional work on docs, build system, and testing.  

roboticstoolbox_python-1.4.2/CMakeLists.txt

@@ -0,0 +1,61 @@
+cmake_minimum_required(VERSION 3.15)
+project(${SKBUILD_PROJECT_NAME} LANGUAGES C CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+# Locate Python (interpreter needed to find nanobind cmake dir)
+find_package(Python COMPONENTS Interpreter Development.Module REQUIRED)
+
+# Locate nanobind via the installed Python package
+execute_process(
+    COMMAND "${Python_EXECUTABLE}" -c "import nanobind; print(nanobind.cmake_dir())"
+    OUTPUT_VARIABLE NB_DIR
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+)
+find_package(nanobind CONFIG REQUIRED HINTS "${NB_DIR}")
+
+# Set -DRTB_BUILD_EXTENSIONS=OFF to skip both compiled extensions and build a
+# genuinely pure-Python wheel instead -- both _fknm_c and _frne_c have
+# complete, tested pure-Python fallbacks (see fknm.py/frne.py and
+# tests/test_fknm_fallback.py), so this is a real, working configuration,
+# not just a stub. Used for the Pyodide/JupyterLite wheel (see release.yml's
+# build_pyodide job and pyproject.toml's scikit-build-core override): rather
+# than cross-compiling for wasm32 via cibuildwheel's Pyodide platform (which
+# ties the wheel to a specific Pyodide/Emscripten ABI version -- see git
+# history on this file/release.yml for the JSPI/tag saga that caused),
+# building on a normal runner with extensions off produces an ordinary
+# py3-none-any wheel with no such coupling at all.
+option(RTB_BUILD_EXTENSIONS "Build the compiled _fknm_c/_frne_c nanobind extensions" ON)
+
+if(RTB_BUILD_EXTENSIONS)
+    # -----------------------------------------------------------------------
+    # _frne_c — Newton-Euler inverse dynamics
+    # ne.c / vmath.c are pure C maths; frne_nb.cpp is the nanobind glue.
+    # -----------------------------------------------------------------------
+    nanobind_add_module(_frne_c
+        src/roboticstoolbox/robot/cpp-extensions/vmath.c
+        src/roboticstoolbox/robot/cpp-extensions/ne.c
+        src/roboticstoolbox/robot/cpp-extensions/frne_nb.cpp
+    )
+    target_include_directories(_frne_c PRIVATE
+        src/roboticstoolbox/robot/cpp-extensions
+    )
+
+    # -----------------------------------------------------------------------
+    # _fknm_c — forward kinematics, Jacobian, Hessian, IK
+    # Eigen is vendored as header-only in src/roboticstoolbox/ets/cpp-extensions/Eigen/
+    # fknm_nb.cpp is the nanobind glue; maths lives in methods/ik/linalg.
+    # -----------------------------------------------------------------------
+    nanobind_add_module(_fknm_c
+        src/roboticstoolbox/ets/cpp-extensions/methods.cpp
+        src/roboticstoolbox/ets/cpp-extensions/ik.cpp
+        src/roboticstoolbox/ets/cpp-extensions/linalg.cpp
+        src/roboticstoolbox/ets/cpp-extensions/fknm_nb.cpp
+    )
+    target_include_directories(_fknm_c PRIVATE
+        src/roboticstoolbox/ets/cpp-extensions
+    )
+
+    install(TARGETS _frne_c _fknm_c DESTINATION roboticstoolbox)
+endif()

{roboticstoolbox_python-1.4.0 → roboticstoolbox_python-1.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: roboticstoolbox-python
-Version: 1.4.0
+Version: 1.4.2
 Summary: A Python library for robotics education and research
 Keywords: python,robotics,robotics-toolbox,kinematics,dynamics,motion-planning,trajectory-generation,jacobian,hessian,control,simulation,robot-manipulator,mobile-robot
 Author-Email: Jesse Haviland <j.haviland@qut.edu.au>, Peter Corke <rvc@petercorke.com>
@@ -33,6 +33,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Project-URL: homepage, https://petercorke.github.io/robotics-toolbox-python/
 Project-URL: documentation, https://petercorke.github.io/robotics-toolbox-python/
 Project-URL: repository, https://github.com/petercorke/robotics-toolbox-python

{roboticstoolbox_python-1.4.0 → roboticstoolbox_python-1.4.2}/docs/source/IK/ik_lm.rst

@@ -1,5 +1,5 @@
-IK_LM - Levemberg-Marquadt Numerical IK
----------------------------------------
+IK_LM - Levenberg-Marquardt Numerical IK
+----------------------------------------
 
 .. currentmodule:: roboticstoolbox.robot.IK
 

{roboticstoolbox_python-1.4.0 → roboticstoolbox_python-1.4.2}/docs/source/arm_ets.rst

@@ -66,6 +66,28 @@ The ETS inherits list-like properties and has methods like ``reverse`` and ``pop
    - `A simple and systematic approach to assigning Denavit-Hartenberg parameters <https://petercorke.com/robotics/a-simple-and-systematic-approach-to-assigning-denavit-hartenberg-parameters>`_.
      Peter I. Corke, IEEE Transactions on Robotics, 23(3), pp 590-594, June 2007.
 
+Transform chains
+----------------
+
+The :func:`~roboticstoolbox.tools.trchain.trchain` and
+:func:`~roboticstoolbox.tools.trchain.trchain2` functions provide the compact
+string notation used by the MATLAB Toolbox for one-off SE(3) and SE(2)
+transform chains.  Joint variables are numbered from one, while named
+constants are passed explicitly in ``variables``.
+
+.. runblock:: pycon
+
+   >>> import roboticstoolbox as rtb
+   >>> rtb.trchain("Rz(q1) Tx(a)", [0.3], variables={"a": 1})
+   >>> rtb.trchain2("R(q1) Tx(a)", [0.3], variables={"a": 1})
+
+Parsed tokens can also be returned and reused when evaluating the same chain
+for different joint values.
+
+.. autofunction:: roboticstoolbox.tools.trchain.trchain
+
+.. autofunction:: roboticstoolbox.tools.trchain.trchain2
+
 ETS - 3D
 --------
 
@@ -82,4 +104,3 @@ ETS - 2D
    :members: __str__, __repr__, __mul__, __getitem__, n, m, structure, joints, jindex_set, split, inv, compile, insert, fkine, jacob0, jacobe
    :undoc-members:
    :show-inheritance:
-

{roboticstoolbox_python-1.4.0 → roboticstoolbox_python-1.4.2}/docs/source/conf.py

@@ -198,6 +198,7 @@ rst_epilog = """
    :format: html
 .. |BlockOptions| replace:: :raw-html:`<a href="https://petercorke.github.io/bdsim/internals.html?highlight=block%20__init__#bdsim.Block.__init__">common Block options</a>`
 .. |GraphicsBlockOptions| replace:: :raw-html:`<a href="https://petercorke.github.io/bdsim/internals.html?highlight=graphicsblock%20__init__#bdsim.GraphicsBlock.__init__">common GraphicsBlock options</a>`
+.. |ikargs| replace:: additional keyword arguments accepted by the underlying numerical IK solver -- ``ilimit``, ``slimit``, ``tol``, ``mask``, ``joint_limits``, ``seed``, ``k``, ``method``, ``kq``, ``km`` -- see :meth:`~roboticstoolbox.ETS.ikine_LM` for details of each
 """
 
 # -------- Suppress common noisy warnings ----------------------------------------#

{roboticstoolbox_python-1.4.0 → roboticstoolbox_python-1.4.2}/docs/source/intro.rst

@@ -103,7 +103,7 @@ All robots can generate a random joint configuration informed by joint limits, i
     >>> puma.random_q()
 
 ``ikine_LM`` is a generalised iterative numerical solution based on
-Levenberg-Marquadt minimization, and additional status results are also
+Levenberg-Marquardt minimization, and additional status results are also
 returned as part of a named tuple.  
 
 .. warning:: 
@@ -634,11 +634,12 @@ the default ``PyPlot`` backend which draws a "noodle robot" using the PyPlot bac
 
 The more general solution, and what is implemented inside ``plot`` in the example above, is::
 
-    >>> pyplot = roboticstoolbox.backends.PyPlot()
+    >>> from roboticstoolbox.backends.PyPlot import PyPlot
+    >>> pyplot = PyPlot()
     >>> pyplot.launch()
     >>> pyplot.add(puma)
     >>> puma.q = q
-    >>> puma.step()
+    >>> pyplot.step()
 
 This makes it possible to animate multiple robots in the one graphical window, or the one robot in various environments either graphical
 or real.
@@ -658,7 +659,7 @@ to import them if the user attempts to exploit a functionality that requires it.
 If a dependency is not installed, a warning provides instructions on how to install it using ``pip``.
 
 C/C++ extensions are provided for recursive Newton-Euler dynamics and optimized forward and inverse kinematics for ETS defined robots.  These
-wheels are built by the GitHub CI actions.  A pyodide wheel is also built for use in the browser and is available as a GitHub release resource.
+wheels are built by the GitHub CI actions.  A pure-Python wheel (using tested pure-Python fallbacks for the C/C++ functionality) is also built for use in the browser via Pyodide/JupyterLite, and is published to PyPI alongside the compiled wheels.
 
 
 Spatial math layer