inspect-robots-so101 0.3.0__tar.gz

inspect_robots_so101-0.3.0/.gitignore

@@ -0,0 +1,28 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+.eggs/
+build/
+dist/
+
+# Virtualenvs
+.venv/
+venv/
+
+# Test / coverage
+.pytest_cache/
+.coverage
+coverage.xml
+htmlcov/
+.mypy_cache/
+.ruff_cache/
+
+# Secrets / env
+.env
+.env.*
+
+# OS / editor
+.DS_Store
+.idea/
+.vscode/

inspect_robots_so101-0.3.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 RoboCurve
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

inspect_robots_so101-0.3.0/PKG-INFO

@@ -0,0 +1,209 @@
+Metadata-Version: 2.4
+Name: inspect-robots-so101
+Version: 0.3.0
+Summary: Inspect Robots adapters for LeRobot SO-ARM followers (SO-100/SO-101) driven by LeRobot policies.
+Project-URL: Homepage, https://github.com/robocurve/inspect-robots-so101
+Project-URL: Framework, https://github.com/robocurve/inspect-robots
+Project-URL: LeRobot, https://github.com/huggingface/lerobot
+Author: RoboCurve
+License-Expression: MIT
+License-File: LICENSE
+Keywords: inspect-robots,lerobot,robotics,so-arm,so100,so101,vla
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: inspect-robots>=0.3
+Requires-Dist: numpy>=1.24
+Provides-Extra: dev
+Requires-Dist: mypy>=1.11; extra == 'dev'
+Requires-Dist: numpy<2.5; extra == 'dev'
+Requires-Dist: pre-commit>=3.5; extra == 'dev'
+Requires-Dist: pytest-cov>=5.0; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Provides-Extra: lerobot
+Requires-Dist: lerobot[feetech]<0.6,>=0.5; (python_version >= '3.12') and extra == 'lerobot'
+Description-Content-Type: text/markdown
+
+<div align="center">
+
+# 🦾 inspect-robots-so101
+
+**Run [Inspect Robots](https://github.com/robocurve/inspect-robots) evals on real
+[SO-ARM](https://github.com/TheRobotStudio/SO-ARM100) followers (SO-100 / SO-101)
+driven by [LeRobot](https://github.com/huggingface/lerobot) policies.**
+
+[![CI](https://github.com/robocurve/inspect-robots-so101/actions/workflows/ci.yml/badge.svg)](https://github.com/robocurve/inspect-robots-so101/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green)](LICENSE)
+[![Coverage](https://img.shields.io/badge/coverage-100%25-brightgreen)](https://github.com/robocurve/inspect-robots-so101/actions/workflows/ci.yml)
+[![Built on Inspect Robots](https://img.shields.io/badge/built%20on-Inspect%20Robots-indigo)](https://github.com/robocurve/inspect-robots)
+
+</div>
+
+Inspect Robots has **two** swappable inputs: a `Policy` (the VLA brain) and an
+`Embodiment` (the robot body + world). This package provides both for the
+SO-ARM + LeRobot stack, so any embodiment-agnostic Inspect Robots task runs on a real
+arm:
+
+- **`lerobot` policy** — wraps a LeRobot checkpoint (ACT, SmolVLA, π0, diffusion…)
+  and runs it **in process** on the GPU, returning an action chunk per inference.
+- **`so_arm` embodiment** — the LeRobot SO follower driver (Feetech bus), with a
+  hard safety clamp, operator-in-the-loop success, and self-paced control.
+
+Both declare the **same 6-D joint-position contract** (`shoulder_pan`,
+`shoulder_lift`, `elbow_flex`, `wrist_flex`, `wrist_roll`, `gripper`; the cameras
+you configure; packed `joint_pos` state), so Inspect Robots's compatibility check passes
+with **zero errors and zero warnings** — verifiable before any motion.
+
+```bash
+inspect-robots run --task cubepick-reach --policy lerobot --embodiment so_arm
+```
+
+> This is the SO-ARM/LeRobot sibling of
+> [inspect-robots-yam](https://github.com/robocurve/inspect-robots-yam) (bimanual I2RT YAM +
+> MolmoAct2). Same Inspect Robots contract, different body and brain.
+
+## Install (on the robot/GPU machine)
+
+```bash
+# Inspect Robots isn't on PyPI yet; uv resolves it from git. The `lerobot` extra pulls
+# torch + lerobot + the Feetech motor bus the SO follower uses.
+uv pip install "inspect-robots-so101[lerobot] @ git+https://github.com/robocurve/inspect-robots-so101"
+```
+
+- `lerobot` → `lerobot[feetech]` (torch, the policy, and the SO-ARM driver).
+- **The `lerobot` extra needs Python ≥ 3.12** (lerobot ≥ 0.5's floor). On
+  3.10/3.11 the extra silently resolves to *nothing*: the core package still
+  imports, but no torch/lerobot is installed and hardware runs will fail.
+
+Then pick a checkpoint. Any LeRobot policy trained on your SO-ARM works — e.g. the
+public `lerobot/smolvla_base`, or your own ACT/π0 checkpoint on the Hub or a path.
+
+## Preflight — *prove compatibility before any motion*
+
+```bash
+inspect-robots-so101-preflight                          # dims/semantics/cameras/state
+inspect-robots-so101-preflight --task cubepick-reach    # + scene realizability
+inspect-robots-so101-preflight --dry-run                # affirm no motion
+```
+
+A green preflight means action dim (6), control mode (`joint_pos`), cameras, and
+state keys all line up. **It does not prove the joint values are interpreted the
+same way** — see *Safety* below.
+
+## Calibrate first (once, with lerobot)
+
+The embodiment **never** runs lerobot's interactive calibration — connecting with
+an uncalibrated arm would otherwise drop into a *blocking* prompt that moves the
+arm mid-eval. Calibrate once with lerobot's own tool, then tell the config which
+identity you used:
+
+```bash
+lerobot-calibrate --robot.type=so101_follower --robot.port=/dev/ttyACM0 --robot.id=my_follower
+```
+
+`SOArmConfig(robot_id="my_follower")` selects that calibration file
+(`<calibration_dir>/<robot_id>.json`; leave `calibration_dir=None` for lerobot's
+default location). If the arm isn't calibrated — or the file no longer matches
+the motors — `reset()` fails fast with an actionable error instead of prompting.
+
+## Run on hardware
+
+You must point the embodiment at your serial port, calibration id, and camera
+config, and the policy at a checkpoint:
+
+```python
+from inspect_robots import eval
+from inspect_robots.approver import ClampApprover
+from inspect_robots_so101 import LeRobotPolicy, SOArmEmbodiment, SOArmConfig, LeRobotPolicyConfig
+from lerobot.cameras.opencv import OpenCVCameraConfig  # your camera backend
+
+emb = SOArmEmbodiment(SOArmConfig(
+    port="/dev/ttyACM0",
+    robot_type="so101_follower",
+    robot_id="my_follower",    # the id you ran `lerobot-calibrate` with
+    max_relative_target=10.0,  # lerobot's slew limit (deg/step); required for home_pose
+    cameras=("front",),
+    camera_configs={"front": OpenCVCameraConfig(index_or_path=0, width=640, height=480, fps=30)},
+))
+pol = LeRobotPolicy(LeRobotPolicyConfig(
+    pretrained_path="lerobot/smolvla_base", policy_type="smolvla", device="cuda",
+))
+
+with emb:  # guarantees disconnect (and torque-off) even if the eval raises
+    (log,) = eval("cubepick-reach", pol, emb,
+                  approver=ClampApprover(emb.info.action_space))  # defense in depth
+print(log.status, log.results.metrics)
+```
+
+(Equivalently, wrap the `eval(...)` in `try: ... finally: emb.close()`.)
+
+At each episode end the embodiment asks the operator (y/N); a `yes` records
+`termination_reason="success"`, which the task's `success_at_end` scorer reads.
+Unattended runs simply run to `max_steps` and score as failures.
+
+## Safety
+
+- **Hard clamp backstop.** Every command is clipped to `SOArmConfig.joint_low/high`
+  *inside* `step()`, independent of any Inspect Robots `Approver` and on top of LeRobot's
+  own `max_relative_target` slew limit — unclamped model outputs can never reach
+  the motors. **Set these to your real, calibrated SO-ARM joint limits** (the
+  defaults are conservative placeholders: joints ±180°, gripper 0–100).
+- **Use `ClampApprover`** on hardware for a second layer.
+- **Native units, no renormalization.** LeRobot's postprocessor unnormalizes the
+  policy output to the robot's native motor units (degrees for joints, 0–100 for
+  the gripper), so the embodiment commands them verbatim after the clamp. Train
+  and run the policy in the *same* units. `use_degrees=False` (lerobot's
+  normalized ±100 mode) is **rejected** — the state spec and default limits here
+  assume degrees. Also note the units are *degrees* while Inspect Robots's canonical
+  `joint_pos` convention is radians: the compat check compares state **keys**
+  only, so pairing either component with a third-party counterpart will *not*
+  flag a unit mismatch — verify units yourself when mixing stacks.
+- **Homing is slew-limited or refused.** `home_pose` sends a single absolute
+  command, so the config requires `max_relative_target` (LeRobot's per-step slew
+  limit) whenever `home_pose` is set — otherwise the arm would slam to home at
+  full speed from wherever it happens to be.
+- **Absolute vs. delta joints — verify first.** Actions are treated as **absolute**
+  joint targets by default. If your checkpoint emits deltas, set
+  `SOArmConfig(joints_are_delta=True)` (the embodiment converts to absolute
+  internally so the declared `joint_pos` stays honest). The compat check *cannot*
+  tell these apart — confirm with `--dry-run` and a single slow jog before a task.
+
+## Configuration
+
+`SOArmConfig`: `port`, `robot_type`, `robot_id`, `calibration_dir`, `cameras`,
+`camera_configs`, `control_hz`, `cam_height/width`, `joint_low/high`,
+`home_pose` (requires `max_relative_target`), `joints_are_delta`, `use_degrees`
+(must stay `True`), `max_relative_target`, `disable_torque_on_disconnect`.
+`robot_type` is validated (`so101_follower` / `so100_follower`) but is a label:
+at lerobot v0.5.x both names alias the same driver class, so it changes no
+runtime behavior.
+`LeRobotPolicyConfig`: `pretrained_path`, `policy_type`, `device`, `cameras`,
+`state_key`, `chunk_size`, `cam_height/width`.
+
+Scalar knobs are settable from the CLI:
+`inspect-robots run -P pretrained_path=lerobot/smolvla_base -E port=/dev/ttyACM0 ...`.
+
+## Development
+
+```bash
+uv venv && uv pip install -e ".[dev]"     # inspect-robots from a git tag
+uv run pre-commit install
+uv run pytest --cov                        # 100% coverage required
+uv run ruff check . && uv run mypy
+```
+
+The whole suite runs with **no hardware, no GPU, no torch, no lerobot, and no
+stdin** — the SO-ARM driver, the policy inference, the clock, and operator I/O are
+all injected. The real model seam (`_default_predict`) is covered via
+`sys.modules` fakes, and a dedicated `lerobot-seam` CI job (py3.12) imports the
+real lerobot symbols it uses; only direct hardware/TTY I/O keeps
+`# pragma: no cover`.
+
+## License
+
+[MIT](LICENSE)

inspect_robots_so101-0.3.0/README.md

@@ -0,0 +1,178 @@
+<div align="center">
+
+# 🦾 inspect-robots-so101
+
+**Run [Inspect Robots](https://github.com/robocurve/inspect-robots) evals on real
+[SO-ARM](https://github.com/TheRobotStudio/SO-ARM100) followers (SO-100 / SO-101)
+driven by [LeRobot](https://github.com/huggingface/lerobot) policies.**
+
+[![CI](https://github.com/robocurve/inspect-robots-so101/actions/workflows/ci.yml/badge.svg)](https://github.com/robocurve/inspect-robots-so101/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green)](LICENSE)
+[![Coverage](https://img.shields.io/badge/coverage-100%25-brightgreen)](https://github.com/robocurve/inspect-robots-so101/actions/workflows/ci.yml)
+[![Built on Inspect Robots](https://img.shields.io/badge/built%20on-Inspect%20Robots-indigo)](https://github.com/robocurve/inspect-robots)
+
+</div>
+
+Inspect Robots has **two** swappable inputs: a `Policy` (the VLA brain) and an
+`Embodiment` (the robot body + world). This package provides both for the
+SO-ARM + LeRobot stack, so any embodiment-agnostic Inspect Robots task runs on a real
+arm:
+
+- **`lerobot` policy** — wraps a LeRobot checkpoint (ACT, SmolVLA, π0, diffusion…)
+  and runs it **in process** on the GPU, returning an action chunk per inference.
+- **`so_arm` embodiment** — the LeRobot SO follower driver (Feetech bus), with a
+  hard safety clamp, operator-in-the-loop success, and self-paced control.
+
+Both declare the **same 6-D joint-position contract** (`shoulder_pan`,
+`shoulder_lift`, `elbow_flex`, `wrist_flex`, `wrist_roll`, `gripper`; the cameras
+you configure; packed `joint_pos` state), so Inspect Robots's compatibility check passes
+with **zero errors and zero warnings** — verifiable before any motion.
+
+```bash
+inspect-robots run --task cubepick-reach --policy lerobot --embodiment so_arm
+```
+
+> This is the SO-ARM/LeRobot sibling of
+> [inspect-robots-yam](https://github.com/robocurve/inspect-robots-yam) (bimanual I2RT YAM +
+> MolmoAct2). Same Inspect Robots contract, different body and brain.
+
+## Install (on the robot/GPU machine)
+
+```bash
+# Inspect Robots isn't on PyPI yet; uv resolves it from git. The `lerobot` extra pulls
+# torch + lerobot + the Feetech motor bus the SO follower uses.
+uv pip install "inspect-robots-so101[lerobot] @ git+https://github.com/robocurve/inspect-robots-so101"
+```
+
+- `lerobot` → `lerobot[feetech]` (torch, the policy, and the SO-ARM driver).
+- **The `lerobot` extra needs Python ≥ 3.12** (lerobot ≥ 0.5's floor). On
+  3.10/3.11 the extra silently resolves to *nothing*: the core package still
+  imports, but no torch/lerobot is installed and hardware runs will fail.
+
+Then pick a checkpoint. Any LeRobot policy trained on your SO-ARM works — e.g. the
+public `lerobot/smolvla_base`, or your own ACT/π0 checkpoint on the Hub or a path.
+
+## Preflight — *prove compatibility before any motion*
+
+```bash
+inspect-robots-so101-preflight                          # dims/semantics/cameras/state
+inspect-robots-so101-preflight --task cubepick-reach    # + scene realizability
+inspect-robots-so101-preflight --dry-run                # affirm no motion
+```
+
+A green preflight means action dim (6), control mode (`joint_pos`), cameras, and
+state keys all line up. **It does not prove the joint values are interpreted the
+same way** — see *Safety* below.
+
+## Calibrate first (once, with lerobot)
+
+The embodiment **never** runs lerobot's interactive calibration — connecting with
+an uncalibrated arm would otherwise drop into a *blocking* prompt that moves the
+arm mid-eval. Calibrate once with lerobot's own tool, then tell the config which
+identity you used:
+
+```bash
+lerobot-calibrate --robot.type=so101_follower --robot.port=/dev/ttyACM0 --robot.id=my_follower
+```
+
+`SOArmConfig(robot_id="my_follower")` selects that calibration file
+(`<calibration_dir>/<robot_id>.json`; leave `calibration_dir=None` for lerobot's
+default location). If the arm isn't calibrated — or the file no longer matches
+the motors — `reset()` fails fast with an actionable error instead of prompting.
+
+## Run on hardware
+
+You must point the embodiment at your serial port, calibration id, and camera
+config, and the policy at a checkpoint:
+
+```python
+from inspect_robots import eval
+from inspect_robots.approver import ClampApprover
+from inspect_robots_so101 import LeRobotPolicy, SOArmEmbodiment, SOArmConfig, LeRobotPolicyConfig
+from lerobot.cameras.opencv import OpenCVCameraConfig  # your camera backend
+
+emb = SOArmEmbodiment(SOArmConfig(
+    port="/dev/ttyACM0",
+    robot_type="so101_follower",
+    robot_id="my_follower",    # the id you ran `lerobot-calibrate` with
+    max_relative_target=10.0,  # lerobot's slew limit (deg/step); required for home_pose
+    cameras=("front",),
+    camera_configs={"front": OpenCVCameraConfig(index_or_path=0, width=640, height=480, fps=30)},
+))
+pol = LeRobotPolicy(LeRobotPolicyConfig(
+    pretrained_path="lerobot/smolvla_base", policy_type="smolvla", device="cuda",
+))
+
+with emb:  # guarantees disconnect (and torque-off) even if the eval raises
+    (log,) = eval("cubepick-reach", pol, emb,
+                  approver=ClampApprover(emb.info.action_space))  # defense in depth
+print(log.status, log.results.metrics)
+```
+
+(Equivalently, wrap the `eval(...)` in `try: ... finally: emb.close()`.)
+
+At each episode end the embodiment asks the operator (y/N); a `yes` records
+`termination_reason="success"`, which the task's `success_at_end` scorer reads.
+Unattended runs simply run to `max_steps` and score as failures.
+
+## Safety
+
+- **Hard clamp backstop.** Every command is clipped to `SOArmConfig.joint_low/high`
+  *inside* `step()`, independent of any Inspect Robots `Approver` and on top of LeRobot's
+  own `max_relative_target` slew limit — unclamped model outputs can never reach
+  the motors. **Set these to your real, calibrated SO-ARM joint limits** (the
+  defaults are conservative placeholders: joints ±180°, gripper 0–100).
+- **Use `ClampApprover`** on hardware for a second layer.
+- **Native units, no renormalization.** LeRobot's postprocessor unnormalizes the
+  policy output to the robot's native motor units (degrees for joints, 0–100 for
+  the gripper), so the embodiment commands them verbatim after the clamp. Train
+  and run the policy in the *same* units. `use_degrees=False` (lerobot's
+  normalized ±100 mode) is **rejected** — the state spec and default limits here
+  assume degrees. Also note the units are *degrees* while Inspect Robots's canonical
+  `joint_pos` convention is radians: the compat check compares state **keys**
+  only, so pairing either component with a third-party counterpart will *not*
+  flag a unit mismatch — verify units yourself when mixing stacks.
+- **Homing is slew-limited or refused.** `home_pose` sends a single absolute
+  command, so the config requires `max_relative_target` (LeRobot's per-step slew
+  limit) whenever `home_pose` is set — otherwise the arm would slam to home at
+  full speed from wherever it happens to be.
+- **Absolute vs. delta joints — verify first.** Actions are treated as **absolute**
+  joint targets by default. If your checkpoint emits deltas, set
+  `SOArmConfig(joints_are_delta=True)` (the embodiment converts to absolute
+  internally so the declared `joint_pos` stays honest). The compat check *cannot*
+  tell these apart — confirm with `--dry-run` and a single slow jog before a task.
+
+## Configuration
+
+`SOArmConfig`: `port`, `robot_type`, `robot_id`, `calibration_dir`, `cameras`,
+`camera_configs`, `control_hz`, `cam_height/width`, `joint_low/high`,
+`home_pose` (requires `max_relative_target`), `joints_are_delta`, `use_degrees`
+(must stay `True`), `max_relative_target`, `disable_torque_on_disconnect`.
+`robot_type` is validated (`so101_follower` / `so100_follower`) but is a label:
+at lerobot v0.5.x both names alias the same driver class, so it changes no
+runtime behavior.
+`LeRobotPolicyConfig`: `pretrained_path`, `policy_type`, `device`, `cameras`,
+`state_key`, `chunk_size`, `cam_height/width`.
+
+Scalar knobs are settable from the CLI:
+`inspect-robots run -P pretrained_path=lerobot/smolvla_base -E port=/dev/ttyACM0 ...`.
+
+## Development
+
+```bash
+uv venv && uv pip install -e ".[dev]"     # inspect-robots from a git tag
+uv run pre-commit install
+uv run pytest --cov                        # 100% coverage required
+uv run ruff check . && uv run mypy
+```
+
+The whole suite runs with **no hardware, no GPU, no torch, no lerobot, and no
+stdin** — the SO-ARM driver, the policy inference, the clock, and operator I/O are
+all injected. The real model seam (`_default_predict`) is covered via
+`sys.modules` fakes, and a dedicated `lerobot-seam` CI job (py3.12) imports the
+real lerobot symbols it uses; only direct hardware/TTY I/O keeps
+`# pragma: no cover`.
+
+## License
+
+[MIT](LICENSE)

inspect_robots_so101-0.3.0/pyproject.toml

@@ -0,0 +1,115 @@
+[build-system]
+requires = ["hatchling>=1.18"]
+build-backend = "hatchling.build"
+
+[project]
+name = "inspect-robots-so101"
+version = "0.3.0"
+description = "Inspect Robots adapters for LeRobot SO-ARM followers (SO-100/SO-101) driven by LeRobot policies."
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "RoboCurve" }]
+keywords = ["robotics", "vla", "so-arm", "so100", "so101", "lerobot", "inspect-robots"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Typing :: Typed",
+]
+dependencies = ["inspect-robots>=0.3", "numpy>=1.24"]
+
+[project.optional-dependencies]
+# Real SO-ARM driver + in-process LeRobot policy inference (torch + the checkpoint).
+# `lerobot[feetech]` pulls the Feetech motor bus the SO follower uses. lerobot>=0.5
+# requires Python>=3.12, so the extra is gated to 3.12+ (the numpy-only core still
+# imports on 3.10/3.11 — the hardware extra just isn't installable there). Without
+# this marker `uv`'s universal resolution fails on the 3.10/3.11 splits.
+# Capped <0.6: the inference seam relies on internal-ish lerobot modules
+# (async_inference.helpers, datasets.feature_utils) whose paths already moved once
+# within 0.5.x; the `lerobot-seam` CI job validates the pin before it is raised.
+lerobot = ["lerobot[feetech]>=0.5,<0.6; python_version >= '3.12'"]
+dev = [
+    "pytest>=8.0",
+    "pytest-cov>=5.0",
+    "ruff>=0.6",
+    "mypy>=1.11",
+    "pre-commit>=3.5",
+    # numpy 2.5.0's type stubs use 3.12-only syntax that mypy (python_version 3.10)
+    # rejects; pin the 2.4.x line for a deterministic dev/CI gate (runtime is free).
+    "numpy<2.5",
+]
+
+[project.urls]
+Homepage = "https://github.com/robocurve/inspect-robots-so101"
+Framework = "https://github.com/robocurve/inspect-robots"
+LeRobot = "https://github.com/huggingface/lerobot"
+
+# inspect-robots isn't on PyPI yet — resolve from a tagged GitHub release. lerobot IS on
+# PyPI (the `lerobot` extra above). This is uv-only metadata (stripped from wheels).
+# For local dev against a sibling inspect-robots checkout: uv pip install -e ../inspect-robots
+[tool.uv.sources]
+inspect-robots = { git = "https://github.com/robocurve/inspect-robots", tag = "v0.3.0" }
+
+# Inspect Robots discovers these by entry point — no import needed for `inspect-robots list`.
+[project.entry-points."inspect_robots.embodiments"]
+so_arm = "inspect_robots_so101.embodiment:SOArmEmbodiment"
+
+[project.entry-points."inspect_robots.policies"]
+lerobot = "inspect_robots_so101.policy:LeRobotPolicy"
+
+[project.scripts]
+inspect-robots-so101-preflight = "inspect_robots_so101.preflight:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/inspect_robots_so101"]
+
+[tool.hatch.build.targets.sdist]
+include = ["src/inspect_robots_so101", "tests", "README.md"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+src = ["src", "tests"]
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "I", "UP", "B", "C4", "SIM", "RUF"]
+
+[tool.ruff.lint.isort]
+known-first-party = ["inspect_robots_so101"]
+
+[tool.mypy]
+python_version = "3.10"
+strict = true
+files = ["src/inspect_robots_so101"]
+
+# torch / lerobot are lazily imported behind pragma'd seams and are not test deps;
+# silence mypy's missing-import errors for them (mirrors inspect-robots-isaacsim).
+[[tool.mypy.overrides]]
+module = ["torch.*", "lerobot.*"]
+ignore_missing_imports = true
+
+[tool.pytest.ini_options]
+minversion = "8.0"
+testpaths = ["tests"]
+addopts = "-ra --strict-markers"
+
+[tool.coverage.run]
+branch = true
+source = ["inspect_robots_so101"]
+
+[tool.coverage.report]
+fail_under = 100
+show_missing = true
+exclude_also = [
+    "if TYPE_CHECKING:",
+    "@(abc\\.)?abstractmethod",
+    "raise NotImplementedError",
+    "if __name__ == .__main__.:",
+    "^\\s*\\.\\.\\.$",
+    ": \\.\\.\\.$",
+    "pragma: no cover",
+]

inspect_robots_so101-0.3.0/src/inspect_robots_so101/CLAUDE.md

@@ -0,0 +1,36 @@
+# `inspect_robots_so101` package — module map
+
+Two Inspect Robots components + the glue to make them an honest, testable, safe pair.
+The package is `mypy --strict` clean, ships `py.typed`, and is 100%-covered.
+
+## Modules
+
+| Module | Responsibility |
+|--------|----------------|
+| `packing.py` | **Pure** 6-D SO-ARM packing — the single source of truth for the motor order (`shoulder_pan, shoulder_lift, elbow_flex, wrist_flex, wrist_roll, gripper`) and how the flat vector maps to LeRobot's `"<motor>.pos"` dicts. `to_action_dict`/`from_obs_dict`/`validate_dim`, `STATE_KEY`, `STATE_SPEC`, `MOTORS`. No optional deps. |
+| `config.py` | `SOArmConfig` / `LeRobotPolicyConfig` (frozen, `from_kwargs` for CLI scalars) + shared `action_box()` / `observation_space()` / `ACTION_SEMANTICS` so both components declare an **identical** contract. |
+| `operator.py` | `OperatorIO` (injectable stdin/stdout) for readiness + success prompts; `default_poll_end` (real TTY poll, `# pragma: no cover`). |
+| `policy.py` | `LeRobotPolicy` — wraps a LeRobot checkpoint. `act()` builds the RAW robot payload (`"<motor>.pos"` floats, frames keyed by camera name, `task`), runs the injectable `predict_fn`, truncates to `chunk_size`, returns an `ActionChunk`. Real in-process inference is `_default_predict` (lazy torch + lerobot; obs prep via lerobot's own `raw_observation_to_observation`) — NOT pragma'd: it is covered by `sys.modules`-fake tests, and its real import paths are validated by the `lerobot-seam` CI job. |
+| `embodiment.py` | `SOArmEmbodiment` — LeRobot SO follower driver. Clamp backstop, optional delta→abs, `SELF_PACED` pacing, operator-keypress success, context manager (`with emb:` guarantees `close()`; `close()` clears the handle even if disconnect raises). The driver's `get_observation` yields motor positions **and** cameras. Hardware seam (`_default_driver_factory`) is injected/pragma'd; it connects with `calibrate=False` and fails fast via the tested `_check_calibrated` (never lerobot's blocking interactive calibration). |
+| `preflight.py` | `build` / `run_preflight` + the `inspect-robots-so101-preflight` CLI: run the compat check, print, exit non-zero on errors. |
+| `__init__.py` | Public API fenced by `__all__` (guarded by `tests/test_api_snapshot.py`). |
+
+## Key invariants
+
+- **Contract symmetry:** policy and embodiment build their `action_space` /
+  `observation_space` from the *same* `config.py` helpers. If you change the dim,
+  semantics, camera names, or state key, change them there once — not in two
+  places — or compat breaks.
+- **Construction is inert:** `__init__` touches no hardware/model/stdin (only
+  `.info`). The driver connects, and the model loads, lazily on first use. This is
+  what lets the registry (`factories[name]()`) and preflight construct components
+  freely — and keeps `import inspect_robots_so101` free of torch.
+- **Coverage discipline:** the only uncoverable code is hardware/TTY I/O,
+  isolated in `# pragma: no cover` seams (`_default_driver_factory`,
+  `default_poll_end`, the `_require_driver` pre-reset guard, `__main__`).
+  `_default_predict` is NOT pragma'd — it is exercised with `sys.modules` fakes
+  (see `tests/test_policy.py`), and the `lerobot-seam` CI job imports the real
+  lerobot symbols it relies on. Prefer that pattern (fake the modules, assert the
+  wiring, guard the imports in CI) over new pragmas.
+- **Safety lives in `step()`**, not in an optional Approver — see the root
+  `CLAUDE.md`.

inspect_robots_so101-0.3.0/src/inspect_robots_so101/__init__.py

@@ -0,0 +1,38 @@
+"""inspect-robots-so101 — Inspect Robots adapters for LeRobot SO-ARM followers + LeRobot policies.
+
+Registers two Inspect Robots components via entry points:
+
+* embodiment ``so_arm`` — :class:`~inspect_robots_so101.embodiment.SOArmEmbodiment`
+* policy ``lerobot`` — :class:`~inspect_robots_so101.policy.LeRobotPolicy`
+
+so ``inspect-robots run --task cubepick-reach --policy lerobot --embodiment so_arm``
+works once both packages are installed. Use
+:func:`~inspect_robots_so101.preflight.run_preflight` (or the ``inspect-robots-so101-preflight``
+CLI) to verify compatibility before any motion.
+"""
+
+from __future__ import annotations
+
+from inspect_robots_so101.config import LeRobotPolicyConfig, SOArmConfig
+from inspect_robots_so101.embodiment import SOArmEmbodiment
+from inspect_robots_so101.operator import OperatorIO
+from inspect_robots_so101.packing import MOTORS, STATE_KEY, TOTAL_DIM, from_obs_dict, to_action_dict
+from inspect_robots_so101.policy import LeRobotPolicy
+from inspect_robots_so101.preflight import build, run_preflight
+
+__version__ = "0.3.0"
+
+__all__ = [
+    "MOTORS",
+    "STATE_KEY",
+    "TOTAL_DIM",
+    "LeRobotPolicy",
+    "LeRobotPolicyConfig",
+    "OperatorIO",
+    "SOArmConfig",
+    "SOArmEmbodiment",
+    "build",
+    "from_obs_dict",
+    "run_preflight",
+    "to_action_dict",
+]