standardbots 2.20241003.31__tar.gz → 2.20241003.33__tar.gz

{standardbots-2.20241003.31 → standardbots-2.20241003.33}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: standardbots
-Version: 2.20241003.31
+Version: 2.20241003.33
 Summary: Standard Bots RO1 Robotics API
 Home-page: 
 Author: Standard Bots Support

{standardbots-2.20241003.31 → standardbots-2.20241003.33}/setup.py

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

{standardbots-2.20241003.31 → standardbots-2.20241003.33}/standardbots/auto_generated/apis.py

@@ -1002,15 +1002,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"
@@ -1021,7 +1021,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))
 
@@ -1036,6 +1036,41 @@ class Recovery:
         response
       )
 
+    def get_status(
+      self,
+    ) -> Response[
+      Union[
+        models.FailureStateResponse,
+        models.ErrorResponse,
+        None
+      ],
+      models.FailureStateResponse
+    ]:
+      """
+      Get the robot's recovery status.
+
+      """
+      path = "/api/v1/recovery/status"
+      response = self._request_manager.request(
+        "GET",
+        path,
+        headers=self._request_manager.json_headers(),
+      )
+      parsed = None
+      if response.status == 200:
+        parsed = models.parse_failure_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
+      )
+
   recover: Recover
 
   def __init__(self, request_manager: RequestManager):

{standardbots-2.20241003.31 → standardbots-2.20241003.33}/standardbots/auto_generated/models.py

