standardbots 2.0.0.dev1734558734__tar.gz → 2.0.0.dev1736521253__tar.gz

{standardbots-2.0.0.dev1734558734 → standardbots-2.0.0.dev1736521253}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: standardbots
-Version: 2.0.0.dev1734558734
+Version: 2.0.0.dev1736521253
 Summary: Standard Bots RO1 Robotics API
 Home-page: 
 Author: Standard Bots Support
@@ -10,6 +10,13 @@ Requires-Python: >=3.7
 Requires-Dist: setuptools>=21.0.0
 Requires-Dist: typing_extensions>=4.3.0
 Requires-Dist: urllib3>=1.26.7
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: keywords
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
     Standard Bots RO1 Robotics API.  # noqa: E501
     

{standardbots-2.0.0.dev1734558734 → standardbots-2.0.0.dev1736521253}/setup.py

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

{standardbots-2.0.0.dev1734558734 → standardbots-2.0.0.dev1736521253}/standardbots/auto_generated/apis.py

@@ -932,6 +932,113 @@ class Faults:
         self._request_manager = request_manager
         self.user_faults = Faults.UserFaults(request_manager)
 
+class General:
+    _request_manager: RequestManager
+    class BotIdentity:
+        def __init__(self, request_manager: RequestManager):
+            self._request_manager = request_manager
+
+
+        def bot_identity(
+            self,
+        ) -> Response[
+            Union[
+                models.BotIdentityData,
+                models.ErrorResponse,
+                None
+            ],
+            models.BotIdentityData
+        ]:
+            """
+            Get information about the robot's identity.
+            """
+            path = "/api/v1/identity/bot_identity"
+            try:
+                response = self._request_manager.request(
+                    "GET",
+                    path,
+                    headers=self._request_manager.json_headers(),
+                )
+                parsed = None
+                if response.status == 200:
+                    parsed = models.parse_bot_identity_data(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
+                )
+    class Joints:
+        def __init__(self, request_manager: RequestManager):
+            self._request_manager = request_manager
+
+
+        def get_joints_state(
+            self,
+        ) -> Response[
+            Union[
+                models.JointsStateResponse,
+                models.ErrorResponse,
+                None
+            ],
+            models.JointsStateResponse
+        ]:
+            """
+            Retrieves information about the state of each joint
+            """
+            path = "/api/v1/joints"
+            try:
+                response = self._request_manager.request(
+                    "GET",
+                    path,
+                    headers=self._request_manager.json_headers(),
+                )
+                parsed = None
+                if response.status == 200:
+                    parsed = models.parse_joints_state_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
+                )
+
+    bot_identity: BotIdentity
+    joints: Joints
+
+    def __init__(self, request_manager: RequestManager):
+        self._request_manager = request_manager
+        self.bot_identity = General.BotIdentity(request_manager)
+        self.joints = General.Joints(request_manager)
+
 class ChatGPT:
     _request_manager: RequestManager
     class Data:
@@ -1136,63 +1243,6 @@ class IO:
         self.control = IO.Control(request_manager)
         self.status = IO.Status(request_manager)
 
-class General:
-    _request_manager: RequestManager
-    class Joints:
-        def __init__(self, request_manager: RequestManager):
-            self._request_manager = request_manager
-
-
-        def get_joints_state(
-            self,
-        ) -> Response[
-            Union[
-                models.JointsStateResponse,
-                models.ErrorResponse,
-                None
-            ],
-            models.JointsStateResponse
-        ]:
-            """
-            Retrieves information about the state of each joint
-            """
-            path = "/api/v1/joints"
-            try:
-                response = self._request_manager.request(
-                    "GET",
-                    path,
-                    headers=self._request_manager.json_headers(),
-                )
-                parsed = None
-                if response.status == 200:
-                    parsed = models.parse_joints_state_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
-                )
-
-    joints: Joints
-
-    def __init__(self, request_manager: RequestManager):
-        self._request_manager = request_manager
-        self.joints = General.Joints(request_manager)
-
 class Poses:
     _request_manager: RequestManager
     class ConstructPose:
@@ -1662,15 +1712,15 @@ class Recovery:
             self,
         ) -> Response[
             Union[
-                models.RecoveryStatusResponse,
+                models.FailureStateResponse,
                 models.ErrorResponse,
                 models.ErrorResponse,
                 None
             ],
-            models.RecoveryStatusResponse
+            models.FailureStateResponse
         ]:
             """
-            Recovers the robot from a fault state.
+            Attempts to recover the robot from a fault state. Inspect the response to determine if additional recovery actions are required.
 
             """
             path = "/api/v1/recovery/recover"
@@ -1682,7 +1732,7 @@ class Recovery:
                 )
                 parsed = None
                 if response.status == 200:
-                    parsed = models.parse_recovery_status_response(json.loads(response.data))
+                    parsed = models.parse_failure_state_response(json.loads(response.data))
                 if response.status == 400:
                     parsed = models.parse_error_response(json.loads(response.data))
 
@@ -2493,9 +2543,9 @@ class StandardBotsRobot(Default):
     movement: Movement
     camera: Camera
     faults: Faults
+    general: General
     chat_gpt: ChatGPT
     io: IO
-    general: General
     poses: Poses
     recovery: Recovery
     ros: ROS
@@ -2517,9 +2567,9 @@ class StandardBotsRobot(Default):
         self.movement = Movement(self._request_manager)
         self.camera = Camera(self._request_manager)
         self.faults = Faults(self._request_manager)
+        self.general = General(self._request_manager)
         self.chat_gpt = ChatGPT(self._request_manager)
         self.io = IO(self._request_manager)
-        self.general = General(self._request_manager)
         self.poses = Poses(self._request_manager)
         self.recovery = Recovery(self._request_manager)
         self.ros = ROS(self._request_manager)

{standardbots-2.0.0.dev1734558734 → standardbots-2.0.0.dev1736521253}/standardbots/auto_generated/models.py

@@ -224,6 +224,81 @@ def parse_arm_position_update_request_response_kind_enum(data: object) -> ArmPos
 def serialize_arm_position_update_request_response_kind_enum(data: Union[ArmPositionUpdateRequestResponseKindEnum, str]) -> object:
   return ArmPositionUpdateRequestResponseKindEnum(data).value
 
