standardbots 2.0.0.dev1737492400__py3-none-any.whl → 2.0.0.dev1744666924__py3-none-any.whl

standardbots/auto_generated/apis.py

@@ -76,6 +76,95 @@ class RequestManager:
 
 class Default:
     _request_manager: RequestManager
+    class Calibration:
+        def __init__(self, request_manager: RequestManager):
+            self._request_manager = request_manager
+
+
+        def get_active_calibration(
+            self,
+        ) -> Response[
+            Union[
+                models.ActiveCalibrationContainer,
+                models.ErrorResponse,
+                None
+            ],
+            models.ActiveCalibrationContainer
+        ]:
+            """
+            Get the active calibration for the robot.
+
+            """
+            path = "/api/v1/calibration/active"
+            try:
+                response = self._request_manager.request(
+                    "GET",
+                    path,
+                    headers=self._request_manager.json_headers(),
+                )
+                parsed = None
+                if response.status == 200:
+                    parsed = models.parse_active_calibration_container(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_active_calibration(
+            self,
+            body: models.ActiveCalibrationContainer,
+        ) -> Response[
+            None,
+            None
+        ]:
+            """
+            Set the active calibration for the robot.
+
+            """
+            path = "/api/v1/calibration/active"
+            try:
+                response = self._request_manager.request(
+                    "POST",
+                    path,
+                    headers=self._request_manager.json_headers(),
+                    body=json.dumps(models.serialize_active_calibration_container(body)),
+                )
+                parsed = None
+
+                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
+                )
     class Equipment:
         def __init__(self, request_manager: RequestManager):
             self._request_manager = request_manager
@@ -83,7 +172,7 @@ class Default:
         def onrobot_2fg7_move(
           self,
           value: Union[int, float],
-          direction: Union[str, models.LinearGripDirectionEnum] = models.LinearGripDirectionEnum.Inward,
+          direction: Union[str, models.LinearGripDirectionEnum] = models.LinearGripDirectionEnum.Internal,
           unit_kind: Union[str, models.LinearUnitKind] = models.LinearUnitKind.Millimeters
         ):
           """Move the robot to the onrobot_2fg7 position.
@@ -105,7 +194,7 @@ class Default:
         def onrobot_2fg7_grip(
           self,
           value: Union[int, float],
-          direction: Union[str, models.LinearGripDirectionEnum] = models.LinearGripDirectionEnum.Inward,
+          direction: Union[str, models.LinearGripDirectionEnum] = models.LinearGripDirectionEnum.Internal,
           unit_kind: Union[str, models.LinearUnitKind] = models.LinearUnitKind.Millimeters,
           force: Union[int, float] = 0.0,
           force_unit: Union[str, models.ForceUnitKind] = models.ForceUnitKind.Newtons
@@ -382,12 +471,14 @@ class Default:
                     None
                 )
 
+    calibration: Calibration
     equipment: Equipment
     sensors: Sensors
     space: Space
 
     def __init__(self, request_manager: RequestManager):
         self._request_manager = request_manager
+        self.calibration = Default.Calibration(request_manager)
         self.equipment = Default.Equipment(request_manager)
         self.sensors = Default.Sensors(request_manager)
         self.space = Default.Space(request_manager)
@@ -425,6 +516,7 @@ class Movement:
             Union[
                 models.BrakesState,
                 models.ErrorResponse,
+                models.ErrorResponse,
                 None
             ],
             models.BrakesState
@@ -444,6 +536,8 @@ class Movement:
                 parsed = None
                 if response.status == 200:
                     parsed = models.parse_brakes_state(json.loads(response.data))
+                if response.status == 500:
+                    parsed = models.parse_error_response(json.loads(response.data))
 
                 is_user_error = response.status >= 400 and response.status <= 500
                 is_unavailable = response.status == 503
@@ -713,7 +807,7 @@ class Camera:
             None
         ]:
             """
-            Retrieve the latest RGB frame from the camera. In JPEG format.
+            Retrieve the latest RGB frame from the camera as base64 string. In JPEG format.
             """
             path = "/api/v1/camera/frame/rgb"
             try:
@@ -747,8 +841,12 @@ class Camera:
         def get_camera_intrinsics_color(
             self,
         ) -> Response[
-            None,
-            None
+            Union[
+                models.CameraIntrinsics,
+                models.ErrorResponse,
+                None
+            ],
+            models.CameraIntrinsics
         ]:
             """
             Retrieve the intrinsic parameters for the color camera.
@@ -761,6 +859,8 @@ class Camera:
                     headers=self._request_manager.json_headers(),
                 )
                 parsed = None
