standardbots 2.20250921.1__tar.gz → 2.20250923.2__tar.gz

{standardbots-2.20250921.1 → standardbots-2.20250923.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: standardbots
-Version: 2.20250921.1
+Version: 2.20250923.2
 Summary: Standard Bots RO1 Robotics API
 Home-page: 
 Author: Standard Bots Support

{standardbots-2.20250921.1 → standardbots-2.20250923.2}/setup.py

@@ -13,7 +13,7 @@
 from setuptools import setup, find_packages  # noqa: H301
 
 NAME = "standardbots"
-VERSION = "2.20250921.1"
+VERSION = "2.20250923.2"
 # To install the library, run the following
 #
 # python setup.py install

{standardbots-2.20250921.1 → standardbots-2.20250923.2}/standardbots/auto_generated/apis.py

@@ -1118,7 +1118,7 @@ class Default:
             models.TeleopState
         ]:
             """
-            Set ratio control parameters
+            Set ratio control parameters for movement and rotation
             """
             path = "/api/v1/teleop/set-ratio-control"
             try:

{standardbots-2.20250921.1 → standardbots-2.20250923.2}/standardbots/auto_generated/models.py

@@ -1736,6 +1736,14 @@ def parse_max_joint_speeds(data: object) -> MaxJointSpeeds:
 def serialize_max_joint_speeds(data: MaxJointSpeeds) -> object:
   return [serialize_f_64(data[0]),serialize_f_64(data[1]),serialize_f_64(data[2]),serialize_f_64(data[3]),serialize_f_64(data[4]),serialize_f_64(data[5]),]
 
+MaxJointTorques = Tuple[float,float,float,float,float,float,]
+
+def parse_max_joint_torques(data: object) -> MaxJointTorques:
+  return (parse_f_64(data[0]),parse_f_64(data[1]),parse_f_64(data[2]),parse_f_64(data[3]),parse_f_64(data[4]),parse_f_64(data[5]),)
+
+def serialize_max_joint_torques(data: MaxJointTorques) -> object:
+  return [serialize_f_64(data[0]),serialize_f_64(data[1]),serialize_f_64(data[2]),serialize_f_64(data[3]),serialize_f_64(data[4]),serialize_f_64(data[5]),]
+
 class MovementKindEnum(Enum):
   Joint = "joint"
   """Enum Joint = `joint`"""
@@ -3156,7 +3164,8 @@ def serialize_sensor_config(data: SensorConfig) -> object:
 class SetRatioControlRequest:
   """Request to set ratio control parameters"""
   enabled: Union[bool, None] = None
-  value: Union[float, None] = None
+  movementValue: Union[float, None] = None
+  rotationValue: Union[float, None] = None
 
   def validate_enabled(self, value: bool) -> Tuple[bool, str]:
     if value is None:
@@ -3167,12 +3176,21 @@ class SetRatioControlRequest:
 
     return [True, ""]
 
