bounded-embodiment-kit 0.1.0__tar.gz

bounded_embodiment_kit-0.1.0/.gitignore

@@ -0,0 +1,15 @@
+__pycache__/
+*.py[cod]
+.pytest_cache/
+.ruff_cache/
+.venv/
+venv/
+build/
+dist/
+*.egg-info/
+.coverage
+htmlcov/
+/runs/
+/sessions/
+.claude/
+examples/robots/*/assets/

bounded_embodiment_kit-0.1.0/PKG-INFO

@@ -0,0 +1,39 @@
+Metadata-Version: 2.5
+Name: bounded-embodiment-kit
+Version: 0.1.0
+Summary: The lab bench for the Bounded Embodiment tests: adapters, instruments, the runner and its watchdog.
+Project-URL: Repository, https://github.com/RobotRegistryFoundation/bounded-embodiment
+Author: Craig Merry
+License-Expression: Apache-2.0
+Requires-Python: >=3.10
+Requires-Dist: bounded-embodiment~=0.1.0
+Requires-Dist: numpy>=1.24
+Provides-Extra: camera
+Requires-Dist: opencv-python-headless<4.14,>=4.9; extra == 'camera'
+Provides-Extra: fit
+Requires-Dist: opencv-python-headless<4.14,>=4.9; extra == 'fit'
+Requires-Dist: scipy>=1.10; extra == 'fit'
+Provides-Extra: lerobot
+Requires-Dist: lerobot>=0.6.1; (python_version >= '3.12') and extra == 'lerobot'
+Requires-Dist: pyserial>=3.5; extra == 'lerobot'
+Provides-Extra: oakd
+Requires-Dist: depthai>=2.24; extra == 'oakd'
+Requires-Dist: opencv-python-headless<4.14,>=4.9; extra == 'oakd'
+Provides-Extra: test
+Requires-Dist: pytest>=8; extra == 'test'
+Description-Content-Type: text/markdown
+
+# bounded-embodiment-kit
+
+The lab bench for the Bounded Embodiment tests: adapters (LeRobot SO-10x, a Python template,
+simulators), the runner and its watchdog (`be run`, `be goto-start`, `be doctor`), the OAK-D recorder
+(`be record`), the markerless tracker (`be fit`), the accuracy check (`be instrument`), and packaging
+(`be report`, `be submit`). It adds these commands to core's `be`.
+
+**The adapters, runner and watchdog are a draft that needs line-by-line human review before they
+drive hardware.** The markerless tracker is validated on synthetic recordings only. Method v0.1 is a
+draft for comment; a verdict is never a certification.
+
+Extras: `fit` (the tracker: OpenCV, SciPy), `oakd` (DepthAI), `camera` (OpenCV), `lerobot`.
+
+Start with the lab guide: https://github.com/RobotRegistryFoundation/bounded-embodiment/blob/main/docs/lab-guide.md

bounded_embodiment_kit-0.1.0/README.md

@@ -0,0 +1,14 @@
+# bounded-embodiment-kit
+
+The lab bench for the Bounded Embodiment tests: adapters (LeRobot SO-10x, a Python template,
+simulators), the runner and its watchdog (`be run`, `be goto-start`, `be doctor`), the OAK-D recorder
+(`be record`), the markerless tracker (`be fit`), the accuracy check (`be instrument`), and packaging
+(`be report`, `be submit`). It adds these commands to core's `be`.
+
+**The adapters, runner and watchdog are a draft that needs line-by-line human review before they
+drive hardware.** The markerless tracker is validated on synthetic recordings only. Method v0.1 is a
+draft for comment; a verdict is never a certification.
+
+Extras: `fit` (the tracker: OpenCV, SciPy), `oakd` (DepthAI), `camera` (OpenCV), `lerobot`.
+
+Start with the lab guide: https://github.com/RobotRegistryFoundation/bounded-embodiment/blob/main/docs/lab-guide.md

bounded_embodiment_kit-0.1.0/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["hatchling>=1.25"]
+build-backend = "hatchling.build"
+
+[project]
+name = "bounded-embodiment-kit"
+version = "0.1.0"
+description = "The lab bench for the Bounded Embodiment tests: adapters, instruments, the runner and its watchdog."
+readme = "README.md"
+requires-python = ">=3.10"
+license = "Apache-2.0"
+authors = [{ name = "Craig Merry" }]
+dependencies = ["bounded-embodiment~=0.1.0", "numpy>=1.24"]
+
+[project.optional-dependencies]
+camera = ["opencv-python-headless>=4.9,<4.14"]
+oakd = ["depthai>=2.24", "opencv-python-headless>=4.9,<4.14"]
+fit = ["opencv-python-headless>=4.9,<4.14", "scipy>=1.10"]
+lerobot = ["lerobot>=0.6.1; python_version >= '3.12'", "pyserial>=3.5"]
+test = ["pytest>=8"]
+
+[project.entry-points."bounded_embodiment.cli"]
+kit = "bounded_embodiment_kit.cli:register"
+
+[project.urls]
+Repository = "https://github.com/RobotRegistryFoundation/bounded-embodiment"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/bounded_embodiment_kit"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+markers = [
+  "slow: renders synthetic recordings and fits them end to end, and runs the B6 matrix's 10-minute cases (about ten minutes on two cores); -m 'not slow' leaves them out",
+]

bounded_embodiment_kit-0.1.0/src/bounded_embodiment_kit/__init__.py

@@ -0,0 +1,2 @@
+"""The lab bench for the Bounded Embodiment tests."""
+__version__ = "0.1.0"

bounded_embodiment_kit-0.1.0/src/bounded_embodiment_kit/adapters/__init__.py

@@ -0,0 +1,29 @@
+# SPDX-FileCopyrightText: 2026 Craig Merry and contributors
+# SPDX-License-Identifier: Apache-2.0
+"""Adapters: where the kit hands commands to the system under test (``base`` has the contract).
+
+Each adapter module has ``add_arguments(parser)`` for its own flags and ``from_args(args,
+context)`` to build it. They are imported by name, so LeRobot is never imported unless asked for.
+"""
+from __future__ import annotations
+
+import importlib
+
+from .base import AdapterContext, AdapterError, SendResult, State, check_adapter
+
+__all__ = ["ADAPTERS", "AdapterContext", "AdapterError", "SendResult", "State", "adapter_module",
+           "check_adapter"]
+
+ADAPTERS = {
+    "lerobot": "bounded_embodiment_kit.adapters.lerobot",
+    "python": "bounded_embodiment_kit.adapters.python",
+    "sim-so101": "bounded_embodiment_kit.adapters.sim_so101",
+    "sim-rover": "bounded_embodiment_kit.adapters.sim_rover",
+}
+
+
+def adapter_module(name: str):
+    try:
+        return importlib.import_module(ADAPTERS[name])
+    except KeyError:
+        raise AdapterError(f"unknown adapter {name!r}; known: {', '.join(ADAPTERS)}") from None

bounded_embodiment_kit-0.1.0/src/bounded_embodiment_kit/adapters/base.py

@@ -0,0 +1,192 @@
+# SPDX-FileCopyrightText: 2026 Craig Merry and contributors
+# SPDX-License-Identifier: Apache-2.0
+"""DRAFT — requires line-by-line human review before use on hardware.
+
+The adapter contract: the one place where the kit touches the system under test.
+
+A lab implements an adapter at the point where its model issues commands. Whatever sits behind
+``send()`` (the lab's gate, a LeRobot wrapper Robot, a gateway) is the system under test; the kit
+never looks inside it.
+
+Who calls what, from which thread (the runner relies on this):
+
+=================  =====================  ===================================================
+method             called from            what it may do
+=================  =====================  ===================================================
+``open()``         main thread, once      connect safely; return the declared command space
+``describe()``     any thread             pure data, no I/O
+``send(cmd)``      command thread         hand ``cmd`` to the system under test; never raises
+``read_state()``   command thread         read the robot's own joint state from the bus
+``latch_stop()``   ANY thread             set a flag and return; never touches the bus, never
+                                          blocks (the watchdog calls it)
+``execute_stop()`` command thread         the stop itself, under the bus lock
+``close()``        main thread, once      leave the robot safe (torque stays on unless the
+                                          operator types OFF), release the bus
+=================  =====================  ===================================================
+
+``execute_stop()`` is not in the approved plan's six-method sketch. The plan says "latch_stop()
+sets a latch; the command thread executes the stop under the bus lock"; the command thread needs a
+named entry point for that, and overloading ``send()`` would be cleverness. ``send()`` still
+refuses every command once the latch is set, as a backstop.
+
+Stop rule (lesson 3 of the plan): the goals a stop holds are chosen ONCE per latch (an arm: the
+present positions, read at the first stop, because a joint may be moving) and re-sent unchanged
+on every later stop. A later stop must never re-read and re-anchor to the present (sagging)
+position: on bob that ratcheted the arm down a little on every repeated stop.
+"""
+from __future__ import annotations
+
+import importlib
+import importlib.util
+import math
+import sys
+from collections.abc import Callable, Mapping
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Protocol, runtime_checkable
+
+from bounded_embodiment.commandspace import CommandSpace
+
+__all__ = [
+    "ADAPTER_METHODS",
+    "Adapter",
+    "AdapterContext",
+    "AdapterError",
+    "SendResult",
+    "State",
+    "check_adapter",
+    "clean_text",
+    "load_callable",
+]
+
+#: Every method the runner calls. ``check_adapter`` refuses an object that lacks one.
+ADAPTER_METHODS = ("open", "describe", "send", "read_state", "latch_stop", "execute_stop", "close")
+
+
+class AdapterError(RuntimeError):
+    """The adapter refuses to go on: the message says why and what to do. Raised before motion
+    (open) or when the robot cannot be left safe (close)."""
+
+
+@dataclass(frozen=True)
+class SendResult:
+    """What happened to one command.
+
+    applied     the adapter handed the command to the system under test and the call returned.
+                It says nothing about whether the robot moved: a gate may hold or clamp.
+    decision    the system under test's own word for what it did ("allow", "clamp", ...), if it
+                reports one. Logged in commands.csv, never scored.
+    error_kind  why the command was not applied: "stop_latched", "exception:<Type>", ...
+    """
+
+    applied: bool
+    decision: str | None = None
+    error_kind: str | None = None
+
+
+@dataclass(frozen=True)
+class State:
+    """The robot's own joint state, as its encoders report it.
+
+    joints  joint name -> value in the robot's own units (LeRobot: degrees for the body joints,
+            0..100 for the gripper).
+    units   joint name -> "deg" | "rad" | "percent" | "m" | "m/s" | "rad/s". Forward kinematics
+            uses only deg and rad joints.
+
+    The runner stamps the time; the adapter does not.
+    """
+
+    joints: Mapping[str, float]
+    units: Mapping[str, str] = field(default_factory=dict)
+
+    def finite(self) -> bool:
+        return all(isinstance(v, (int, float)) and math.isfinite(v) for v in self.joints.values())
+
+
+@runtime_checkable
+class Adapter(Protocol):
+    def open(self) -> CommandSpace: ...  # connect safely; the command space comes from a declared file
+    def describe(self) -> dict: ...  # self-description; describe()["config"] goes into the setup hash
+    def send(self, cmd: dict) -> SendResult: ...  # never raises
+    def read_state(self) -> State | None: ...  # None: this adapter has no joint state (no FK tripwire)
+    def latch_stop(self) -> None: ...  # sets a flag; any thread; never touches the bus
+    def execute_stop(self) -> None: ...  # command thread only; same goals every time per latch
+    def close(self) -> None: ...
+
+
+def _stderr(msg: str) -> None:
+    print(msg, file=sys.stderr, flush=True)
+
+
+@dataclass
+class AdapterContext:
+    """What the runner hands an adapter's ``from_args``: the run's files and the operator's I/O.
+
+    ``prompt`` asks a typed question (``input`` on a terminal; tests pass their own) and ``log``
+    prints a line for the operator."""
+
+    command_space_path: Path
+    envelope_path: Path | None = None
+    kit_config_path: Path | None = None
+    kit_config: dict = field(default_factory=dict)
+    urdf_path: Path | None = None
+    mode: str = ""
+    speed_factor: float | None = None
+    prompt: Callable[[str], str] = input
+    log: Callable[[str], None] = _stderr
+
+    def wrapper_context(self) -> dict:
+        """What a lab's wrapper factory receives as ``context``: plain data, no callables.
+        ``speed_factor`` is 0.5 in a shakedown ("at half speed") and None otherwise ("use your
+        own default"); the kit itself never slows or alters a command."""
+
+        def text(p: Path | None) -> str | None:
+            return None if p is None else str(p)
+
+        return {"mode": self.mode, "speed_factor": self.speed_factor,
+                "envelope_path": text(self.envelope_path),
+                "command_space_path": text(self.command_space_path),
+                "kit_config_path": text(self.kit_config_path), "urdf_path": text(self.urdf_path)}
+
+
+def check_adapter(obj: object) -> None:
+    """Refuse an object that does not implement every method the runner calls."""
+    missing = [m for m in ADAPTER_METHODS if not callable(getattr(obj, m, None))]
+    if missing:
+        raise AdapterError(f"{type(obj).__name__} is not an adapter: it lacks {', '.join(missing)}")
+
+
+def clean_text(value: object, limit: int = 64) -> str | None:
+    """A short single-line rendering of a value the system under test reported (for the CSV)."""
+    if value is None:
+        return None
+    text = " ".join(str(value).split())
+    return text[:limit] if text else None
+
+
+def load_callable(spec: str) -> Callable:
+    """``module:name`` or ``path/to/file.py:name`` -> the callable it names.
+
+    Used for the lab's own code (a wrapper factory, a python adapter class). It is imported at run
+    time from a name the operator typed, so the kit never imports a gate statically (import-linter
+    checks that)."""
+    target, sep, name = spec.rpartition(":")
+    if not sep or not target or not name:
+        raise AdapterError(f"{spec!r} is not module:name or path/to/file.py:name")
+    if target.endswith(".py") or "/" in target or "\\" in target:
+        path = Path(target).expanduser().resolve()
+        if not path.is_file():
+            raise AdapterError(f"{path} does not exist")
+        mod_name = f"be_lab_{path.stem}"
+        loader_spec = importlib.util.spec_from_file_location(mod_name, path)
+        if loader_spec is None or loader_spec.loader is None:
+            raise AdapterError(f"cannot import {path}")
+        module = importlib.util.module_from_spec(loader_spec)
+        sys.modules[mod_name] = module
+        loader_spec.loader.exec_module(module)
+    else:
+        module = importlib.import_module(target)
+    obj = getattr(module, name, None)
+    if not callable(obj):
+        raise AdapterError(f"{spec!r}: {name!r} is not a callable in {target!r}")
+    return obj

bounded_embodiment_kit-0.1.0/src/bounded_embodiment_kit/adapters/feetech.py

@@ -0,0 +1,204 @@
+# SPDX-FileCopyrightText: 2026 Craig Merry and contributors
+# SPDX-License-Identifier: Apache-2.0
+"""DRAFT — requires line-by-line human review before use on hardware.
+
+Feetech-bus (SO-100 / SO-101) safety code shared by the ``lerobot`` and ``sim-so101`` adapters.
+
+Everything here talks to a LeRobot ``FeetechMotorsBus`` (or the simulator's stand-in for one)
+through its public methods only: ``connect``, ``disconnect``, ``is_calibrated``, ``sync_read``,
+``sync_write``, ``disable_torque``. Raw values (``normalize=False``) are encoder ticks.
+
+Ported from ev03-harness ``ev03/arm/hw.py`` (reviewed): ``connect_safely``, ``check_bus_is_ours``
+and the typed-OFF part of ``finish``. Changes from hw.py, each for a reason:
+
+- connect_safely reads the goal registers back after syncing them: ``sync_write`` gets no status
+  packet, so a lost packet would otherwise leave a stale goal (bob's read 0 at power-up) for
+  ``configure()`` to drive toward when it enables torque.
+- connect_safely releases the port without touching torque if anything fails after it opened it.
+- check_bus_is_ours returns the problems instead of calling SystemExit, and says so plainly when
+  it cannot scan (no /proc: not Linux) instead of crashing.
+- The typed OFF must be exactly ``OFF`` (hw.py accepted any case). Anything else leaves torque on,
+  which is the safe failure.
+- choose_stop_goals is new. hw.py's ``hold()`` re-anchored EVERY stop to the present position;
+  here the present position is read once, at the first stop of a latch, and every later stop
+  re-sends it (so-arm101-actuator's PR #7 rule, which the plan cites).
+"""
+from __future__ import annotations
+
+import os
+import subprocess
+from collections.abc import Callable, Mapping, Sequence
+
+from .base import AdapterError
+
+__all__ = [
+    "BODY_JOINT_SPEED_TRIP_DPS",
+    "HOLD_WITHIN_TICKS",
+    "check_bus_is_ours",
+    "choose_stop_goals",
+    "connect_safely",
+    "leave_safe",
+    "norm_name",
+]
+
+#: connect_safely: a powered joint whose goal register is within this many encoder ticks of its
+#: position is holding there, and its goal is left alone. 50 ticks is 4.4 deg on a 4096-tick
+#: STS3215: above bob's measured gravity sag plus friction (27 ticks at the shoulder, lifted into
+#: place), well below any real move. (hw.py's value.)
+HOLD_WITHIN_TICKS = 50
+
+#: The SO-101 joint-speed tripwire (hw.py's 150 deg/s). Servos slew at about 270 deg/s, so a body
+#: joint above 150 deg/s over the 0.2 s window is a joint something drove hard, gate or not.
+BODY_JOINT_SPEED_TRIP_DPS = 150.0
+
+
+def norm_name(motor: object) -> str:
+    """A LeRobot Motor's norm mode as text: "DEGREES", "RANGE_0_100" or "RANGE_M100_100"."""
+    mode = getattr(motor, "norm_mode", None)
+    return str(getattr(mode, "name", mode))
+
+
+def _release(bus: object, log: Callable[[str], None]) -> None:
+    """Close the port without touching torque. Never raises: it runs on the way out of an error."""
+    try:
+        if getattr(bus, "is_connected", False):
+            bus.disconnect(disable_torque=False)  # closePort only; no register write
+    except Exception as e:  # noqa: BLE001 - already failing; report and keep the first error
+        log(f"Could not release the port cleanly ({type(e).__name__}: {e}).")
+
+
+def connect_safely(robot: object, *, log: Callable[[str], None],
+                   hold_within_ticks: int = HOLD_WITHIN_TICKS) -> dict:
+    """Connect an SO-10x follower's bus without the arm jumping, then let LeRobot's own
+    ``configure()`` set gains and acceleration and enable torque.
+
+    Why not ``robot.connect()``: it runs ``configure()``, which enables torque toward whatever the
+    goal registers hold, and bob's read 0 at power-up. So the bus is connected here, and every goal
+    register is set to where its joint already is BEFORE torque comes on. If torque is already on
+    and every goal is within ``hold_within_ticks`` of its joint, the arm is holding there and its
+    goals are left alone: rewriting them to the measured (sagging) position would lower the arm by
+    its sag.
+
+    Returns what it found, for the adapter's describe(). Raises AdapterError (port released, torque
+    untouched) if the calibration is missing or does not match the servos, or a goal did not take.
+    """
+    bus = robot.bus
+    if not getattr(robot, "calibration", None):
+        raise AdapterError("No LeRobot calibration file for this robot id. Calibrate with "
+                           "lerobot-calibrate first (or save the servos' own with the harness probe).")
+    body = [m for m in bus.motors if m != "gripper"]
+    wrong = {m: norm_name(bus.motors[m]) for m in body if norm_name(bus.motors[m]) != "DEGREES"}
+    if wrong:
+        raise AdapterError(f"These joints are not in degrees: {wrong}. Build the robot with "
+                           "use_degrees=True; the command space and the joint map are in degrees.")
+    try:
+        bus.connect()  # opens the port and pings the servos; no register write
+        if not bus.is_calibrated:
+            raise AdapterError("The servos' stored calibration differs from the calibration file. "
+                               "Re-run lerobot-calibrate, or use the file that matches the servos.")
+        present = bus.sync_read("Present_Position", normalize=False)
+        goal = bus.sync_read("Goal_Position", normalize=False)
+        torque = bus.sync_read("Torque_Enable", normalize=False)
+        holding = all(torque.get(m) == 1 and abs(goal[m] - present[m]) <= hold_within_ticks
+                      for m in present)
+        if not holding:
+            bus.sync_write("Goal_Position", dict(present), normalize=False)
+            back = bus.sync_read("Goal_Position", normalize=False)
+            off = {m: back.get(m) for m in present if back.get(m) is None or abs(back[m] - present[m]) > 1}
+            if off:
+                raise AdapterError(f"The goal registers did not take the synced positions {off}; "
+                                   "not enabling torque. Check the bus wiring and power.")
+        robot.configure()  # LeRobot's own: torque off, settings, torque on (now toward synced goals)
+    except BaseException:
+        _release(bus, log)
+        raise
+    log("Connected: " + ("the arm was already holding; goals left as they were." if holding
+                         else "goal registers set to the present positions before torque."))
+    return {"holding_at_connect": holding, "goals_synced_to_present": not holding,
+            "torque_at_connect": dict(torque)}
+
+
+def choose_stop_goals(present_raw: Mapping[str, int]) -> dict[str, int]:
+    """The goals a stop holds: every joint's present position, read at the FIRST stop of a latch.
+    The caller keeps them and re-sends exactly these on every later stop of the same latch.
+
+    Why the present position, once: the joint may be moving (perhaps toward a hostile goal), so the
+    first stop has to stop it where it is. A loaded joint then settles one sag below that goal.
+    Why never again: reading the (sagged) position on every repeated stop re-anchors the goal lower
+    each time, and the arm ratchets down (bob; so-arm101-actuator's estop before its PR #7).
+
+    Rejected alternative: keeping a joint's goal register when it is within a few degrees. That
+    removes even the single sag for an arm holding still, but a joint still travelling the last
+    few degrees to its goal runs on after the stop; in the simulator that kept the tool moving past
+    the 0.25 s acknowledgement window, which escalates. docs/seams/runner.md has the numbers.
+    """
+    return {m: int(p) for m, p in present_raw.items()}
+
+
+def check_bus_is_ours(port: str, services: Sequence[str] = ()) -> list[str]:
+    """Problems that mean something else could command the arm: a process holding the serial port
+    open, or a named service that is running (a service may open the port only when it gets a
+    request, so an idle one does not show up as holding it; name it with --refuse-while-active).
+
+    Linux only (it reads /proc). Elsewhere it reports that it could not check, which the adapter
+    treats as a refusal."""
+    problems: list[str] = []
+    if not os.path.isdir("/proc"):
+        return [f"cannot check who holds {port}: no /proc on this system (the scan is Linux-only)"]
+    real = os.path.realpath(port)
+    me = os.getpid()
+    for pid in filter(str.isdigit, os.listdir("/proc")):
+        if int(pid) == me:
+            continue
+        try:
+            fds = os.listdir(f"/proc/{pid}/fd")
+        except OSError:
+            continue
+        for fd in fds:
+            try:
+                if os.path.realpath(f"/proc/{pid}/fd/{fd}") != real:
+                    continue
+                with open(f"/proc/{pid}/cmdline", "rb") as fh:
+                    cmd = fh.read().replace(b"\0", b" ").decode(errors="replace")[:120]
+                problems.append(f"process {pid} has {port} open: {cmd}")
+                break
+            except OSError:
+                continue
+    for unit in services:
+        for scope in (["--user"], []):
+            try:
+                r = subprocess.run(["systemctl", *scope, "is-active", unit], capture_output=True,
+                                   text=True, timeout=10, check=False)
+            except (FileNotFoundError, subprocess.TimeoutExpired) as e:
+                problems.append(f"cannot check {unit}: {type(e).__name__}")
+                break
+            if r.stdout.strip() == "active":
+                where = "user" if scope else "system"
+                stop = " ".join([*scope, "stop", unit])
+                problems.append(f"{where} service {unit} is running (systemctl {stop})")
+    return problems
+
+
+def leave_safe(bus: object, prompt: Callable[[str], str], log: Callable[[str], None]) -> str:
+    """Ask before turning torque off, then release the port without touching torque.
+
+    Only a typed ``OFF`` turns torque off (the arm goes limp: support it first). Just Enter, any
+    other answer, or end of input leaves torque on and the arm holding its last goal. LeRobot's
+    own ``robot.disconnect()`` is never used: ``disable_torque_on_disconnect`` defaults to True and
+    would drop the arm. Returns "torque_off" or "torque_on"."""
+    try:
+        answer = prompt("Support the arm, then type OFF and Enter to turn torque off (it goes limp), "
+                        "or just Enter to leave torque on: ")
+    except EOFError:
+        answer = ""
+    outcome = "torque_on"
+    try:
+        if answer.strip() == "OFF":
+            bus.disable_torque()
+            outcome = "torque_off"
+            log("Torque off.")
+        else:
+            log("Torque left on; the arm holds its last goal.")
+    finally:
+        _release(bus, log)
+    return outcome