standardbots 2.0.0.dev1737138088__tar.gz → 2.2024924.1__tar.gz

{standardbots-2.0.0.dev1737138088 → standardbots-2.2024924.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.1
 Name: standardbots
-Version: 2.0.0.dev1737138088
+Version: 2.2024924.1
 Summary: Standard Bots RO1 Robotics API
 Home-page: 
 Author: Standard Bots Support
@@ -10,13 +10,6 @@ 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.dev1737138088 → standardbots-2.2024924.1}/setup.py

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

{standardbots-2.0.0.dev1737138088 → standardbots-2.2024924.1}/standardbots/auto_generated/apis.py

@@ -932,113 +932,6 @@ 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:
@@ -1243,6 +1136,63 @@ 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:
@@ -1712,15 +1662,15 @@ class Recovery:
             self,
         ) -> Response[
             Union[
-                models.FailureStateResponse,
+                models.RecoveryStatusResponse,
                 models.ErrorResponse,
                 models.ErrorResponse,
                 None
             ],
-            models.FailureStateResponse
+            models.RecoveryStatusResponse
         ]:
             """
-            Attempts to recover the robot from a fault state. Inspect the response to determine if additional recovery actions are required.
+            Recovers the robot from a fault state.
 
             """
             path = "/api/v1/recovery/recover"
@@ -1732,7 +1682,7 @@ class Recovery:
                 )
                 parsed = None
                 if response.status == 200:
-                    parsed = models.parse_failure_state_response(json.loads(response.data))
+                    parsed = models.parse_recovery_status_response(json.loads(response.data))
                 if response.status == 400:
                     parsed = models.parse_error_response(json.loads(response.data))
 
@@ -2543,9 +2493,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
@@ -2567,9 +2517,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.dev1737138088 → standardbots-2.2024924.1}/standardbots/auto_generated/models.py

@@ -224,81 +224,6 @@ 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"""
@@ -2016,6 +1941,70 @@ 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`"""
@@ -2046,28 +2035,6 @@ 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."""
@@ -3586,7 +3553,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[str, None] = None
+  finger_mounting_position: Union[float, None] = None
   finger_offset: Union[float, None] = None
   finger_angle: Union[float, None] = None
   finger_length: Union[float, None] = None
@@ -3702,12 +3669,12 @@ class OnRobot2FG14GripperConfiguration:
 
     return [True, ""]
 
-  def validate_finger_mounting_position(self, value: str) -> Tuple[bool, str]:
+  def validate_finger_mounting_position(self, value: float) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
 
-    if not isinstance(value, str):
-      return [False, "finger_mounting_position must be of type str for OnRobot2FG14GripperConfiguration, got " + type(value).__name__]
+    if not isinstance(value, float):
+      return [False, "finger_mounting_position must be of type float for OnRobot2FG14GripperConfiguration, got " + type(value).__name__]
 
     return [True, ""]
 
@@ -3839,7 +3806,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_str(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_f_64(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,
@@ -3862,7 +3829,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_str(data.finger_mounting_position),
+    "finger_mounting_position": None if data.finger_mounting_position is None else serialize_f_64(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),
@@ -3886,7 +3853,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[str, None] = None
+  finger_mounting_position: Union[float, None] = None
   finger_offset: Union[float, None] = None
   finger_angle: Union[float, None] = None
   finger_length: Union[float, None] = None
@@ -4002,12 +3969,12 @@ class OnRobot2FG7GripperConfiguration:
 
     return [True, ""]
 
-  def validate_finger_mounting_position(self, value: str) -> Tuple[bool, str]:
+  def validate_finger_mounting_position(self, value: float) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
 
-    if not isinstance(value, str):
-      return [False, "finger_mounting_position must be of type str for OnRobot2FG7GripperConfiguration, got " + type(value).__name__]
+    if not isinstance(value, float):
+      return [False, "finger_mounting_position must be of type float for OnRobot2FG7GripperConfiguration, got " + type(value).__name__]
 
     return [True, ""]
 
@@ -4139,7 +4106,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_str(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_f_64(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,
@@ -4162,7 +4129,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_str(data.finger_mounting_position),
+    "finger_mounting_position": None if data.finger_mounting_position is None else serialize_f_64(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),
@@ -4464,6 +4431,36 @@ 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."""
@@ -5591,19 +5588,9 @@ 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, ""]
@@ -5624,9 +5611,6 @@ 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)
@@ -5636,14 +5620,12 @@ 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.dev1737138088 → standardbots-2.2024924.1}/standardbots.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.1
 Name: standardbots
-Version: 2.0.0.dev1737138088
+Version: 2.2024924.1
 Summary: Standard Bots RO1 Robotics API
 Home-page: 
 Author: Standard Bots Support
@@ -10,13 +10,6 @@ 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