+                if response.status == 200:
+                    parsed = models.parse_camera_intrinsics(json.loads(response.data))
 
                 is_user_error = response.status >= 400 and response.status <= 500
                 is_unavailable = response.status == 503
@@ -788,7 +888,7 @@ class Camera:
             None
         ]:
             """
-            Retrieve the latest RGB frame from the camera.
+            Retrieve the latest RGB frame from the camera as base64 string. In JPEG format.
             """
             path = "/api/v1/camera/stream/rgb"
             try:
@@ -863,14 +963,64 @@ class Camera:
                     503,
                     None
                 )
+    class Status:
+        def __init__(self, request_manager: RequestManager):
+            self._request_manager = request_manager
+
+
+        def get_camera_status(
+            self,
+        ) -> Response[
+            Union[
+                models.CameraStatus,
+                models.ErrorResponse,
+                None
+            ],
+            models.CameraStatus
+        ]:
+            """
+            Retrieve the current status of the camera.
+            """
+            path = "/api/v1/camera/status"
+            try:
+                response = self._request_manager.request(
+                    "GET",
+                    path,
+                    headers=self._request_manager.json_headers(),
+                )
+                parsed = None
+                if response.status == 200:
+                    parsed = models.parse_camera_status(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
+                )
 
     data: Data
     settings: Settings
+    status: Status
 
     def __init__(self, request_manager: RequestManager):
         self._request_manager = request_manager
         self.data = Camera.Data(request_manager)
         self.settings = Camera.Settings(request_manager)
+        self.status = Camera.Status(request_manager)
 
 class Faults:
     _request_manager: RequestManager
@@ -1927,8 +2077,13 @@ class RoutineEditor:
             body: models.PlayRoutineRequest,
             routine_id: str,
         ) -> Response[
-            None,
-            None
+            Union[
+                models.PlayRoutineResponse,
+                models.ErrorResponse,
+                models.ErrorResponse,
+                None
+            ],
+            models.PlayRoutineResponse
         ]:
             """
             Play a routine
@@ -1943,6 +2098,10 @@ class RoutineEditor:
                     body=json.dumps(models.serialize_play_routine_request(body)),
                 )
                 parsed = None
+                if response.status == 200:
+                    parsed = models.parse_play_routine_response(json.loads(response.data))
+                if response.status == 400:
+                    parsed = models.parse_error_response(json.loads(response.data))
 
                 is_user_error = response.status >= 400 and response.status <= 500
                 is_unavailable = response.status == 503
@@ -1967,11 +2126,15 @@ class RoutineEditor:
             self,
             routine_id: str,
         ) -> Response[
-            None,
+            Union[
+                models.ErrorResponse,
+                models.ErrorResponse,
+                None
+            ],
             None
         ]:
             """
-            Pause a routine
+            Pause a routine. Routine must be running.
             """
             path = "/api/v1/routine-editor/routines/{routine_id}/pause"
             path = path.replace("{routine_id}", str(routine_id))
@@ -1982,6 +2145,8 @@ class RoutineEditor:
                     headers=self._request_manager.json_headers(),
                 )
                 parsed = None
+                if response.status == 400:
+                    parsed = models.parse_error_response(json.loads(response.data))
 
                 is_user_error = response.status >= 400 and response.status <= 500
                 is_unavailable = response.status == 503
@@ -2005,11 +2170,15 @@ class RoutineEditor:
         def stop(
             self,
         ) -> Response[
-            None,
+            Union[
+                models.ErrorResponse,
+                models.ErrorResponse,
+                None
+            ],
             None
         ]:
             """
-            Stop running routine and all ongoing motions
+            Stop running routine and all ongoing motions. Routine must be running.
             """
             path = "/api/v1/routine-editor/stop"
             try:
@@ -2019,6 +2188,8 @@ class RoutineEditor:
                     headers=self._request_manager.json_headers(),
                 )
                 parsed = None
+                if response.status == 400:
+                    parsed = models.parse_error_response(json.loads(response.data))
 
                 is_user_error = response.status >= 400 and response.status <= 500
                 is_unavailable = response.status == 503
@@ -2293,7 +2464,7 @@ class RoutineEditor:
             models.RuntimeVariable
         ]:
             """
-            Returns current state of a variable
+            Returns current state of a variable. Routine must be running.
             """
             path = "/api/v1/routine-editor/variables/{variable_name}"
             path = path.replace("{variable_name}", str(variable_name))
@@ -2339,7 +2510,7 @@ class RoutineEditor:
             models.RuntimeVariable
         ]:
             """