-  def validate_value(self, value: float) -> Tuple[bool, str]:
+  def validate_movementValue(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "movementValue must be of type float for SetRatioControlRequest, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_rotationValue(self, value: float) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
 
     if not isinstance(value, float):
-      return [False, "value must be of type float for SetRatioControlRequest, got " + type(value).__name__]
+      return [False, "rotationValue must be of type float for SetRatioControlRequest, got " + type(value).__name__]
 
     return [True, ""]
 
@@ -3181,20 +3199,25 @@ class SetRatioControlRequest:
     is_valid, error_str = self.validate_enabled(self.enabled)
     if not is_valid:
       raise TypeError(error_str)
-    is_valid, error_str = self.validate_value(self.value)
+    is_valid, error_str = self.validate_movementValue(self.movementValue)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_rotationValue(self.rotationValue)
     if not is_valid:
       raise TypeError(error_str)
 
 def parse_set_ratio_control_request(data: object):
   return SetRatioControlRequest(
     enabled=parse_bool(data["enabled"]) if "enabled" in data and data.get("enabled") is not None else None,
-    value=parse_f_64(data["value"]) if "value" in data and data.get("value") is not None else None,
+    movementValue=parse_f_64(data["movementValue"]) if "movementValue" in data and data.get("movementValue") is not None else None,
+    rotationValue=parse_f_64(data["rotationValue"]) if "rotationValue" in data and data.get("rotationValue") is not None else None,
   )
 
 def serialize_set_ratio_control_request(data: SetRatioControlRequest) -> object:
   return {
     "enabled": None if data.enabled is None else serialize_bool(data.enabled),
-    "value": None if data.value is None else serialize_f_64(data.value),
+    "movementValue": None if data.movementValue is None else serialize_f_64(data.movementValue),
+    "rotationValue": None if data.rotationValue is None else serialize_f_64(data.rotationValue),
   }
 
 class SignalMessageType(Enum):
@@ -3356,6 +3379,14 @@ def parse_string_array(data: object) -> StringArray:
 def serialize_string_array(data: StringArray) -> List[object]:
   return [serialize_str(item) for item in data]
 
+TeleopErrorArray = List[str]
+
+def parse_teleop_error_array(data: object) -> TeleopErrorArray:
+  return [parse_str(item) for item in data]
+
+def serialize_teleop_error_array(data: TeleopErrorArray) -> List[object]:
+  return [serialize_str(item) for item in data]
+
 class TeleopStatus(Enum):
   WaitForTeleop = "wait_for_teleop"
   """Enum WaitForTeleop = `wait_for_teleop`"""
@@ -4901,6 +4932,7 @@ class SpeedProfile:
   max_joint_speeds: Union[MaxJointSpeeds, None] = None
   max_joint_accelerations: Union[MaxJointAcclerations, None] = None
   max_tooltip_speed: Union[float, None] = None
+  max_joint_torques: Union[MaxJointTorques, None] = None
   base_acceleration_scaling: Union[float, None] = None
   base_velocity_scaling: Union[float, None] = None
   scaling_factor: Union[float, None] = None
@@ -4932,6 +4964,15 @@ class SpeedProfile:
 
     return [True, ""]
 
+  def validate_max_joint_torques(self, value: MaxJointTorques) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not (isinstance(value, tuple) and len(value) == 6):
+      return [False, "max_joint_torques must be of type MaxJointTorques for SpeedProfile, got " + type(value).__name__]
+
+    return [True, ""]
+
   def validate_base_acceleration_scaling(self, value: float) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
@@ -4968,6 +5009,9 @@ class SpeedProfile:
     if not is_valid:
       raise TypeError(error_str)
     is_valid, error_str = self.validate_max_tooltip_speed(self.max_tooltip_speed)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_max_joint_torques(self.max_joint_torques)
     if not is_valid:
       raise TypeError(error_str)
     is_valid, error_str = self.validate_base_acceleration_scaling(self.base_acceleration_scaling)
@@ -4985,6 +5029,7 @@ def parse_speed_profile(data: object):
     max_joint_speeds=parse_max_joint_speeds(data["max_joint_speeds"]) if "max_joint_speeds" in data and data.get("max_joint_speeds") is not None else None,
     max_joint_accelerations=parse_max_joint_acclerations(data["max_joint_accelerations"]) if "max_joint_accelerations" in data and data.get("max_joint_accelerations") is not None else None,
     max_tooltip_speed=parse_f_64(data["max_tooltip_speed"]) if "max_tooltip_speed" in data and data.get("max_tooltip_speed") is not None else None,
+    max_joint_torques=parse_max_joint_torques(data["max_joint_torques"]) if "max_joint_torques" in data and data.get("max_joint_torques") is not None else None,
     base_acceleration_scaling=parse_f_64(data["base_acceleration_scaling"]) if "base_acceleration_scaling" in data and data.get("base_acceleration_scaling") is not None else None,
     base_velocity_scaling=parse_f_64(data["base_velocity_scaling"]) if "base_velocity_scaling" in data and data.get("base_velocity_scaling") is not None else None,
     scaling_factor=parse_f_64(data["scaling_factor"]) if "scaling_factor" in data and data.get("scaling_factor") is not None else None,
@@ -4995,6 +5040,7 @@ def serialize_speed_profile(data: SpeedProfile) -> object:
     "max_joint_speeds": None if data.max_joint_speeds is None else serialize_max_joint_speeds(data.max_joint_speeds),
     "max_joint_accelerations": None if data.max_joint_accelerations is None else serialize_max_joint_acclerations(data.max_joint_accelerations),
     "max_tooltip_speed": None if data.max_tooltip_speed is None else serialize_f_64(data.max_tooltip_speed),
+    "max_joint_torques": None if data.max_joint_torques is None else serialize_max_joint_torques(data.max_joint_torques),
     "base_acceleration_scaling": None if data.base_acceleration_scaling is None else serialize_f_64(data.base_acceleration_scaling),
     "base_velocity_scaling": None if data.base_velocity_scaling is None else serialize_f_64(data.base_velocity_scaling),
     "scaling_factor": None if data.scaling_factor is None else serialize_f_64(data.scaling_factor),
@@ -6557,6 +6603,7 @@ class BotTeleopDetails:
   isSecondary: Union[bool, None] = None
   isEnabled: Union[bool, None] = None
   status: Union[TeleopStatus, None] = None
+  errors: Union[TeleopErrorArray, None] = None
 
   def validate_botId(self, value: str) -> Tuple[bool, str]:
     if value is None:
@@ -6621,6 +6668,15 @@ class BotTeleopDetails:
 
     return [True, ""]
 
+  def validate_errors(self, value: TeleopErrorArray) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not (isinstance(value, list) and all(isinstance(x, str) for x in value)):
+      return [False, "errors must be of type TeleopErrorArray for BotTeleopDetails, got " + type(value).__name__]
+
+    return [True, ""]
+
   def __post_init__(self):
     # Type check incoming model - raise error if invalid (required or wrong type)
     is_valid, error_str = self.validate_botId(self.botId)
@@ -6644,6 +6700,9 @@ class BotTeleopDetails:
     is_valid, error_str = self.validate_status(self.status)
     if not is_valid:
       raise TypeError(error_str)
+    is_valid, error_str = self.validate_errors(self.errors)
+    if not is_valid:
+      raise TypeError(error_str)
 
 def parse_bot_teleop_details(data: object):
   return BotTeleopDetails(
@@ -6654,6 +6713,7 @@ def parse_bot_teleop_details(data: object):
     isSecondary=parse_bool(data["isSecondary"]) if "isSecondary" in data and data.get("isSecondary") is not None else None,
     isEnabled=parse_bool(data["isEnabled"]) if "isEnabled" in data and data.get("isEnabled") is not None else None,
     status=parse_teleop_status(data["status"]) if "status" in data and data.get("status") is not None else None,
+    errors=parse_teleop_error_array(data["errors"]) if "errors" in data and data.get("errors") is not None else None,
   )
 
 def serialize_bot_teleop_details(data: BotTeleopDetails) -> object:
@@ -6665,6 +6725,7 @@ def serialize_bot_teleop_details(data: BotTeleopDetails) -> object:
     "isSecondary": None if data.isSecondary is None else serialize_bool(data.isSecondary),
     "isEnabled": None if data.isEnabled is None else serialize_bool(data.isEnabled),
     "status": None if data.status is None else serialize_teleop_status(data.status),
+    "errors": None if data.errors is None else serialize_teleop_error_array(data.errors),
   }
 
 @dataclass