+@dataclass
+class BotIdentityData:
+  """Data about the robot's identity"""
+  robotId: Union[str, None] = None
+  alias: Union[str, None] = None
+  robotOperationMode: Union[str, None] = None
+  applicationUrl: Union[str, None] = None
+
+  def validate_robotId(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "robotId must be of type str for BotIdentityData, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_alias(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "alias must be of type str for BotIdentityData, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_robotOperationMode(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "robotOperationMode must be of type str for BotIdentityData, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_applicationUrl(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "applicationUrl must be of type str for BotIdentityData, 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_robotId(self.robotId)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_alias(self.alias)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_robotOperationMode(self.robotOperationMode)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_applicationUrl(self.applicationUrl)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_bot_identity_data(data: object):
+  return BotIdentityData(
+    robotId=parse_str(data["robotId"]) if "robotId" in data and data.get("robotId") is not None else None,
+    alias=parse_str(data["alias"]) if "alias" in data and data.get("alias") is not None else None,
+    robotOperationMode=parse_str(data["robotOperationMode"]) if "robotOperationMode" in data and data.get("robotOperationMode") is not None else None,
+    applicationUrl=parse_str(data["applicationUrl"]) if "applicationUrl" in data and data.get("applicationUrl") is not None else None,
+  )
+
+def serialize_bot_identity_data(data: BotIdentityData) -> object:
+  return {
+    "robotId": None if data.robotId is None else serialize_str(data.robotId),
+    "alias": None if data.alias is None else serialize_str(data.alias),
+    "robotOperationMode": None if data.robotOperationMode is None else serialize_str(data.robotOperationMode),
+    "applicationUrl": None if data.applicationUrl is None else serialize_str(data.applicationUrl),
+  }
+
 class BrakesStateEnum(Enum):
   Engaged = "engaged"
   """Robot Brakes are engaged, robot is not able to move"""
@@ -1941,70 +2016,6 @@ def serialize_quaternion(data: Quaternion) -> object:
     "w": None if data.w is None else serialize_f_64(data.w),
   }
 
-class RecoveryStateEnum(Enum):
-  Success = "Success"
-  """Enum Success = `Success`"""
-  Interrupted = "Interrupted"
-  """Enum Interrupted = `Interrupted`"""
-  NonIdle = "NonIdle"
-  """Enum NonIdle = `NonIdle`"""
-  Braked = "Braked"
-  """Enum Braked = `Braked`"""
-  PlanningFailure = "PlanningFailure"
-  """Enum PlanningFailure = `PlanningFailure`"""
-  ExecutionFailure = "ExecutionFailure"
-  """Enum ExecutionFailure = `ExecutionFailure`"""
-  ControlSystemFailure = "ControlSystemFailure"
-  """Enum ControlSystemFailure = `ControlSystemFailure`"""
-  EStopTriggered = "EStopTriggered"
-  """Enum EStopTriggered = `EStopTriggered`"""
-  GripperFailure = "GripperFailure"
-  """Enum GripperFailure = `GripperFailure`"""
-  OutOfJointLimitsFailure = "OutOfJointLimitsFailure"
-  """Enum OutOfJointLimitsFailure = `OutOfJointLimitsFailure`"""
-  CollisionFailure = "CollisionFailure"
-  """Enum CollisionFailure = `CollisionFailure`"""
-  TorqueCollisionFailure = "TorqueCollisionFailure"
-  """Enum TorqueCollisionFailure = `TorqueCollisionFailure`"""
-  InBoxingPositionFailure = "InBoxingPositionFailure"
-  """Enum InBoxingPositionFailure = `InBoxingPositionFailure`"""
-  PowerBoardCheckFailure = "PowerBoardCheckFailure"
-  """Enum PowerBoardCheckFailure = `PowerBoardCheckFailure`"""
-  MotionPlannerFailure = "MotionPlannerFailure"
-  """Enum MotionPlannerFailure = `MotionPlannerFailure`"""
-  MotionPlannerFailureStartPositionCollision = "MotionPlannerFailureStartPositionCollision"
-  """Enum MotionPlannerFailureStartPositionCollision = `MotionPlannerFailureStartPositionCollision`"""
-  IOFailure = "IOFailure"
-  """Enum IOFailure = `IOFailure`"""
-  InvalidRoutineLoadedFailure = "InvalidRoutineLoadedFailure"
-  """Enum InvalidRoutineLoadedFailure = `InvalidRoutineLoadedFailure`"""
-  InferenceFailure = "InferenceFailure"
-  """Enum InferenceFailure = `InferenceFailure`"""
-  CameraFailure = "CameraFailure"
-  """Enum CameraFailure = `CameraFailure`"""
-  HaasFailure = "HaasFailure"
-  """Enum HaasFailure = `HaasFailure`"""
-  BotmanHeartbeatLost = "BotmanHeartbeatLost"
-  """Enum BotmanHeartbeatLost = `BotmanHeartbeatLost`"""
-  InternalFailure = "InternalFailure"
-  """Enum InternalFailure = `InternalFailure`"""
-  TorqueLimitExceeded = "TorqueLimitExceeded"
-  """Enum TorqueLimitExceeded = `TorqueLimitExceeded`"""
-  StepPlayFailure = "StepPlayFailure"
-  """Enum StepPlayFailure = `StepPlayFailure`"""
-  UnbrakeFailure = "UnbrakeFailure"
-  """Enum UnbrakeFailure = `UnbrakeFailure`"""
-  WeldFailure = "WeldFailure"
-  """Enum WeldFailure = `WeldFailure`"""
-  TriggerFaultFailure = "TriggerFaultFailure"
-  """Enum TriggerFaultFailure = `TriggerFaultFailure`"""
-
-def parse_recovery_state_enum(data: object) -> RecoveryStateEnum:
-  return RecoveryStateEnum(data)
-
-def serialize_recovery_state_enum(data: Union[RecoveryStateEnum, str]) -> object:
-  return RecoveryStateEnum(data).value
-
 class RecoveryTypeEnum(Enum):
   Recoverable = "Recoverable"
   """Enum Recoverable = `Recoverable`"""
@@ -2035,6 +2046,28 @@ 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 RobotStatusEnum(Enum):
+  Idle = "Idle"
+  """Enum Idle = `Idle`"""
+  RunningAdHocCommand = "RunningAdHocCommand"
+  """Enum RunningAdHocCommand = `RunningAdHocCommand`"""
+  RoutineRunning = "RoutineRunning"
+  """Enum RoutineRunning = `RoutineRunning`"""
+  Antigravity = "Antigravity"
+  """Enum Antigravity = `Antigravity`"""
+  AntigravitySlow = "AntigravitySlow"
+  """Enum AntigravitySlow = `AntigravitySlow`"""
+  Failure = "Failure"
+  """Enum Failure = `Failure`"""
+  Recovering = "Recovering"
+  """Enum Recovering = `Recovering`"""
+
+def parse_robot_status_enum(data: object) -> RobotStatusEnum:
+  return RobotStatusEnum(data)
+
+def serialize_robot_status_enum(data: Union[RobotStatusEnum, str]) -> object:
+  return RobotStatusEnum(data).value
+
 class ROSControlStateEnum(Enum):
   Enabled = "enabled"
   """ROS control is enabled."""
@@ -3553,7 +3586,7 @@ class OnRobot2FG14GripperConfiguration:
   max_width_outer: Union[float, None] = None
   force: Union[float, None] = None
   max_force: Union[float, None] = None
-  finger_mounting_position: Union[float, None] = None
+  finger_mounting_position: Union[str, None] = None
   finger_offset: Union[float, None] = None
   finger_angle: Union[float, None] = None
   finger_length: Union[float, None] = None
@@ -3669,12 +3702,12 @@ class OnRobot2FG14GripperConfiguration:
 
     return [True, ""]
 
-  def validate_finger_mounting_position(self, value: float) -> Tuple[bool, str]:
+  def validate_finger_mounting_position(self, value: str) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
 
-    if not isinstance(value, float):
-      return [False, "finger_mounting_position must be of type float for OnRobot2FG14GripperConfiguration, got " + type(value).__name__]
+    if not isinstance(value, str):
+      return [False, "finger_mounting_position must be of type str for OnRobot2FG14GripperConfiguration, got " + type(value).__name__]
 
     return [True, ""]
 
@@ -3806,7 +3839,7 @@ def parse_on_robot_2_fg_14_gripper_configuration(data: object):
     max_width_outer=parse_f_64(data["max_width_outer"]) if "max_width_outer" in data and data.get("max_width_outer") is not None else None,
     force=parse_f_64(data["force"]) if "force" in data and data.get("force") is not None else None,
     max_force=parse_f_64(data["max_force"]) if "max_force" in data and data.get("max_force") is not None else None,
-    finger_mounting_position=parse_f_64(data["finger_mounting_position"]) if "finger_mounting_position" in data and data.get("finger_mounting_position") is not None else None,
+    finger_mounting_position=parse_str(data["finger_mounting_position"]) if "finger_mounting_position" in data and data.get("finger_mounting_position") is not None else None,
     finger_offset=parse_f_64(data["finger_offset"]) if "finger_offset" in data and data.get("finger_offset") is not None else None,
     finger_angle=parse_f_64(data["finger_angle"]) if "finger_angle" in data and data.get("finger_angle") is not None else None,
     finger_length=parse_f_64(data["finger_length"]) if "finger_length" in data and data.get("finger_length") is not None else None,
@@ -3829,7 +3862,7 @@ def serialize_on_robot_2_fg_14_gripper_configuration(data: OnRobot2FG14GripperCo
     "max_width_outer": None if data.max_width_outer is None else serialize_f_64(data.max_width_outer),
     "force": None if data.force is None else serialize_f_64(data.force),
     "max_force": None if data.max_force is None else serialize_f_64(data.max_force),
-    "finger_mounting_position": None if data.finger_mounting_position is None else serialize_f_64(data.finger_mounting_position),
+    "finger_mounting_position": None if data.finger_mounting_position is None else serialize_str(data.finger_mounting_position),
     "finger_offset": None if data.finger_offset is None else serialize_f_64(data.finger_offset),
     "finger_angle": None if data.finger_angle is None else serialize_f_64(data.finger_angle),
     "finger_length": None if data.finger_length is None else serialize_f_64(data.finger_length),
@@ -3853,7 +3886,7 @@ class OnRobot2FG7GripperConfiguration:
   max_width_outer: Union[float, None] = None
   force: Union[float, None] = None
   max_force: Union[float, None] = None
-  finger_mounting_position: Union[float, None] = None
+  finger_mounting_position: Union[str, None] = None
   finger_offset: Union[float, None] = None
   finger_angle: Union[float, None] = None
   finger_length: Union[float, None] = None
@@ -3969,12 +4002,12 @@ class OnRobot2FG7GripperConfiguration:
 
     return [True, ""]
 
-  def validate_finger_mounting_position(self, value: float) -> Tuple[bool, str]:
+  def validate_finger_mounting_position(self, value: str) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
 
-    if not isinstance(value, float):
-      return [False, "finger_mounting_position must be of type float for OnRobot2FG7GripperConfiguration, got " + type(value).__name__]
+    if not isinstance(value, str):
+      return [False, "finger_mounting_position must be of type str for OnRobot2FG7GripperConfiguration, got " + type(value).__name__]
 
     return [True, ""]
 
@@ -4106,7 +4139,7 @@ def parse_on_robot_2_fg_7_gripper_configuration(data: object):
     max_width_outer=parse_f_64(data["max_width_outer"]) if "max_width_outer" in data and data.get("max_width_outer") is not None else None,
     force=parse_f_64(data["force"]) if "force" in data and data.get("force") is not None else None,
     max_force=parse_f_64(data["max_force"]) if "max_force" in data and data.get("max_force") is not None else None,
-    finger_mounting_position=parse_f_64(data["finger_mounting_position"]) if "finger_mounting_position" in data and data.get("finger_mounting_position") is not None else None,
+    finger_mounting_position=parse_str(data["finger_mounting_position"]) if "finger_mounting_position" in data and data.get("finger_mounting_position") is not None else None,
     finger_offset=parse_f_64(data["finger_offset"]) if "finger_offset" in data and data.get("finger_offset") is not None else None,
     finger_angle=parse_f_64(data["finger_angle"]) if "finger_angle" in data and data.get("finger_angle") is not None else None,
     finger_length=parse_f_64(data["finger_length"]) if "finger_length" in data and data.get("finger_length") is not None else None,
@@ -4129,7 +4162,7 @@ def serialize_on_robot_2_fg_7_gripper_configuration(data: OnRobot2FG7GripperConf
     "max_width_outer": None if data.max_width_outer is None else serialize_f_64(data.max_width_outer),
     "force": None if data.force is None else serialize_f_64(data.force),
     "max_force": None if data.max_force is None else serialize_f_64(data.max_force),
-    "finger_mounting_position": None if data.finger_mounting_position is None else serialize_f_64(data.finger_mounting_position),
+    "finger_mounting_position": None if data.finger_mounting_position is None else serialize_str(data.finger_mounting_position),
     "finger_offset": None if data.finger_offset is None else serialize_f_64(data.finger_offset),
     "finger_angle": None if data.finger_angle is None else serialize_f_64(data.finger_angle),
     "finger_length": None if data.finger_length is None else serialize_f_64(data.finger_length),
@@ -4431,36 +4464,6 @@ def serialize_orientation(data: Orientation) -> object:
     "quaternion": None if data.quaternion is None else serialize_quaternion(data.quaternion),
   }
 
-@dataclass
-class RecoveryStatusResponse:
-  """Recovery status response"""
-  state: Union[RecoveryStateEnum, None] = None
-
-  def validate_state(self, value: RecoveryStateEnum) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
-
-    if not ((isinstance(value, str) and RecoveryStateEnum in ['Success', 'Interrupted', 'NonIdle', 'Braked', 'PlanningFailure', 'ExecutionFailure', 'ControlSystemFailure', 'EStopTriggered', 'GripperFailure', 'OutOfJointLimitsFailure', 'CollisionFailure', 'TorqueCollisionFailure', 'InBoxingPositionFailure', 'PowerBoardCheckFailure', 'MotionPlannerFailure', 'MotionPlannerFailureStartPositionCollision', 'IOFailure', 'InvalidRoutineLoadedFailure', 'InferenceFailure', 'CameraFailure', 'HaasFailure', 'BotmanHeartbeatLost', 'InternalFailure', 'TorqueLimitExceeded', 'StepPlayFailure', 'UnbrakeFailure', 'WeldFailure', 'TriggerFaultFailure']) or isinstance(value, RecoveryStateEnum)):
-      return [False, "state must be of type RecoveryStateEnum for RecoveryStatusResponse, 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)
-    if not is_valid:
-      raise TypeError(error_str)
-
-def parse_recovery_status_response(data: object):
-  return RecoveryStatusResponse(
-    state=parse_recovery_state_enum(data["state"]) if "state" in data and data.get("state") is not None else None,
-  )
-
-def serialize_recovery_status_response(data: RecoveryStatusResponse) -> object:
-  return {
-    "state": None if data.state is None else serialize_recovery_state_enum(data.state),
-  }
-
 @dataclass
 class FailureStateDetails:
   """Failure state details."""
@@ -5588,9 +5591,19 @@ def serialize_position_and_orientation(data: PositionAndOrientation) -> object:
 @dataclass
 class FailureStateResponse:
   """Failure state response informs user of how and whether the robot may be recovered."""
+  status: Union[RobotStatusEnum, None] = None
   failed: Union[bool, None] = None
   failure: Union[FailureStateDetails, 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 FailureStateResponse, got " + type(value).__name__]
+
+    return [True, ""]
+
   def validate_failed(self, value: bool) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
@@ -5611,6 +5624,9 @@ class FailureStateResponse:
 
   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)
     is_valid, error_str = self.validate_failed(self.failed)
     if not is_valid:
       raise TypeError(error_str)
@@ -5620,12 +5636,14 @@ class FailureStateResponse:
 
 def parse_failure_state_response(data: object):
   return FailureStateResponse(
+    status=parse_robot_status_enum(data["status"]) if "status" in data and data.get("status") is not None else None,
     failed=parse_bool(data["failed"]) if "failed" in data and data.get("failed") is not None else None,
     failure=parse_failure_state_details(data["failure"]) if "failure" in data and data.get("failure") is not None else None,
   )
 
 def serialize_failure_state_response(data: FailureStateResponse) -> object:
   return {
+    "status": None if data.status is None else serialize_robot_status_enum(data.status),
     "failed": None if data.failed is None else serialize_bool(data.failed),
     "failure": None if data.failure is None else serialize_failure_state_details(data.failure),
   }

{standardbots-2.0.0.dev1734558734 → standardbots-2.0.0.dev1736521253}/standardbots.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: standardbots
-Version: 2.0.0.dev1734558734
+Version: 2.0.0.dev1736521253
 Summary: Standard Bots RO1 Robotics API
 Home-page: 
 Author: Standard Bots Support
@@ -10,6 +10,13 @@ Requires-Python: >=3.7
 Requires-Dist: setuptools>=21.0.0
 Requires-Dist: typing_extensions>=4.3.0
 Requires-Dist: urllib3>=1.26.7
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: keywords
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
     Standard Bots RO1 Robotics API.  # noqa: E501