@@ -1419,69 +1419,23 @@ 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`"""
+  NotRecoverable = "NotRecoverable"
+  """Enum NotRecoverable = `NotRecoverable`"""
+  Restart = "Restart"
+  """Enum Restart = `Restart`"""
+  GuidedMode = "GuidedMode"
+  """Enum GuidedMode = `GuidedMode`"""
+  ManualRecoveryMode = "ManualRecoveryMode"
+  """Enum ManualRecoveryMode = `ManualRecoveryMode`"""
+
+def parse_recovery_type_enum(data: object) -> RecoveryTypeEnum:
+  return RecoveryTypeEnum(data)
+
+def serialize_recovery_type_enum(data: Union[RecoveryTypeEnum, str]) -> object:
+  return RecoveryTypeEnum(data).value
 
 class RobotControlModeEnum(Enum):
   Api = "api"
@@ -1495,6 +1449,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."""
@@ -2261,7 +2237,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
@@ -2377,12 +2353,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, ""]
 
@@ -2514,7 +2490,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 else None,
     force=parse_f_64(data["force"]) if "force" in data else None,
     max_force=parse_f_64(data["max_force"]) if "max_force" in data else None,
-    finger_mounting_position=parse_f_64(data["finger_mounting_position"]) if "finger_mounting_position" in data else None,
+    finger_mounting_position=parse_str(data["finger_mounting_position"]) if "finger_mounting_position" in data else None,
     finger_offset=parse_f_64(data["finger_offset"]) if "finger_offset" in data else None,
     finger_angle=parse_f_64(data["finger_angle"]) if "finger_angle" in data else None,
     finger_length=parse_f_64(data["finger_length"]) if "finger_length" in data else None,
@@ -2537,7 +2513,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),
@@ -2561,7 +2537,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
@@ -2677,12 +2653,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, ""]
 
@@ -2814,7 +2790,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 else None,
     force=parse_f_64(data["force"]) if "force" in data else None,
     max_force=parse_f_64(data["max_force"]) if "max_force" in data else None,
-    finger_mounting_position=parse_f_64(data["finger_mounting_position"]) if "finger_mounting_position" in data else None,
+    finger_mounting_position=parse_str(data["finger_mounting_position"]) if "finger_mounting_position" in data else None,
     finger_offset=parse_f_64(data["finger_offset"]) if "finger_offset" in data else None,
     finger_angle=parse_f_64(data["finger_angle"]) if "finger_angle" in data else None,
     finger_length=parse_f_64(data["finger_length"]) if "finger_length" in data else None,
@@ -2837,7 +2813,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),
@@ -3095,33 +3071,108 @@ def serialize_orientation(data: Orientation) -> object:
   }
 
 @dataclass
-class RecoveryStatusResponse:
-  """Recovery status response"""
-  state: Union[RecoveryStateEnum, None] = None
+class FailureStateDetails:
+  """Failure state details."""
+  failure_trace_id: Union[str, None] = None
+  kind: Union[str, None] = None
+  failed_step: Union[str, None] = None
+  reason: Union[str, None] = None
+  recovery_type: Union[RecoveryTypeEnum, None] = None
+  is_recoverable_with_wrist_button: Union[bool, None] = None
 
-  def validate_state(self, value: RecoveryStateEnum) -> Tuple[bool, str]:
+  def validate_failure_trace_id(self, value: str) -> 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__]
+    if not isinstance(value, str):
+      return [False, "failure_trace_id must be of type str for FailureStateDetails, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_kind(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "kind must be of type str for FailureStateDetails, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_failed_step(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "failed_step must be of type str for FailureStateDetails, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_reason(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "reason must be of type str for FailureStateDetails, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_recovery_type(self, value: RecoveryTypeEnum) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not ((isinstance(value, str) and RecoveryTypeEnum in ['Recoverable', 'NotRecoverable', 'Restart', 'GuidedMode', 'ManualRecoveryMode']) or isinstance(value, RecoveryTypeEnum)):
+      return [False, "recovery_type must be of type RecoveryTypeEnum for FailureStateDetails, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_is_recoverable_with_wrist_button(self, value: bool) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, bool):
+      return [False, "is_recoverable_with_wrist_button must be of type bool for FailureStateDetails, 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)
+    is_valid, error_str = self.validate_failure_trace_id(self.failure_trace_id)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_kind(self.kind)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_failed_step(self.failed_step)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_reason(self.reason)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_recovery_type(self.recovery_type)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_is_recoverable_with_wrist_button(self.is_recoverable_with_wrist_button)
     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 else None,
+def parse_failure_state_details(data: object):
+  return FailureStateDetails(
+    failure_trace_id=parse_str(data["failure_trace_id"]) if "failure_trace_id" in data else None,
+    kind=parse_str(data["kind"]) if "kind" in data else None,
+    failed_step=parse_str(data["failed_step"]) if "failed_step" in data else None,
+    reason=parse_str(data["reason"]) if "reason" in data else None,
+    recovery_type=parse_recovery_type_enum(data["recovery_type"]) if "recovery_type" in data else None,
+    is_recoverable_with_wrist_button=parse_bool(data["is_recoverable_with_wrist_button"]) if "is_recoverable_with_wrist_button" in data else None,
   )
 
-def serialize_recovery_status_response(data: RecoveryStatusResponse) -> object:
+def serialize_failure_state_details(data: FailureStateDetails) -> object:
   return {
-    "state": None if data.state is None else serialize_recovery_state_enum(data.state),
+    "failure_trace_id": None if data.failure_trace_id is None else serialize_str(data.failure_trace_id),
+    "kind": None if data.kind is None else serialize_str(data.kind),
+    "failed_step": None if data.failed_step is None else serialize_str(data.failed_step),
+    "reason": None if data.reason is None else serialize_str(data.reason),
+    "recovery_type": None if data.recovery_type is None else serialize_recovery_type_enum(data.recovery_type),
+    "is_recoverable_with_wrist_button": None if data.is_recoverable_with_wrist_button is None else serialize_bool(data.is_recoverable_with_wrist_button),
   }
 
 @dataclass
@@ -4067,6 +4118,66 @@ def serialize_position_and_orientation(data: PositionAndOrientation) -> object:
     "orientation": serialize_orientation(data.orientation),
   }
 
+@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, ""]
+
+    if not isinstance(value, bool):
+      return [False, "failed must be of type bool for FailureStateResponse, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_failure(self, value: FailureStateDetails) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, FailureStateDetails):
+      return [False, "failure must be of type FailureStateDetails for FailureStateResponse, 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)
+    is_valid, error_str = self.validate_failed(self.failed)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_failure(self.failure)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_failure_state_response(data: object):
+  return FailureStateResponse(
+    status=parse_robot_status_enum(data["status"]) if "status" in data else None,
+    failed=parse_bool(data["failed"]) if "failed" in data else None,
+    failure=parse_failure_state_details(data["failure"]) if "failure" in data 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),
+  }
+
 @dataclass
 class ArmPositionUpdateRequestResponseFormat:
   """Specify how the response should be sent

{standardbots-2.20241003.31 → standardbots-2.20241003.33}/standardbots.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: standardbots
-Version: 2.20241003.31
+Version: 2.20241003.33
 Summary: Standard Bots RO1 Robotics API
 Home-page: 
 Author: Standard Bots Support