@@ -8853,6 +8914,7 @@ class TeleopState:
   config: Union[TeleopConfig, None] = None
   status: Union[TeleopStatus, None] = None
   botsInSync: Union[bool, None] = None
+  errors: Union[TeleopErrorArray, None] = None
 
   def validate_config(self, value: TeleopConfig) -> Tuple[bool, str]:
     if value is None:
@@ -8881,6 +8943,15 @@ class TeleopState:
 
     return [True, ""]
 
+  def validate_errors(self, value: TeleopErrorArray) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not (isinstance(value, list) and all(isinstance(x, str) for x in value)):
+      return [False, "errors must be of type TeleopErrorArray for TeleopState, got " + type(value).__name__]
+
+    return [True, ""]
+
   def __post_init__(self):
     # Type check incoming model - raise error if invalid (required or wrong type)
     is_valid, error_str = self.validate_config(self.config)
@@ -8892,12 +8963,16 @@ class TeleopState:
     is_valid, error_str = self.validate_botsInSync(self.botsInSync)
     if not is_valid:
       raise TypeError(error_str)
+    is_valid, error_str = self.validate_errors(self.errors)
+    if not is_valid:
+      raise TypeError(error_str)
 
 def parse_teleop_state(data: object):
   return TeleopState(
     config=parse_teleop_config(data["config"]) if "config" in data and data.get("config") is not None else None,
     status=parse_teleop_status(data["status"]) if "status" in data and data.get("status") is not None else None,
     botsInSync=parse_bool(data["botsInSync"]) if "botsInSync" in data and data.get("botsInSync") is not None else None,
+    errors=parse_teleop_error_array(data["errors"]) if "errors" in data and data.get("errors") is not None else None,
   )
 
 def serialize_teleop_state(data: TeleopState) -> object:
@@ -8905,6 +8980,7 @@ def serialize_teleop_state(data: TeleopState) -> object:
     "config": None if data.config is None else serialize_teleop_config(data.config),
     "status": None if data.status is None else serialize_teleop_status(data.status),
     "botsInSync": None if data.botsInSync is None else serialize_bool(data.botsInSync),