-            Update the value of a variable
+            Update the value of a variable. Routine must be running.
             """
             path = "/api/v1/routine-editor/variables/{variable_name}"
             path = path.replace("{variable_name}", str(variable_name))

standardbots/auto_generated/models.py

@@ -551,6 +551,51 @@ def serialize_camera_settings(data: CameraSettings) -> object:
     "autoWhiteBalance": None if data.autoWhiteBalance is None else serialize_bool(data.autoWhiteBalance),
   }
 
+@dataclass
+class CameraStatus:
+  """Current camera status."""
+  connected: Union[bool, None] = None
+  message: Union[str, None] = None
+
+  def validate_connected(self, value: bool) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, bool):
+      return [False, "connected must be of type bool for CameraStatus, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_message(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "message must be of type str for CameraStatus, 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_connected(self.connected)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_message(self.message)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_camera_status(data: object):
+  return CameraStatus(
+    connected=parse_bool(data["connected"]) if "connected" in data and data.get("connected") is not None else None,
+    message=parse_str(data["message"]) if "message" in data and data.get("message") is not None else None,
+  )
+
+def serialize_camera_status(data: CameraStatus) -> object:
+  return {
+    "connected": None if data.connected is None else serialize_bool(data.connected),
+    "message": None if data.message is None else serialize_str(data.message),
+  }
+
 @dataclass
 class CartesianPose:
   """Cartesian pose
@@ -1089,6 +1134,16 @@ class ErrorEnum(Enum):
   """Space specified was invalid or not found"""
   InvalidParameters = "invalid_parameters"
   """Parameters are invalid"""
+  RoutineDoesNotExist = "routine_does_not_exist"
+  """Routine does not exist"""
+  CannotPlayRoutine = "cannot_play_routine"
+  """Routine is not in the correct state to play"""
+  RoutineMustBePlaying = "routine_must_be_playing"
+  """Routine must be playing"""
+  CannotChangeRosState = "cannot_change_ros_state"
+  """Cannot change ROS state"""
+  IoSafeguardError = "io_safeguard_error"
+  """Cannot change IO state because of safeguard"""
 
 def parse_error_enum(data: object) -> ErrorEnum:
   return ErrorEnum(data)
@@ -1202,6 +1257,14 @@ def serialize_euler_pose(data: EulerPose) -> object:
     "rz": None if data.rz is None else serialize_f_64(data.rz),
   }
 
+FloatList = List[float]
+
+def parse_float_list(data: object) -> FloatList:
+  return [parse_f_64(item) for item in data]
+
+def serialize_float_list(data: FloatList) -> List[object]:
+  return [serialize_f_64(item) for item in data]
+
 class ForceUnitKind(Enum):
   Newtons = "newtons"
   """Enum Newtons = `newtons`"""
@@ -1435,10 +1498,10 @@ def serialize_joint_state_disturbance(data: JointStateDisturbance) -> object:
   }
 
 class LinearGripDirectionEnum(Enum):
-  Inward = "inward"
-  """Move gripper inward to grip. Measure grip position based on interior of gripper fingers and exterior of object"""
-  Outward = "outward"
-  """Grip gripper outward to grip. Measure grip position based on exterior of gripper fingers and interior of object"""
+  Internal = "internal"
+  """Grip object on the inside of gripper fingers. Measure grip position based on interior of gripper fingers and exterior of object"""
+  External = "external"
+  """Grip object on the outside of gripper fingers. Measure grip position based on exterior of gripper fingers and interior of object"""
 
 def parse_linear_grip_direction_enum(data: object) -> LinearGripDirectionEnum:
   return LinearGripDirectionEnum(data)
@@ -1531,10 +1594,10 @@ def serialize_on_robot_3_fg_15_control_kind_enum(data: Union[OnRobot3FG15Control
   return OnRobot3FG15ControlKindEnum(data).value
 
 class OnRobotGripKindEnum(Enum):
-  Inward = "inward"
-  """Enum Inward = `inward`"""
-  Outward = "outward"
-  """Enum Outward = `outward`"""
+  Internal = "internal"
+  """Enum Internal = `internal`"""
+  External = "external"
+  """Enum External = `external`"""
 
 def parse_on_robot_grip_kind_enum(data: object) -> OnRobotGripKindEnum:
   return OnRobotGripKindEnum(data)
@@ -2685,36 +2748,6 @@ def serialize_brakes_state(data: BrakesState) -> object:
     "state": serialize_brakes_state_enum(data.state),
   }
 
-@dataclass
-class CameraIntrinsicsResponse:
-  """Response with intrinsic parameters of the camera."""
-  intrinsics: Union[CameraIntrinsics, None] = None
-
-  def validate_intrinsics(self, value: CameraIntrinsics) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
-
-    if not isinstance(value, CameraIntrinsics):
-      return [False, "intrinsics must be of type CameraIntrinsics for CameraIntrinsicsResponse, 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_intrinsics(self.intrinsics)
-    if not is_valid:
-      raise TypeError(error_str)
-
-def parse_camera_intrinsics_response(data: object):
-  return CameraIntrinsicsResponse(
-    intrinsics=parse_camera_intrinsics(data["intrinsics"]) if "intrinsics" in data and data.get("intrinsics") is not None else None,
-  )
-
-def serialize_camera_intrinsics_response(data: CameraIntrinsicsResponse) -> object:
-  return {
-    "intrinsics": None if data.intrinsics is None else serialize_camera_intrinsics(data.intrinsics),
-  }
-
 @dataclass
 class CameraFrameRequest:
   """Request for a single camera frame. In JPEG format."""
@@ -3039,7 +3072,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']) 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']) or isinstance(value, ErrorEnum)):
       return [False, "error must be of type ErrorEnum for ErrorResponse, got " + type(value).__name__]
 
     return [True, ""]
