standardbots 2.0.0.dev1736549072__tar.gz → 2.2024924.1__tar.gz

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.1
 Name: standardbots
-Version: 2.0.0.dev1736549072
+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.dev1736549072 → standardbots-2.2024924.1}/setup.py

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

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

@@ -188,7 +188,7 @@ class Default:
             return self.control_gripper(
                 body=models.GripperCommandRequest(
                     kind=models.GripperKindEnum.DhCgi,
-                    dh_cgi=models.DHCGIGripperCommandRequest(
+                    dh_pgc=models.DHCGIGripperCommandRequest(
                         target_diameter, target_force, target_speed
                     ),
                 ),
@@ -713,7 +713,7 @@ class Camera:
             None
         ]:
             """
-            Retrieve the latest RGB frame from the camera. In JPEG format.
+            Retrieve the latest RGB frame from the camera.
             """
             path = "/api/v1/camera/frame/rgb"
             try:
@@ -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.dev1736549072 → 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"""
@@ -1372,66 +1297,6 @@ def parse_joint_rotations(data: object) -> JointRotations:
 def serialize_joint_rotations(data: JointRotations) -> object:
   return [serialize_f_64(data[0]),serialize_f_64(data[1]),serialize_f_64(data[2]),serialize_f_64(data[3]),serialize_f_64(data[4]),serialize_f_64(data[5]),]
 
-@dataclass
-class JointStateDisturbance:
-  """Disturbance of a joint"""
-  disturbance: Union[float, None] = None
-  amperageDisturbance: Union[float, None] = None
-  windupDisturbance: Union[float, None] = None
-
-  def validate_disturbance(self, value: float) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
-
-    if not isinstance(value, float):
-      return [False, "disturbance must be of type float for JointStateDisturbance, got " + type(value).__name__]
-
-    return [True, ""]
-
-  def validate_amperageDisturbance(self, value: float) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
-
-    if not isinstance(value, float):
-      return [False, "amperageDisturbance must be of type float for JointStateDisturbance, got " + type(value).__name__]
-
-    return [True, ""]
-
-  def validate_windupDisturbance(self, value: float) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
-
-    if not isinstance(value, float):
-      return [False, "windupDisturbance must be of type float for JointStateDisturbance, 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_disturbance(self.disturbance)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_amperageDisturbance(self.amperageDisturbance)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_windupDisturbance(self.windupDisturbance)
-    if not is_valid:
-      raise TypeError(error_str)
-
-def parse_joint_state_disturbance(data: object):
-  return JointStateDisturbance(
-    disturbance=parse_f_64(data["disturbance"]) if "disturbance" in data and data.get("disturbance") is not None else None,
-    amperageDisturbance=parse_f_64(data["amperageDisturbance"]) if "amperageDisturbance" in data and data.get("amperageDisturbance") is not None else None,
-    windupDisturbance=parse_f_64(data["windupDisturbance"]) if "windupDisturbance" in data and data.get("windupDisturbance") is not None else None,
-  )
-
-def serialize_joint_state_disturbance(data: JointStateDisturbance) -> object:
-  return {
-    "disturbance": None if data.disturbance is None else serialize_f_64(data.disturbance),
-    "amperageDisturbance": None if data.amperageDisturbance is None else serialize_f_64(data.amperageDisturbance),
-    "windupDisturbance": None if data.windupDisturbance is None else serialize_f_64(data.windupDisturbance),
-  }
-
 class LinearGripDirectionEnum(Enum):
   Inward = "inward"
   """Move gripper inward to grip. Measure grip position based on interior of gripper fingers and exterior of object"""
@@ -2076,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`"""
@@ -2106,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."""
@@ -2715,7 +2622,7 @@ def serialize_camera_intrinsics_response(data: CameraIntrinsicsResponse) -> obje
 
 @dataclass
 class CameraFrameRequest:
-  """Request for a single camera frame. In JPEG format."""
+  """Request for a single camera frame."""
   camera_settings: Union[CameraSettings, None] = None
 
   def validate_camera_settings(self, value: CameraSettings) -> Tuple[bool, str]:
@@ -3019,6 +2926,81 @@ def serialize_tooltip_position_response(data: TooltipPositionResponse) -> object
     "pose": None if data.pose is None else serialize_cartesian_pose(data.pose),
   }
 
+@dataclass
+class JointState:
+  """State of a joint"""
+  braked: Union[bool, None] = None
+  connectionStatus: Union[ConnectionStatus, None] = None
+  inCollision: Union[bool, None] = None
+  disturbance: Union[float, None] = None
+
+  def validate_braked(self, value: bool) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, bool):
+      return [False, "braked must be of type bool for JointState, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_connectionStatus(self, value: ConnectionStatus) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not ((isinstance(value, str) and ConnectionStatus in ['connected', 'disconnected', 'ready']) or isinstance(value, ConnectionStatus)):
+      return [False, "connectionStatus must be of type ConnectionStatus for JointState, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_inCollision(self, value: bool) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, bool):
+      return [False, "inCollision must be of type bool for JointState, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_disturbance(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "disturbance must be of type float for JointState, 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_braked(self.braked)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_connectionStatus(self.connectionStatus)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_inCollision(self.inCollision)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_disturbance(self.disturbance)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_joint_state(data: object):
+  return JointState(
+    braked=parse_bool(data["braked"]) if "braked" in data and data.get("braked") is not None else None,
+    connectionStatus=parse_connection_status(data["connectionStatus"]) if "connectionStatus" in data and data.get("connectionStatus") is not None else None,
+    inCollision=parse_bool(data["inCollision"]) if "inCollision" in data and data.get("inCollision") is not None else None,
+    disturbance=parse_f_64(data["disturbance"]) if "disturbance" in data and data.get("disturbance") is not None else None,
+  )
+
+def serialize_joint_state(data: JointState) -> object:
+  return {
+    "braked": None if data.braked is None else serialize_bool(data.braked),
+    "connectionStatus": None if data.connectionStatus is None else serialize_connection_status(data.connectionStatus),
+    "inCollision": None if data.inCollision is None else serialize_bool(data.inCollision),
+    "disturbance": None if data.disturbance is None else serialize_f_64(data.disturbance),
+  }
+
 EnvironmentVariablesList = List[EnvironmentVariable]
 
 def parse_environment_variables_list(data: object) -> EnvironmentVariablesList:
@@ -3330,81 +3312,6 @@ def serialize_arm_joint_rotations(data: ArmJointRotations) -> object:
     "joints": serialize_joint_rotations(data.joints),
   }
 
-@dataclass
-class JointState:
-  """State of a joint"""
-  braked: Union[bool, None] = None
-  connectionStatus: Union[ConnectionStatus, None] = None
-  inCollision: Union[bool, None] = None
-  disturbance: Union[JointStateDisturbance, None] = None
-
-  def validate_braked(self, value: bool) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
-
-    if not isinstance(value, bool):
-      return [False, "braked must be of type bool for JointState, got " + type(value).__name__]
-
-    return [True, ""]
-
-  def validate_connectionStatus(self, value: ConnectionStatus) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
-
-    if not ((isinstance(value, str) and ConnectionStatus in ['connected', 'disconnected', 'ready']) or isinstance(value, ConnectionStatus)):
-      return [False, "connectionStatus must be of type ConnectionStatus for JointState, got " + type(value).__name__]
-
-    return [True, ""]
-
-  def validate_inCollision(self, value: bool) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
-
-    if not isinstance(value, bool):
-      return [False, "inCollision must be of type bool for JointState, got " + type(value).__name__]
-
-    return [True, ""]
-
-  def validate_disturbance(self, value: JointStateDisturbance) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
-
-    if not isinstance(value, JointStateDisturbance):
-      return [False, "disturbance must be of type JointStateDisturbance for JointState, 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_braked(self.braked)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_connectionStatus(self.connectionStatus)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_inCollision(self.inCollision)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_disturbance(self.disturbance)
-    if not is_valid:
-      raise TypeError(error_str)
-
-def parse_joint_state(data: object):
-  return JointState(
-    braked=parse_bool(data["braked"]) if "braked" in data and data.get("braked") is not None else None,
-    connectionStatus=parse_connection_status(data["connectionStatus"]) if "connectionStatus" in data and data.get("connectionStatus") is not None else None,
-    inCollision=parse_bool(data["inCollision"]) if "inCollision" in data and data.get("inCollision") is not None else None,
-    disturbance=parse_joint_state_disturbance(data["disturbance"]) if "disturbance" in data and data.get("disturbance") is not None else None,
-  )
-
-def serialize_joint_state(data: JointState) -> object:
-  return {
-    "braked": None if data.braked is None else serialize_bool(data.braked),
-    "connectionStatus": None if data.connectionStatus is None else serialize_connection_status(data.connectionStatus),
-    "inCollision": None if data.inCollision is None else serialize_bool(data.inCollision),
-    "disturbance": None if data.disturbance is None else serialize_joint_state_disturbance(data.disturbance),
-  }
-
 @dataclass
 class LinearUnit:
   """Reusable Abstraction for linear units (eg distance, position, offset)
@@ -3646,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
@@ -3762,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, ""]
 