+    "errors": None if data.errors is None else serialize_teleop_error_array(data.errors),
   }
 
 @dataclass

{standardbots-2.20250921.1 → standardbots-2.20250923.2}/standardbots.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: standardbots
-Version: 2.20250921.1
+Version: 2.20250923.2
 Summary: Standard Bots RO1 Robotics API
 Home-page: 
 Author: Standard Bots Support

{standardbots-2.20250921.1 → standardbots-2.20250923.2}/tests/test_apis.py

@@ -1231,7 +1231,7 @@ class TestPostMovementPositionArm:
 
             target_position_res = client.movement.position.get_arm_position()
             target_joint_pose_rounded = tuple(
-                round(val, 3) for val in target_position_res.data.joint_rotations
+                round(val, 2) for val in target_position_res.data.joint_rotations
             )
 
             # check if robot successfully moved to target pose
@@ -1246,7 +1246,7 @@ class TestPostMovementPositionArm:
             initial_position_res = client.movement.position.get_arm_position()
 
             initial_joint_pose_rounded = tuple(
-                round(val, 3) for val in initial_position_res.data.joint_rotations
+                round(val, 2) for val in initial_position_res.data.joint_rotations
             )
             # check if pose correctly moved to initial pose
             assert initial_joint_pose_rounded == initial_position
@@ -1266,7 +1266,7 @@ class TestPostMovementPositionArm:
             initial_position = (0.0, 0.0, 0.0, 0.0, 0.0, 0.0)
             pose_res = client.movement.position.get_arm_position()
             initial_joint_pose_rounded = tuple(
-                round(val, 3) for val in pose_res.data.joint_rotations
+                round(val, 2) for val in pose_res.data.joint_rotations
             )
 
             #  if robot is not in initial position, move it to initial position
@@ -1298,7 +1298,7 @@ class TestPostMovementPositionArm:
 
             pose_res = client.movement.position.get_arm_position()
             joint_pose_rounded = tuple(
-                round(val, 3) for val in pose_res.data.joint_rotations
+                round(val, 2) for val in pose_res.data.joint_rotations
             )
 
             # check if robot successfully moved into initial pose
@@ -1346,9 +1346,9 @@ class TestPostMovementPositionArm:
             pose_res = client.movement.position.get_arm_position()
             target_tooltip = pose_res.data.tooltip_position.position
 
-            assert approx_equal(target_tooltip.x, target_tooltip_position.x)
-            assert approx_equal(target_tooltip.y, target_tooltip_position.y)
-            assert approx_equal(target_tooltip.z, target_tooltip_position.z)
+            assert approx_equal(target_tooltip.x, target_tooltip_position.x, 2)
+            assert approx_equal(target_tooltip.y, target_tooltip_position.y, 2)
+            assert approx_equal(target_tooltip.z, target_tooltip_position.z, 2)
 
             pose_body = models.ArmPositionUpdateRequest(
                 kind=models.ArmPositionUpdateRequestKindEnum.TooltipPosition,
@@ -1369,9 +1369,9 @@ class TestPostMovementPositionArm:
             pose_res = client.movement.position.get_arm_position()
             tooltip_position = pose_res.data.tooltip_position.position
 
-            assert approx_equal(tooltip_position.x, initial_tooltip_position.x)
-            assert approx_equal(tooltip_position.y, initial_tooltip_position.y)
-            assert approx_equal(tooltip_position.z, initial_tooltip_position.z)
+            assert approx_equal(tooltip_position.x, initial_tooltip_position.x, 2)
+            assert approx_equal(tooltip_position.y, initial_tooltip_position.y, 2)
+            assert approx_equal(tooltip_position.z, initial_tooltip_position.z, 2)
 
     def test_tooltip_positions_to_target_and_back(
         self, client_live: StandardBotsRobot
@@ -3317,12 +3317,13 @@ class TestPostMovementPositionArmControlled:
                 assert not approx_equal(joint, target_position[i], 2), (
                     f"Joint {i} is approximately equal to target position (should not reach goal) (actual={joint}, expected={target_position[i]})"
                 )
+            time.sleep(2)
 
             # Now retrieve the failure
             assert heartbeat_data.event is not None
             assert heartbeat_data.event.kind == models.ArmPositionUpdateKindEnum.Failure
             assert heartbeat_data.event.failure is not None
-            assert heartbeat_data.event.failure.reason == "Error while running motion"
+            assert heartbeat_data.event.failure.reason == "Failed to generate a motion plan"
 
     def test_move_then_stop_heartbeat(
         self,