standardbots 2.0.0.dev1760378411__tar.gz → 2.0.0.dev1763152552__tar.gz

{standardbots-2.0.0.dev1760378411 → standardbots-2.0.0.dev1763152552}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: standardbots
-Version: 2.0.0.dev1760378411
+Version: 2.0.0.dev1763152552
 Summary: Standard Bots RO1 Robotics API
 Home-page: 
 Author: Standard Bots Support

{standardbots-2.0.0.dev1760378411 → standardbots-2.0.0.dev1763152552}/setup.py

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

{standardbots-2.0.0.dev1760378411 → standardbots-2.0.0.dev1763152552}/standardbots/auto_generated/apis.py

@@ -833,6 +833,49 @@ class Default:
             self._request_manager = request_manager
 
 
+        def list_global_spaces(
+            self,
+        ) -> Response[
+            Union[
+                models.SpacesPaginatedResponse,
+                models.ErrorResponse,
+                None
+            ],
+            models.SpacesPaginatedResponse
+        ]:
+            """
+            List Global Spaces
+            """
+            path = "/api/v1/space/globals"
+            try:
+                response = self._request_manager.request(
+                    "GET",
+                    path,
+                    headers=self._request_manager.json_headers(),
+                )
+                parsed = None
+                if response.status == 200:
+                    parsed = models.parse_spaces_paginated_response(json.loads(response.data))
+
+                is_user_error = response.status >= 400 and response.status <= 500
+                is_unavailable = response.status == 503
+                if parsed is None and (is_user_error or is_unavailable):
+                    parsed = models.parse_error_response(json.loads(response.data))
+
+                return Response(
+                    parsed,
+                    response.status,
+                    response
+                )
+            except urllib3.exceptions.MaxRetryError:
+                return Response(
+                    models.ErrorResponse(
+                        error=models.ErrorEnum.InternalServerError,
+                        message="Connection Refused"
+                    ),
+                    503,
+                    None
+                )
         def list_planes(
             self,
             limit: int,
@@ -1118,7 +1161,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:
@@ -1137,6 +1180,96 @@ class Default:
                 if parsed is None and (is_user_error or is_unavailable):
                     parsed = models.parse_error_response(json.loads(response.data))
 
+                return Response(
+                    parsed,
+                    response.status,
+                    response
+                )
+            except urllib3.exceptions.MaxRetryError:
+                return Response(
+                    models.ErrorResponse(
+                        error=models.ErrorEnum.InternalServerError,
+                        message="Connection Refused"
+                    ),
+                    503,
+                    None
+                )
+        def set_gripper_bounds(
+            self,
+            body: models.SetGripperBoundsRequest,
+        ) -> Response[
+            Union[
+                models.TeleopState,
+                models.ErrorResponse,
+                None
+            ],
+            models.TeleopState
+        ]:
+            """
+            Set gripper bounds for primary and secondary bots
+            """
+            path = "/api/v1/teleop/set-gripper-bounds"
+            try:
+                response = self._request_manager.request(
+                    "POST",
+                    path,
+                    headers=self._request_manager.json_headers(),
+                    body=json.dumps(models.serialize_set_gripper_bounds_request(body)),
+                )
+                parsed = None
+                if response.status == 200:
+                    parsed = models.parse_teleop_state(json.loads(response.data))
+
+                is_user_error = response.status >= 400 and response.status <= 500
+                is_unavailable = response.status == 503
+                if parsed is None and (is_user_error or is_unavailable):
+                    parsed = models.parse_error_response(json.loads(response.data))
+
+                return Response(
+                    parsed,
+                    response.status,
+                    response
+                )
+            except urllib3.exceptions.MaxRetryError:
+                return Response(
+                    models.ErrorResponse(
+                        error=models.ErrorEnum.InternalServerError,
+                        message="Connection Refused"
+                    ),
+                    503,
+                    None
+                )
+        def set_robot_frame(
+            self,
+            body: models.SetRobotFrameRequest,
+        ) -> Response[
+            Union[
+                models.TeleopState,
+                models.ErrorResponse,
+                None
+            ],
+            models.TeleopState
+        ]:
+            """
+            Set robot frame
+            """
+            path = "/api/v1/teleop/set-robot-frame"
+            try:
+                response = self._request_manager.request(
+                    "POST",
+                    path,
+                    headers=self._request_manager.json_headers(),
+                    body=json.dumps(models.serialize_set_robot_frame_request(body)),
+                )
+                parsed = None
+                if response.status == 200:
+                    parsed = models.parse_teleop_state(json.loads(response.data))
+
+                is_user_error = response.status >= 400 and response.status <= 500
+                is_unavailable = response.status == 503
+                if parsed is None and (is_user_error or is_unavailable):
+                    parsed = models.parse_error_response(json.loads(response.data))
+
                 return Response(
                     parsed,
                     response.status,

{standardbots-2.0.0.dev1760378411 → standardbots-2.0.0.dev1763152552}/standardbots/auto_generated/models.py

@@ -1337,6 +1337,8 @@ class ErrorEnum(Enum):
   """Cannot change ROS state"""
   IoSafeguardError = "io_safeguard_error"
   """Cannot change IO state because of safeguard"""
+  RobotOutOfComplianceBounds = "robot_out_of_compliance_bounds"
+  """Cannot initiate compliance control: Robot is outside compliance bounds"""
 
 def parse_error_enum(data: object) -> ErrorEnum:
   return ErrorEnum(data)
@@ -1470,6 +1472,51 @@ def parse_force_unit_kind(data: object) -> ForceUnitKind:
 def serialize_force_unit_kind(data: Union[ForceUnitKind, str]) -> object:
   return ForceUnitKind(data).value
 
+@dataclass
+class GripperBounds:
+  """Gripper bounds configuration"""
+  min: Union[float, None] = None
+  max: Union[float, None] = None
+
+  def validate_min(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "min is required for GripperBounds"]
+
+    if not isinstance(value, float):
+      return [False, "min must be of type float for GripperBounds, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_max(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "max is required for GripperBounds"]
+
+    if not isinstance(value, float):
+      return [False, "max must be of type float for GripperBounds, 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_min(self.min)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_max(self.max)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_gripper_bounds(data: object):
+  return GripperBounds(
+    min=parse_f_64(data["min"]) if "min" in data and data.get("min") is not None else None,
+    max=parse_f_64(data["max"]) if "max" in data and data.get("max") is not None else None,
+  )
+
+def serialize_gripper_bounds(data: GripperBounds) -> object:
+  return {
+    "min": serialize_f_64(data.min),
+    "max": serialize_f_64(data.max),
+  }
+
 class GripperKindEnum(Enum):
   Onrobot2Fg7 = "onrobot_2fg7"
   """An OnRobot 2FG7 Gripper is connected"""
@@ -1736,6 +1783,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`"""
@@ -2652,6 +2707,18 @@ def parse_robot_control_mode_enum(data: object) -> RobotControlModeEnum:
 def serialize_robot_control_mode_enum(data: Union[RobotControlModeEnum, str]) -> object:
   return RobotControlModeEnum(data).value
 
+class RobotFrame(Enum):
+  World = "world"
+  """Enum World = `world`"""
+  Tooltip = "tooltip"
+  """Enum Tooltip = `tooltip`"""
+
+def parse_robot_frame(data: object) -> RobotFrame:
+  return RobotFrame(data)
+
+def serialize_robot_frame(data: Union[RobotFrame, str]) -> object:
+  return RobotFrame(data).value
+
 class RobotStatusEnum(Enum):
   Idle = "Idle"
   """Enum Idle = `Idle`"""
@@ -3156,7 +3223,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 +3235,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 +3258,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):
@@ -3318,36 +3400,6 @@ def serialize_status_version_data(data: StatusVersionData) -> object:
     "name": None if data.name is None else serialize_str(data.name),
   }
 
-@dataclass
-class StopRecordingRequest:
-  """Request to stop recording movement and camera data"""
-  delete: Union[bool, None] = None
-
-  def validate_delete(self, value: bool) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
-
-    if not isinstance(value, bool):
-      return [False, "delete must be of type bool for StopRecordingRequest, 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_delete(self.delete)
-    if not is_valid:
-      raise TypeError(error_str)
-
-def parse_stop_recording_request(data: object):
-  return StopRecordingRequest(
-    delete=parse_bool(data["delete"]) if "delete" in data and data.get("delete") is not None else None,
-  )
-
-def serialize_stop_recording_request(data: StopRecordingRequest) -> object:
-  return {
-    "delete": None if data.delete is None else serialize_bool(data.delete),
-  }
-
 StringArray = List[str]
 
 def parse_string_array(data: object) -> StringArray:
@@ -3356,6 +3408,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`"""
@@ -4211,7 +4271,7 @@ class ErrorResponse:
     if value is None:
       return [False, "error is required for ErrorResponse"]
 
-    if not ((isinstance(value, str) and ErrorEnum in ['authorization_required', 'routine_must_be_running', 'api_control_required', 'robot_brakes_disengage_failed', 'robot_brakes_engage_failed', 'request_failed_validation', 'robot_not_idle', 'brakes_must_be_engaged', 'brakes_must_be_disengaged', 'equipment_no_matching', 'service_initializing', 'camera_disconnected', 'settings_validation_error', 'settings_timeout', 'internal_server_error', 'recovery_error', 'not_found', 'invalid_space_specified', 'invalid_parameters', 'routine_does_not_exist', 'cannot_play_routine', 'routine_must_be_playing', 'cannot_change_ros_state', 'io_safeguard_error']) or isinstance(value, ErrorEnum)):
+    if not ((isinstance(value, str) and ErrorEnum in ['authorization_required', 'routine_must_be_running', 'api_control_required', 'robot_brakes_disengage_failed', 'robot_brakes_engage_failed', 'request_failed_validation', 'robot_not_idle', 'brakes_must_be_engaged', 'brakes_must_be_disengaged', 'equipment_no_matching', 'service_initializing', 'camera_disconnected', 'settings_validation_error', 'settings_timeout', 'internal_server_error', 'recovery_error', 'not_found', 'invalid_space_specified', 'invalid_parameters', 'routine_does_not_exist', 'cannot_play_routine', 'routine_must_be_playing', 'cannot_change_ros_state', 'io_safeguard_error', 'robot_out_of_compliance_bounds']) or isinstance(value, ErrorEnum)):
       return [False, "error must be of type ErrorEnum for ErrorResponse, got " + type(value).__name__]
 
     return [True, ""]
@@ -4548,6 +4608,18 @@ def serialize_force_unit(data: ForceUnit) -> object:
     "value": None if data.value is None else serialize_f_64(data.value),
   }
 
+SecondaryBotGripperBounds = Dict[str, GripperBounds]
+
+def parse_secondary_bot_gripper_bounds(data: object) -> SecondaryBotGripperBounds:
+  return {
+    parse_str(key): parse_gripper_bounds(value) for key, value in data.items()
+  }
+
+def serialize_secondary_bot_gripper_bounds(data: SecondaryBotGripperBounds) -> object:
+  return {
+    serialize_str(key): serialize_gripper_bounds(value) for key, value in data.items()
+  }
+
 @dataclass
 class IOStateResponse:
   """Response to a query for the current state of I/O."""
@@ -4901,6 +4973,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 +5005,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 +5050,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 +5070,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 +5081,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),
@@ -6036,6 +6123,18 @@ def serialize_robot_control_mode(data: RobotControlMode) -> object:
     "kind": None if data.kind is None else serialize_robot_control_mode_enum(data.kind),
   }
 
+SecondaryBotRobotFrame = Dict[str, RobotFrame]
+
+def parse_secondary_bot_robot_frame(data: object) -> SecondaryBotRobotFrame:
+  return {
+    parse_str(key): parse_robot_frame(value) for key, value in data.items()
+  }
+
+def serialize_secondary_bot_robot_frame(data: SecondaryBotRobotFrame) -> object:
+  return {
+    serialize_str(key): serialize_robot_frame(value) for key, value in data.items()
+  }
+
 @dataclass
 class PlayRoutineResponse:
   """Status response informs user of of robot state"""
@@ -6547,6 +6646,51 @@ def serialize_save_recording_response(data: SaveRecordingResponse) -> object:
     "errors": None if data.errors is None else serialize_string_array(data.errors),
   }
 
+@dataclass
+class StopRecordingRequest:
+  """Request to stop recording movement and camera data"""
+  delete: Union[bool, None] = None
+  tags: Union[StringArray, None] = None
+
+  def validate_delete(self, value: bool) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, bool):
+      return [False, "delete must be of type bool for StopRecordingRequest, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_tags(self, value: StringArray) -> 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, "tags must be of type StringArray for StopRecordingRequest, 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_delete(self.delete)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_tags(self.tags)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_stop_recording_request(data: object):
+  return StopRecordingRequest(
+    delete=parse_bool(data["delete"]) if "delete" in data and data.get("delete") is not None else None,
+    tags=parse_string_array(data["tags"]) if "tags" in data and data.get("tags") is not None else None,
+  )
+
+def serialize_stop_recording_request(data: StopRecordingRequest) -> object:
+  return {
+    "delete": None if data.delete is None else serialize_bool(data.delete),
+    "tags": None if data.tags is None else serialize_string_array(data.tags),
+  }
+
 @dataclass
 class BotTeleopDetails:
   """Details of the bot"""
@@ -6557,6 +6701,9 @@ class BotTeleopDetails:
   isSecondary: Union[bool, None] = None
   isEnabled: Union[bool, None] = None
   status: Union[TeleopStatus, None] = None
+  errors: Union[TeleopErrorArray, None] = None
+  gripperBounds: Union[GripperBounds, None] = None
+  robotFrame: Union[RobotFrame, None] = None
 
   def validate_botId(self, value: str) -> Tuple[bool, str]:
     if value is None:
@@ -6621,6 +6768,33 @@ 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 validate_gripperBounds(self, value: GripperBounds) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, GripperBounds):
+      return [False, "gripperBounds must be of type GripperBounds for BotTeleopDetails, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_robotFrame(self, value: RobotFrame) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not ((isinstance(value, str) and RobotFrame in ['world', 'tooltip']) or isinstance(value, RobotFrame)):
+      return [False, "robotFrame must be of type RobotFrame 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 +6818,15 @@ 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)
+    is_valid, error_str = self.validate_gripperBounds(self.gripperBounds)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_robotFrame(self.robotFrame)
+    if not is_valid:
+      raise TypeError(error_str)
 
 def parse_bot_teleop_details(data: object):
   return BotTeleopDetails(
@@ -6654,6 +6837,9 @@ 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,
+    gripperBounds=parse_gripper_bounds(data["gripperBounds"]) if "gripperBounds" in data and data.get("gripperBounds") is not None else None,
+    robotFrame=parse_robot_frame(data["robotFrame"]) if "robotFrame" in data and data.get("robotFrame") is not None else None,
   )
 
 def serialize_bot_teleop_details(data: BotTeleopDetails) -> object:
@@ -6665,6 +6851,9 @@ 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),
+    "gripperBounds": None if data.gripperBounds is None else serialize_gripper_bounds(data.gripperBounds),
+    "robotFrame": None if data.robotFrame is None else serialize_robot_frame(data.robotFrame),
   }
 
 @dataclass
@@ -6857,6 +7046,51 @@ def serialize_calibration_data(data: CalibrationData) -> object:
     "urdfParameters": serialize_urdf_parameters(data.urdfParameters),
   }
 
+@dataclass
+class SetGripperBoundsRequest:
+  """Request to set gripper bounds for primary and secondary bots"""
+  primary: Union[GripperBounds, None] = None
+  secondary: Union[SecondaryBotGripperBounds, None] = None
+
+  def validate_primary(self, value: GripperBounds) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "primary is required for SetGripperBoundsRequest"]
+
+    if not isinstance(value, GripperBounds):
+      return [False, "primary must be of type GripperBounds for SetGripperBoundsRequest, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_secondary(self, value: SecondaryBotGripperBounds) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not (isinstance(value, dict) and all((isinstance(k, str) and isinstance(val, GripperBounds)) for k, val in value.items())):
+      return [False, "secondary must be of type SecondaryBotGripperBounds for SetGripperBoundsRequest, 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_primary(self.primary)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_secondary(self.secondary)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_set_gripper_bounds_request(data: object):
+  return SetGripperBoundsRequest(
+    primary=parse_gripper_bounds(data["primary"]) if "primary" in data and data.get("primary") is not None else None,
+    secondary=parse_secondary_bot_gripper_bounds(data["secondary"]) if "secondary" in data and data.get("secondary") is not None else None,
+  )
+
+def serialize_set_gripper_bounds_request(data: SetGripperBoundsRequest) -> object:
+  return {
+    "primary": serialize_gripper_bounds(data.primary),
+    "secondary": None if data.secondary is None else serialize_secondary_bot_gripper_bounds(data.secondary),
+  }
+
 ArmJointRotationsList = List[ArmJointRotations]
 
 def parse_arm_joint_rotations_list(data: object) -> ArmJointRotationsList:
@@ -7627,6 +7861,51 @@ def serialize_failure_state_response(data: FailureStateResponse) -> object:
     "failure": None if data.failure is None else serialize_failure_state_details(data.failure),
   }
 
+@dataclass
+class SetRobotFrameRequest:
+  """Request to set robot frame"""
+  primary: Union[RobotFrame, None] = None
+  secondary: Union[SecondaryBotRobotFrame, None] = None
+
+  def validate_primary(self, value: RobotFrame) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "primary is required for SetRobotFrameRequest"]
+
+    if not ((isinstance(value, str) and RobotFrame in ['world', 'tooltip']) or isinstance(value, RobotFrame)):
+      return [False, "primary must be of type RobotFrame for SetRobotFrameRequest, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_secondary(self, value: SecondaryBotRobotFrame) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not (isinstance(value, dict) and all((isinstance(k, str) and ((isinstance(val, str) and RobotFrame in ['world', 'tooltip']) or isinstance(val, RobotFrame))) for k, val in value.items())):
+      return [False, "secondary must be of type SecondaryBotRobotFrame for SetRobotFrameRequest, 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_primary(self.primary)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_secondary(self.secondary)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_set_robot_frame_request(data: object):
+  return SetRobotFrameRequest(
+    primary=parse_robot_frame(data["primary"]) if "primary" in data and data.get("primary") is not None else None,
+    secondary=parse_secondary_bot_robot_frame(data["secondary"]) if "secondary" in data and data.get("secondary") is not None else None,
+  )
+
+def serialize_set_robot_frame_request(data: SetRobotFrameRequest) -> object:
+  return {
+    "primary": serialize_robot_frame(data.primary),
+    "secondary": None if data.secondary is None else serialize_secondary_bot_robot_frame(data.secondary),
+  }
+
 @dataclass
 class SensorsConfiguration:
   """Configuration of all sensors defined in custom equipment"""
@@ -8189,6 +8468,7 @@ class RecorderConfig:
   offset: Union[OffsetConfig, None] = None
   sensors: Union[SensorConfigList, None] = None
   equipmentKeyAssignments: Union[EquipmentKeyAssignments, None] = None
+  tags: Union[StringArray, None] = None
 
   def validate_isSecondary(self, value: bool) -> Tuple[bool, str]:
     if value is None:
@@ -8253,6 +8533,15 @@ class RecorderConfig:
 
     return [True, ""]
 
+  def validate_tags(self, value: StringArray) -> 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, "tags must be of type StringArray for RecorderConfig, 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_isSecondary(self.isSecondary)
@@ -8276,6 +8565,9 @@ class RecorderConfig:
     is_valid, error_str = self.validate_equipmentKeyAssignments(self.equipmentKeyAssignments)
     if not is_valid:
       raise TypeError(error_str)
+    is_valid, error_str = self.validate_tags(self.tags)
+    if not is_valid:
+      raise TypeError(error_str)
 
 def parse_recorder_config(data: object):
   return RecorderConfig(
@@ -8286,6 +8578,7 @@ def parse_recorder_config(data: object):
     offset=parse_offset_config(data["offset"]) if "offset" in data and data.get("offset") is not None else None,
     sensors=parse_sensor_config_list(data["sensors"]) if "sensors" in data and data.get("sensors") is not None else None,
     equipmentKeyAssignments=parse_equipment_key_assignments(data["equipmentKeyAssignments"]) if "equipmentKeyAssignments" in data and data.get("equipmentKeyAssignments") is not None else None,
+    tags=parse_string_array(data["tags"]) if "tags" in data and data.get("tags") is not None else None,
   )
 
 def serialize_recorder_config(data: RecorderConfig) -> object:
@@ -8297,6 +8590,7 @@ def serialize_recorder_config(data: RecorderConfig) -> object:
     "offset": None if data.offset is None else serialize_offset_config(data.offset),
     "sensors": None if data.sensors is None else serialize_sensor_config_list(data.sensors),
     "equipmentKeyAssignments": None if data.equipmentKeyAssignments is None else serialize_equipment_key_assignments(data.equipmentKeyAssignments),
+    "tags": None if data.tags is None else serialize_string_array(data.tags),
   }
 
 @dataclass
@@ -8838,6 +9132,9 @@ class TeleopState:
   config: Union[TeleopConfig, None] = None
   status: Union[TeleopStatus, None] = None
   botsInSync: Union[bool, None] = None
+  errors: Union[TeleopErrorArray, None] = None
+  gripperBounds: Union[GripperBounds, None] = None
+  robotFrame: Union[RobotFrame, None] = None
 
   def validate_config(self, value: TeleopConfig) -> Tuple[bool, str]:
     if value is None:
@@ -8866,6 +9163,33 @@ 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 validate_gripperBounds(self, value: GripperBounds) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, GripperBounds):
+      return [False, "gripperBounds must be of type GripperBounds for TeleopState, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_robotFrame(self, value: RobotFrame) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not ((isinstance(value, str) and RobotFrame in ['world', 'tooltip']) or isinstance(value, RobotFrame)):
+      return [False, "robotFrame must be of type RobotFrame 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)
@@ -8877,12 +9201,24 @@ 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)
+    is_valid, error_str = self.validate_gripperBounds(self.gripperBounds)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_robotFrame(self.robotFrame)
+    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,
+    gripperBounds=parse_gripper_bounds(data["gripperBounds"]) if "gripperBounds" in data and data.get("gripperBounds") is not None else None,
+    robotFrame=parse_robot_frame(data["robotFrame"]) if "robotFrame" in data and data.get("robotFrame") is not None else None,
   )
 
 def serialize_teleop_state(data: TeleopState) -> object:
@@ -8890,6 +9226,9 @@ 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),
+    "gripperBounds": None if data.gripperBounds is None else serialize_gripper_bounds(data.gripperBounds),
+    "robotFrame": None if data.robotFrame is None else serialize_robot_frame(data.robotFrame),
   }
 
 @dataclass
@@ -9071,6 +9410,7 @@ class StopRecordingResponse:
   state: Union[RecorderState, None] = None
   startTimestamp: Union[str, None] = None
   endTimestamp: Union[str, None] = None
+  status: Union[RecorderStatus, None] = None
 
   def validate_state(self, value: RecorderState) -> Tuple[bool, str]:
     if value is None:
@@ -9099,6 +9439,15 @@ class StopRecordingResponse:
 
     return [True, ""]
 
+  def validate_status(self, value: RecorderStatus) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not ((isinstance(value, str) and RecorderStatus in ['not_recording', 'recording', 'error', 'complete', 'initializing']) or isinstance(value, RecorderStatus)):
+      return [False, "status must be of type RecorderStatus for StopRecordingResponse, 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_state(self.state)
@@ -9110,12 +9459,16 @@ class StopRecordingResponse:
     is_valid, error_str = self.validate_endTimestamp(self.endTimestamp)
     if not is_valid:
       raise TypeError(error_str)
+    is_valid, error_str = self.validate_status(self.status)
+    if not is_valid:
+      raise TypeError(error_str)
 
 def parse_stop_recording_response(data: object):
   return StopRecordingResponse(
     state=parse_recorder_state(data["state"]) if "state" in data and data.get("state") is not None else None,
     startTimestamp=parse_str(data["startTimestamp"]) if "startTimestamp" in data and data.get("startTimestamp") is not None else None,
     endTimestamp=parse_str(data["endTimestamp"]) if "endTimestamp" in data and data.get("endTimestamp") is not None else None,
+    status=parse_recorder_status(data["status"]) if "status" in data and data.get("status") is not None else None,
   )
 
 def serialize_stop_recording_response(data: StopRecordingResponse) -> object:
@@ -9123,6 +9476,7 @@ def serialize_stop_recording_response(data: StopRecordingResponse) -> object:
     "state": None if data.state is None else serialize_recorder_state(data.state),
     "startTimestamp": None if data.startTimestamp is None else serialize_str(data.startTimestamp),
     "endTimestamp": None if data.endTimestamp is None else serialize_str(data.endTimestamp),
+    "status": None if data.status is None else serialize_recorder_status(data.status),
   }
 
 @dataclass

{standardbots-2.0.0.dev1760378411 → standardbots-2.0.0.dev1763152552}/standardbots.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: standardbots
-Version: 2.0.0.dev1760378411
+Version: 2.0.0.dev1763152552
 Summary: Standard Bots RO1 Robotics API
 Home-page: 
 Author: Standard Bots Support

{standardbots-2.0.0.dev1760378411 → standardbots-2.0.0.dev1763152552}/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
@@ -2442,6 +2442,21 @@ class TestGetStatusHealthHealth:
         assert res.health == models.StatusHealthEnum.Ok
 
 
+class TestGetSpaceGlobalSpaces:
+    """Tests: [GET] `/api/v1/space/globals`"""
+
+    def test_basic(self, client_live: StandardBotsRobot) -> None:
+        """Basic test"""
+        client = client_live
+        with client.connection():
+            res = client.space.list_global_spaces()
+            assert not res.isNotOk()
+            data = res.data
+            assert isinstance(data, models.SpacesPaginatedResponse)
+            # Implied by test bed requirements
+            assert len(data.items) >= 0
+
+
 class TestGetSpacePlanes:
     """Tests: [GET] `/api/v1/space/planes`"""
 
@@ -3317,12 +3332,16 @@ 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,