@@ -3899,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,
@@ -3922,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),
@@ -3946,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
@@ -4062,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, ""]
 
@@ -4199,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,
@@ -4222,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),
@@ -4524,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."""
@@ -4923,74 +4860,6 @@ def serialize_arm_position_update_request_response_event_stream_details(data: Ar
     "subscriptions": serialize_arm_position_update_request_response_event_stream_subscriptions_list(data.subscriptions),
   }
 
-@dataclass
-class Routine:
-  """Robot Routine containing steps to automate robot movement and operations"""
-  id: Union[str, None] = None
-  name: Union[str, None] = None
-  environment_variables: Union[EnvironmentVariablesList, None] = None
-
-  def validate_id(self, value: str) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
-
-    if not isinstance(value, str):
-      return [False, "id must be of type str for Routine, got " + type(value).__name__]
-
-    return [True, ""]
-
-  def validate_name(self, value: str) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
-
-    if not isinstance(value, str):
-      return [False, "name must be of type str for Routine, got " + type(value).__name__]
-
-    return [True, ""]
-
-  def validate_environment_variables(self, value: EnvironmentVariablesList) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
-
-    if not (isinstance(value, list) and all(isinstance(x, EnvironmentVariable) for x in value)):
-      return [False, "environment_variables must be of type EnvironmentVariablesList for Routine, 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_id(self.id)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_name(self.name)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_environment_variables(self.environment_variables)
-    if not is_valid:
-      raise TypeError(error_str)
-
-def parse_routine(data: object):
-  return Routine(
-    id=parse_str(data["id"]) if "id" in data and data.get("id") is not None else None,
-    name=parse_str(data["name"]) if "name" in data and data.get("name") is not None else None,
-    environment_variables=parse_environment_variables_list(data["environment_variables"]) if "environment_variables" in data and data.get("environment_variables") is not None else None,
-  )
-
-def serialize_routine(data: Routine) -> object:
-  return {
-    "id": None if data.id is None else serialize_str(data.id),
-    "name": None if data.name is None else serialize_str(data.name),
-    "environment_variables": None if data.environment_variables is None else serialize_environment_variables_list(data.environment_variables),
-  }
-
-ArmJointRotationsList = List[ArmJointRotations]
-
-def parse_arm_joint_rotations_list(data: object) -> ArmJointRotationsList:
-  return [parse_arm_joint_rotations(item) for item in data]
-
-def serialize_arm_joint_rotations_list(data: ArmJointRotationsList) -> List[object]:
-  return [serialize_arm_joint_rotations(item) for item in data]
-
 @dataclass
 class JointsStateResponse:
   """Response to a query for the current state of the joints"""
@@ -5096,6 +4965,74 @@ def serialize_joints_state_response(data: JointsStateResponse) -> object:
     "J5": None if data.J5 is None else serialize_joint_state(data.J5),
   }
 
+@dataclass
+class Routine:
+  """Robot Routine containing steps to automate robot movement and operations"""
+  id: Union[str, None] = None
+  name: Union[str, None] = None
+  environment_variables: Union[EnvironmentVariablesList, None] = None
+
+  def validate_id(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "id must be of type str for Routine, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_name(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "name must be of type str for Routine, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_environment_variables(self, value: EnvironmentVariablesList) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not (isinstance(value, list) and all(isinstance(x, EnvironmentVariable) for x in value)):
+      return [False, "environment_variables must be of type EnvironmentVariablesList for Routine, 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_id(self.id)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_name(self.name)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_environment_variables(self.environment_variables)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_routine(data: object):
+  return Routine(
+    id=parse_str(data["id"]) if "id" in data and data.get("id") is not None else None,
+    name=parse_str(data["name"]) if "name" in data and data.get("name") is not None else None,
+    environment_variables=parse_environment_variables_list(data["environment_variables"]) if "environment_variables" in data and data.get("environment_variables") is not None else None,
+  )
+
+def serialize_routine(data: Routine) -> object:
+  return {
+    "id": None if data.id is None else serialize_str(data.id),
+    "name": None if data.name is None else serialize_str(data.name),
+    "environment_variables": None if data.environment_variables is None else serialize_environment_variables_list(data.environment_variables),
+  }
+
+ArmJointRotationsList = List[ArmJointRotations]
+
+def parse_arm_joint_rotations_list(data: object) -> ArmJointRotationsList:
+  return [parse_arm_joint_rotations(item) for item in data]
+
+def serialize_arm_joint_rotations_list(data: ArmJointRotationsList) -> List[object]:
+  return [serialize_arm_joint_rotations(item) for item in data]
+
 @dataclass
 class OnRobot2FG14GripperCommandRequest:
   """Control the OnRobot 2FG14 gripper (end effector) of the robot
@@ -5651,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, ""]
@@ -5684,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)
@@ -5696,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.dev1736549072 → 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.dev1736549072
+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