@@ -3135,6 +3168,201 @@ def serialize_cartesian_pose_request(data: CartesianPoseRequest) -> object:
     "pose": serialize_euler_pose(data.pose),
   }
 
+@dataclass
+class URDFParameters:
+  """The URDF parameters for the robot"""
+  joint0_xyz: Union[FloatList, None] = None
+  joint0_rpy: Union[FloatList, None] = None
+  joint1_xyz: Union[FloatList, None] = None
+  joint1_rpy: Union[FloatList, None] = None
+  joint2_xyz: Union[FloatList, None] = None
+  joint2_rpy: Union[FloatList, None] = None
+  joint3_xyz: Union[FloatList, None] = None
+  joint3_rpy: Union[FloatList, None] = None
+  joint4_xyz: Union[FloatList, None] = None
+  joint4_rpy: Union[FloatList, None] = None
+  joint5_xyz: Union[FloatList, None] = None
+  joint5_rpy: Union[FloatList, None] = None
+
+  def validate_joint0_xyz(self, value: FloatList) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "joint0_xyz is required for URDFParameters"]
+
+    if not (isinstance(value, list) and all(isinstance(x, float) for x in value)):
+      return [False, "joint0_xyz must be of type FloatList for URDFParameters, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_joint0_rpy(self, value: FloatList) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "joint0_rpy is required for URDFParameters"]
+
+    if not (isinstance(value, list) and all(isinstance(x, float) for x in value)):
+      return [False, "joint0_rpy must be of type FloatList for URDFParameters, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_joint1_xyz(self, value: FloatList) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "joint1_xyz is required for URDFParameters"]
+
+    if not (isinstance(value, list) and all(isinstance(x, float) for x in value)):
+      return [False, "joint1_xyz must be of type FloatList for URDFParameters, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_joint1_rpy(self, value: FloatList) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "joint1_rpy is required for URDFParameters"]
+
+    if not (isinstance(value, list) and all(isinstance(x, float) for x in value)):
+      return [False, "joint1_rpy must be of type FloatList for URDFParameters, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_joint2_xyz(self, value: FloatList) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "joint2_xyz is required for URDFParameters"]
+
+    if not (isinstance(value, list) and all(isinstance(x, float) for x in value)):
+      return [False, "joint2_xyz must be of type FloatList for URDFParameters, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_joint2_rpy(self, value: FloatList) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "joint2_rpy is required for URDFParameters"]
+
+    if not (isinstance(value, list) and all(isinstance(x, float) for x in value)):
+      return [False, "joint2_rpy must be of type FloatList for URDFParameters, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_joint3_xyz(self, value: FloatList) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "joint3_xyz is required for URDFParameters"]
+
+    if not (isinstance(value, list) and all(isinstance(x, float) for x in value)):
+      return [False, "joint3_xyz must be of type FloatList for URDFParameters, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_joint3_rpy(self, value: FloatList) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "joint3_rpy is required for URDFParameters"]
+
+    if not (isinstance(value, list) and all(isinstance(x, float) for x in value)):
+      return [False, "joint3_rpy must be of type FloatList for URDFParameters, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_joint4_xyz(self, value: FloatList) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "joint4_xyz is required for URDFParameters"]
+
+    if not (isinstance(value, list) and all(isinstance(x, float) for x in value)):
+      return [False, "joint4_xyz must be of type FloatList for URDFParameters, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_joint4_rpy(self, value: FloatList) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "joint4_rpy is required for URDFParameters"]
+
+    if not (isinstance(value, list) and all(isinstance(x, float) for x in value)):
+      return [False, "joint4_rpy must be of type FloatList for URDFParameters, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_joint5_xyz(self, value: FloatList) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "joint5_xyz is required for URDFParameters"]
+
+    if not (isinstance(value, list) and all(isinstance(x, float) for x in value)):
+      return [False, "joint5_xyz must be of type FloatList for URDFParameters, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_joint5_rpy(self, value: FloatList) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "joint5_rpy is required for URDFParameters"]
+
+    if not (isinstance(value, list) and all(isinstance(x, float) for x in value)):
+      return [False, "joint5_rpy must be of type FloatList for URDFParameters, 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_joint0_xyz(self.joint0_xyz)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_joint0_rpy(self.joint0_rpy)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_joint1_xyz(self.joint1_xyz)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_joint1_rpy(self.joint1_rpy)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_joint2_xyz(self.joint2_xyz)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_joint2_rpy(self.joint2_rpy)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_joint3_xyz(self.joint3_xyz)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_joint3_rpy(self.joint3_rpy)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_joint4_xyz(self.joint4_xyz)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_joint4_rpy(self.joint4_rpy)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_joint5_xyz(self.joint5_xyz)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_joint5_rpy(self.joint5_rpy)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_urdf_parameters(data: object):
+  return URDFParameters(
+    joint0_xyz=parse_float_list(data["joint0_xyz"]) if "joint0_xyz" in data and data.get("joint0_xyz") is not None else None,
+    joint0_rpy=parse_float_list(data["joint0_rpy"]) if "joint0_rpy" in data and data.get("joint0_rpy") is not None else None,
+    joint1_xyz=parse_float_list(data["joint1_xyz"]) if "joint1_xyz" in data and data.get("joint1_xyz") is not None else None,
+    joint1_rpy=parse_float_list(data["joint1_rpy"]) if "joint1_rpy" in data and data.get("joint1_rpy") is not None else None,
+    joint2_xyz=parse_float_list(data["joint2_xyz"]) if "joint2_xyz" in data and data.get("joint2_xyz") is not None else None,
+    joint2_rpy=parse_float_list(data["joint2_rpy"]) if "joint2_rpy" in data and data.get("joint2_rpy") is not None else None,
+    joint3_xyz=parse_float_list(data["joint3_xyz"]) if "joint3_xyz" in data and data.get("joint3_xyz") is not None else None,
+    joint3_rpy=parse_float_list(data["joint3_rpy"]) if "joint3_rpy" in data and data.get("joint3_rpy") is not None else None,
+    joint4_xyz=parse_float_list(data["joint4_xyz"]) if "joint4_xyz" in data and data.get("joint4_xyz") is not None else None,
+    joint4_rpy=parse_float_list(data["joint4_rpy"]) if "joint4_rpy" in data and data.get("joint4_rpy") is not None else None,
+    joint5_xyz=parse_float_list(data["joint5_xyz"]) if "joint5_xyz" in data and data.get("joint5_xyz") is not None else None,
+    joint5_rpy=parse_float_list(data["joint5_rpy"]) if "joint5_rpy" in data and data.get("joint5_rpy") is not None else None,
+  )
+
+def serialize_urdf_parameters(data: URDFParameters) -> object:
+  return {
+    "joint0_xyz": serialize_float_list(data.joint0_xyz),
+    "joint0_rpy": serialize_float_list(data.joint0_rpy),
+    "joint1_xyz": serialize_float_list(data.joint1_xyz),
+    "joint1_rpy": serialize_float_list(data.joint1_rpy),
+    "joint2_xyz": serialize_float_list(data.joint2_xyz),
+    "joint2_rpy": serialize_float_list(data.joint2_rpy),
+    "joint3_xyz": serialize_float_list(data.joint3_xyz),
+    "joint3_rpy": serialize_float_list(data.joint3_rpy),
+    "joint4_xyz": serialize_float_list(data.joint4_xyz),
+    "joint4_rpy": serialize_float_list(data.joint4_rpy),
+    "joint5_xyz": serialize_float_list(data.joint5_xyz),
+    "joint5_rpy": serialize_float_list(data.joint5_rpy),
+  }
+
 @dataclass
 class ForceUnit:
   """Reusable Abstraction for force units (eg force, torque)
@@ -3660,7 +3888,7 @@ class OnRobot2FG14GripperConfiguration:
     if value is None:
       return [True, ""]
 
-    if not ((isinstance(value, str) and OnRobotGripKindEnum in ['inward', 'outward']) or isinstance(value, OnRobotGripKindEnum)):
+    if not ((isinstance(value, str) and OnRobotGripKindEnum in ['internal', 'external']) or isinstance(value, OnRobotGripKindEnum)):
       return [False, "grip_kind must be of type OnRobotGripKindEnum for OnRobot2FG14GripperConfiguration, got " + type(value).__name__]
 
     return [True, ""]
@@ -3960,7 +4188,7 @@ class OnRobot2FG7GripperConfiguration:
     if value is None:
       return [True, ""]
 
-    if not ((isinstance(value, str) and OnRobotGripKindEnum in ['inward', 'outward']) or isinstance(value, OnRobotGripKindEnum)):
+    if not ((isinstance(value, str) and OnRobotGripKindEnum in ['internal', 'external']) or isinstance(value, OnRobotGripKindEnum)):
       return [False, "grip_kind must be of type OnRobotGripKindEnum for OnRobot2FG7GripperConfiguration, got " + type(value).__name__]
 
     return [True, ""]
@@ -4289,7 +4517,7 @@ class OnRobot3FG15GripperConfiguration:
     if value is None:
       return [True, ""]
 
-    if not ((isinstance(value, str) and OnRobotGripKindEnum in ['inward', 'outward']) or isinstance(value, OnRobotGripKindEnum)):
+    if not ((isinstance(value, str) and OnRobotGripKindEnum in ['internal', 'external']) or isinstance(value, OnRobotGripKindEnum)):
       return [False, "grip_kind must be of type OnRobotGripKindEnum for OnRobot3FG15GripperConfiguration, got " + type(value).__name__]
 
     return [True, ""]
@@ -4661,6 +4889,36 @@ def serialize_robot_control_mode(data: RobotControlMode) -> object:
     "kind": None if data.kind is None else serialize_robot_control_mode_enum(data.kind),
   }
 
+@dataclass
+class PlayRoutineResponse:
+  """Status response informs user of of robot state"""
+  status: Union[RobotStatusEnum, None] = None
+
+  def validate_status(self, value: RobotStatusEnum) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not ((isinstance(value, str) and RobotStatusEnum in ['Idle', 'RunningAdHocCommand', 'RoutineRunning', 'Antigravity', 'AntigravitySlow', 'Failure', 'Recovering']) or isinstance(value, RobotStatusEnum)):
+      return [False, "status must be of type RobotStatusEnum for PlayRoutineResponse, 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_status(self.status)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_play_routine_response(data: object):
+  return PlayRoutineResponse(
+    status=parse_robot_status_enum(data["status"]) if "status" in data and data.get("status") is not None else None,
+  )
+
+def serialize_play_routine_response(data: PlayRoutineResponse) -> object:
+  return {
+    "status": None if data.status is None else serialize_robot_status_enum(data.status),
+  }
+
 @dataclass
 class ROSControlStateResponse:
   """Response to a query for the current state of ROS control."""
@@ -4985,6 +5243,66 @@ def serialize_routine(data: Routine) -> object:
     "environment_variables": None if data.environment_variables is None else serialize_environment_variables_list(data.environment_variables),
   }
 
+@dataclass
+class CalibrationData:
+  """The result of a calibration"""
+  timestamp: Union[str, None] = None
+  armSerial: Union[str, None] = None
+  urdfParameters: Union[URDFParameters, None] = None
+
+  def validate_timestamp(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "timestamp is required for CalibrationData"]
+
+    if not isinstance(value, str):
+      return [False, "timestamp must be of type str for CalibrationData, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_armSerial(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "armSerial is required for CalibrationData"]
+
+    if not isinstance(value, str):
+      return [False, "armSerial must be of type str for CalibrationData, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_urdfParameters(self, value: URDFParameters) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "urdfParameters is required for CalibrationData"]
+
+    if not isinstance(value, URDFParameters):
+      return [False, "urdfParameters must be of type URDFParameters for CalibrationData, 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_timestamp(self.timestamp)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_armSerial(self.armSerial)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_urdfParameters(self.urdfParameters)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_calibration_data(data: object):
+  return CalibrationData(
+    timestamp=parse_str(data["timestamp"]) if "timestamp" in data and data.get("timestamp") is not None else None,
+    armSerial=parse_str(data["armSerial"]) if "armSerial" in data and data.get("armSerial") is not None else None,
+    urdfParameters=parse_urdf_parameters(data["urdfParameters"]) if "urdfParameters" in data and data.get("urdfParameters") is not None else None,
+  )
+
+def serialize_calibration_data(data: CalibrationData) -> object:
+  return {
+    "timestamp": serialize_str(data.timestamp),
+    "armSerial": serialize_str(data.armSerial),
+    "urdfParameters": serialize_urdf_parameters(data.urdfParameters),
+  }
+
 ArmJointRotationsList = List[ArmJointRotations]
 
 def parse_arm_joint_rotations_list(data: object) -> ArmJointRotationsList:
@@ -5111,7 +5429,7 @@ class OnRobot2FG14GripperCommandRequest:
     if value is None:
       return [False, "grip_direction is required for OnRobot2FG14GripperCommandRequest"]
 
-    if not ((isinstance(value, str) and LinearGripDirectionEnum in ['inward', 'outward']) or isinstance(value, LinearGripDirectionEnum)):
+    if not ((isinstance(value, str) and LinearGripDirectionEnum in ['internal', 'external']) or isinstance(value, LinearGripDirectionEnum)):
       return [False, "grip_direction must be of type LinearGripDirectionEnum for OnRobot2FG14GripperCommandRequest, got " + type(value).__name__]
 
     return [True, ""]
@@ -5187,7 +5505,7 @@ class OnRobot2FG7GripperCommandRequest:
     if value is None:
       return [False, "grip_direction is required for OnRobot2FG7GripperCommandRequest"]
 
-    if not ((isinstance(value, str) and LinearGripDirectionEnum in ['inward', 'outward']) or isinstance(value, LinearGripDirectionEnum)):
+    if not ((isinstance(value, str) and LinearGripDirectionEnum in ['internal', 'external']) or isinstance(value, LinearGripDirectionEnum)):
       return [False, "grip_direction must be of type LinearGripDirectionEnum for OnRobot2FG7GripperCommandRequest, got " + type(value).__name__]
 
     return [True, ""]
@@ -5263,7 +5581,7 @@ class OnRobot3FG15GripperCommandRequest:
     if value is None:
       return [False, "grip_direction is required for OnRobot3FG15GripperCommandRequest"]
 
-    if not ((isinstance(value, str) and LinearGripDirectionEnum in ['inward', 'outward']) or isinstance(value, LinearGripDirectionEnum)):
+    if not ((isinstance(value, str) and LinearGripDirectionEnum in ['internal', 'external']) or isinstance(value, LinearGripDirectionEnum)):
       return [False, "grip_direction must be of type LinearGripDirectionEnum for OnRobot3FG15GripperCommandRequest, got " + type(value).__name__]
 
     return [True, ""]
@@ -5794,6 +6112,36 @@ def parse_routines_list(data: object) -> RoutinesList:
 def serialize_routines_list(data: RoutinesList) -> List[object]:
   return [serialize_routine(item) for item in data]
 
+@dataclass
+class ActiveCalibrationContainer:
+  """The response to an active calibration request"""
+  calibrationData: Union[CalibrationData, None] = None
+
+  def validate_calibrationData(self, value: CalibrationData) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, CalibrationData):
+      return [False, "calibrationData must be of type CalibrationData for ActiveCalibrationContainer, 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_calibrationData(self.calibrationData)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_active_calibration_container(data: object):
+  return ActiveCalibrationContainer(
+    calibrationData=parse_calibration_data(data["calibrationData"]) if "calibrationData" in data and data.get("calibrationData") is not None else None,
+  )
+
+def serialize_active_calibration_container(data: ActiveCalibrationContainer) -> object:
+  return {
+    "calibrationData": None if data.calibrationData is None else serialize_calibration_data(data.calibrationData),
+  }
+
 @dataclass
 class GripperCommandRequest:
   """Control the gripper (end effector) of the robot
@@ -6226,7 +6574,6 @@ class ArmPositionUpdateRequest:
   joint_rotation: Union[ArmJointRotations, None] = None
   movement_kind: Union[MovementKindEnum, None] = None
   speed_profile: Union[SpeedProfile, None] = None
-  response: Union[ArmPositionUpdateRequestResponseFormat, None] = None
 
   def validate_kind(self, value: ArmPositionUpdateRequestKindEnum) -> Tuple[bool, str]:
     if value is None:
@@ -6291,15 +6638,6 @@ class ArmPositionUpdateRequest:
 
     return [True, ""]
 
-  def validate_response(self, value: ArmPositionUpdateRequestResponseFormat) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
-
-    if not isinstance(value, ArmPositionUpdateRequestResponseFormat):
-      return [False, "response must be of type ArmPositionUpdateRequestResponseFormat for ArmPositionUpdateRequest, 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_kind(self.kind)
@@ -6323,9 +6661,6 @@ class ArmPositionUpdateRequest:
     is_valid, error_str = self.validate_speed_profile(self.speed_profile)
     if not is_valid:
       raise TypeError(error_str)
-    is_valid, error_str = self.validate_response(self.response)
-    if not is_valid:
-      raise TypeError(error_str)
 
 def parse_arm_position_update_request(data: object):
   return ArmPositionUpdateRequest(
@@ -6336,7 +6671,6 @@ def parse_arm_position_update_request(data: object):
     joint_rotation=parse_arm_joint_rotations(data["joint_rotation"]) if "joint_rotation" in data and data.get("joint_rotation") is not None else None,
     movement_kind=parse_movement_kind_enum(data["movement_kind"]) if "movement_kind" in data and data.get("movement_kind") is not None else None,
     speed_profile=parse_speed_profile(data["speed_profile"]) if "speed_profile" in data and data.get("speed_profile") is not None else None,
-    response=parse_arm_position_update_request_response_format(data["response"]) if "response" in data and data.get("response") is not None else None,
   )
 
 def serialize_arm_position_update_request(data: ArmPositionUpdateRequest) -> object:
@@ -6348,7 +6682,6 @@ def serialize_arm_position_update_request(data: ArmPositionUpdateRequest) -> obj
     "joint_rotation": None if data.joint_rotation is None else serialize_arm_joint_rotations(data.joint_rotation),
     "movement_kind": None if data.movement_kind is None else serialize_movement_kind_enum(data.movement_kind),
     "speed_profile": None if data.speed_profile is None else serialize_speed_profile(data.speed_profile),
-    "response": None if data.response is None else serialize_arm_position_update_request_response_format(data.response),
   }
 
 @dataclass

{standardbots-2.0.0.dev1737492400.dist-info → standardbots-2.0.0.dev1744666924.dist-info}/METADATA

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

standardbots-2.0.0.dev1744666924.dist-info/RECORD

@@ -0,0 +1,11 @@
+standardbots/__init__.py,sha256=PT6Z2HPama2fb6SaNhF3J1skpYABQWGgDzKEtQY6BDM,29
+standardbots/auto_generated/__init__.py,sha256=PZtDUzYcjIO6R-gE-0NzY0vFXk1Je1tJ3je0ivV5o-k,98
+standardbots/auto_generated/apis.py,sha256=y0U33UjyD6yDF2dgqNjJLdMWdmC4TwceqpL8d0v_EoU,97866
+standardbots/auto_generated/models.py,sha256=aA5vR9NFp6VXS03Hr3CKX68-Y15HpOdoSOI-RKLucAU,276091
+tests/fixtures/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/fixtures/client_fixt.py,sha256=Va_L90iYIYPguyqr2eYE15ERkCgGgbee3AVLei8TCq4,644
+tests/fixtures/routines_fixt.py,sha256=CpdwndlSDmwFCxzCXicIAeFT2CO2VQqFm_6gVAF385c,1326
+standardbots-2.0.0.dev1744666924.dist-info/METADATA,sha256=HeI03zEguU5s2SWVVkUq6HfiF0vtk5qXLnzfK5VaSCQ,558
+standardbots-2.0.0.dev1744666924.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+standardbots-2.0.0.dev1744666924.dist-info/top_level.txt,sha256=eHgNxowGe-eEE7gOyeuwXN3bHLClu-TQ1VnsOOzzTkw,19
+standardbots-2.0.0.dev1744666924.dist-info/RECORD,,

{standardbots-2.0.0.dev1737492400.dist-info → standardbots-2.0.0.dev1744666924.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.0)
+Generator: setuptools (78.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

standardbots-2.0.0.dev1737492400.dist-info/RECORD

@@ -1,11 +0,0 @@
-standardbots/__init__.py,sha256=PT6Z2HPama2fb6SaNhF3J1skpYABQWGgDzKEtQY6BDM,29
-standardbots/auto_generated/__init__.py,sha256=PZtDUzYcjIO6R-gE-0NzY0vFXk1Je1tJ3je0ivV5o-k,98
-standardbots/auto_generated/apis.py,sha256=G3sh8CbbfjxoFTmzc8xI4swajPxD5xOWTaKg6hjY5kg,91393
-standardbots/auto_generated/models.py,sha256=VtkMHR2aEnsXO3U2xuhDQrRMcVCQp2uRj_WbAKLZYAc,261851
-tests/fixtures/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/fixtures/client_fixt.py,sha256=Va_L90iYIYPguyqr2eYE15ERkCgGgbee3AVLei8TCq4,644
-tests/fixtures/routines_fixt.py,sha256=CpdwndlSDmwFCxzCXicIAeFT2CO2VQqFm_6gVAF385c,1326
-standardbots-2.0.0.dev1737492400.dist-info/METADATA,sha256=Kq7S7_-CRiWzSdLyABdW0bz8HDUlFKyP33OYJxttDx8,558
-standardbots-2.0.0.dev1737492400.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-standardbots-2.0.0.dev1737492400.dist-info/top_level.txt,sha256=eHgNxowGe-eEE7gOyeuwXN3bHLClu-TQ1VnsOOzzTkw,19
-standardbots-2.0.0.dev1737492400.dist-info/RECORD,,