griip-sdk-dev 0.4.0.dev24238__tar.gz → 0.6.0.dev25546__tar.gz

griip_sdk_dev-0.4.0.dev24238/README.md → griip_sdk_dev-0.6.0.dev25546/PKG-INFO

@@ -1,3 +1,36 @@
+Metadata-Version: 2.5
+Name: griip-sdk-dev
+Version: 0.6.0.dev25546
+Summary: Dev build of griip-sdk from commit 0af7ee671 (PR #6192). Not a release.
+Author: VentionCo
+License: Proprietary
+Requires-Python: <3.13,>=3.10
+Requires-Dist: defusedxml<0.8.0,>=0.7.1
+Requires-Dist: fastapi[standard]>=0.121.1
+Requires-Dist: foxglove-schemas-protobuf
+Requires-Dist: griip-core-dev==0.5.6.dev25546
+Requires-Dist: grpcio>=1.78.0
+Requires-Dist: httpx[http2]<0.29.0,>=0.28.1
+Requires-Dist: mcap-protobuf-support<1.0,>=0.4.0
+Requires-Dist: mcap<2.0,>=1.3.0
+Requires-Dist: numpy>=1.24
+Requires-Dist: omegaconf<3.0.0,>=2.3.0
+Requires-Dist: opencv-python-headless<5.0.0,>=4.9.0
+Requires-Dist: paho-mqtt<2.0,>=1.5
+Requires-Dist: protobuf>=4.0
+Requires-Dist: pydantic==2.11.1
+Requires-Dist: pymodbus==3.11
+Requires-Dist: pyserial<4.0,>=3.5
+Requires-Dist: pyyaml<7.0,>=6.0
+Requires-Dist: scipy<2.0,>=1.11.0
+Requires-Dist: spatialmath-python<2.0.0,>=1.1.15
+Requires-Dist: toppra<=0.6.3,>=0.6.0
+Requires-Dist: trimesh<5.0,>=4.11
+Requires-Dist: urchin<0.0.31,>=0.0.30
+Requires-Dist: vention-grpc-py-sdk>=0.0.72
+Requires-Dist: vention-sim-grpc-py-sdk==0.1.3
+Description-Content-Type: text/markdown
+
 # griip-sdk
 
 Hardware control and orchestration for bin picking, by [Vention](https://vention.io).
@@ -257,12 +290,12 @@ hardware connections.
 
 For a cell where the application moves the robot itself. The SDK takes and
 stores pictures, runs perception on a stored picture when asked, and keeps
-one queue of ranked grasp poses. It never commands motion.
+one queue of ranked grasps. It never commands motion.
 
 ```python
 from griip_sdk import build_grasp_provider
 
-with build_grasp_provider("pick.yaml", part_id="smallest_splice") as sdk:
+with build_grasp_provider("pick.yaml", part_id="smallest_splice", robot=MyRmiRobot(rmi)) as sdk:
     # First round: one picture of each pallet, then start on the left.
     move_robot_to(LEFT_CAPTURE_POSE)     # your motion
     sdk.capture("left")                  # take a picture now, store it as "left"
@@ -272,29 +305,27 @@ with build_grasp_provider("pick.yaml", part_id="smallest_splice") as sdk:
 
     while True:
         # Left pallet
-        target = sdk.next_target()       # wait for the "left" run, pop its best pose; None = nothing graspable
+        target = sdk.next_target()       # wait for the "left" run, pop its best reachable grasp; None = nothing graspable
         sdk.process("right")             # start perception on the "right" picture; it runs during the steps below
         picked_left = target is not None
         if picked_left:
-            pose = target.flange_pose_mm_deg   # [x, y, z, rx, ry, rz], mm and degrees, as on the pendant
-            move_robot_to(approach(pose))
-            move_robot_to(pose)
+            move_robot_to(target.approach_pose_mm_deg)   # [x, y, z, w, p, r], mm and degrees, as on the pendant
+            move_linear(target.grasp_pose_mm_deg)        # straight in along the tool Z
             close_gripper()
-            move_robot_to(approach(pose))
+            move_linear(target.approach_pose_mm_deg)     # straight back out
             sdk.capture("left")          # new picture of the left pallet for the next round, taken now
             move_robot_to(PLACE_POSE)
             open_gripper()
 
         # Right pallet
-        target = sdk.next_target()       # wait for the "right" run, pop its best pose
+        target = sdk.next_target()       # wait for the "right" run, pop its best reachable grasp
         sdk.process("left")              # start perception on the new "left" picture; runs while we pick right
         picked_right = target is not None
         if picked_right:
-            pose = target.flange_pose_mm_deg
-            move_robot_to(approach(pose))
-            move_robot_to(pose)
+            move_robot_to(target.approach_pose_mm_deg)
+            move_linear(target.grasp_pose_mm_deg)
             close_gripper()
-            move_robot_to(approach(pose))
+            move_linear(target.approach_pose_mm_deg)
             sdk.capture("right")         # new picture of the right pallet for the next round
             move_robot_to(PLACE_POSE)
             open_gripper()
@@ -303,12 +334,12 @@ with build_grasp_provider("pick.yaml", part_id="smallest_splice") as sdk:
             break                        # both pallets came back empty
 ```
 
-Five verbs. `capture(tag)` stores a picture with the robot pose at that
-moment, so park the robot first; the tag is any string you choose, one
+Five verbs. `capture(tag)` stores a picture with the robot pose and joints at
+that moment, so park the robot first; the tag is any string you choose, one
 stored picture per tag. `captures()` lists the stored pictures, `delete(tag)`
 removes one. `process(tag)` runs perception on a stored picture in the
 background, one image at a time. `next_target(timeout=None)` waits for
-in-flight runs and pops the best pose; it returns `None` when the last
+in-flight runs and pops the best grasp; it returns `None` when the last
 picture had nothing graspable, when the run failed (`captures()` carries the
 state and the reason), or on timeout.
 
@@ -318,22 +349,24 @@ picture is dropped.
 
 Each `GraspTarget` answers what a motion-owning app needs to know:
 
-- `capture_tag` says which picture, and therefore which pallet, it came from.
-- Several come back per picture, ranked by `priority`, at most
-  `picking.max_detections × picking.max_grasps_per_object`.
-- `flange_pose` and `tcp_pose` are the same target in the world / robot base
-  frame, the frame the robot reports (the camera pose is built from it and the
-  hand-eye calibration). `flange_pose = tcp_pose · X_tcp_flg⁻¹`, where
-  `X_tcp_flg` is the translation `tool.tcp_offset`, returned as `tcp_offset`.
-- `flange_pose_mm_deg` and `tcp_pose_mm_deg` are the same poses as
-  `[x, y, z, rx, ry, rz]`: millimetres, and degrees of roll, pitch, yaw about
-  X, Y then Z, the convention the pendant shows. The `SE3` forms stay in metres
-  for code that composes transforms.
+- `capture_tag` says which picture, and therefore which pallet, it came from;
+  `object_index` which part in it. Several grasps can come back per part.
+- `approach_pose` is where to go first; `grasp_pose` is where the gripper
+  closes, `approach_offset` (from the grasp definition) further along the tool
+  Z. Both are TCP poses in the robot base frame. `approach_pose_mm_deg` /
+  `grasp_pose_mm_deg` give them as `[x, y, z, w, p, r]`: millimetres, and
+  degrees about X, Y then Z, the pendant convention. The `SE3` forms stay in
+  metres for code that composes transforms.
+- `at_flange(pose)` converts either one for a controller whose TCP is the
+  flange (`tool.tcp_offset` is returned as `tcp_offset`).
+- `plunge_pose` / `scoop_pose` are the SDK's own guarded-scoop phases. The
+  scoop can end past the grasp point, so never move to it without a force stop.
+- `approach_joint_angles` / `grasp_joint_angles` are your robot's IK solutions
+  when it checked the grasp (see below).
 
 Same `pick.yaml` as a self-driving cell: part, grasps, `tool.tcp_offset`,
 camera, hand-eye. No `home_bin*` poses are needed; the capture pose is
-whatever the robot reports. The robot must be registered in VRMCS, where
-reachability is checked. No gripper is built or actuated.
+whatever the robot reports. No gripper is built or actuated.
 
 Only if the pictures show a container with walls: `capture(tag, bin_number=N)`
 attaches the `bin_N_*` cuboids from `cuboids.json` to the request so grasps
@@ -341,6 +374,60 @@ through a wall or below the floor are rejected. `N` must be listed in
 `runtime.bins.available`. It is not a taught pose. Open pallets need none of
 this.
 
+### Your own robot (no VRMCS)
+
+When the app owns the robot, say a Fanuc over RMI, set `robot.driver: external`
+in `pick.yaml` (`robot.model` names the arm) and pass any object with these
+three methods, in pendant units. The SDK opens no connection of its own.
+
+```python
+class MyRmiRobot:
+    def __init__(self, rmi):
+        self._rmi = rmi              # your RMI session; the SDK never opens one
+
+    def get_tcp_pose(self) -> list[float]:
+        # Current TCP in UFrame 0, active UTool, [x, y, z, w, p, r] in mm and degrees.
+        return self._rmi.read_cartesian_position()
+
+    def get_joint_angles(self) -> list[float]:
+        # Any units: the SDK only hands them back to inverse_kinematics as the seed.
+        return self._rmi.read_joint_angles()
+
+    def inverse_kinematics(self, tcp_pose: list[float], seed_joint_angles: list[float]) -> list[float] | None:
+        # None only when tcp_pose is unreachable; raise for anything else (not ready, comms).
+        return self._rmi.inverse_kinematics(tcp_pose, seed_joint_angles)
+
+
+with build_grasp_provider("pick.yaml", part_id="smallest_splice", robot=MyRmiRobot(rmi)) as sdk:
+    assert rmi.active_utool_offset_mm() == sdk.tcp_offset_mm   # optional: check the controller tool once
+    ...
+```
+
+- **Threads.** The SDK calls these methods only on the thread that called
+  `capture` (`get_tcp_pose`, `get_joint_angles`) or `next_target`, never
+  from a background thread, so they serialize with the app's motion if the app
+  calls them between moves. Call them while the arm moves and they need the
+  app's robot lock.
+- **Calls per `next_target`.** One `get_joint_angles`, then two
+  `inverse_kinematics` for the grasp it returns (approach, then grasp). Each
+  skipped candidate adds one or two.
+- **Seeds.** The approach is seeded with the current joints read at the start
+  of that `next_target`; the grasp with the approach solution, the
+  configuration the arm is in when it starts the straight move. Both come from
+  your robot, in your units.
+- **Errors.** `None` drops that candidate as unreachable. An exception from
+  your robot propagates out of `next_target` and the candidate stays at the
+  front of the queue for the next call.
+- **Frames.** Poses are TCP poses in the robot base frame (UFrame 0) at
+  `tool.tcp_offset`, which `sdk.tcp_offset_mm` returns; the active UTool must
+  match it, or use UTool 0 with `target.at_flange(...)`.
+
+With an external robot nothing talks to VRMCS. The server skips its IK,
+collision and path-planning stages and sends every grasp that clears the bin
+walls; `next_target` drops what your IK can't reach and attaches both
+solutions (`approach_joint_angles`, `grasp_joint_angles`). Arm-link collisions
+are not checked: approach and retreat safety are the app's.
+
 ## Calibration
 
 The SDK exposes the two calibration primitives — hand-eye and
@@ -362,6 +449,17 @@ The SDK plans to `cell.positions.calibration_joints`, runs the bundled sphere
 routine, returns the robot to that start pose, and persists the result. The
 fuller form below adds progress reporting and the operator-driven scan session:
 
+On a cell with `robot.driver: external`, pass the app's `CalibrationRobot`: a
+`GraspRobot` plus `execute_joint_path(waypoints)`. VAMP still plans every
+move for `robot.model`, in-process, and your robot executes the path; joints
+are radians in the robot model's convention here. Environment scanning needs
+freedrive and is not available on an external robot.
+
+```python
+with build_calibration_app("cell.yaml", robot=MyRmiCalibrationRobot(rmi)) as cal:
+    x_cam_flg = cal.run_hand_eye_calibration()
+```
+
 ```python
 from pathlib import Path
 

griip_sdk_dev-0.4.0.dev24238/PKG-INFO → griip_sdk_dev-0.6.0.dev25546/README.md

@@ -1,35 +1,3 @@
-Metadata-Version: 2.5
-Name: griip-sdk-dev
-Version: 0.4.0.dev24238
-Summary: Dev build of griip-sdk from commit 920520032 (PR #6192). Not a release.
-Author: VentionCo
-License: Proprietary
-Requires-Python: <3.11,>=3.10
-Requires-Dist: defusedxml<0.8.0,>=0.7.1
-Requires-Dist: fastapi[standard]>=0.121.1
-Requires-Dist: foxglove-schemas-protobuf
-Requires-Dist: griip-core>=0.4.0
-Requires-Dist: grpcio>=1.78.0
-Requires-Dist: httpx[http2]<0.29.0,>=0.28.1
-Requires-Dist: mcap-protobuf-support<1.0,>=0.4.0
-Requires-Dist: mcap<2.0,>=1.3.0
-Requires-Dist: numpy>=1.24
-Requires-Dist: omegaconf<3.0.0,>=2.3.0
-Requires-Dist: opencv-python-headless<5.0.0,>=4.9.0
-Requires-Dist: paho-mqtt<2.0,>=1.5
-Requires-Dist: protobuf>=4.0
-Requires-Dist: pydantic==2.11.1
-Requires-Dist: pymodbus==3.11
-Requires-Dist: pyserial<4.0,>=3.5
-Requires-Dist: pyyaml<7.0,>=6.0
-Requires-Dist: scipy<2.0,>=1.11.0
-Requires-Dist: spatialmath-python<2.0.0,>=1.1.15
-Requires-Dist: toppra<=0.6.3,>=0.6.0
-Requires-Dist: trimesh<5.0,>=4.11
-Requires-Dist: urchin<0.0.31,>=0.0.30
-Requires-Dist: vention-grpc-py-sdk==0.0.67.dev34389318765
-Description-Content-Type: text/markdown
-
 # griip-sdk
 
 Hardware control and orchestration for bin picking, by [Vention](https://vention.io).
@@ -289,12 +257,12 @@ hardware connections.
 
 For a cell where the application moves the robot itself. The SDK takes and
 stores pictures, runs perception on a stored picture when asked, and keeps
-one queue of ranked grasp poses. It never commands motion.
+one queue of ranked grasps. It never commands motion.
 
 ```python
 from griip_sdk import build_grasp_provider
 
-with build_grasp_provider("pick.yaml", part_id="smallest_splice") as sdk:
+with build_grasp_provider("pick.yaml", part_id="smallest_splice", robot=MyRmiRobot(rmi)) as sdk:
     # First round: one picture of each pallet, then start on the left.
     move_robot_to(LEFT_CAPTURE_POSE)     # your motion
     sdk.capture("left")                  # take a picture now, store it as "left"
@@ -304,29 +272,27 @@ with build_grasp_provider("pick.yaml", part_id="smallest_splice") as sdk:
 
     while True:
         # Left pallet
-        target = sdk.next_target()       # wait for the "left" run, pop its best pose; None = nothing graspable
+        target = sdk.next_target()       # wait for the "left" run, pop its best reachable grasp; None = nothing graspable
         sdk.process("right")             # start perception on the "right" picture; it runs during the steps below
         picked_left = target is not None
         if picked_left:
-            pose = target.flange_pose_mm_deg   # [x, y, z, rx, ry, rz], mm and degrees, as on the pendant
-            move_robot_to(approach(pose))
-            move_robot_to(pose)
+            move_robot_to(target.approach_pose_mm_deg)   # [x, y, z, w, p, r], mm and degrees, as on the pendant
+            move_linear(target.grasp_pose_mm_deg)        # straight in along the tool Z
             close_gripper()
-            move_robot_to(approach(pose))
+            move_linear(target.approach_pose_mm_deg)     # straight back out
             sdk.capture("left")          # new picture of the left pallet for the next round, taken now
             move_robot_to(PLACE_POSE)
             open_gripper()
 
         # Right pallet
-        target = sdk.next_target()       # wait for the "right" run, pop its best pose
+        target = sdk.next_target()       # wait for the "right" run, pop its best reachable grasp
         sdk.process("left")              # start perception on the new "left" picture; runs while we pick right
         picked_right = target is not None
         if picked_right:
-            pose = target.flange_pose_mm_deg
-            move_robot_to(approach(pose))
-            move_robot_to(pose)
+            move_robot_to(target.approach_pose_mm_deg)
+            move_linear(target.grasp_pose_mm_deg)
             close_gripper()
-            move_robot_to(approach(pose))
+            move_linear(target.approach_pose_mm_deg)
             sdk.capture("right")         # new picture of the right pallet for the next round
             move_robot_to(PLACE_POSE)
             open_gripper()
@@ -335,12 +301,12 @@ with build_grasp_provider("pick.yaml", part_id="smallest_splice") as sdk:
             break                        # both pallets came back empty
 ```
 
-Five verbs. `capture(tag)` stores a picture with the robot pose at that
-moment, so park the robot first; the tag is any string you choose, one
+Five verbs. `capture(tag)` stores a picture with the robot pose and joints at
+that moment, so park the robot first; the tag is any string you choose, one
 stored picture per tag. `captures()` lists the stored pictures, `delete(tag)`
 removes one. `process(tag)` runs perception on a stored picture in the
 background, one image at a time. `next_target(timeout=None)` waits for
-in-flight runs and pops the best pose; it returns `None` when the last
+in-flight runs and pops the best grasp; it returns `None` when the last
 picture had nothing graspable, when the run failed (`captures()` carries the
 state and the reason), or on timeout.
 
@@ -350,22 +316,24 @@ picture is dropped.
 
 Each `GraspTarget` answers what a motion-owning app needs to know:
 
-- `capture_tag` says which picture, and therefore which pallet, it came from.
-- Several come back per picture, ranked by `priority`, at most
-  `picking.max_detections × picking.max_grasps_per_object`.
-- `flange_pose` and `tcp_pose` are the same target in the world / robot base
-  frame, the frame the robot reports (the camera pose is built from it and the
-  hand-eye calibration). `flange_pose = tcp_pose · X_tcp_flg⁻¹`, where
-  `X_tcp_flg` is the translation `tool.tcp_offset`, returned as `tcp_offset`.
-- `flange_pose_mm_deg` and `tcp_pose_mm_deg` are the same poses as
-  `[x, y, z, rx, ry, rz]`: millimetres, and degrees of roll, pitch, yaw about
-  X, Y then Z, the convention the pendant shows. The `SE3` forms stay in metres
-  for code that composes transforms.
+- `capture_tag` says which picture, and therefore which pallet, it came from;
+  `object_index` which part in it. Several grasps can come back per part.
+- `approach_pose` is where to go first; `grasp_pose` is where the gripper
+  closes, `approach_offset` (from the grasp definition) further along the tool
+  Z. Both are TCP poses in the robot base frame. `approach_pose_mm_deg` /
+  `grasp_pose_mm_deg` give them as `[x, y, z, w, p, r]`: millimetres, and
+  degrees about X, Y then Z, the pendant convention. The `SE3` forms stay in
+  metres for code that composes transforms.
+- `at_flange(pose)` converts either one for a controller whose TCP is the
+  flange (`tool.tcp_offset` is returned as `tcp_offset`).
+- `plunge_pose` / `scoop_pose` are the SDK's own guarded-scoop phases. The
+  scoop can end past the grasp point, so never move to it without a force stop.
+- `approach_joint_angles` / `grasp_joint_angles` are your robot's IK solutions
+  when it checked the grasp (see below).
 
 Same `pick.yaml` as a self-driving cell: part, grasps, `tool.tcp_offset`,
 camera, hand-eye. No `home_bin*` poses are needed; the capture pose is
-whatever the robot reports. The robot must be registered in VRMCS, where
-reachability is checked. No gripper is built or actuated.
+whatever the robot reports. No gripper is built or actuated.
 
 Only if the pictures show a container with walls: `capture(tag, bin_number=N)`
 attaches the `bin_N_*` cuboids from `cuboids.json` to the request so grasps
@@ -373,6 +341,60 @@ through a wall or below the floor are rejected. `N` must be listed in
 `runtime.bins.available`. It is not a taught pose. Open pallets need none of
 this.
 
+### Your own robot (no VRMCS)
+
+When the app owns the robot, say a Fanuc over RMI, set `robot.driver: external`
+in `pick.yaml` (`robot.model` names the arm) and pass any object with these
+three methods, in pendant units. The SDK opens no connection of its own.
+
+```python
+class MyRmiRobot:
+    def __init__(self, rmi):
+        self._rmi = rmi              # your RMI session; the SDK never opens one
+
+    def get_tcp_pose(self) -> list[float]:
+        # Current TCP in UFrame 0, active UTool, [x, y, z, w, p, r] in mm and degrees.
+        return self._rmi.read_cartesian_position()
+
+    def get_joint_angles(self) -> list[float]:
+        # Any units: the SDK only hands them back to inverse_kinematics as the seed.
+        return self._rmi.read_joint_angles()
+
+    def inverse_kinematics(self, tcp_pose: list[float], seed_joint_angles: list[float]) -> list[float] | None:
+        # None only when tcp_pose is unreachable; raise for anything else (not ready, comms).
+        return self._rmi.inverse_kinematics(tcp_pose, seed_joint_angles)
+
+
+with build_grasp_provider("pick.yaml", part_id="smallest_splice", robot=MyRmiRobot(rmi)) as sdk:
+    assert rmi.active_utool_offset_mm() == sdk.tcp_offset_mm   # optional: check the controller tool once
+    ...
+```
+
+- **Threads.** The SDK calls these methods only on the thread that called
+  `capture` (`get_tcp_pose`, `get_joint_angles`) or `next_target`, never
+  from a background thread, so they serialize with the app's motion if the app
+  calls them between moves. Call them while the arm moves and they need the
+  app's robot lock.
+- **Calls per `next_target`.** One `get_joint_angles`, then two
+  `inverse_kinematics` for the grasp it returns (approach, then grasp). Each
+  skipped candidate adds one or two.
+- **Seeds.** The approach is seeded with the current joints read at the start
+  of that `next_target`; the grasp with the approach solution, the
+  configuration the arm is in when it starts the straight move. Both come from
+  your robot, in your units.
+- **Errors.** `None` drops that candidate as unreachable. An exception from
+  your robot propagates out of `next_target` and the candidate stays at the
+  front of the queue for the next call.
+- **Frames.** Poses are TCP poses in the robot base frame (UFrame 0) at
+  `tool.tcp_offset`, which `sdk.tcp_offset_mm` returns; the active UTool must
+  match it, or use UTool 0 with `target.at_flange(...)`.
+
+With an external robot nothing talks to VRMCS. The server skips its IK,
+collision and path-planning stages and sends every grasp that clears the bin
+walls; `next_target` drops what your IK can't reach and attaches both
+solutions (`approach_joint_angles`, `grasp_joint_angles`). Arm-link collisions
+are not checked: approach and retreat safety are the app's.
+
 ## Calibration
 
 The SDK exposes the two calibration primitives — hand-eye and
@@ -394,6 +416,17 @@ The SDK plans to `cell.positions.calibration_joints`, runs the bundled sphere
 routine, returns the robot to that start pose, and persists the result. The
 fuller form below adds progress reporting and the operator-driven scan session:
 
+On a cell with `robot.driver: external`, pass the app's `CalibrationRobot`: a
+`GraspRobot` plus `execute_joint_path(waypoints)`. VAMP still plans every
+move for `robot.model`, in-process, and your robot executes the path; joints
+are radians in the robot model's convention here. Environment scanning needs
+freedrive and is not available on an external robot.
+
+```python
+with build_calibration_app("cell.yaml", robot=MyRmiCalibrationRobot(rmi)) as cal:
+    x_cam_flg = cal.run_hand_eye_calibration()
+```
+
 ```python
 from pathlib import Path
 

{griip_sdk_dev-0.4.0.dev24238 → griip_sdk_dev-0.6.0.dev25546}/project.json

@@ -26,8 +26,9 @@
     "lint": {
       "executor": "@nxlv/python:run-commands",
       "options": {
-        "command": "uv run ruff check src/",
-        "cwd": "projects/physical-ai/libs/griip-sdk"
+        "cwd": "projects/physical-ai/libs/griip-sdk",
+        "commands": ["uv run ruff check src/", "uv run ruff format --check src/"],
+        "parallel": false
       }
     },
     "typecheck": {

{griip_sdk_dev-0.4.0.dev24238 → griip_sdk_dev-0.6.0.dev25546}/pyproject.toml

@@ -2,12 +2,12 @@ dependency-groups = { }
 
 [project]
 name = "griip-sdk-dev"
-version = "0.4.0.dev24238"
-description = "Dev build of griip-sdk from commit 920520032 (PR #6192). Not a release."
+version = "0.6.0.dev25546"
+description = "Dev build of griip-sdk from commit 0af7ee671 (PR #6192). Not a release."
 readme = "README.md"
-requires-python = ">=3.10,<3.11"
+requires-python = ">=3.10,<3.13"
 dependencies = [
-  "griip-core>=0.4.0",
+  "griip-core-dev==0.5.6.dev25546",
   "grpcio>=1.78.0",
   "numpy>=1.24",
   "protobuf>=4.0",
@@ -28,7 +28,8 @@ dependencies = [
   "foxglove-schemas-protobuf",
   "mcap>=1.3.0,<2.0",
   "mcap-protobuf-support>=0.4.0,<1.0",
-  "vention-grpc-py-sdk==0.0.67.dev34389318765",
+  "vention-grpc-py-sdk>=0.0.72",
+  "vention-sim-grpc-py-sdk==0.1.3",
   "fastapi[standard]>=0.121.1"
 ]
 

{griip_sdk_dev-0.4.0.dev24238 → griip_sdk_dev-0.6.0.dev25546}/src/griip_sdk/__init__.py

@@ -20,6 +20,7 @@ from griip_sdk.hardware.gripper import (
     SuctionGripper,
     ThreeFingerGripper,
 )
+from griip_sdk.hardware.robot_interface import CalibrationRobot, GraspRobot
 from griip_sdk.orchestration.bin_picking_manager import BinPickingManager
 from griip_sdk.orchestration.grasp_provider import GraspProvider
 from griip_sdk.orchestration.pick_and_place_manager import SingleCyclePickAndPlaceManager
@@ -49,10 +50,12 @@ __all__ = [
     "build_grasp_provider",
     "build_pick_only_manager",
     "CalibrationApp",
+    "CalibrationRobot",
     "CaptureInfo",
     "ConfigError",
     "Cuboid",
     "GraspProvider",
+    "GraspRobot",
     "GraspTarget",
     "GripperMoveResult",
     "list_available_parts",

{griip_sdk_dev-0.4.0.dev24238 → griip_sdk_dev-0.6.0.dev25546}/src/griip_sdk/calibration/app.py

@@ -22,9 +22,9 @@ import grpc
 import numpy as np
 import numpy.typing as npt
 from spatialmath import SE3, SO3
-from vention.vision.v1.vision_service_abc import ImageServiceBackend
 
 from griip_sdk.calibration.camera_factory import build_calibration_camera
+from griip_sdk.calibration.external_robot import ExternalCalibrationRobotClient
 from griip_sdk.calibration.config_store import (
     DEFAULT_CALIBRATION_DATA_PATH,
     CalibrationConfigStore,
@@ -53,9 +53,12 @@ from griip_sdk.cell.config import PrototypeCellConfig
 from griip_sdk.cell.initialize import build_robot_initialize_request, send_initialize
 from griip_sdk.errors import ConfigError
 from griip_core.generated import griip_pb2 as pb
+from griip_core.robot_drivers import EXTERNAL_ROBOT_DRIVER
 from griip_core.generated import griip_pb2_grpc
 from griip_sdk.grpc_adapters.servicer_as_stub import ServicerAsStub
 from griip_sdk.hardware.robot_client import VrmcsRobotClient, build_vrmcs_client
+from griip_sdk.hardware.robot_interface import CalibrationRobot
+from griip_sdk.hardware.vision_backend import VisionServiceBackend
 
 logger = logging.getLogger(__name__)
 
@@ -74,7 +77,7 @@ class CalibrationApp:
         cell: PrototypeCellConfig,
         config_path: Path,
         robot_client: VrmcsRobotClient,
-        vision_backend: ImageServiceBackend,
+        vision_backend: VisionServiceBackend,
         cam_name: str,
         camera_mxid: str,
         sensor: str,
@@ -545,6 +548,7 @@ def build_calibration_app(
     mqtt_host: str | None = "localhost",
     mqtt_port: int = 1883,
     strict_intrinsics: bool = True,
+    robot: CalibrationRobot | None = None,
 ) -> Iterator[CalibrationApp]:
     """Yield a wired :class:`CalibrationApp` for the cell at ``cell_yaml``.
 
@@ -571,6 +575,11 @@ def build_calibration_app(
         strict_intrinsics: when ``True`` (default), missing calibio intrinsics
             raise :class:`FileNotFoundError`; ``False`` falls back to live
             ``camera_info`` (camera-swap escape hatch).
+        robot: the app's own robot, required when ``robot.driver`` is
+            ``external``. Nothing talks to VRMCS: reads, IK and path execution
+            go through it, and VAMP plans in-process for ``robot.model`` in
+            either API mode, since the server has no planner for such a robot.
+            Joints are radians in the robot model's convention.
     """
     resolved_path = Path(cell_yaml).expanduser().resolve()
     cell = load_cell_config(resolved_path)
@@ -583,7 +592,15 @@ def build_calibration_app(
     logger.info("=== build_calibration_app ===")
     logger.info("Config: %s     griip_api.mode: %s", resolved_path, cell.griip_api.mode)
 
-    robot_client = build_vrmcs_client(resolved_path, cell)
+    robot_is_external = cell.robot.driver == EXTERNAL_ROBOT_DRIVER
+    if robot_is_external and robot is None:
+        raise ValueError(f"robot.driver is '{EXTERNAL_ROBOT_DRIVER}' in {resolved_path}: pass the app's robot to build_calibration_app")
+    if robot is not None:
+        app_tcp_offset = cell.tool.tcp_offset if cell.tool is not None else [0.0, 0.0, 0.0]
+        # Duck-typed stand-in for the slice of VrmcsRobotClient calibration uses.
+        robot_client = cast(VrmcsRobotClient, ExternalCalibrationRobotClient(robot, app_tcp_offset))
+    else:
+        robot_client = build_vrmcs_client(resolved_path, cell)
     grpc_channel: grpc.Channel | None = None
     mqtt_publisher: MqttProgressPublisher | None = None
     if mqtt_host is not None:
@@ -604,7 +621,12 @@ def build_calibration_app(
             grpc_channel, planning_stub, perception_stub = _build_grpc_calibration_stubs(cell.griip_api.url)
             logger.info("Connected to mmai-griip-api over gRPC at %s", cell.griip_api.url)
             _initialize_remote_api(grpc_channel, cell)
-            _configure_remote_planner(planning_stub, cell, resolved_path.parent, cuboids_path_override=effective_cuboids_path)
+            if robot_is_external:
+                planning_stub = _build_in_process_planning_stub(
+                    robot_client, cell, resolved_path.parent, cuboids_path_override=effective_cuboids_path
+                )
+            else:
+                _configure_remote_planner(planning_stub, cell, resolved_path.parent, cuboids_path_override=effective_cuboids_path)
         else:
             planning_stub = _build_in_process_planning_stub(
                 robot_client, cell, resolved_path.parent, cuboids_path_override=effective_cuboids_path

{griip_sdk_dev-0.4.0.dev24238 → griip_sdk_dev-0.6.0.dev25546}/src/griip_sdk/calibration/camera_factory.py

@@ -12,12 +12,12 @@ from __future__ import annotations
 import logging
 from dataclasses import dataclass
 
-from vention.vision.v1.vision_service_abc import ImageServiceBackend
 
 from griip_sdk.calibration.config_store import CalibrationConfigStore
 from griip_sdk.cell.config import CameraConfig
 from griip_sdk.hardware.grpc_vision_backend import GrpcVisionServiceBackend, camera_identity_from_backend
 from griip_sdk.hardware.mmai_vision_backend import MmaiVisionServiceBackend
+from griip_sdk.hardware.vision_backend import VisionServiceBackend
 
 logger = logging.getLogger(__name__)
 
@@ -31,7 +31,7 @@ class CalibrationCamera:
     so calibration-time saves and pick-time loads provably agree.
     """
 
-    vision_backend: ImageServiceBackend
+    vision_backend: VisionServiceBackend
     camera_vendor: str
     camera_mx_id: str
 
@@ -65,7 +65,7 @@ def build_calibration_camera(
             "Using vention.vision gRPC camera at %s; intrinsics/calibration are owned by the vision service.",
             camera_config.target,
         )
-        vision_backend: ImageServiceBackend = GrpcVisionServiceBackend(
+        vision_backend: VisionServiceBackend = GrpcVisionServiceBackend(
             camera_config.target, source_metadata_defaults=camera_config.source_metadata
         )
         camera_vendor, camera_mx_id = camera_identity_from_backend(vision_backend, camera_config.sensor)