standardbots 2.0.0.dev1758730305__tar.gz → 2.0.0.dev1763152552__tar.gz

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

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

{standardbots-2.0.0.dev1758730305 → 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-dev1758730305"
+VERSION = "2.0.0-dev1763152552"
 # To install the library, run the following
 #
 # python setup.py install

{standardbots-2.0.0.dev1758730305 → 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,
@@ -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.dev1758730305 → 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"""
@@ -2660,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`"""
@@ -3341,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:
@@ -4242,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, ""]
@@ -4579,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."""
@@ -6082,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"""
@@ -6593,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"""
@@ -6604,6 +6702,8 @@ class BotTeleopDetails:
   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:
@@ -6677,6 +6777,24 @@ class BotTeleopDetails:
 
     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)
@@ -6703,6 +6821,12 @@ class BotTeleopDetails:
     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(
@@ -6714,6 +6838,8 @@ def parse_bot_teleop_details(data: object):
     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:
@@ -6726,6 +6852,8 @@ def serialize_bot_teleop_details(data: BotTeleopDetails) -> object:
     "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
@@ -6918,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:
@@ -7688,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"""
@@ -8244,13 +8462,13 @@ def serialize_get_messages_response(data: GetMessagesResponse) -> object:
 class RecorderConfig:
   """Config of the recorder"""
   isSecondary: Union[bool, None] = None
-  isInference: Union[bool, None] = None
   userId: Union[str, None] = None
   taskId: Union[str, None] = None
   bots: Union[RecorderBotDetailsList, None] = None
   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:
@@ -8261,15 +8479,6 @@ class RecorderConfig:
 
     return [True, ""]
 
-  def validate_isInference(self, value: bool) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
-
-    if not isinstance(value, bool):
-      return [False, "isInference must be of type bool for RecorderConfig, got " + type(value).__name__]
-
-    return [True, ""]
-
   def validate_userId(self, value: str) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
@@ -8324,12 +8533,18 @@ 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)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_isInference(self.isInference)
     if not is_valid:
       raise TypeError(error_str)
     is_valid, error_str = self.validate_userId(self.userId)
@@ -8350,29 +8565,32 @@ 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(
     isSecondary=parse_bool(data["isSecondary"]) if "isSecondary" in data and data.get("isSecondary") is not None else None,
-    isInference=parse_bool(data["isInference"]) if "isInference" in data and data.get("isInference") is not None else None,
     userId=parse_str(data["userId"]) if "userId" in data and data.get("userId") is not None else None,
     taskId=parse_str(data["taskId"]) if "taskId" in data and data.get("taskId") is not None else None,
     bots=parse_recorder_bot_details_list(data["bots"]) if "bots" in data and data.get("bots") is not None else None,
     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:
   return {
     "isSecondary": None if data.isSecondary is None else serialize_bool(data.isSecondary),
-    "isInference": None if data.isInference is None else serialize_bool(data.isInference),
     "userId": None if data.userId is None else serialize_str(data.userId),
     "taskId": None if data.taskId is None else serialize_str(data.taskId),
     "bots": None if data.bots is None else serialize_recorder_bot_details_list(data.bots),
     "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
@@ -8915,6 +9133,8 @@ class TeleopState:
   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:
@@ -8952,6 +9172,24 @@ class TeleopState:
 
     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)
@@ -8966,6 +9204,12 @@ class TeleopState:
     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(
@@ -8973,6 +9217,8 @@ def parse_teleop_state(data: object):
     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:
@@ -8981,6 +9227,8 @@ def serialize_teleop_state(data: TeleopState) -> object:
     "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
@@ -9162,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:
@@ -9190,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)
@@ -9201,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:
@@ -9214,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.dev1758730305 → standardbots-2.0.0.dev1763152552}/standardbots.egg-info/PKG-INFO

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

{standardbots-2.0.0.dev1758730305 → standardbots-2.0.0.dev1763152552}/tests/test_apis.py

@@ -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`"""
 
@@ -3323,7 +3338,10 @@ class TestPostMovementPositionArmControlled:
             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 == "Failed to generate a motion plan"
+            assert (
+                heartbeat_data.event.failure.reason
+                == "Failed to generate a motion plan"
+            )
 
     def test_move_then_stop_heartbeat(
         self,